carray 3.0.1 → 3.0.2

data/ext/carray_cast.c

@@ -552,6 +552,77 @@ rb_ca_object_to_data_class (VALUE self, VALUE rtype, ca_size_t bytes)
   return obj;
 }
 
+typedef struct {
+  CArray     *ca;
+  CArray     *cb;
+  boolean8_t *scratch;
+} ca_to_type_ctx_t;
+
+/* The cast proper, with `ca` attached.  It can raise (a value the target
+   type cannot hold), so it runs under rb_ensure. */
+static VALUE
+ca_to_type_cast (VALUE arg)
+{
+  ca_to_type_ctx_t *c = (ca_to_type_ctx_t *) arg;
+  CArray *ca = c->ca, *cb = c->cb;
+
+  if ( ca->data_type == CA_OBJECT
+       && ( (cb->data_type >= CA_INT8 && cb->data_type <= CA_UINT64)
+            || cb->data_type == CA_FLOAT32 || cb->data_type == CA_FLOAT64 ) ) {
+    /* object -> int/float: give the cast a mask buffer so an unparseable
+       cell becomes UNDEF (see ext/carray_cast_func.rb).  Cast into a
+       scratch mask seeded from the source mask, then attach it to the
+       output only if some cell ended up masked -- an all-valid cast keeps
+       the mask-less result the legacy path produced. */
+    ca_size_t ne = cb->elements;
+    ca_size_t i;
+    boolean8_t any = 0;
+    boolean8_t *scratch;
+    c->scratch = scratch = ALLOC_N(boolean8_t, ne > 0 ? ne : 1);
+    if ( cb->mask ) {
+      memcpy(scratch, cb->mask->ptr, ne);   /* copy of source mask */
+    }
+    else {
+      memset(scratch, 0, ne);
+    }
+    ca_cast_block_with_mask(ne, ca, ca->ptr, cb, cb->ptr, scratch);
+    for (i=0; i<ne; i++) {
+      if ( scratch[i] ) {
+        any = 1;
+        break;
+      }
+    }
+    if ( any ) {
+      if ( ! cb->mask ) {
+        ca_create_mask(cb);
+      }
+      memcpy(cb->mask->ptr, scratch, ne);
+    }
+    xfree(scratch);
+    c->scratch = NULL;
+  }
+  else if ( ca_has_mask(ca) ) {
+    ca_cast_block_with_mask(cb->elements, ca, ca->ptr, cb, cb->ptr,
+                            (boolean8_t*)ca->mask->ptr);
+  }
+  else {
+    ca_cast_block(cb->elements, ca, ca->ptr, cb, cb->ptr);
+  }
+  return Qnil;
+}
+
+static VALUE
+ca_to_type_release (VALUE arg)
+{
+  ca_to_type_ctx_t *c = (ca_to_type_ctx_t *) arg;
+  if ( c->scratch ) {
+    xfree(c->scratch);
+    c->scratch = NULL;
+  }
+  ca_detach(c->ca);
+  return Qnil;
+}
+
 /* CArray#to_type(data_type, bytes:) -- eager copy of self converted to
    data_type (a new entity owning its storage).  User doc lives in
    yard-stubs/carray_cast.rb. */
