carray 3.0.1 → 3.0.2

data/ext/ca_obj_face.h

@@ -259,6 +259,21 @@ void ca_face_register_state_portable (int obj_type, int portable);
    (= falls through to default). */
 int ca_face_state_portable (int obj_type, VALUE klass);
 
+/* Bring a Face *operand* into the reference's storage space, or refuse.
+
+   The gate asks `fz_face_descend`'s question -- "is your storage your
+   surface?" -- of the receiver, and for a long time asked nothing at all of
+   the operand: a COMPARABLE receiver stripped any Face handed to it, and got
+   back that Face's encoding rather than its values.  Where the two encodings
+   happened to be the same width the comparison then answered, wrongly and
+   silently.  Call this instead of stripping an operand by hand.
+
+   A Face passes only if it declares COMPARABLE_STORAGE, i.e. its storage
+   cells *are* the values it shows.  Anything else -- a byte range, a code, a
+   tick -- is refused rather than compared as bytes.  Non-Face operands are
+   returned untouched.  `name` opens the message. */
+VALUE ca_face_operand_descend (VALUE operand, const char *name);
+
 #define CA_FACE_STORAGE_TO_SCALAR_IF_FACE(obj, self, ca) do {                \
   if ( ca_is_face(ca) && (obj) != CA_UNDEF && (obj) != Qnil                  \
        && ! rb_obj_is_kind_of((obj), rb_cCArray) ) {                         \

data/ext/ca_obj_fixlen_string.c

@@ -91,11 +91,24 @@ ca_fixlen_string_setup (CAFixlenString *ca, CArray *parent)
 
   ca->obj_type  = CA_OBJ_FIXLEN_STRING;
   ca->data_type = CA_FIXLEN;
-  /* ORDERABLE + COMPARABLE, and both hold by construction: this Face's surface
-     IS its storage, byte for byte (a cell decodes to its own bytes, padding
-     included), so the descent is the identity map.  memcmp order is therefore
-     String#<=> order for these cells, and byte equality is cell equality --
-     which is what the equality families need (docs/topics/CAFace.md §6.3).
+  /* ORDERABLE + COMPARABLE.  The descent is NOT the identity map -- the
+     scalar decode below strips trailing NUL -- but both flags still hold,
+     for a reason worth stating exactly, since it is what a Face author
+     copying this would need:
+
+       ORDERABLE: every cell is padded to the same K with NUL, and NUL is
+       the smallest byte, so memcmp on the padded cells orders them the same
+       way String#<=> orders the stripped strings (a prefix sorts before any
+       continuation, which is what the padding reproduces).  Stripping is
+       order-preserving; it is not order-irrelevant by being absent.
+
+       COMPARABLE: a String query is padded out to the cell width before it
+       is compared, so byte equality on the padded form is equality on the
+       stripped form -- for a query that fits.  A query longer than K is
+       truncated to its own first K bytes by that same padding step, and
+       then matches a cell it is not equal to.
+
+     Which is what the equality families need (docs/topics/CAFace.md §6.3).
      Without the flags the sort family still worked (it exempts CA_FIXLEN
      storage from the gate and orders by memcmp), but the value-hash family
      handed its results back as a plain fixlen array, and search refused a

data/ext/ca_obj_meld.c

@@ -39,6 +39,8 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* ca_attach_all */
+#include "ca_obj_face.h"       /* ca_face_state_portable */
 
 /* ------------------------------------------------------------------- */
 /* TypedData                                                            */
@@ -150,6 +152,19 @@ ca_meld_setup (CAMeld *ca, int32_t n_parents, CArray **parents, int8_t meld_axis
   int32_t i;
   int8_t  a;
 
+  /* Pre-strip Face parents one level to storage, as CAStack does, so a
+     melded Face lifts to a single-Face chain (CATime[CAMeld[entity, ...]])
+     rather than a Face sitting on Face parents.  One level, not a full walk,
+     preserves any distinct Face a parent melded underneath.  A Face is
+     storage-transparent, so welding over storage reads the same bytes; the
+     lifted top Face (rb_ca_meld_s_new) carries the identity.  The @parents
+     accessor keeps the originals, which the callers set. */
+  for ( i = 0; i < n_parents; i++ ) {
+    if ( ca_is_face(parents[i]) ) {
+      parents[i] = CAVIEW(parents[i])->parent;
+    }
+  }
+
   ca_meld_check_uniform(n_parents, parents, meld_axis);
   ref = parents[0];
 
@@ -601,21 +616,6 @@ ca_meld_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   s = ca->bytes;
   for ( i = ca->ndim - 1; i >= 0; i-- ) { native[i] = s; s *= ca->dim[i]; }
 
-  /* Bound check on meld_axis.  The step along the axis is strides[ma] /
-     native[ma] and it can be negative -- a reversed read starts at the far
-     end and walks down -- so the region runs between the first and last
-     index, which is not the same as starts[ma] .. starts[ma] + counts[ma]. */
-  {
-    ca_size_t step = strides[ma] / native[ma];
-    ca_size_t last = starts[ma] + (counts[ma] - 1) * step;
-    ca_size_t req_lo = ( last < starts[ma] ) ? last : starts[ma];
-    ca_size_t req_hi = (( last < starts[ma] ) ? starts[ma] : last) + 1;
-    if ( counts[ma] > 0 && ( req_lo < 0 || req_hi > ca->dim[ma] ) ) {
-      rb_raise(rb_eIndexError,
-               "CAMeld xfer_stride meld_axis (axis %d) [%lld, %lld) out of range [0, %lld)",
-               (int) ma, (long long) req_lo, (long long) req_hi, (long long) ca->dim[ma]);
-    }
-  }
   for ( i = 0; i < ca->ndim; i++ ) {
     if ( strides[i] != native[i] ) { structural = 0; break; }
   }
@@ -624,6 +624,23 @@ ca_meld_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     ca_meld_xfer_stride_per_cell(ca, starts, counts, strides, data, dir);
     return;
   }
+
+  /* Bound check on meld_axis, after the gate and not before it.  Only once
+     strides == native is established does request axis ma mean view axis ma;
+     asked earlier, strides[ma] / native[ma] is not a step along the meld axis
+     and legal requests get rejected.  Inside the gate the step is 1, so the
+     region is starts[ma] .. starts[ma] + counts[ma].  ca_meld_xfer_stride_ma_
+     internal below is handed no strides at all and depends on both facts. */
+  {
+    ca_size_t req_lo = starts[ma];
+    ca_size_t req_hi = starts[ma] + counts[ma];
+    if ( counts[ma] > 0 && ( req_lo < 0 || req_hi > ca->dim[ma] ) ) {
+      rb_raise(rb_eIndexError,
+               "CAMeld xfer_stride meld_axis (axis %d) [%lld, %lld) out of range [0, %lld)",
+               (int) ma, (long long) req_lo, (long long) req_hi, (long long) ca->dim[ma]);
+    }
+  }
+
   if ( ma == 0 ) {
     ca_meld_xfer_stride_ma0(ca, starts, counts, strides, data, dir);
   } else {
@@ -770,10 +787,7 @@ static void
 ca_meld_func_allocate (void *ap)
 {
   CAMeld *ca = (CAMeld *) ap;
-  int32_t k;
-  for ( k = 0; k < ca->n_parents; k++ ) {
-    ca_attach(ca->parents[k]);
-  }
+  ca_attach_all(ca->parents, ca->n_parents);
   ca->ptr = xmalloc(ca_length(ca));
 }
 
@@ -781,10 +795,7 @@ static void
 ca_meld_func_attach (void *ap)
 {
   CAMeld *ca = (CAMeld *) ap;
-  int32_t k;
-  for ( k = 0; k < ca->n_parents; k++ ) {
-    ca_attach(ca->parents[k]);
-  }
+  ca_attach_all(ca->parents, ca->n_parents);
   ca->ptr = xmalloc(ca_length(ca));
   ca_meld_func_xfer_all(ca, ca->ptr, CA_XFER_GET);
 }
@@ -887,6 +898,17 @@ ca_operation_function_t ca_meld_func = {
 /* Ruby surface                                                         */
 /* ------------------------------------------------------------------- */
 
+/* One-level strip of a Face VALUE to its storage-side parent (non-Face as-is).
+   Keeps the @parent ivar in step with the pre-stripped C parents, so the
+   Ruby-visible chain of a melded Face is single-Face too. */
+static VALUE
+ca_meld_face_parent1 (VALUE v)
+{
+  CArray *c;
+  TypedData_Get_Struct(v, CArray, &carray_data_type, c);
+  return ca_is_face(c) ? rb_ca_parent(v) : v;
+}
+
 VALUE
 rb_ca_meld_new (VALUE parents_ary, int8_t meld_axis)
 {
@@ -910,7 +932,7 @@ rb_ca_meld_new (VALUE parents_ary, int8_t meld_axis)
   ca  = ca_meld_new((int32_t) n, parents, meld_axis);
   obj = ca_wrap_struct(ca);
   rb_ivar_set(obj, id_parents, rb_ary_dup(parents_ary));
-  rb_ca_set_parent(obj, rb_ary_entry(parents_ary, 0));
+  rb_ca_set_parent(obj, ca_meld_face_parent1(rb_ary_entry(parents_ary, 0)));
   ALLOCV_END(holder);
   return obj;
 }
@@ -967,11 +989,86 @@ rb_ca_meld_initialize (int argc, VALUE *argv, VALUE self)
   }
   ca_meld_setup(ca, (int32_t) n, parents, meld_axis);
   rb_ivar_set(self, id_parents, rb_ary_dup(list));
-  rb_ca_set_parent(self, rb_ary_entry(list, 0));
+  rb_ca_set_parent(self, ca_meld_face_parent1(rb_ary_entry(list, 0)));
   ALLOCV_END(holder);
   return self;
 }
 
+/* CAMeld.new(list, axis: 0) -- Class#new override, the twin of
+   rb_ca_stack_s_new.  A melded view has one surface over many parents, so a
+   homogeneous Face list is treated the way CAStack treats it: refuse a Face
+   whose state is per-parent (the cells of parent i are only readable against
+   parent i's own state -- a CAConstString's cells are byte ranges into ITS
+   buffer), and lift the rest so the Face survives the weld.
+
+   Without this meld was the one multi-parent constructor that neither asked
+   nor lifted: it returned the raw storage of whatever it was given, which for
+   CAConstString meant 16-byte (start,end) pairs presented as the string cells,
+   and for CATime meant raw int64 ticks.  Both looked like data.
+
+   Doing it here rather than in CArray.meld covers CAFrame.meld and a direct
+   CAMeld.new by the same check. */
+static VALUE
+rb_ca_meld_s_new (int argc, VALUE *argv, VALUE klass)
+{
+  VALUE list, kwargs;
+  long n, i;
+  int  all_face = 1;
+  VALUE face_class = Qnil;
+  CArray *ref_face = NULL;
+  VALUE obj;
+
+  rb_scan_args(argc, argv, "1:", &list, &kwargs);
+  Check_Type(list, T_ARRAY);
+  n = RARRAY_LEN(list);
+  if ( n <= 0 ) {
+    rb_raise(rb_eArgError, "CAMeld.new requires at least one parent");
+  }
+
+  for ( i = 0; i < n; i++ ) {
+    VALUE p = rb_ary_entry(list, i);
+    CArray *ca;
+    rb_check_carray_object(p);
+    TypedData_Get_Struct(p, CArray, &carray_data_type, ca);
+    if ( !ca_is_face(ca) ) { all_face = 0; break; }
+    if ( i == 0 ) {
+      face_class = rb_obj_class(p);
+      ref_face   = ca;
+    } else if ( rb_obj_class(p) != face_class ) {
+      all_face = 0; break;
+    }
+  }
+
+  /* A single parent has nothing to weld against, so its Face rides the
+     chain as it always did; refuse and lift only apply from two up. */
+  if ( all_face && n > 1
+       && !ca_face_state_portable(ref_face->obj_type, face_class) ) {
+    rb_raise(rb_eArgError,
+             "CAMeld.new: %s state is not portable across multiple "
+             "parents (= per-parent storage like CAConstString's buffer); "
+             "strip Face with .parent if a storage-level CAMeld is intended",
+             rb_class2name(face_class));
+  }
+
+  obj = rb_obj_alloc(klass);
+  rb_obj_call_init_kw(obj, argc, argv, RB_PASS_CALLED_KEYWORDS);
+
+  if ( !all_face || n < 2 ) return obj;
+
+  for ( i = 1; i < n; i++ ) {
+    VALUE p = rb_ary_entry(list, i);
+    CArray *ca;
+    TypedData_Get_Struct(p, CArray, &carray_data_type, ca);
+    if ( !ca_face_state_compatible(rb_ary_entry(list, 0), ref_face, p, ca) ) {
+      rb_raise(rb_eArgError,
+               "CAMeld.new: Face state mismatch across parents "
+               "(= %s instance at index %ld differs in state from index 0)",
+               rb_class2name(face_class), i);
+    }
+  }
+  return ca_face_lift(obj, rb_ary_entry(list, 0));
+}
+
 static VALUE
 rb_ca_meld_n_parents (VALUE self)
 {
@@ -1027,6 +1124,7 @@ Init_ca_obj_meld (void)
   id_parents = rb_intern("parents");
 
   rb_define_alloc_func(rb_cCAMeld, rb_ca_meld_s_allocate);
+  rb_define_singleton_method(rb_cCAMeld, "new", rb_ca_meld_s_new, -1);
   rb_define_method(rb_cCAMeld, "initialize",
                                       rb_ca_meld_initialize, -1);
   rb_define_method(rb_cCAMeld, "initialize_copy",

data/ext/ca_obj_object.c

@@ -738,6 +738,14 @@ ca_object_dispatch_fill (CAObject *ca, void *ptr)
     volatile VALUE rval = rb_ca_ptr2obj(ca->self, ptr);
     rb_funcall(ca->self, rb_intern("fill_data"), 1, rval);
   }
+  else if ( rb_obj_respond_to(ca->self, rb_intern("fill_block"), Qtrue)
+            || rb_obj_respond_to(ca->self, rb_intern("fill_addrs"), Qtrue) ) {
+    /* An author who wrote the region slots but not fill_data would otherwise
+       get the per-cell default for the one request that is easiest to batch.
+       Hand the whole extent to the region path, which reaches `fill_block` in
+       one call or `fill_addrs` in address windows. */
+    ca_fill_stride_whole(ca, ptr);
+  }
   else {
     ca_size_t addr;
     for ( addr = 0; addr < ca->elements; addr++ ) {

data/ext/ca_obj_select.c

@@ -83,22 +83,57 @@ VALUE rb_cCASelectMask;
 
 /* ------------------------------------------------------------------- */
 
-/* Snapshot the selector into ca->select (always a copy) and pre-compute
-   ca->indices (TRUE positions in flat parent order).  Masked selector
-   cells become false in the snapshot.  After construction, mutating
-   the caller's live selector does not affect the view. */
-static int
-ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
+/* Owned snapshot of the selector: masked selector cells become false.
+   After construction, mutating the caller's live selector does not affect
+   the view.  Reading the selector can raise (a lazy boolean view), so the
+   snapshot is taken before the view struct is allocated, and a snapshot
+   whose fill raises is freed on the way out. */
+static VALUE
+ca_select_snapshot_masked (VALUE arg)
 {
-  int8_t data_type;
-  ca_size_t bytes;
+  CArray **pair = (CArray **) arg;
+  CArray *select = pair[0], *snap = pair[1];
+  boolean8_t *p, *q, *m;
   ca_size_t i;
+  ca_attach(select);
+  q = (boolean8_t *) snap->ptr;
+  p = (boolean8_t *) select->ptr;
+  m = (boolean8_t *) select->mask->ptr;
+  for (i = 0; i < select->elements; i++) {
+    *q = ( *m ) ? 0 : *p;
+    q++; p++; m++;
+  }
+  ca_detach(select);
+  return Qnil;
+}
 
+static CArray *
+ca_select_snapshot (CArray *select)
+{
   if ( ! ca_is_boolean_type(select) ) {
     rb_raise(rb_eRuntimeError,
              "selection array for CASelect should be have "
              "the data_type of CA_BOOLEAN");
   }
+  if ( ca_has_mask(select) ) {
+    CArray *pair[2];
+    pair[0] = select;
+    pair[1] = ca_template(select);
+    ca_fill_or_free(pair[1], ca_select_snapshot_masked, (VALUE) pair);
+    return pair[1];
+  }
+  return ca_copy(select);
+}
+
+/* Set up the view over `parent` from an owned selector snapshot (see
+   ca_select_snapshot) and pre-compute ca->indices (TRUE positions in flat
+   parent order).  Does not raise. */
+static int
+ca_select_setup (CASelect *ca, CArray *parent, CArray *snapshot)
+{
+  int8_t data_type;
+  ca_size_t bytes;
+  ca_size_t i;
 
   data_type = parent->data_type;
   bytes     = parent->bytes;
@@ -114,26 +149,7 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
   ca->attach    = 0;
   ca->nosync    = 0;
   ca->indices   = NULL;
-
-  /* The `share` argument is preserved for source compatibility but
-     no longer toggles a live-reference path; both paths copy.
-     Masked selector cells become false in the snapshot. */
-  (void) share;
-  if ( ca_has_mask(select) ) {
-    boolean8_t *p, *q, *m;
-    ca->select = ca_template(select);
-    ca_attach(select);
-    q = (boolean8_t *) ca->select->ptr;
-    p = (boolean8_t *) select->ptr;
-    m = (boolean8_t *) select->mask->ptr;
-    for (i = 0; i < select->elements; i++) {
-      *q = ( *m ) ? 0 : *p;
-      q++; p++; m++;
-    }
-    ca_detach(select);
-  } else {
-    ca->select = ca_copy(select);
-  }
+  ca->select    = snapshot;
 
   /* Count TRUE positions and snapshot them into ca->indices. */
   {
@@ -181,7 +197,7 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
   ca->dim       = &(ca->_dim);
   ca->dim[0]    = ca->elements;
 
-  if ( ca_is_scalar(select) ) {
+  if ( ca_is_scalar(snapshot) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
   }
 
@@ -191,8 +207,9 @@ ca_select_setup (CASelect *ca, CArray *parent, CArray *select, int share)
 CArray *
 ca_select_new (CArray *parent, CArray *select)
 {
+  CArray *snapshot = ca_select_snapshot(select);
   CASelect *ca = ALLOC(CASelect);
-  ca_select_setup(ca, parent, select, 0);
+  ca_select_setup(ca, parent, snapshot);
   return (CArray*) ca;
 }
 
@@ -202,9 +219,7 @@ ca_select_new (CArray *parent, CArray *select)
 CArray *
 ca_select_new_share (CArray *parent, CArray *select)
 {
-  CASelect *ca = ALLOC(CASelect);
-  ca_select_setup(ca, parent, select, 1);
-  return (CArray*) ca;
+  return ca_select_new(parent, select);
 }
 
 static void
@@ -613,7 +628,7 @@ rb_cm_initialize_copy (VALUE self, VALUE other)
 
   /* Re-snapshot from the source's selector copy so the two views
      end up with independent indices buffers. */
-  ca_select_setup(ca, cs->parent, cs->select, 1);
+  ca_select_setup(ca, cs->parent, ca_select_snapshot(cs->select));
 
   return self;
 }

data/ext/ca_obj_stack.c

@@ -18,6 +18,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* ca_attach_all */
 #include "ca_composite_dispatch.h"
 #include "ca_obj_face.h"
 
@@ -740,10 +741,7 @@ static void
 ca_stack_func_allocate (void *ap)
 {
   CAStack *ca = (CAStack *) ap;
-  int32_t k;
-  for ( k = 0; k < ca->n_parents; k++ ) {
-    ca_attach(ca->parents[k]);
-  }
+  ca_attach_all(ca->parents, ca->n_parents);
   ca->ptr = xmalloc(ca_length(ca));
 }
 
@@ -751,10 +749,7 @@ static void
 ca_stack_func_attach (void *ap)
 {
   CAStack *ca = (CAStack *) ap;
-  int32_t k;
-  for ( k = 0; k < ca->n_parents; k++ ) {
-    ca_attach(ca->parents[k]);
-  }
+  ca_attach_all(ca->parents, ca->n_parents);
   ca->ptr = xmalloc(ca_length(ca));
   ca_stack_func_xfer_all(ca, ca->ptr, CA_XFER_GET);
 }

data/ext/ca_obj_stride.c

@@ -836,6 +836,59 @@ ca_stride_region_axes (CAStride *ca, ca_size_t base, int8_t ndim,
    root in units root does not share, so there is no address to hand over
    and the per-cell descent stands in. */
 
+static void
+ca_stride_func_fill_addrs (void *ap, ca_size_t n, ca_size_t *addrs, void *ptr)
+{
+  CAStride *ca = (CAStride *) ap;
+  CArray   *root;
+  ca_size_t composed_strides[CA_RANK_MAX];
+  ca_size_t composed_base;
+  ca_size_t rbytes;
+  ca_size_t *paddrs;
+  ca_size_t  i;
+  int8_t     k;
+  int        all_aligned = 1;
+  volatile VALUE holder;
+
+  /* Addresses name cells one by one, so unlike fill_stride there is nothing
+     here that only the whole extent can express: translate each view address
+     into the root's and hand the list down in one call.  Without this the
+     region is still the only thing touched -- ca_fill_addrs_default sees to
+     that -- but it costs the parent one call per cell, which is the whole
+     difference on a backing where a call is a request. */
+  if ( n == 0 ) {
+    return;
+  }
+
+  ca_stride_compose_to_root(ca, &root, composed_strides, &composed_base);
+  rbytes = root->bytes;
+
+  if ( ca->bytes != rbytes ) {
+    ca_fill_addrs_default(ca, n, addrs, ptr);
+    return;
+  }
+
+  paddrs = ALLOCV_N(ca_size_t, holder, n);
+  for ( i = 0; i < n; i++ ) {
+    ca_size_t idx[CA_RANK_MAX];
+    ca_size_t off = composed_base;
+    ca_addr2index((CArray *) ca, addrs[i], idx);
+    for ( k = 0; k < ca->ndim; k++ ) {
+      off += idx[k] * composed_strides[k];
+    }
+    if ( off % rbytes != 0 ) { all_aligned = 0; break; }
+    paddrs[i] = off / rbytes;
+  }
+
+  if ( all_aligned ) {
+    ca_fill_addrs(root, n, paddrs, ptr);
+  }
+  else {
+    ca_fill_addrs_default(ca, n, addrs, ptr);
+  }
+  ALLOCV_END(holder);
+}
+
 static void
 ca_stride_func_fill_stride (void *ap, ca_size_t base, int8_t ndim,
                             ca_size_t *counts, ca_size_t *steps, void *ptr)
@@ -1003,6 +1056,15 @@ ca_stride_func_allocate (void *ap)
   }
 }
 
+/* Region request into the cold-root attach buffer; a lazy root can raise. */
+static VALUE
+ca_stride_cold_fill (VALUE arg)
+{
+  void **args = (void **) arg;
+  ca_copy_data((CArray *) args[0], (char *) args[1]);
+  return Qnil;
+}
+
 static void
 ca_stride_func_attach (void *ap)
 {
@@ -1018,7 +1080,15 @@ ca_stride_func_attach (void *ap)
        view with a live ptr is what makes the per-cell dispatchers bypass the
        transfer slots. */
     char *buf = xmalloc(ca_length(ca));
-    ca_copy_data(ca, buf);       /* region request, root stays cold */
+    void *args[2];
+    int tag = 0;
+    args[0] = ca;
+    args[1] = buf;
+    rb_protect(ca_stride_cold_fill, (VALUE) args, &tag);   /* root stays cold */
+    if (tag) {
+      xfree(buf);
+      rb_jump_tag(tag);
+    }
     ca->ptr = buf;
     return;
   }
@@ -1483,6 +1553,7 @@ ca_operation_function_t ca_stride_func = {
   sizeof(CAStride),           /* struct_size: pool framework */
   ca_stride_pool_bytes,       /* pool_bytes  */
   ca_stride_pool_init,        /* pool_init   */
+  .fill_addrs   = ca_stride_func_fill_addrs,
   .fill_stride  = ca_stride_func_fill_stride,
 };
 

data/ext/ca_obj_string.c

@@ -90,10 +90,14 @@ ca_string_setup (CAString *ca, CArray *parent)
 
   ca->obj_type  = CA_OBJ_STRING;
   ca->data_type = CA_OBJECT;
-  /* ORDERABLE: object storage sorts by <=> (= String order on the surface),
-     so the sort family may descend to storage.  COMPARABLE is left off for
-     now; ordered search (bsearch) is a later phase. */
-  ca->flags     = CA_FLAG_IS_FACE | CA_FLAG_FACE_ORDERABLE_STORAGE;
+  /* ORDERABLE + COMPARABLE, and both hold by construction: a storage cell
+     IS the Ruby String the surface shows, so storage order is surface
+     order and an external String compares against storage directly, with
+     nothing to reconcile.  (A unit-bearing Face like CATime is the case
+     that has to stop at ORDERABLE; this one carries no unit.) */
+  ca->flags     = CA_FLAG_IS_FACE
+                | CA_FLAG_FACE_ORDERABLE_STORAGE
+                | CA_FLAG_FACE_COMPARABLE_STORAGE;
   ca->ndim      = parent->ndim;
   ca->bytes     = sizeof(VALUE);
   ca->elements  = parent->elements;

data/ext/ca_obj_window.c

@@ -1416,6 +1416,12 @@ rb_ca_window (int argc, VALUE *argv, VALUE self)
   }
 
   if ( ! NIL_P(rbounds) ) {
+    /* A Symbol says the same thing as the String, and is what the window
+       iterator (CArray#windows) is given -- accept both so the two spellings
+       of one policy do not diverge. */
+    if ( SYMBOL_P(rbounds) ) {
+      rbounds = rb_sym2str(rbounds);
+    }
     switch ( TYPE(rbounds) ) {
     case T_STRING:
       cbounds = StringValuePtr(rbounds);
@@ -1597,7 +1603,6 @@ rb_ca_window_get_bounds (VALUE self)
 }
 
 static VALUE rb_cw_get_attr_ary(start);
-static VALUE rb_cw_get_attr_ary(count);
 static VALUE rb_cw_get_attr_ary(size0);
 
 #ifdef CARRAY_DEV_BUILD
@@ -1680,8 +1685,9 @@ Init_ca_obj_window (void)
 
   rb_define_method(rb_cCAWindow, "bounds", rb_ca_window_get_bounds, 0);
 
+  /* No `count` accessor: the per-axis window widths are what `shape`
+     already answers, and the name belongs to CArray#count. */
   rb_define_method(rb_cCAWindow, "start",  rb_cw_start, 0);
-  rb_define_method(rb_cCAWindow, "count",  rb_cw_count, 0);
   rb_define_method(rb_cCAWindow, "size0",  rb_cw_size0, 0);
 
 #ifdef CARRAY_DEV_BUILD

data/ext/ca_op_ipower.c

@@ -273,8 +273,7 @@ rb_ca_ipower_bang (VALUE self, VALUE other)
 /* CArray#pow(other) (alias `**`) — Float/Complex ** Integer takes the
  * ipower fast path in this file; everything else falls through to the
  * mkkernel-generated general pow/cpow (rb_ca_power in
- * ext/carray_kernels.c).  Non-bang variant preserves UnboundRepeat
- * wrapping on the result. */
+ * ext/carray_kernels.c). */
 static VALUE rb_ca_pow (VALUE self, VALUE other)
 {
   volatile VALUE obj;

data/ext/ca_rng_normal.h

@@ -0,0 +1,42 @@
+/* ---------------------------------------------------------------------------
+
+   ca_rng_normal.h -- uniform to standard normal, as text
+
+   Read the two ways ca_rng_xoshiro256pp.h is read: compiled into this
+   extension, and handed out through CArray::Rng::COMMON_SOURCE for
+   another gem to paste.  The same rules apply -- no include guard,
+   nothing beyond <math.h>, `static inline` only.
+
+   Separate from any generator's file because it belongs to none of
+   them: it takes two uniforms and gives a normal, whichever generator
+   the uniforms came from.  Whoever pastes it pastes it once however
+   many generators are drawing, which is why it is not simply repeated
+   inside each generator's text.
+
+   --------------------------------------------------------------------------- */
+
+/* One standard normal from two uniforms in [0.0, 1.0), by Box-Muller.
+ *
+ * Exactly two, always.  The classical form takes two uniforms and gives
+ * two normals, and keeping the second would make the cost one uniform
+ * apiece -- but the spare has to live somewhere between calls, and the
+ * place it would live is the generator's state.  A kernel draws one
+ * number per cell and `CArray#random!` fills whole arrays, so a spare
+ * held across that boundary is a second kind of state to keep in step,
+ * on top of the one this design exists to keep in step.  Two uniforms
+ * and no spare costs an extra draw, at about a nanosecond, and buys a
+ * rule with nothing behind it: one normal is two draws, wherever it is
+ * taken.
+ *
+ * `1.0 - u1` rather than `u1`, so the argument to log is in (0.0, 1.0]
+ * and never zero.  Redrawing on a zero -- which is what the paired form
+ * does -- would make the number of uniforms per normal depend on the
+ * draw, and then "where is this generator" has no answer that can be
+ * worked out rather than run. */
+static inline double
+ca_rng_normal (double u1, double u2)
+{
+  const double radius = sqrt(-2.0 * log(1.0 - u1));
+  const double theta = 2.0 * M_PI * u2;
+  return radius * cos(theta);
+}