carray 3.0.0 → 3.0.2

data/ext/carray_call_cfunc.h

@@ -16,6 +16,18 @@
 #ifndef CARRAY_CALL_CFUNC_H
 #define CARRAY_CALL_CFUNC_H
 
+/* Chunk callback for the ca_call_cslab_N family.  `base` and `stride` are
+   one entry per operand, in the order the operands were passed; `n` is the
+   number of cells in this chunk; `m0` is the chunk's slice of the mask,
+   one byte per cell, or NULL when no INPUT carried a mask.  The arity does
+   not appear in the signature -- the operands arrive through `base` -- so
+   one typedef serves every arity. */
+typedef void (*ca_cslab_t) (char **base, ca_size_t *stride, ca_size_t n,
+                            const boolean8_t *m0);
+
+typedef void (*ca_cslab_r_t) (char **base, ca_size_t *stride, ca_size_t n,
+                              const boolean8_t *m0, void *userdata);
+
 VALUE
 ca_call_cfunc_1 (void (*func)(void *p0), const char *fsync,
                             VALUE rcx0);
@@ -157,4 +169,145 @@ ca_call_cfunc_3_2_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t
 VALUE
 ca_call_cfunc_3_3_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, int8_t dtx3, void (*mathfunc)(void*, void*, void*, void*, void*, void*, void *userdata), volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, void *userdata);
 
+VALUE
+ca_call_cslab_1 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0);
+
+VALUE
+ca_call_cslab_2 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1);
+
+VALUE
+ca_call_cslab_3 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2);
+
+VALUE
+ca_call_cslab_4 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3);
+
+VALUE
+ca_call_cslab_5 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4);
+
+VALUE
+ca_call_cslab_6 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5);
+
+VALUE
+ca_call_cslab_7 (ca_cslab_t func, const char *fsync,
+                             VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5, VALUE rcx6);
+
+VALUE
+ca_call_cslab_1_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_2_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_3_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_4_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_5_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_6_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_7_r (ca_cslab_r_t func, const char *fsync,
+                               VALUE rcx0, VALUE rcx1, VALUE rcx2, VALUE rcx3, VALUE rcx4, VALUE rcx5, VALUE rcx6,
+                               void *userdata);
+
+VALUE
+ca_call_cslab_1_1 (int8_t dty, int8_t dtx1, ca_cslab_t slabfunc, volatile VALUE rx1);
+
+VALUE
+ca_call_cslab_1_2 (int8_t dty, int8_t dtx1, int8_t dtx2, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2);
+
+VALUE
+ca_call_cslab_1_3 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3);
+
+VALUE
+ca_call_cslab_1_4 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4);
+
+VALUE
+ca_call_cslab_1_5 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5);
+
+VALUE
+ca_call_cslab_1_6 (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, int8_t dtx6, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5, volatile VALUE rx6);
+
+VALUE
+ca_call_cslab_2_1 (int8_t dty1, int8_t dty2, int8_t dtx1, ca_cslab_t slabfunc, volatile VALUE rx1);
+
+VALUE
+ca_call_cslab_2_2 (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2);
+
+VALUE
+ca_call_cslab_2_3 (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3);
+
+VALUE
+ca_call_cslab_2_4 (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4);
+
+VALUE
+ca_call_cslab_3_1 (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, ca_cslab_t slabfunc, volatile VALUE rx1);
+
+VALUE
+ca_call_cslab_3_2 (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2);
+
+VALUE
+ca_call_cslab_3_3 (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3);
+
+VALUE
+ca_call_cslab_1_1_r (int8_t dty, int8_t dtx1, ca_cslab_r_t slabfunc, volatile VALUE rx1, void *userdata);
+
+VALUE
+ca_call_cslab_1_2_r (int8_t dty, int8_t dtx1, int8_t dtx2, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, void *userdata);
+
+VALUE
+ca_call_cslab_1_3_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, void *userdata);
+
+VALUE
+ca_call_cslab_1_4_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, void *userdata);
+
+VALUE
+ca_call_cslab_1_5_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5, void *userdata);
+
+VALUE
+ca_call_cslab_1_6_r (int8_t dty, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, int8_t dtx5, int8_t dtx6, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, volatile VALUE rx5, volatile VALUE rx6, void *userdata);
+
+VALUE
+ca_call_cslab_2_1_r (int8_t dty1, int8_t dty2, int8_t dtx1, ca_cslab_r_t slabfunc, volatile VALUE rx1, void *userdata);
+
+VALUE
+ca_call_cslab_2_2_r (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, void *userdata);
+
+VALUE
+ca_call_cslab_2_3_r (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, void *userdata);
+
+VALUE
+ca_call_cslab_2_4_r (int8_t dty1, int8_t dty2, int8_t dtx1, int8_t dtx2, int8_t dtx3, int8_t dtx4, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, volatile VALUE rx4, void *userdata);
+
+VALUE
+ca_call_cslab_3_1_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, ca_cslab_r_t slabfunc, volatile VALUE rx1, void *userdata);
+
+VALUE
+ca_call_cslab_3_2_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, void *userdata);
+
+VALUE
+ca_call_cslab_3_3_r (int8_t dty1, int8_t dty2, int8_t dty3, int8_t dtx1, int8_t dtx2, int8_t dtx3, ca_cslab_r_t slabfunc, volatile VALUE rx1, volatile VALUE rx2, volatile VALUE rx3, void *userdata);
+
 #endif /* CARRAY_CALL_CFUNC_H */