@@ -561,6 +632,7 @@ rb_ca_to_type_internal (int argc, VALUE *argv, VALUE self)
 {
   volatile VALUE obj, rtype = Qnil, ropt, rbytes = Qnil;
   CArray *ca, *cb;
+  ca_to_type_ctx_t ctx;
   int8_t data_type;
   ca_size_t bytes;
 
@@ -601,48 +673,11 @@ rb_ca_to_type_internal (int argc, VALUE *argv, VALUE self)
 
   TypedData_Get_Struct(obj, CArray, &carray_data_type, cb);
 
+  ctx.ca      = ca;
+  ctx.cb      = cb;
+  ctx.scratch = NULL;
   ca_attach(ca);
-  if ( ca->data_type == CA_OBJECT
-       && ( (data_type >= CA_INT8 && data_type <= CA_UINT64)
-            || data_type == CA_FLOAT32 || data_type == CA_FLOAT64 ) ) {
-    /* object -> int/float: give the cast a mask buffer so an unparseable
-       cell becomes UNDEF (see ext/carray_cast_func.rb).  Cast into a
-       scratch mask seeded from the source mask, then attach it to the
-       output only if some cell ended up masked -- an all-valid cast keeps
-       the mask-less result the legacy path produced. */
-    ca_size_t ne = cb->elements;
-    ca_size_t i;
-    boolean8_t any = 0;
-    boolean8_t *scratch = ALLOC_N(boolean8_t, ne > 0 ? ne : 1);
-    if ( cb->mask ) {
-      memcpy(scratch, cb->mask->ptr, ne);   /* copy of source mask */
-    }
-    else {
-      memset(scratch, 0, ne);
-    }
-    ca_cast_block_with_mask(ne, ca, ca->ptr, cb, cb->ptr, scratch);
-    for (i=0; i<ne; i++) {
-      if ( scratch[i] ) {
-        any = 1;
-        break;
-      }
-    }
-    if ( any ) {
-      if ( ! cb->mask ) {
-        ca_create_mask(cb);
-      }
-      memcpy(cb->mask->ptr, scratch, ne);
-    }
-    xfree(scratch);
-  }
-  else if ( ca_has_mask(ca) ) {
-    ca_cast_block_with_mask(cb->elements, ca, ca->ptr, cb, cb->ptr,
-                            (boolean8_t*)ca->mask->ptr);
-  }
-  else {
-    ca_cast_block(cb->elements, ca, ca->ptr, cb, cb->ptr);
-  }
-  ca_detach(ca);
+  rb_ensure(ca_to_type_cast, (VALUE) &ctx, ca_to_type_release, (VALUE) &ctx);
 
   /* When rtype is a data_class (e.g. CAStruct subclass), wrap the
      result in CARecord so the cast output carries data_class. */
@@ -1366,6 +1401,36 @@ rb_ca_cast (volatile VALUE self)
   return obj;
 }
 
+/* A String operand against a fixlen array is a value of that array's cell
+   width.  ca_value_to_data_type answers CA_OBJECT for a String, so without
+   this the operand became an object scalar and the comparison ran down the
+   object lane -- an rb_funcall of String#== per cell, against the cell's
+   NUL-padded text.  A fixlen array pads a short String on write
+   (`a[i] = "be"` stores "be\0\0\0"), so that answered that an array does
+   not equal the string it was written from, and did it 30x slower than the
+   memcmp lane the fixlen comparison bodies are there to provide.
+
+   Two fixlen *arrays* of different widths keep the variable-width byte
+   string semantics those bodies implement (min-width memcmp with a length
+   tiebreak); this is only about a scalar standing in for a cell. */
+static int
+ca_fixlen_scalar_operand (volatile VALUE *scalar, VALUE reference)
+{
+  CArray *cr;
+  /* A String is the only operand that means a cell value here.  A Regexp
+     (match) or any other object keeps its own coercion: those are asking
+     something about the bytes, not standing in for them. */
+  if ( ! RB_TYPE_P(*scalar, T_STRING) || ! rb_obj_is_carray(reference) ) {
+    return 0;
+  }
+  TypedData_Get_Struct(reference, CArray, &carray_data_type, cr);
+  if ( cr->data_type != CA_FIXLEN ) {
+    return 0;
+  }
+  *scalar = rb_cscalar_new_with_value(CA_FIXLEN, cr->bytes, *scalar);
+  return 1;
+}
+
 /* CArray.cast(value) -- singleton entry delegating to rb_ca_cast, which
    returns a CArray unchanged and coerces a Ruby value to a CScalar / CArray.
    User doc lives in yard-stubs/carray_cast.rb. */
@@ -1409,6 +1474,9 @@ rb_ca_cast_self_or_other (volatile VALUE *self, volatile VALUE *other)
       *self = rb_cscalar_new_with_value(CA_CMPLX128, 0, *self);
     }
 #endif
