carray 3.0.6 → 3.0.7

data/ext/carray_mask.c

@@ -531,11 +531,69 @@ ca_mask_standin_current (CArray *mask_view, CArray *reading, CArray *parent,
   return ( parent->mask != NULL ) ? parent->mask : reading;
 }
 
+/* The first view from ca up the parent chain whose mask is attached, or
+   NULL.  An attached mask may alias its root: whether it does is not asked,
+   as ca_attach_is_alias answers yes for any view that already has a pointer,
+   and the copy made for one that does is a no-op. */
+static CArray *
+ca_mask_buffer_holder (CArray *ca)
+{
+  while ( ca != NULL && ca_is_view(ca)
+          && ! ca_test_flag(ca, CA_FLAG_MULTI_PARENTS) ) {
+    if ( ca->mask != NULL && ca_is_view(ca->mask)
+         && ca_is_attached(ca->mask) ) {
+      return ca;
+    }
+    ca = CAVIEW(ca)->parent;
+  }
+  return NULL;
+}
+
+/* Marks the cells addrs of mask, the mask of a view at or below chain.  The
+   write goes past any buffer an attach window holds on the way to the root,
+   and the sync that closes that window sends the buffer: the cells this
+   write turned true are copied into it, read as the difference of two
+   gathers so that what the window has written there meanwhile stays. */
+static void
+ca_mask_fill_past_buffers (CArray *mask, CArray *chain, ca_size_t m,
+                           ca_size_t *addrs)
+{
+  volatile VALUE holder = 0, reader;
+  CArray     *owner = ca_mask_buffer_holder(chain);
+  CArray     *held, *rd;
+  boolean8_t *before, *after, *z;
+  boolean8_t  one = 1;
+  ca_size_t   i, n;
+
+  if ( owner == NULL ) {
+    ca_fill_addrs(mask, m, addrs, &one);
+    return;
+  }
+  held   = owner->mask;
+  n      = held->elements;
+  /* A view answers from its buffer while it has one: the clone has none. */
+  rd     = (CArray *) ca_clone(held);
+  reader = ca_wrap_struct(rd);
+  before = ALLOCV_N(boolean8_t, holder, 2 * n);
+  after  = before + n;
+  ca_xfer_all(rd, before, CA_XFER_GET);
+  ca_mask_fill_past_buffers(mask, CAVIEW(owner)->parent, m, addrs);
+  ca_xfer_all(rd, after, CA_XFER_GET);
+  z = (boolean8_t *) held->ptr;
+  for ( i = 0; i < n; i++ ) {
+    if ( after[i] && ! before[i] ) {
+      z[i] = 1;
+    }
+  }
+  ALLOCV_END(holder);
+  RB_GC_GUARD(reader);
+}
+
 void
 ca_mask_standin_settle (CArray *parent, CArray *standin)
 {
   volatile VALUE holder = 0;
-  boolean8_t    *z, one = 1;
+  boolean8_t    *z;
   ca_size_t     *addrs;
   ca_size_t      i, m = 0, n;
 
@@ -561,7 +619,7 @@ ca_mask_standin_settle (CArray *parent, CArray *standin)
   }
   MEMZERO(z, boolean8_t, n);
   ca_create_mask(parent);
-  ca_fill_addrs(parent->mask, m, addrs, &one);
+  ca_mask_fill_past_buffers(parent->mask, parent, m, addrs);
   ALLOCV_END(holder);
 }
 
@@ -628,20 +686,52 @@ ca_multi_parent_mask_adopt (CArray *mask, CArray **parents,
   CAVIEW(mask)->parent = mp->parents[0];
 }
 