data/ext/carray_cast.c

@@ -2,9 +2,11 @@
 
   Cast surface (3 layers):
 
-    to_<type>     `a.to_int32` etc.  Returns a fresh entity CArray
-                  of the target data_type.  Independent storage from
-                  `self`.
+    <type>        `a.int32` etc., and the general `a.to_type(:int32)`.
+                  Returns a fresh entity CArray of the target
+                  data_type.  Independent storage from `self`.  (The
+                  C functions are named rb_ca_to_<type>, but the
+                  methods they register carry no `to_` prefix.)
 
     as_<type>     `a.as_int32` etc.  Returns a writable CAMonOp view
                   that reinterprets `self` cell-by-cell at the target
@@ -550,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. */
@@ -559,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;
 
@@ -599,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. */
@@ -773,16 +810,62 @@ extern VALUE rb_ca_monop_build (VALUE cary, uint16_t op_id);
 /* Forward declaration: clip kernel (ext/carray_kernels.c, generated).  */
 extern VALUE rb_ca_clip (VALUE self, VALUE lo, VALUE hi);
 
+/* Which surface asked for a type-adapt view.  A Face's cells do not mean
+   their storage bytes and there is no view that decodes them, so each
+   caller says what it does instead of reinterpreting the storage.  */
+enum {
+  CA_ADAPT_VIEW,        /* as_type: the values are behind #to_type */
+  CA_ADAPT_READONLY,    /* wrap_readonly: the eager conversion is the answer */
+  CA_ADAPT_WRITABLE     /* wrap_writable: writes have nowhere to land */
+};
+
 /* Routes a type-adapt view request to CAMonOp(cast_<dt>) when the
    target is a plain numeric data_type (NOT CA_FIXLEN, NOT CA_OBJECT,
    and `rtype` is not a Class).  Falls back to CAFake
    (`rb_ca_fake_type`) for CA_FIXLEN sizing, CA_OBJECT, and class-rtype
    data_class overlay cases.
    Called by rb_ca_as_type_internal, rb_ca_wrap_readonly, and
-   rb_ca_wrap_writable in this file.  */
+   rb_ca_wrap_writable in this file.
+
+   A Face whose surface is not its storage reaches neither: reinterpreting
+   the storage would hand back the bytes the surface exists to hide (the
+   serial instead of the time, the descriptor instead of the string).
+   wrap_readonly, which already returns entities for its non-CArray inputs,
+   answers with the eager conversion #to_type performs -- the surface values,
+   or the Face's own #to_numeric for a numeric target.  as_type and
+   wrap_writable have no honest answer and say so.  */
 static VALUE