+    else if ( ca_fixlen_scalar_operand(self, *other) ) {
+      /* width taken from the fixlen reference; see the helper above */
+    }
     else if ( rb_ca_is_float_type(*other) ) {
       *self = rb_cscalar_new_with_value(CA_FLOAT64, 0, *self);
     }
@@ -1437,6 +1505,9 @@ rb_ca_cast_self_or_other (volatile VALUE *self, volatile VALUE *other)
       *other = rb_cscalar_new_with_value(CA_CMPLX128, 0, *other);
     }
 #endif
+    else if ( ca_fixlen_scalar_operand(other, *self) ) {
+      /* width taken from the fixlen reference; see the helper above */
+    }
     else if ( rb_ca_is_float_type(*self) ) {
       *other = rb_cscalar_new_with_value(CA_FLOAT64, 0, *other);
     }
@@ -1824,6 +1895,9 @@ rb_ca_cast_other (VALUE *self, volatile VALUE *other)
     if ( rb_ca_is_object_type(*self) ) {
       *other = rb_cscalar_new_with_value(CA_OBJECT, 0, *other);
     }
+    else if ( ca_fixlen_scalar_operand(other, *self) ) {
+      return;   /* already the receiver's data_type and width */
+    }
     else if ( rb_ca_is_float_type(*self) ) {
       *other = rb_cscalar_new_with_value(CA_FLOAT64, 0, *other);
     }

data/ext/carray_copy.c

@@ -11,6 +11,7 @@
 #include "carray.h"
 #include "ca_obj_face.h"   /* CA_FACE_LIFT_IF_FACE */
 #include "carray_internal.h"   /* ca_gc_hold_push / ca_gc_hold_pop_to */
+#include "ca_sweep_engine.h"   /* ca_sweep_same_shape / ca_sweep_refuse_shapes */
 #include <stdarg.h>
 
 /* ------------------------------------------------------------------- */
@@ -19,22 +20,27 @@
  * and bytes as `ca`, copies the element payload, and reproduces the
  * mask state.  Always copies even when `ca` is an entity; for view
  * sources the data path goes through `ca_copy_data`, otherwise a flat
- * memcpy of `ca_length(ca)` bytes.
+ * memcpy of `ca_length(ca)` bytes.  If reading the source raises, the
+ * copy is freed before the raise propagates.
  *
  * Backs `CArray#copy` and is also reachable as a C-level utility from
  * other ext files that need an owned snapshot. */