+typedef struct {
+  CArray *parent;
+  CArray *standin;
+} ca_standin_settle_arg;
+
+static VALUE
+ca_standin_settle_body (VALUE arg)
+{
+  ca_standin_settle_arg *a = (ca_standin_settle_arg *) arg;
+  ca_mask_standin_settle(a->parent, a->standin);
+  return Qnil;
+}
+
+/* Every part is settled, past a parent that refuses a mask, so no part keeps
+   a true in its stand-in; then the first exception is raised. */
 void
 ca_multi_parent_mask_settle (CArray *mask, CArray **parents,
                              CArray **standins, int32_t n)
 {
   CAMultiParent *mp = (CAMultiParent *) mask;
+  volatile VALUE error = Qnil;
   int32_t k;
   if ( standins == NULL ) {
     return;
   }
   for ( k = 0; k < n; k++ ) {
     if ( standins[k] != NULL && mp->parents[k] == standins[k] ) {
-      ca_mask_standin_settle(parents[k], standins[k]);
+      ca_standin_settle_arg a = { parents[k], standins[k] };
+      int tag = 0;
+      /* protect: goes on to the other parts; nothing to give back */
+      rb_protect(ca_standin_settle_body, (VALUE) &a, &tag);
+      if ( tag ) {
+        VALUE err = rb_errinfo();
+        if ( ! RTEST(rb_obj_is_kind_of(err, rb_eException)) ) {
+          rb_jump_tag(tag);
+        }
+        if ( NIL_P(error) ) {
+          error = err;
+        }
+        rb_set_errinfo(Qnil);
+      }
     }
   }
+  if ( ! NIL_P(error) ) {
+    rb_exc_raise(error);
+  }
 }
 
 void
@@ -1934,7 +2024,7 @@ rb_ca_inherit_mask_n (VALUE self, int n, VALUE *rothers)
 VALUE
 rb_ca_inherit_mask (VALUE self, int n, ...)
 {
-  VALUE other;
+  volatile VALUE other;
   CArray **slist;
   volatile VALUE holder;
   CArray *ca, *cs;
@@ -2017,7 +2107,7 @@ rb_ca_inherit_mask_replace_n (VALUE self, int n, VALUE *rothers)
 VALUE
 rb_ca_inherit_mask_replace (VALUE self, int n, ...)
 {
-  VALUE other;
+  volatile VALUE other;
   CArray **slist;
   volatile VALUE holder;
   CArray *ca, *cs;
@@ -2253,6 +2343,20 @@ ca_binop_bit_and_i_boolean8_fast (ca_size_t n, boolean8_t *m,
 }
 
 /* ----- bit_or_i (boolean8_t fast) ----- */
+/* Every cell gets 0 or 1, even beside a masked cell: its byte is not
+   defined (any value), and a cell Kleene resolves to true keeps the value
+   written here.  The word path folds each byte's eight bits into its low
+   bit; a shift by less than 8 moves bits of the next byte only into the
+   high bits, which the last mask drops. */
+static inline uint64_t
+ca_mask_word_nonzero_bytes (uint64_t w)
+{
+  w |= w >> 4;
+  w |= w >> 2;
+  w |= w >> 1;
+  return w & CA_MASK_WORD_LSB;
+}
+
 static void
 ca_binop_bit_or_i_boolean8_fast (ca_size_t n, boolean8_t *m,
                                  char *ptr1, ca_size_t i1,
@@ -2273,7 +2377,7 @@ ca_binop_bit_or_i_boolean8_fast (ca_size_t n, boolean8_t *m,
         p1 = q1 + k*i1;
         p2 = q2 + k*i2;
         p3 = q3 + k*i3;
-        (*p3) = (*p1) | (*p2);
+        (*p3) = ( (*p1) | (*p2) ) ? 1 : 0;
       }
     }
   }
@@ -2284,18 +2388,21 @@ ca_binop_bit_or_i_boolean8_fast (ca_size_t n, boolean8_t *m,
     ca_size_t       j;
     for (j = 0; j < nw; j++) {
       ca_mask_word_store(q3 + j*CA_MASK_WORD_BYTES,
-                         ca_mask_word_load(q1 + j*CA_MASK_WORD_BYTES) | ca_mask_word_load(q2 + j*CA_MASK_WORD_BYTES));
+                         ca_mask_word_nonzero_bytes(
+                           ca_mask_word_load(q1 + j*CA_MASK_WORD_BYTES) |
+                           ca_mask_word_load(q2 + j*CA_MASK_WORD_BYTES)));
     }
     for (j = nw * CA_MASK_WORD_BYTES; j < n; j++) {
-      q3[j] = q1[j] | q2[j];
+      q3[j] = ( q1[j] | q2[j] ) ? 1 : 0;
     }
   }
   else {
+    /* non-contig view: byte loop */
     for (k = 0; k < n; k++) {
       p1 = q1 + k*i1;
       p2 = q2 + k*i2;
       p3 = q3 + k*i3;
-      (*p3) = (*p1) | (*p2);
+      (*p3) = ( (*p1) | (*p2) ) ? 1 : 0;
     }
   }
 }