-ca_type_adapt_view (VALUE obj, VALUE rtype, int8_t data_type)
+ca_type_adapt_view (VALUE obj, VALUE rtype, int8_t data_type, int mode)
 {
+  CArray *ca;
+
+  TypedData_Get_Struct(obj, CArray, &carray_data_type, ca);
+
+  /* Same split the eager cast makes: :object is the Face's surface for every
+     Face, and a NonNumeric Face (CA_FIXLEN surface) has no reading of its
+     storage as a number either.  A Numeric Face falls through, because there
+     its surface *is* its storage and the ordinary cast below is right.  */
+  if ( ca_is_face(ca) && ( data_type == CA_OBJECT
+                           || ca->data_type == CA_FIXLEN ) ) {
+    VALUE args[1];
+    switch ( mode ) {
+    case CA_ADAPT_READONLY:
+      args[0] = rtype;
+      return rb_ca_to_type_internal(1, args, obj);
+    case CA_ADAPT_WRITABLE:
+      rb_raise(rb_eTypeError,
+               "%s has no writable view in another data_type: the writes "
+               "would land on the storage its surface hides -- wrap "
+               "#parent to reach that storage",
+               rb_obj_classname(obj));
+    default:
+      rb_raise(rb_eTypeError,
+               "%s has no view of its values in another data_type: "
+               "#to_type gives the values, #parent the raw storage",
+               rb_obj_classname(obj));
+    }
+  }
+
   if ( data_type != CA_FIXLEN
        && data_type != CA_OBJECT
        && TYPE(rtype) != T_CLASS ) {
@@ -815,7 +898,7 @@ rb_ca_as_type_internal (int argc, VALUE *argv, VALUE self)
   /* Natural-width cast: dispatch via helper (CAMonOp for numeric,
      CAFake for CA_FIXLEN sizing / CA_OBJECT / class-rtype). */
   if ( bytes == (ca_size_t) ca_sizeof[data_type] ) {
-    obj = ca_type_adapt_view(self, rtype, data_type);
+    obj = ca_type_adapt_view(self, rtype, data_type, CA_ADAPT_VIEW);
     return obj;
   }
 
@@ -1075,7 +1158,7 @@ rb_ca_wrap_writable (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, rtype, data_type);
+      obj = ca_type_adapt_view(obj, rtype, data_type, CA_ADAPT_WRITABLE);
     }
   }
   else if ( NIL_P(obj) ) {                          /* obj == nil */
@@ -1113,7 +1196,8 @@ rb_ca_wrap_writable (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type);
+      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type,
+                               CA_ADAPT_WRITABLE);
     }
   }
   else if ( rb_memory_view_available_p(obj) ) {     /* MemoryView producer */
@@ -1130,7 +1214,8 @@ rb_ca_wrap_writable (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type);
+      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type,
+                               CA_ADAPT_WRITABLE);
     }
   }
   else {
@@ -1171,7 +1256,7 @@ rb_ca_wrap_readonly (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, rtype, data_type);
+      obj = ca_type_adapt_view(obj, rtype, data_type, CA_ADAPT_READONLY);
     }
   }
   else if ( rb_obj_is_kind_of(obj, rb_cNumeric) ) {  /* number */
@@ -1193,7 +1278,8 @@ rb_ca_wrap_readonly (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type);
+      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type,
+                               CA_ADAPT_READONLY);
     }
   }
   else if ( TYPE(obj) == T_STRING ) {                /* string */
@@ -1234,7 +1320,8 @@ rb_ca_wrap_readonly (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type);
+      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type,
+                               CA_ADAPT_READONLY);
     }
   }
   else if ( rb_memory_view_available_p(obj) ) {     /* MemoryView producer */
@@ -1247,7 +1334,8 @@ rb_ca_wrap_readonly (VALUE arg, VALUE rtype)
       data_type = rb_ca_guess_type(rtype);
     }
     if ( ca->data_type != data_type ) {
-      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type);
+      obj = ca_type_adapt_view(obj, INT2NUM(data_type), data_type,
+                               CA_ADAPT_READONLY);
     }
   }
   else {                                           /* object */
@@ -1313,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. */
@@ -1356,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);
     }
@@ -1384,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);
     }
@@ -1400,16 +1524,6 @@ rb_ca_cast_self_or_other (volatile VALUE *self, volatile VALUE *other)
   TypedData_Get_Struct(*self, CArray, &carray_data_type, ca);
   TypedData_Get_Struct(*other, CArray, &carray_data_type, cb);
 
-  if ( ca->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
-    *self = ca_ubrep_bind_with(*self, *other);
-    TypedData_Get_Struct(*self, CArray, &carray_data_type, ca);
-  }
-
-  if ( cb->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
-    *other = ca_ubrep_bind_with(*other, *self);
-    TypedData_Get_Struct(*other, CArray, &carray_data_type, cb);
-  }
-
   /* Implicit size-1 broadcasting (case A only).  No-op if either side
      is scalar, ndim differs, or shapes are already equal.  If shapes
      are incompatible (neither side is 1 nor equal on some axis), also
@@ -1781,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);
     }
@@ -1806,11 +1923,6 @@ rb_ca_cast_other (VALUE *self, volatile VALUE *other)
 
   TypedData_Get_Struct(*other, CArray, &carray_data_type, cb);
 
-  if ( cb->obj_type == CA_OBJ_UNBOUND_REPEAT ) {
-    *other = ca_ubrep_bind_with(*other, *self);
-    TypedData_Get_Struct(*other, CArray, &carray_data_type, cb);
-  }
-
   test1 = ca_cast_table[cb->data_type][ca->data_type];
 
   if ( test1 == 0 ) {
@@ -1845,8 +1957,8 @@ rb_ca_cast_with (VALUE self, VALUE other)
 }
 
 /* -----------------------------------------------------------------------
-   clip_<dtype> family — clip into the target dtype's representable
-   range, then cast.  Sugar for `clip(lo, hi).as_<dtype>`.
+   clip_<type> family — clip into the target data type's representable
+   range, then cast.  Sugar for `clip(lo, hi).as_<type>`.
 ----------------------------------------------------------------------- */
 
 #define CLIP_CAST_FUNC(name, lo_expr, hi_expr, cast_func) \
@@ -1873,7 +1985,7 @@ CLIP_CAST_FUNC(clip_uint32, INT2NUM(0),                       UINT2NUM(429496729
    an overflowing float source (e.g. 1e20) to 2^64 and the subsequent cast to
    uint64 wraps around to 0.  For floating-point sources we take a saturating
    path: compare in float space against 2^64 (which IS representable) and
-   saturate to UINT64_MAX above it and 0 below zero.  Other source dtypes use
+   saturate to UINT64_MAX above it and 0 below zero.  Other source data types use
    the plain clip-then-cast path. */
 static VALUE
 rb_ca_clip_uint64 (VALUE self)