-CArray *
-ca_copy (void *ap)
+void
+ca_fill_or_free (CArray *co, VALUE (*fill)(VALUE), VALUE arg)
 {
-  CArray *ca = (CArray *) ap;
-  CArray *co;
-
-  if ( ca_is_scalar(ca) ) {
-    co = (CArray *) cscalar_new(ca->data_type, ca->bytes, 0);
-  }
-  else {
-    co = carray_new(ca->data_type, ca->ndim, ca->dim, ca->bytes, 0);
+  int tag = 0;
+  rb_protect(fill, arg, &tag);
+  if ( tag ) {
+    ca_free(co);
+    rb_jump_tag(tag);
   }
+}
+
+static VALUE
+ca_copy_fill (VALUE arg)
+{
+  CArray **pair = (CArray **) arg;
+  CArray *ca = pair[0], *co = pair[1];
 
   if ( ca_is_attached(ca) ) {
     memcpy(co->ptr, ca->ptr, ca_length(ca));
@@ -47,6 +53,26 @@ ca_copy (void *ap)
   if ( ca->mask ) {
     ca_copy_mask(co, ca);
   }
+  return Qnil;
+}
+
+CArray *
+ca_copy (void *ap)
+{
+  CArray *ca = (CArray *) ap;
+  CArray *co;
+  CArray *pair[2];
+
+  if ( ca_is_scalar(ca) ) {
+    co = (CArray *) cscalar_new(ca->data_type, ca->bytes, 0);
+  }
+  else {
+    co = carray_new(ca->data_type, ca->ndim, ca->dim, ca->bytes, 0);
+  }
+
+  pair[0] = ca;
+  pair[1] = co;
+  ca_fill_or_free(co, ca_copy_fill, (VALUE) pair);
 
   return co;
 }
@@ -272,16 +298,16 @@ rb_ca_template_with_type (VALUE self, VALUE rtype, VALUE rbytes)
   return rb_ca_template_method(2, args, self);
 }
 
-/* Picks the largest-shape CArray among `n` variadic CArray arguments
- * and returns `template(largest)`.  Used by `carray_call_cfunc.c` to
- * size the output of vectorised scalar C-function calls, where the
- * inputs may be a mix of scalars and arrays. */
+/* Returns `template` of the first non-scalar among `n` variadic CArray
+ * arguments (of the first argument when all are scalars).  Used by
+ * `carray_call_cfunc.c` to size the output of vectorised scalar
+ * C-function calls: a scalar pairs with any array, two arrays only when
+ * their shapes agree. */
 VALUE
 rb_ca_template_n (int n, ...)
 {
-  volatile VALUE varg, obj;
-  CArray *ca;
-  ca_size_t elements = -1;
+  volatile VALUE varg, obj = Qnil;
+  CArray *ca, *donor = NULL;
   va_list vargs;
   int i;
 
@@ -289,24 +315,23 @@ rb_ca_template_n (int n, ...)
   for (i=0; i<n; i++) {
     varg = va_arg(vargs, VALUE);
     if ( ! rb_obj_is_carray(varg) ) {
+      va_end(vargs);
       rb_raise(rb_eRuntimeError, "[BUG] not-carray object given to rb_ca_template_n");
     }
     TypedData_Get_Struct(varg, CArray, &carray_data_type, ca);
     if ( i == 0 ) {
       obj = varg;
-      elements = ca->elements;
     }
-    else {
-      if ( rb_obj_is_cscalar(varg) ) {
-        continue;
-      }
-      if ( rb_obj_is_cscalar(obj) ) {
-        obj = varg;
-        elements = ca->elements;
-      }
-      else if ( ca->elements != elements ) {
-        rb_raise(rb_eRuntimeError, "size mismatch");
-      }
+    if ( ca_is_scalar(ca) ) {
+      continue;
+    }
+    if ( ! donor ) {
+      donor = ca;
+      obj   = varg;
+    }
+    else if ( ! ca_sweep_same_shape(donor, ca) ) {
+      va_end(vargs);
+      ca_sweep_refuse_shapes(donor, ca);
     }
   }
   va_end(vargs);

data/ext/carray_core.c

@@ -1655,6 +1655,18 @@ ca_allocate (void *ap)
   ca_allocate(ca->mask);
 }
 
+/* The first attach of a view: materialise through the type's slot, then
+   its mask.  Run under rb_protect by ca_attach. */
+static VALUE
+ca_attach_view_first (VALUE arg)
+{
+  CArray *ca = (CArray *) arg;
+  ca_func[ca->obj_type].attach(ca);
+  ca_update_mask(ca);
+  ca_attach(ca->mask);
+  return Qnil;
+}
+
 /* attach parent's data to ca->ptr */
 
 void
@@ -1668,14 +1680,30 @@ ca_attach (void *ap)
 
   if ( ca_is_view(ca) ) {  /* view array */
 
-    CAVIEW(ca)->attach += 1; /* increments attach level */
-    if ( CAVIEW(ca)->attach > CA_ATTACH_MAX ) {
+    if ( CAVIEW(ca)->attach >= CA_ATTACH_MAX ) {
       rb_raise(rb_eRuntimeError,
                "too large attach count of view array");
     }
+    CAVIEW(ca)->attach += 1; /* increments attach level */
 
     if ( ! ca->ptr ) {
-      ca_func[ca->obj_type].attach(ap);
+      /* A slot can raise part way (a conversion meeting a value it cannot
+         hold).  Undo the attach then, or the next attach finds ca->ptr
+         set, skips the slot and reads a half-filled buffer.  A slot that
+         got as far as publishing ca->ptr has also attached what its
+         detach slot releases; one that raised earlier has published
+         nothing and released its own parent attach on the way out. */
+      int tag = 0;
+      rb_protect(ca_attach_view_first, (VALUE) ca, &tag);
+      if ( tag ) {
+        if ( ca->ptr ) {
+          ca_func[ca->obj_type].detach(ca);
+          ca->ptr = NULL;
+        }
+        CAVIEW(ca)->attach -= 1;
+        rb_jump_tag(tag);
+      }
+      return;
     }
   }
   else {                      /* entity array */
@@ -1686,6 +1714,43 @@ ca_attach (void *ap)
   ca_attach(ca->mask);
 }
 
+/* Attach every array in list[0..n-1], or, if one of those attaches
+   raises, none of them: the ones already attached are detached before the
+   raise propagates.  For views over several parents. */
+
+typedef struct {
+  CArray **list;
+  int32_t  n;
+  int32_t  done;
+} ca_attach_all_ctx_t;
+
+static VALUE
+ca_attach_all_body (VALUE arg)
+{
+  ca_attach_all_ctx_t *c = (ca_attach_all_ctx_t *) arg;
+  for ( ; c->done < c->n; c->done++ ) {
+    ca_attach(c->list[c->done]);
+  }
+  return Qnil;
+}
+
+void
+ca_attach_all (CArray **list, int32_t n)
+{
+  ca_attach_all_ctx_t c;
+  int tag = 0;
+  c.list = list;
+  c.n    = n;
+  c.done = 0;
+  rb_protect(ca_attach_all_body, (VALUE) &c, &tag);
+  if ( tag ) {
+    while ( c.done > 0 ) {
+      ca_detach(list[--c.done]);
+    }
+    rb_jump_tag(tag);
+  }
+}
+
 /* attach parent's data to ca->ptr */
 
 void
@@ -2087,6 +2152,17 @@ ca_fill (void *ap, void *aptr)
 
 /* ------------------------------------------------------------------- */
 
+#ifdef CARRAY_DEV_BUILD
+
+/* The Ruby attach surface is built into development builds only.  Ruby has no
+   raw pointer, so the only thing a block can do inside an attach window is call
+   back into the array API -- and which door that takes is invisible in the
+   syntax: v[0] reads the attached buffer while v[] and v[0..1] compose past it
+   to the root (R5, see the contract beside ca_attach in carray.h).  Per-cell and
+   whole-array writes reach the buffer and survive the sync; a write through a
+   derived view is discarded.  The in-tree tests drive the healthy spellings, so
+   the surface stays reachable here and out of released builds. */
+
 /* subroutines for CArray.attach, CArray.attach!
                    CArray#attach, CArray#attach! */
 
@@ -2307,6 +2383,8 @@ rb_ca__detach__ (VALUE self)
   return self;
 }
 
+#endif /* CARRAY_DEV_BUILD */
+
 /* ------------------------------------------------------------------- */
 
 static ID id_decode, id_encode;
@@ -2515,6 +2593,7 @@ Init_carray_core (void)
 
   ca_init_obj_type();
 
+#ifdef CARRAY_DEV_BUILD
   rb_define_singleton_method(rb_cCArray, "attach", rb_ca_s_attach, -1);
   rb_define_singleton_method(rb_cCArray, "attach!", rb_ca_s_attach_bang, -1);
 
@@ -2524,6 +2603,7 @@ Init_carray_core (void)
   rb_define_method(rb_cCArray, "__attach__", rb_ca__attach__, 0);
   rb_define_method(rb_cCArray, "__sync__", rb_ca__sync__, 0);
   rb_define_method(rb_cCArray, "__detach__", rb_ca__detach__, 0);
+#endif
 
   rb_define_method(rb_cCArray, "members", rb_ca_members, 0);
 

data/ext/carray_count.c

@@ -39,11 +39,12 @@ VALUE rb_ca_count_not_masked (int argc, VALUE *argv, VALUE self);
      - v is a CArray             -> broadcast: count each v[k] and stack
                                     (rejected for boolean self; see below)
      - self is boolean, v scalar -> v must be true/false literal
-     - self is numeric, v scalar -> count_equal_ki (numeric equality)
+     - self is numeric or object, v scalar -> count_equal_ki (numeric ==
+                                    for a number, Ruby == for an object)
 
-   FIXLEN and OBJECT data_types raise CArray::DataTypeError (the
-   kernel-iterator helpers do not implement them).  Extend
-   count_equal_ki if demand returns. */
+     - self is fixlen, v scalar -> count_equal_ki (memcmp over the whole
+                                    cell; a short String query is padded
+                                    out to the cell width) */
 
 static VALUE
 rb_ca_count (int argc, VALUE *argv, VALUE self)
@@ -95,11 +96,7 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
     }
     if ( ca_test_flag(src, CA_FLAG_FACE_COMPARABLE_STORAGE) ) {
       if ( ! query_was_scalar ) {
-        CArray *cv;
-        GetCArray(rval, cv);
-        if ( ca_is_face(cv) ) {
-          rval = rb_ca_strip_face_value(rval);
-        }
+        rval = ca_face_operand_descend(rval, "count(v)");
       }
     }
     else if ( rb_respond_to(self_ref, rb_intern("to_comparable")) ) {
@@ -290,7 +287,9 @@ rb_ca_count (int argc, VALUE *argv, VALUE self)
                rb_obj_classname(rval));
     }
   } else {
-    if ( rval == Qtrue || rval == Qfalse ) {
+    /* true / false are the boolean array's own domain, not a number --
+       except in an object array, where they are ordinary stored values. */
+    if ( ( rval == Qtrue || rval == Qfalse ) && src->data_type != CA_OBJECT ) {
       rb_raise(rb_eTypeError,
                "count(v) on numeric array: v must be numeric, got %s",
                rb_obj_classname(rval));

data/ext/carray_factorize.c

@@ -105,13 +105,27 @@
 /* Descend `self` when it is an ORDERABLE Face; *pface keeps the pre-strip Face
    for the re-lift (Qnil when there is nothing to put back). */
 static VALUE
-fz_face_descend (VALUE self, volatile VALUE *pface)
+fz_face_descend (VALUE self, volatile VALUE *pface, const char *name)
 {
   CArray *ca;
   GetCArray(self, ca);
-  if ( ca_is_face(ca) && ca_test_flag(ca, CA_FLAG_FACE_ORDERABLE_STORAGE) ) {
-    *pface = self;
-    return rb_ca_strip_face_value(self);
+  if ( ca_is_face(ca) ) {
+    if ( ca_test_flag(ca, CA_FLAG_FACE_ORDERABLE_STORAGE) ) {
+      *pface = self;
+      return rb_ca_strip_face_value(self);
+    }
+    /* A Face that cannot be descended must not flow on undescended: whatever
+       reads it next reads its storage anyway, which is the encoding rather
+       than the values.  A Face in this position normally never arrives --
+       CAConstString and CACategorical define their own members in Ruby -- but
+       the overrides only fire when the Face is the receiver, and this same
+       helper descends the *reference* for locate_addr, where it is the
+       argument. */
+    rb_raise(rb_eArgError,
+             "%s: %s is not orderable by storage (a cell encodes the value "
+             "rather than being it); convert it first -- #to_string for a "
+             "string Face -- or pass .parent to work in storage space",
+             name, rb_obj_classname(self));
   }
   *pface = Qnil;
   return self;
@@ -140,15 +154,7 @@ fz_face_reconcile (VALUE reference, VALUE operand, const char *name)
                                              rb_intern("to_comparable"),
                                              1, operand));
   }
-  if ( rb_obj_is_carray(operand) ) {
-    CArray *op;
-    GetCArray(operand, op);
-    if ( ca_is_face(op) ) {
-      return rb_ca_strip_face_value(operand);
-    }
-  }
-  (void) name;
-  return operand;
+  return ca_face_operand_descend(operand, name);
 }
 
 /* Put the Face back on a value-carrying output. */
@@ -495,7 +501,7 @@ rb_ca_factorize_appearance (VALUE self)
 {
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face);
+  self = fz_face_descend(self, &face, "categorize");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -863,7 +869,7 @@ rb_ca_unique_flat (VALUE self)
 {
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face);
+  self = fz_face_descend(self, &face, "unique");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -1113,7 +1119,7 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
 {
   CArray *ca, *cv;
   volatile VALUE face;
-  self     = fz_face_descend(self, &face);
+  self     = fz_face_descend(self, &face, "is_in");
   rvalues  = fz_face_reconcile(face, rvalues, "is_in");
   GetCArray(self, ca);
 
@@ -1137,9 +1143,16 @@ rb_ca_is_in (VALUE self, VALUE rvalues)
     rb_raise(rb_eArgError, "__is_in__: values must be a CArray");
   }
   GetCArray(rvalues, cv);
-  if ( cv->data_type != dt || (dt == CA_FIXLEN && cv->bytes != ca->bytes) ) {
+  if ( cv->data_type != dt ) {
+    rb_raise(rb_eCADataTypeError,
+             "__is_in__: values data type (%s) must match self (%s)",
+             ca_type_name[cv->data_type], ca_type_name[dt]);
+  }
+  if ( dt == CA_FIXLEN && cv->bytes != ca->bytes ) {
     rb_raise(rb_eCADataTypeError,
-             "__is_in__: values data type must match self (%d)", dt);
+             "__is_in__: a fixlen value is a cell-width blob, so the values "
+             "must be %ld bytes wide like self, not %ld",
+             (long) ca->bytes, (long) cv->bytes);
   }
   if ( cv->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "__is_in__: values need ndim >= 1");
@@ -1271,7 +1284,7 @@ rb_ca_locate_addr (VALUE self, VALUE rref)
      output is an address, so nothing is lifted back. */
   {
     volatile VALUE ref_face;
-    rref = fz_face_descend(rref, &ref_face);
+    rref = fz_face_descend(rref, &ref_face, "locate_addr");
     self = fz_face_reconcile(ref_face, self, "locate_addr");
   }
   GetCArray(self, ca);
@@ -1531,7 +1544,7 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
 {
   CArray *ca, *co;
   volatile VALUE face;
-  self   = fz_face_descend(self, &face);
+  self   = fz_face_descend(self, &face, "set relation");
   rother = fz_face_reconcile(face, rother, "set relation");
   GetCArray(self, ca);
 
@@ -1554,8 +1567,16 @@ fz_set_relation (VALUE self, VALUE rother, int keep_when_hit)
     rb_raise(rb_eArgError, "set relation: other must be a CArray");
   }
   GetCArray(rother, co);
-  if ( co->data_type != dt || (dt == CA_FIXLEN && co->bytes != ca->bytes) ) {
-    rb_raise(rb_eCADataTypeError, "set relation: other data type must match self (%d)", dt);
+  if ( co->data_type != dt ) {
+    rb_raise(rb_eCADataTypeError,
+             "set relation: other data type (%s) must match self (%s)",
+             ca_type_name[co->data_type], ca_type_name[dt]);
+  }
+  if ( dt == CA_FIXLEN && co->bytes != ca->bytes ) {
+    rb_raise(rb_eCADataTypeError,
+             "set relation: a fixlen value is a cell-width blob, so other "
+             "must be %ld bytes wide like self, not %ld",
+             (long) ca->bytes, (long) co->bytes);
   }
   if ( co->ndim < 1 ) {
     rb_raise(rb_eRuntimeError, "set relation: other need ndim >= 1");
@@ -1716,7 +1737,7 @@ rb_ca_set_union (VALUE self, VALUE rother)
 {
   CArray *ca, *co;
   volatile VALUE face;
-  self   = fz_face_descend(self, &face);
+  self   = fz_face_descend(self, &face, "union");
   rother = fz_face_reconcile(face, rother, "union");
   GetCArray(self, ca);
 
@@ -1793,7 +1814,7 @@ rb_ca_value_counts_flat (VALUE self)
 {
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face);
+  self = fz_face_descend(self, &face, "value_counts");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -2332,7 +2353,7 @@ rb_ca_mode_axis (VALUE self, VALUE vaxis)
 {
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face);
+  self = fz_face_descend(self, &face, "mode");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;