@@ -2407,8 +2514,8 @@ ca_inherit_mask_check_args (int argc, VALUE *argv, const char *name)
   for (i=0; i<RARRAY_LEN(rest); i++) {
     VALUE v = RARRAY_AREF(rest, i);
     if ( ! rb_obj_is_carray(v) ) {
-      rb_raise(rb_eTypeError, "%s: argument %ld must be a CArray (got %s)",
-               name, i, rb_obj_classname(v));
+      rb_raise(rb_eTypeError, "%s: argument %ld must be a CArray (got %"PRIsVALUE")",
+               name, i, rb_obj_class(v));
     }
   }
   return rest;

data/ext/carray_median_percentile.c

@@ -138,10 +138,11 @@ mp_keep_axis_full_f64 (VALUE self, double v, int is_undef)
 /* [shared] all-UNDEF reduced CA_FLOAT64 output for a zero-length reduction
    axis.  An order statistic of no elements has no value, so every reduced
    cell is masked -- matching mean / min (which return UNDEF cells), not a
-   raise.  keep_axis controls whether the reduced axis is dropped or kept
-   as a length-1 axis. */
+   raise, unless fill_value (nil for none) gives the cells a value, as it
+   does for a fiber with no present cell.  keep_axis controls whether the
+   reduced axis is dropped or kept as a length-1 axis. */
 static VALUE
-mp_axis_all_masked (VALUE self, long axis, int keep_axis)
+mp_axis_all_masked (VALUE self, long axis, VALUE fill_value, int keep_axis)
 {
   int8_t ax = (int8_t) axis;
   CArray *ca;
@@ -150,6 +151,10 @@ mp_axis_all_masked (VALUE self, long axis, int keep_axis)
                                 (ca->data_type == CA_OBJECT) ? CA_OBJECT
                                                              : CA_FLOAT64,
                                 keep_axis);
+  if ( ! NIL_P(fill_value) ) {
+    rb_ca_store_all(out, fill_value);
+    return out;
+  }
   CArray *co;
   GetCArray(out, co);
   ca_create_mask(co);
@@ -680,7 +685,7 @@ percentile_object_axis (VALUE self, VALUE pers, long axis, VALUE method)
        is applied by the entry (rb_ca_percentile_m), so build reduced. */
     VALUE res = rb_ary_new_capa(npers);
     for ( long i = 0; i < npers; i++ )
-      rb_ary_push(res, mp_axis_all_masked(self, axis, 0));
+      rb_ary_push(res, mp_axis_all_masked(self, axis, Qnil, 0));
     return res;
   }
 
@@ -774,7 +779,7 @@ percentile_object_axis_masked (VALUE self, VALUE pers, long axis, VALUE method,
   if ( M == 0 ) {
     VALUE res = rb_ary_new_capa(npers);
     for ( long i = 0; i < npers; i++ )
-      rb_ary_push(res, mp_axis_all_masked(self, axis, keep_axis));
+      rb_ary_push(res, mp_axis_all_masked(self, axis, fill_value, keep_axis));
     return res;
   }
 
@@ -904,7 +909,7 @@ rb_ca_median_m_body (int argc, VALUE *argv, VALUE self)
   if ( !NIL_P(raxis) ) {
     long axis = rb_ca_normalize_axis_value(self, raxis, "median");
     long n = (long) ca->dim[axis];
-    if ( n == 0 ) return mp_axis_all_masked(self, axis, keep_axis);
+    if ( n == 0 ) return mp_axis_all_masked(self, axis, fill_value, keep_axis);
     /* mask / min_count / fill_value require the per-fiber select (each fiber
        has its own n_present); the plain partition path assumes a uniform n.
        Switch      ca_fast_path(CA_SC_MEDIAN_PARTITION): off, the per-fiber select. */
@@ -1138,7 +1143,7 @@ pct_axis (VALUE self, VALUE pers_ary, long axis, VALUE method, int keep_axis)
     /* zero-length axis: every requested p reduces to an all-UNDEF cell. */
     VALUE res = rb_ary_new_capa(npers);
     for ( long i = 0; i < npers; i++ )
-      rb_ary_push(res, mp_axis_all_masked(self, axis, keep_axis));
+      rb_ary_push(res, mp_axis_all_masked(self, axis, Qnil, keep_axis));
     return res;
   }
 
@@ -1167,7 +1172,7 @@ pct_axis_masked (VALUE self, VALUE pers_ary, long axis, VALUE method,
   if ( M == 0 ) {
     VALUE res = rb_ary_new_capa(npers);
     for ( long i = 0; i < npers; i++ )
-      rb_ary_push(res, mp_axis_all_masked(self, axis, keep_axis));
+      rb_ary_push(res, mp_axis_all_masked(self, axis, fill_value, keep_axis));
     return res;
   }
 

data/ext/carray_memory_view.c

@@ -449,6 +449,22 @@ ca_mv_probe_data_type (VALUE obj)
   return data_type;
 }
 
+/* True when format is a struct of several members that exactly describes an
+   item of item_size bytes.  A consumer takes such items as raw bytes: the
+   format names no members to rebuild a record from. */
+static bool
+ca_mv_format_is_struct (const char *format, ssize_t item_size)
+{
+  rb_memory_view_item_component_t *members = NULL;
+  size_t n_members = 0;
+  const char *err = NULL;
+  ssize_t size;
+  if ( format == NULL ) return false;
+  size = rb_memory_view_parse_item_format(format, &members, &n_members, &err);
+  if ( members != NULL ) xfree(members);
+  return size == item_size && n_members >= 2;
+}
+
 /* Per-element byte width for consumer-side wrap/from CArray allocation.
    For numeric types it is `ca_sizeof[data_type]`; for CA_FIXLEN it is the
    MemoryView item_size, since fixlen has no compile-time element width. */
@@ -511,7 +527,7 @@ ca_mv_alloc_strides_contiguous (CArray *ca, ssize_t *shape, bool row_major)
 
 typedef struct {
   int          depth;        /* 0 = the view itself, 1 = parent, 2 = grand-, ... */
-  const char  *class_name;   /* class name of the offending link */
+  VALUE        klass;        /* class of the offending link (nil: unknown) */
   const char  *reason;       /* short explanation */
   int          face;         /* refused because it is a Face: a copy is
                                 refused too, so no copy is suggested */
@@ -528,11 +544,10 @@ ca_mv_is_castride_family (CArray *ca)
   return ca_func[ca->obj_type].attach == ca_stride_func.attach;
 }
 
-static const char *
-ca_mv_class_name_of (CArray *ca)
+static VALUE
+ca_mv_class_of (CArray *ca)
 {
-  VALUE klass = ca_class[ca->obj_type];
-  return NIL_P(klass) ? "(unknown)" : rb_class2name(klass);
+  return ca_class[ca->obj_type];
 }
 
 static const char *
@@ -597,7 +612,7 @@ ca_mv_compose_to_entity (CArray *ca, ca_mv_reject_t *rej,
   if (ca_is_face(ca)) {
     if (! ca_face_memory_view_exportable(ca)) {
       rej->depth = 0;
-      rej->class_name = ca_mv_class_name_of(ca);
+      rej->klass = ca_mv_class_of(ca);
       rej->reason = "a Face whose storage bytes do not carry its values "
                     "without the Face; export its storage instead "
                     "(e.g. .ticks, .codes)";
@@ -609,7 +624,7 @@ ca_mv_compose_to_entity (CArray *ca, ca_mv_reject_t *rej,
   if (ca_is_entity(ca)) {
     if (! ca_mv_is_core_entity(ca)) {
       rej->depth = 0;
-      rej->class_name = ca_mv_class_name_of(ca);
+      rej->klass = ca_mv_class_of(ca);
       rej->reason = "installed outside the core; its bytes are not "
                     "exported";
       return false;
@@ -620,7 +635,7 @@ ca_mv_compose_to_entity (CArray *ca, ca_mv_reject_t *rej,
   }
   if (!ca_mv_is_castride_family(ca)) {
     rej->depth = 0;
-    rej->class_name = ca_mv_class_name_of(ca);
+    rej->klass = ca_mv_class_of(ca);
     rej->reason = ca_mv_reject_reason_for(ca);
     return false;
   }
@@ -628,7 +643,7 @@ ca_mv_compose_to_entity (CArray *ca, ca_mv_reject_t *rej,
   ca_stride_compose_to_root((CAStride *) ca, &root, out_strides, out_base);
   if (!ca_is_entity(root)) {
     rej->depth = -1;
-    rej->class_name = ca_mv_class_name_of(root);
+    rej->klass = ca_mv_class_of(root);
     if (ca_mv_is_castride_family(root)) {
       rej->reason = "CAStride chain stride pattern does not compose "
                     "linearly into entity (e.g. reshape across non-contig)";
@@ -639,7 +654,7 @@ ca_mv_compose_to_entity (CArray *ca, ca_mv_reject_t *rej,
   }
   if (! ca_mv_is_core_entity(root)) {
     rej->depth = -1;
-    rej->class_name = ca_mv_class_name_of(root);
+    rej->klass = ca_mv_class_of(root);
     rej->reason = "installed outside the core; its bytes are not exported";
     return false;
   }
@@ -704,7 +719,7 @@ ca_mv_fixlen_format (ca_size_t bytes)
 {
   st_data_t found;
   char     *fmt;
-  rb_nativethread_lock_lock(&ca_mv_fixlen_formats_lock);
+  ca_native_lock_without_gvl(&ca_mv_fixlen_formats_lock);
   if ( st_lookup(ca_mv_fixlen_formats, (st_data_t) bytes, &found) ) {
     rb_nativethread_lock_unlock(&ca_mv_fixlen_formats_lock);
     return (const char *) found;
@@ -712,7 +727,8 @@ ca_mv_fixlen_format (ca_size_t bytes)
   rb_nativethread_lock_unlock(&ca_mv_fixlen_formats_lock);
   fmt = ALLOC_N(char, 24);
   snprintf(fmt, 24, "%llds", (long long) bytes);
-  rb_nativethread_lock_lock(&ca_mv_fixlen_formats_lock);
+  /* lock: st_insert can run a GC, which does not take this lock */
+  ca_native_lock_without_gvl(&ca_mv_fixlen_formats_lock);
   if ( st_lookup(ca_mv_fixlen_formats, (st_data_t) bytes, &found) ) {
     xfree(fmt);
     fmt = (char *) found;
@@ -1171,6 +1187,9 @@ ca_mv_holder_take_data (ca_mv_imported_holder_t *h, VALUE src,
   }
 
   data_type = ca_mv_data_type_from_format(v->format, v->item_size);
+  if ( data_type < 0 && ca_mv_format_is_struct(v->format, v->item_size) ) {
+    data_type = CA_FIXLEN;
+  }
   if ( data_type < 0 ) {
     rb_raise(rb_eArgError, "unsupported MemoryView format: %s (item_size=%ld)",
              v->format, (long) v->item_size);
@@ -1344,10 +1363,10 @@ ca_mv_wrap_body (VALUE arg)
      for a class would get something that is not it. */
   if ( a->target_class != rb_cCAWrap && ! d->contiguous ) {
     rb_raise(rb_eArgError,
-             "%s was requested, but this producer is strided, so the result "
+             "%"PRIsVALUE" was requested, but this producer is strided, so the result "
              "would be a CAStride; pass a row-major contiguous producer, or "
              "use CArray.from_memory_view for a copy",
-             rb_class2name(a->target_class));
+             a->target_class);
   }
 
   if ( m != NULL ) {
@@ -1503,8 +1522,8 @@ rb_ca_s_wrap_memory_view (int argc, VALUE *argv, VALUE klass)
   target_class = ( klass == rb_cCArray ) ? rb_cCAWrap : klass;
   if ( ! RTEST(rb_class_inherited_p(target_class, rb_cCAWrap)) ) {
     rb_raise(rb_eTypeError,
-             "wrap_memory_view builds a CAWrap; %s is not a subclass of it",
-             rb_class2name(target_class));
+             "wrap_memory_view builds a CAWrap; %"PRIsVALUE" is not a subclass of it",
+             target_class);
   }
   return ca_mv_wrap(obj, mask_obj, target_class, explicit_data_type, -1, 0);
 }
@@ -1585,8 +1604,8 @@ rb_ca_s_from_memory_view (int argc, VALUE *argv, VALUE klass)
   if ( klass != rb_cCArray &&
        ! RTEST(rb_class_inherited_p(klass, rb_cCAWrap)) ) {
     rb_raise(rb_eTypeError,
-             "from_memory_view builds a CArray; %s cannot be returned from it",
-             rb_class2name(klass));
+             "from_memory_view builds a CArray; %"PRIsVALUE" cannot be returned from it",
+             klass);
   }
   ca_mv_import_args_init(&a, obj, mask_obj);
   a.explicit_data_type = explicit_data_type;
@@ -1642,12 +1661,12 @@ rb_ca_s_memory_view_reject_reason (VALUE klass, VALUE obj)
     else if (rej.depth == 1) where = "parent";
     else                     where = NULL;   /* ancestor[N] */
     if (where) {
-      return rb_sprintf("%s is %s (%s); zero-copy wrap not possible.%s",
-                        where, rej.class_name, rej.reason,
+      return rb_sprintf("%s is %"PRIsVALUE" (%s); zero-copy wrap not possible.%s",
+                        where, NIL_P(rej.klass) ? rb_str_new_cstr("(unknown)") : rej.klass, rej.reason,
                         rej.face ? "" : " Export arr.copy for a snapshot.");
     } else {
-      return rb_sprintf("ancestor[%d] is %s (%s); zero-copy wrap not possible.%s",
-                        rej.depth - 1, rej.class_name, rej.reason,
+      return rb_sprintf("ancestor[%d] is %"PRIsVALUE" (%s); zero-copy wrap not possible.%s",
+                        rej.depth - 1, NIL_P(rej.klass) ? rb_str_new_cstr("(unknown)") : rej.klass, rej.reason,
                         rej.face ? "" : " Export arr.copy for a snapshot.");
     }
   }

data/ext/carray_operator.c

@@ -1272,7 +1272,7 @@ VALUE
 rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
                                          ca_binop_func_t func[])
 {
-  volatile VALUE out;
+  volatile VALUE out, receiver;
   CArray *ca1, *ca2, *ca3; /* ca3 = ca1.op(ca2) */
   int self_is_scalar, other_is_scalar;
   ca_size_t n_kernel;
@@ -1282,12 +1282,43 @@ rb_ca_call_binop (volatile VALUE self, volatile VALUE other,
   ca_binop_read_boolean_as_truth(func[CA_BOOLEAN] != ca_binop_not_implement,
                                  &self, &other);
 
+  receiver = rb_obj_is_carray(other) ? Qnil : self;
+
+  /* pmax and its kin pick by order, so a value the array can not hold is
+     refused as an ordering refuses it. */
+  if ( ! rb_obj_is_carray(other) && rb_obj_is_carray(self) &&
+       ca_binop_picks_by_order(ca_binop_op_id_of_table(func)) ) {
+    CArray *cs;
+    GetCArray(self, cs);
+    /* a boolean array picks as its 0 / 1 int64 numbers */
+    if ( func[cs->data_type == CA_BOOLEAN ? CA_INT64 : cs->data_type]
+         != ca_binop_not_implement ) {
+      ca_refuse_foreign_order(other, self);
+    }
+    else {
+      /* an array the op is not defined for says so, whatever the operand */
+      ca_op_refuse_unimplemented(self, cs->data_type, rb_eCADataTypeError);
+    }
+  }
+
   /* do implicit casting */
   rb_ca_cast_self_or_other(&self, &other);
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca1);
   TypedData_Get_Struct(other, CArray, &carray_data_type, ca2);
 
+  /* A Face whose cells are not Ruby values does not go down to an object
+     array to meet a single Ruby object: an operator it does not define for
+     an array of its own stays undefined. */
+  if ( ca1->data_type == CA_OBJECT && rb_obj_is_carray(receiver) ) {
+    CArray *ca0;
+    TypedData_Get_Struct(receiver, CArray, &carray_data_type, ca0);
+    if ( ca_is_face(ca0) && ca0->data_type == CA_FIXLEN ) {
+      ca_op_refuse_unimplemented(receiver, ca0->data_type,
+                                 rb_eCADataTypeError);
+    }
+  }
+
   /* Boolean-as-numeric promotion: an arithmetic op (+ - * / % ** ...) has
      no boolean kernel, so its func[CA_BOOLEAN] slot is ca_binop_not_implement.
      When both operands promoted to CA_BOOLEAN (= bool op bool), coerce them
@@ -1853,16 +1884,8 @@ rb_ca_call_triop (VALUE self, VALUE other2, VALUE other3,
   volatile VALUE out;
   CArray *ca1, *ca2, *ca3, *cao;
 
-  /* Pairwise data_type promotion: ((self, other2) -> common), then
-     ((self', other3) -> common).  Mirrors how the binop driver normalises
-     two operands; for triop we apply it twice.  After this, all three
-     CArrays share the same data_type (and unbound-repeats are resolved). */
-  rb_ca_cast_self_or_other(&self, &other2);
-  rb_ca_cast_self_or_other(&self, &other3);
-  rb_ca_cast_self_or_other(&other2, &other3);
-  /* one more pass to re-normalise self vs other2 in case the
-     other2/other3 cast widened other2 above self's data_type  */
-  rb_ca_cast_self_or_other(&self, &other2);
+  /* After this, all three CArrays share the same data_type. */
+  rb_ca_cast_three(&self, &other2, &other3);
 
   TypedData_Get_Struct(self,   CArray, &carray_data_type, ca1);
   TypedData_Get_Struct(other2, CArray, &carray_data_type, ca2);
@@ -2426,6 +2449,23 @@ ca_bincmp_mixed_sign (VALUE self, VALUE other, ca_bincmp_func_t func[],
   return out;
 }
 
+/* The answer of eq (ne = 0) or ne (ne = 1) when no cell can match: false
+   (true for ne) in every cell, masked where `self` is masked. */
+VALUE
+ca_bincmp_no_match (VALUE self, int ne)
+{
+  volatile VALUE out;
+  CArray *ca, *co;
+  GetCArray(self, ca);
+  out = RTEST(rb_obj_is_cscalar(self))
+      ? rb_cscalar_new(CA_BOOLEAN, 0, NULL)
+      : rb_carray_new(CA_BOOLEAN, ca->ndim, ca->dim, 0, NULL);
+  TypedData_Get_Struct(out, CArray, &carray_data_type, co);
+  ca_mask_overlay_safe(co, 1, ca);
+  memset(co->ptr, ne ? 1 : 0, co->elements * co->bytes);
+  return out;
+}
+
 VALUE
 rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
                                     ca_bincmp_func_t func[],
@@ -2447,6 +2487,27 @@ rb_ca_call_bincmp (volatile VALUE self, volatile VALUE other,
     }
   }
 
+  /* eq and ne with a value the array can not hold (nil, a String): no cell
+     matches. */
+  if ( (ca_bincmp_func_t) func == (ca_bincmp_func_t) ca_bincmp_eq
+       || (ca_bincmp_func_t) func == (ca_bincmp_func_t) ca_bincmp_ne ) {
+    TypedData_Get_Struct(self, CArray, &carray_data_type, ca1);
+    if ( ca_query_matches_nothing(ca1, other) ) {
+      return ca_bincmp_no_match(self,
+               (ca_bincmp_func_t) func == (ca_bincmp_func_t) ca_bincmp_ne);
+    }
+  }
+
+  /* An ordering with a value the array can not hold is refused as Float#<
+     refuses it.  An array that has no ordering at all (complex) keeps its
+     own refusal below. */
+  if ( ! rb_obj_is_carray(other) && ca_bincmp_op_id_of(func) <= CA_BINCMP_GE ) {
+    TypedData_Get_Struct(self, CArray, &carray_data_type, ca1);
+    if ( func[ca1->data_type] != ca_bincmp_not_implement ) {
+      ca_refuse_foreign_order(other, self);
+    }
+  }
+
   /* Face gate: an ORDERABLE Face over numeric storage descends to storage
      (fixing the surface-fixlen memcmp mis-order) and reconciles a Face RHS
      via to_comparable (e.g. unit alignment).  No-op for non-Face self and