carray 3.0.0 → 3.0.1

data/ext/ca_axis_group.c

@@ -8,7 +8,7 @@
   reduce dispatch, GroupLabels) is wired in ca_group_iter.c (the `[]` gate and
   the iterator) + `axis_group` (lib/carray/axis_group.rb).  Both kernels are
   written in the general form: several group axes + rank-N categorical (an N-D
-  codes map) via a per-slab-element composite code, native dtype dispatch,
+  codes map) via a per-slab-element composite code, native data type dispatch,
   mask support.  They take pre-built code bundles, so they are independent of
   how the classifier is constructed.
 
@@ -40,7 +40,8 @@
 enum {
   GR_SUM = 0, GR_PROD, GR_MEAN, GR_MIN, GR_MAX,
   GR_VARIANCE, GR_STDDEV, GR_COUNT, GR_ALL, GR_ANY,
-  GR_VARIANCEP, GR_STDDEVP, GR_MINADDR, GR_MAXADDR
+  GR_VARIANCEP, GR_STDDEVP, GR_MINADDR, GR_MAXADDR,
+  GR_ACCUM
 };
 
 static int
@@ -48,6 +49,7 @@ group_op_code (VALUE vop)
 {
   ID id = SYM2ID(vop);
   if      ( id == rb_intern("sum") )      return GR_SUM;
+  else if ( id == rb_intern("accumulate") ) return GR_ACCUM;
   else if ( id == rb_intern("prod") )     return GR_PROD;
   else if ( id == rb_intern("mean") )     return GR_MEAN;
   else if ( id == rb_intern("min") )      return GR_MIN;
@@ -72,14 +74,14 @@ group_op_code (VALUE vop)
    group code, applies the mask, and folds the value into whichever
    accumulator buffers are non-NULL.  Accumulation is always in `double` (or
    counts in ca_size_t), so the op-finalisation below is type-agnostic — only
-   the LOAD is monomorphised per dtype, keeping the inner loop autovectorisable
+   the LOAD is monomorphised per data type, keeping the inner loop autovectorisable
    while avoiding a forced float64 materialise of the (large) source. */
 
 /* GROUP_WALK(T, ACCUM): one CA_FOR_EACH_SLAB pass.  For each slab element it
    computes the composite group code, applies the mask, then runs ACCUM with
    `v` (the element, widened to double) and `o` (the output flat index =
    code * band + band_flat) in scope.  ACCUM is the only per-op-varying part,
-   so the dtype is monomorphised once per type while sum / mean / variance /
+   so the data type is monomorphised once per type while sum / mean / variance /
    ... reuse the same walk. */
 /* Sentinel o-code for a slab element whose composite code is out of range
    (excluded categorical), stored in the precomputed plan below. */
@@ -171,7 +173,7 @@ group_op_code (VALUE vop)
     if ( gw_gaddr ) xfree(gw_gaddr);                                          \
   } while (0)
 
-/* Run one walk over every supported native dtype.  Dispatched on the source
+/* Run one walk over every supported native data type.  Dispatched on the source
    data_type so the inner loop stays monomorphic (no forced float64 cast). */
 #define GROUP_DISPATCH(ACCUM)                                                  \
   switch ( ca->data_type ) {                                                   \
@@ -189,6 +191,19 @@ group_op_code (VALUE vop)
   default: break;                                                              \
   }
 
+/* `accumulate` is the one op that folds in the SOURCE's own type instead of in
+   double, so it wraps at that width exactly as CArray#accumulate does.  It
+   folds straight into the (zeroed) output — whose data type is the source's —
+   so an empty group already holds the additive identity 0 and needs no mask.
+   The type cannot travel inside a GROUP_WALK ACCUM argument (an argument's own
+   tokens are not substituted for the macro's parameters), so the walk below
+   names its type twice. */
+#define GACC_ADD(T) ( ((T *) co->ptr)[o] += *(T *)(p + gw_doff[e]) )
+/* A boolean accumulate is XOR parity, matching the core: the result stays
+   boolean, so a second `true` has nowhere to carry into. */
+#define GACC_XOR \
+  ( ((boolean8_t *) co->ptr)[o] ^= (*(boolean8_t *)(p + gw_doff[e]) ? 1 : 0) )
+
 /* __axis_group_reduce__(group_axes, bundles, op) — group-reduces self along
  * the union of `group_axes` (ascending source-axis indices = the slab) into
  * composite groups described by `bundles`, preserving the band (= non-grouped)
@@ -358,7 +373,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   }
   ca_size_t nout = K_total * band;
 
-  /* --- supported dtype gate (before any allocation) --- */
+  /* --- supported data type gate (before any allocation) --- */
   ca = src;
   switch ( src->data_type ) {
   case CA_BOOLEAN: case CA_INT8:  case CA_UINT8:  case CA_INT16: case CA_UINT16:
@@ -371,11 +386,12 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
              src->data_type);
   }
 
-  /* output dtype per op */
+  /* output data type per op */
   int8_t out_dt = CA_FLOAT64;
   if      ( op == GR_COUNT )              out_dt = CA_INT64;
   else if ( op == GR_MINADDR || op == GR_MAXADDR ) out_dt = CA_INT64;
   else if ( op == GR_ALL || op == GR_ANY ) out_dt = CA_BOOLEAN;
+  else if ( op == GR_ACCUM )              out_dt = src->data_type;
   VALUE vout = rb_carray_new(out_dt, ondim, odim, 0, NULL);
   GetCArray(vout, co);
 
@@ -432,7 +448,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
     }
   }
 
-  /* --- compute pass(es), native dtype dispatch, no forced float64 cast ---
+  /* --- compute pass(es), native data type dispatch, no forced float64 cast ---
      variance / stddev use a centred two-pass (= matches CArray's own
      variance, avoids the one-pass sumsq cancellation that breaks ε-close
      for small near-constant groups).  Pass 1 fills sum + cnt; sum is then
@@ -464,6 +480,23 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
       }
     );
   }
+  else if ( op == GR_ACCUM ) {
+    MEMZERO(co->ptr, char, (size_t) nout * co->bytes);
+    switch ( ca->data_type ) {
+    case CA_BOOLEAN: GROUP_WALK(boolean8_t, GACC_XOR);           break;
+    case CA_INT8:    GROUP_WALK(int8_t,   GACC_ADD(int8_t));     break;
+    case CA_UINT8:   GROUP_WALK(uint8_t,  GACC_ADD(uint8_t));    break;
+    case CA_INT16:   GROUP_WALK(int16_t,  GACC_ADD(int16_t));    break;
+    case CA_UINT16:  GROUP_WALK(uint16_t, GACC_ADD(uint16_t));   break;
+    case CA_INT32:   GROUP_WALK(int32_t,  GACC_ADD(int32_t));    break;
+    case CA_UINT32:  GROUP_WALK(uint32_t, GACC_ADD(uint32_t));   break;
+    case CA_INT64:   GROUP_WALK(int64_t,  GACC_ADD(int64_t));    break;
+    case CA_UINT64:  GROUP_WALK(uint64_t, GACC_ADD(uint64_t));   break;
+    case CA_FLOAT32: GROUP_WALK(float,    GACC_ADD(float));      break;
+    case CA_FLOAT64: GROUP_WALK(double,   GACC_ADD(double));     break;
+    default: break;
+    }
+  }
   else {
     GROUP_DISPATCH(
       cnt[o] += 1;
@@ -502,6 +535,9 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
       else out[o] = addr[o];
     }
   }
+  else if ( op == GR_ACCUM ) {
+    /* already folded in place, in the source's own type; empty groups hold 0 */
+  }
   else if ( op == GR_ALL ) {
     boolean8_t *out = (boolean8_t *) co->ptr;    /* empty -> true (vacuous) */
     for ( ca_size_t o = 0; o < nout; o++ )
@@ -722,10 +758,10 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
   }
 
 /* GROUP_SCAN_EXTREMUM_WALK(T, CMP): running extremum (cummax / cummin).  The
-   extremum keeps the source dtype (its magnitude never grows), so it holds a
+   extremum keeps the source data type (its magnitude never grows), so it holds a
    native T accumulator, not a widened double.  The first member of a group
    emits its own value: a per-group `seen` byte initialises the accumulator
-   lazily on first hit — no sentinel like HUGE_VAL, which an integer dtype could
+   lazily on first hit — no sentinel like HUGE_VAL, which an integer data type could
    not represent.  CMP is > for max, < for min: a later member replaces the
    running extremum when `rv CMP acc`.  A cell masked within its group holds the
    current extremum once a member has been seen (output NOT masked, like sum);
@@ -863,18 +899,18 @@ group_scan_op_code (VALUE vop)
  * its group up to and including that cell, in row-major position order along
  * the grouped axes (per band).
 
-   op / output dtype:
+   op / output data type:
      :cumsum   -> float64, inclusive within-group running sum.
      :cumprod  -> float64, inclusive within-group running product (init 1.0;
                   float64 like cumsum since the product grows).
-     :cummax   -> source dtype, running within-group maximum (extrema do not
-                  grow magnitude, so the dtype is preserved; int stays int).
-     :cummin   -> source dtype, running within-group minimum.
+     :cummax   -> source data type, running within-group maximum (extrema do not
+                  grow magnitude, so the data type is preserved; int stays int).
+     :cummin   -> source data type, running within-group minimum.
      :cumcount -> int64, 1-based within-group running count of present cells
                   (matching the core CArray#cumcount): the first present member
                   of a group emits 1, the next 2, ...
    cumsum / cumprod keep float64 (matching the reduce siblings sum / prod);
-   integer-preserving sum / prod is a deliberate non-goal (overflow / dtype
+   integer-preserving sum / prod is a deliberate non-goal (overflow / data type
    consistency), as on the reduce side.  A CA_OBJECT source emits a CA_OBJECT
    result for cumsum / cumprod / cummax / cummin (cumcount stays int64).
 
@@ -1011,7 +1047,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
 
   ca_size_t band = (group_prod > 0) ? (src->elements / group_prod) : 0;
 
-  /* --- supported dtype gate (CA_OBJECT handled by its own lane below) --- */
+  /* --- supported data type gate (CA_OBJECT handled by its own lane below) --- */
   ca = src;
   switch ( src->data_type ) {
   case CA_BOOLEAN: case CA_INT8:  case CA_UINT8:  case CA_INT16: case CA_UINT16:
@@ -1024,8 +1060,8 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
              src->data_type);
   }
 
-  /* --- output dtype per op: cumcount int64; cumsum / cumprod float64 (object
-     source -> object); cummax / cummin preserve the source dtype (object ->
+  /* --- output data type per op: cumcount int64; cumsum / cumprod float64 (object
+     source -> object); cummax / cummin preserve the source data type (object ->
      object). --- */
   int8_t out_dt;
   if      ( op == GS_CUMCOUNT )                        { out_dt = CA_INT64; }
@@ -1153,7 +1189,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
       }
     }
   }
-  else {                                          /* native dtype dispatch */
+  else {                                          /* native data type dispatch */
     switch ( op ) {
     case GS_CUMSUM: {
       double *outd = (double *) co->ptr;

data/ext/ca_binop_dispatch.c

@@ -14,9 +14,9 @@
   operands arrive at the common type.  Two ops break the uniform rule:
 
     QUO    -- only has a CA_OBJECT kernel; both operands promoted to
-              CA_OBJECT regardless of input dtypes
+              CA_OBJECT regardless of input data types
     IPOWER -- heterogeneous (left: float/cmplx preserved, right: int64);
-              output preserves left dtype.  See ca_op_ipower.c.
+              output preserves left data type.  See ca_op_ipower.c.
 
 ---------------------------------------------------------------------------- */
 
@@ -58,7 +58,6 @@ ca_binop_kernel_lookup_vv (uint16_t op_id, int8_t common_dt)
     case CA_BINOP_AND:        return ca_binop_and        [common_dt];
     case CA_BINOP_OR:         return ca_binop_or         [common_dt];
     case CA_BINOP_XOR:        return ca_binop_xor        [common_dt];
-    case CA_BINOP_REMINDER:   return ca_binop_reminder   [common_dt];
     default:                  return NULL;
   }
 }
@@ -107,8 +106,8 @@ ca_binop_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
 int
 ca_binop_is_trapping (uint16_t op_id, int8_t common_dt)
 {
-  /* Integer DIV / MOD / QUO can SIGFPE on a zero divisor.  Float DIV
-     returns NaN/Inf and does NOT trap, so it is not classified
+  /* Integer DIV / MOD / QUO / FMOD can SIGFPE on a zero divisor.  Float
+     DIV returns NaN/Inf and does NOT trap, so it is not classified
      trapping.                                                          */
   int is_integer = ( common_dt >= CA_INT8 && common_dt <= CA_UINT64 );
   if ( ! is_integer ) return 0;
@@ -117,7 +116,7 @@ ca_binop_is_trapping (uint16_t op_id, int8_t common_dt)
     case CA_BINOP_DIV:
     case CA_BINOP_MOD:
     case CA_BINOP_QUO:
-    case CA_BINOP_REMINDER:
+    case CA_BINOP_FMOD:
       return 1;
     default:
       return 0;

data/ext/ca_binop_dispatch.h

@@ -80,12 +80,6 @@ enum {
   CA_BINOP_OR        = 25,
   CA_BINOP_XOR       = 26,
 
-  /* IEEE 754 remainder (round-half-to-even, distinct from MOD which
-     truncates toward zero via C99 fmod on the float branch).  Integer
-     branch is identical to MOD (`%`).  All numeric + object.  Traps on
-     integer zero divisor, like MOD.                                    */
-  CA_BINOP_REMINDER  = 27,
-
   CA_BINOP_COUNT
 };
 
@@ -127,7 +121,6 @@ extern ca_binop_func_t ca_binop_minimum    [CA_NTYPE];
 extern ca_binop_func_t ca_binop_and        [CA_NTYPE];
 extern ca_binop_func_t ca_binop_or         [CA_NTYPE];
 extern ca_binop_func_t ca_binop_xor        [CA_NTYPE];
-extern ca_binop_func_t ca_binop_reminder   [CA_NTYPE];
 
 /* ------------------------------------------------------------------- */
 /* Dispatch API                                                         */

data/ext/ca_categorical_iterator.c

@@ -21,14 +21,14 @@
   kernel_iterator macros do not model, so the flat inputs are materialised here:
   ca_attach aliases a contiguous entity (codes / a contiguous value) and gathers
   a view.  Codes dispatch on their native integer type (no coercion); the value
-  move is a bytes-wide memcpy (grouped shares the value dtype, so no value-dtype
+  move is a bytes-wide memcpy (grouped shares the value data type, so no value-type
   dispatch is needed).
 
   Surface (private): codes.__categorical_scatter__(value, cursor, grouped, k)
     self    = codes   (integer, carries the exclusion mask), read flat
-    value   = payload (any dtype, may carry a mask), read flat, same length
+    value   = payload (any data type, may carry a mask), read flat, same length
     cursor  = int64 length-k segment starts (mutated in place, consumed)
-    grouped = pre-allocated contiguous entity of the value dtype, length nvalid
+    grouped = pre-allocated contiguous entity of the value data type, length nvalid
     k       = number of categories
   Returns grouped.
 
@@ -79,7 +79,7 @@ rb_ca_categorical_scatter (VALUE self, VALUE rvalue, VALUE rcursor,
     rb_raise(rb_eArgError, "__categorical_scatter__: cursor must be int64[k]");
   }
   if ( grouped->bytes != bytes ) {
-    rb_raise(rb_eArgError, "__categorical_scatter__: grouped/value dtype mismatch");
+    rb_raise(rb_eArgError, "__categorical_scatter__: grouped/value data type mismatch");
   }
 
   ca_attach(codes);
@@ -127,12 +127,12 @@ rb_ca_categorical_scatter (VALUE self, VALUE rvalue, VALUE rcursor,
   (empty / all-masked -> sum 0 identity, count 0, min/max masked).
 
   Surface (private): grouped.__reduceat_moments__(offsets, counts, sums, mins, maxs)
-    self    = grouped  (numeric value dtype, may carry a mask), contiguous entity
+    self    = grouped  (numeric value data type, may carry a mask), contiguous entity
     offsets = int64[k] segment STARTS; segment c = [offsets[c], offsets[c+1]),
               the last ends at grouped.elements
     counts  = int64[k]   output: present (non-masked) cells per segment
     sums    = float64[k] output: sum per segment (0 for empty, unmasked)
-    mins/maxs = value-dtype[k] output: min / max per segment; the kernel masks
+    mins/maxs = value-type[k] output: min / max per segment; the kernel masks
               the empty/all-masked segments (no value to report)
   Derived on the Ruby side: mean = sum/count, count_masked = sizes - count, etc.
 
@@ -190,7 +190,7 @@ rb_ca_reduceat_moments (VALUE self, VALUE roffsets, VALUE rcounts,
   if ( counts->elements != k || sums->elements != k ||
        mins->elements != k || maxs->elements != k ||
        mins->data_type != grouped->data_type || maxs->data_type != grouped->data_type ) {
-    rb_raise(rb_eArgError, "__reduceat_moments__: output shape/dtype mismatch");
+    rb_raise(rb_eArgError, "__reduceat_moments__: output shape/data type mismatch");
   }
 
   offs   = (int64_t *) offsets->ptr;
@@ -235,7 +235,7 @@ rb_ca_reduceat_moments (VALUE self, VALUE roffsets, VALUE rcounts,
   (f = (m-1)*p/100, k = floor(f), lo + (f-k)*(hi-lo)).  No per-segment view.
 
   Surface (private): grouped.__reduceat_percentile__(offsets, p, out)
-    self    = grouped  (numeric value dtype, may carry a mask)
+    self    = grouped  (numeric value data type, may carry a mask)
     offsets = int64[k] segment STARTS (last ends at grouped.elements)
     p       = percentile in 0..100 (median = 50, quantile(q) = q*100)
     out     = float64[k] output; empty / all-masked segments are masked
@@ -354,7 +354,7 @@ rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
   SS / (count-1).
 
   Surface (private): grouped.__reduceat_variance__(offsets, means, counts, out)
-    self    = grouped  (numeric value dtype, may carry a mask)
+    self    = grouped  (numeric value data type, may carry a mask)
     offsets = int64[k] segment STARTS
     means   = float64[k] per-segment mean (ignored where count < 2)
     counts  = int64[k]   per-segment present count
@@ -577,7 +577,7 @@ rb_ca_reduceat_argminmax (VALUE self, VALUE roffsets, VALUE rminidx, VALUE rmaxi
 }
 
 /* __reduceat_all_any__(offsets, all_out, any_out) — per-segment boolean AND / OR
-   over present cells. Value dtype must be boolean. Empty segment: all -> true,
+   over present cells. Value data type must be boolean. Empty segment: all -> true,
    any -> false. */
 static VALUE
 rb_ca_reduceat_all_any (VALUE self, VALUE roffsets, VALUE rall, VALUE rany)
@@ -817,8 +817,8 @@ rb_ca_reduceat_wsum_wmean (VALUE self, VALUE roffsets, VALUE rwg,
       counts_out = int64,   shape [K, ...H.band]  (present cells per group)
       sums_out   = float64, shape [K, ...H.band]  (per-group sum, 0 for empty)
 
-  Sums as float64 mirrors __reduceat_moments__; Ruby side casts to h dtype in
-  #sum (matches existing empty→0 identity contract).  Mins/maxs are in h dtype
+  Sums as float64 mirrors __reduceat_moments__; Ruby side casts to h data type in
+  #sum (matches existing empty→0 identity contract).  Mins/maxs are in h data type
   (empty group cell → 0 + masked, matching __reduceat_moments__).
 --------------------------------------------------------------------------- */
 
@@ -921,7 +921,7 @@ rb_ca_fiber_scatter_moments (VALUE self, VALUE rcodes, VALUE raxis, VALUE rk,
   }
   if ( mins->data_type != h->data_type || maxs->data_type != h->data_type ) {
     rb_raise(rb_eArgError,
-             "__fiber_scatter_moments__: mins/maxs must match h dtype");
+             "__fiber_scatter_moments__: mins/maxs must match h data type");
   }
   if ( counts->ndim != h->ndim || sums->ndim != h->ndim ||
        mins->ndim != h->ndim   || maxs->ndim != h->ndim ||

data/ext/ca_for_each_element.h

@@ -125,8 +125,9 @@ typedef struct {
  *   inner  : per-cell loop within chunk_n
  *
  * Memory peak per AC2: INPUT non-alias views materialise into a single
- * chunk scratch (~32KB at f64).  m0 (= masked form) is full size (=
- * n_kernel bytes) for simplicity; macro reads at m0[chunk_off + k].
+ * chunk scratch (~32KB at f64).  m0 (= masked form) is chunk-sized too and
+ * re-gathered per chunk, so the macro reads at m0[k] -- indexed within the
+ * chunk, not by the flat cell index.
  *
  * For MASKED forms (m / m_in / m_out): when source has no mask, m0 is
  * NULL and m / m_in == 0 always.  m_out writes during INOUT_MASKED are
@@ -162,8 +163,7 @@ typedef struct {
               && (((x) = *(T *)((_st1).core.base[0]                     \
                                 + __cfem_k * (_st1).core.stride[0])),   \
                   ((m) = (_st1).core.m0                                 \
-                            ? (_st1).core.m0[(_st1).core.chunk_off      \
-                                             + __cfem_k]                \
+                            ? (_st1).core.m0[__cfem_k]                  \
                             : (boolean8_t)0),                           \
                   1);                                                   \
             __cfem_k++ )
@@ -211,16 +211,14 @@ typedef struct {
               && (((in) = *(T_IN *)((_st2).core.base[0]                 \
                                     + __cfeim_k * (_st2).core.stride[0])), \
                   ((m_in) = (_st2).core.m0                              \
-                              ? (_st2).core.m0[(_st2).core.chunk_off    \
-                                               + __cfeim_k]             \
+                              ? (_st2).core.m0[__cfeim_k]               \
                               : (boolean8_t)0),                         \
                   ((m_out) = (m_in)),                                   \
                   1);                                                   \
             (*(T_OUT *)((_st2).core.base[1]                             \
                         + __cfeim_k * (_st2).core.stride[1]) = (out)),  \
             (((_st2).core.m0)                                           \
-                ? ((_st2).core.m0[(_st2).core.chunk_off + __cfeim_k]    \
-                     = (m_out))                                         \
+                ? ((_st2).core.m0[__cfeim_k] = (m_out))                 \
                 : (boolean8_t)0),                                       \
             __cfeim_k++ )
 

data/ext/ca_group_iter.c

@@ -292,7 +292,7 @@ Init_ca_group_iter (void)
      address of the extremum (there is no group-local min_index for the group
      iterator -- the order-preserving flat address is the meaningful position). */
   {
-    const char *ops[] = { "sum", "prod", "mean", "min", "max",
+    const char *ops[] = { "sum", "accumulate", "prod", "mean", "min", "max",
                           "variance", "stddev", "variancep", "stddevp",
                           "count", "count_not_masked", "min_addr", "max_addr",
                           "all", "any", NULL };

data/ext/ca_kernel_iterator.c

@@ -186,9 +186,7 @@ ca_iter_classify_source (CArray *src)
   if ( attach == ca_window_func.attach      ) return CA_ITER_SRC_DESCRIPTOR;  /* + CAShift */
 
   /* Step 9: SRC_ATTACH 5 view.  Each view-specific attach materialises
-     src->ptr via per-element transform; kernel sees a flat contig slab.
-     CAUnboundRepeat shares ca_stride_func.attach so it was already
-     classified as SRC_CASTRIDE above (prep doc §2.6). */
+     src->ptr via per-element transform; kernel sees a flat contig slab. */
   if ( attach == ca_fake_func.attach        ) return CA_ITER_SRC_ATTACH;
   if ( attach == ca_byte_swap_func.attach   ) return CA_ITER_SRC_ATTACH;
   if ( attach == ca_bitfield_func.attach    ) return CA_ITER_SRC_ATTACH;
@@ -526,6 +524,35 @@ ca_iter_validate_inputs (ca_iter_state    *st,
   return CA_ITER_OK;
 }
 
+/* Storage-identical wrapper strip for the kernel-compute entry.
+
+   A Face layers a semantic identifier and a CALazyMarker layers "read this
+   as the leaf of a lazy chain"; neither changes the storage, so routing and
+   alias decisions belong to what they wrap.  ca_strip_face answers this for
+   Face alone and is read that way in ~60 other places, so the marker is
+   added here rather than inside it.
+
+   The marker is NOT classified as a source in its own right.  Routing it to
+   CA_ITER_SRC_ATTACH would work but would allocate elements * bytes and pull
+   the whole array through ca_xfer_all first -- a.lazy.sum(axis: 0) would copy
+   what a.sum(axis: 0) aliases.  Descending instead lets the parent be
+   classified on its own merits, which costs nothing.
+
+   Unlike Face, nothing re-wraps the result: a reduction over a lazy marker
+   yields a plain entity, not a lazy view.
+
+   CAREFUL: a marker carries CA_FLAG_READ_ONLY and its parent usually does
+   not, so the WRITE rejection has to happen against the wrapper.  The caller
+   does that before stripping. */
+static CArray *
+ca_iter_strip_storage_wrapper (CArray *src)
+{
+  while ( src && ( ca_is_face(src) || ca_is_lazy_marker(src) ) ) {
+    src = ((CAView *) src)->parent;
+  }
+  return src;
+}
+
 int
 ca_iter_state_init_l1 (ca_iter_state    *st,
                        struct _CArray   *src,
@@ -534,10 +561,19 @@ ca_iter_state_init_l1 (ca_iter_state    *st,
                        int8_t            naxes,
                        uint32_t          flags)
 {
-  /* PROPOSAL_CAFACE_PHASE_2 F.2.6: Face strip at entry (= same rationale as
-     init_l2 above). Strip before validate_inputs. */
-  if ( ca_is_face(src) ) {
-    src = ca_strip_face(src);
+  /* PROPOSAL_CAFACE_PHASE_2 F.2.6 + PROPOSAL_LAZY_MARKER_LIFT Phase 0:
+     storage-identical wrapper strip at entry (= same rationale as init_l2
+     below).  Strip before validate_inputs.
+
+     The WRITE rejection is taken against the wrapper, not what it wraps: a
+     CALazyMarker is read-only while its parent is not, and stripping first
+     would let a destructive kernel through to the parent.  validate_inputs
+     re-checks the stripped source, which is harmless. */
+  if ( (flags & CA_KERNEL_WRITE) && ca_is_readonly(src) ) {
+    return CA_ITER_ERR_READONLY;
+  }
+  if ( ca_is_face(src) || ca_is_lazy_marker(src) ) {
+    src = ca_iter_strip_storage_wrapper(src);
   }
 
   int rc = ca_iter_validate_inputs(st, src, policy, flags);
@@ -712,16 +748,27 @@ ca_iter_state_init_l2 (ca_iter_state    *st,
                        int8_t            naxes,
                        uint32_t          flags)
 {
-  /* PROPOSAL_CAFACE_PHASE_2 F.2.6 (= MEMO §3.5 kernel_iterator entry strip):
-     Face only layers a semantic identifier; storage is identical to parent,
-     so strip at the kernel-compute entry and descend to parent. The Face
-     identifier is re-wrapped onto the result by the caller's lift hook
-     (= primary operators / reductions / etc.). Because Face is an identity
-     mask, routing / alias decisions should be based on parent.
-     Strip before validate_inputs — `classify_source` would reject Face as
-     knows-no. */
-  if ( ca_is_face(src) ) {
-    src = ca_strip_face(src);
+  /* PROPOSAL_CAFACE_PHASE_2 F.2.6 (= MEMO §3.5 kernel_iterator entry strip)
+     + PROPOSAL_LAZY_MARKER_LIFT Phase 0.
+
+     A Face only layers a semantic identifier and a CALazyMarker only layers
+     "leaf of a lazy chain"; storage is identical to the parent either way, so
+     strip at the kernel-compute entry and descend.  Routing and alias
+     decisions belong to the parent.  Strip before validate_inputs —
+     classify_source rejects both as knows-no.
+
+     The Face identifier is re-wrapped onto the result by the caller's lift
+     hook (= primary operators / reductions / etc.).  The marker is not:
+     a reduction over a lazy marker yields a plain entity.
+
+     WRITE is rejected against the wrapper, before the strip — a marker is
+     read-only while its parent is not.  validate_inputs re-checks the
+     stripped source, which is harmless. */
+  if ( (flags & CA_KERNEL_WRITE) && ca_is_readonly(src) ) {
+    return CA_ITER_ERR_READONLY;
+  }
+  if ( ca_is_face(src) || ca_is_lazy_marker(src) ) {
+    src = ca_iter_strip_storage_wrapper(src);
   }
 
   int rc = ca_iter_validate_inputs(st, src, policy, flags);
@@ -1028,8 +1075,8 @@ ca_iter_state_init_l2 (ca_iter_state    *st,
       }
       /* slab is all-STRIDE: fall through to B.1.5 / Phase B paths. */
       /* Phase B.1.5: outer SHIFT axis → materialise downgrade.  Alias
-         can't deliver OOB cells (= need fill_value), so per the
-         delivery principle (CLAUDE.md §"deliver" + D1.3 confirmed),
+         can't deliver OOB cells (= need fill_value), and the view-family
+         surface prioritises delivering the cells over avoiding a copy, so
          we materialise the entire view into a row-major scratch
          buffer via ca_axis_dispatch_attach (= same engine as the
          existing SRC_DESCRIPTOR L2 NONE path), then walk it with
@@ -1804,9 +1851,9 @@ ca_iter_state_init_l2 (ca_iter_state    *st,
     return CA_ITER_OK;
   }
 
-  /* Sub-step 5.3: L2 dispatch over descriptor sources.  Per the
-     delivery principle (CLAUDE.md "view-family surface prioritises delivery",
-     PROPOSAL_T1_STEP5_DESCRIPTOR.md §0): always materialise into a
+  /* Sub-step 5.3: L2 dispatch over descriptor sources.  The view-family
+     surface prioritises delivering the cells over avoiding a copy: always
+     materialise into a
      scratch buffer via ca_axis_dispatch_attach and yield a single
      strided slab (stride = bytes).  CASelect/CAMapping always reach
      here, CSA/CAGrid/CAWindow/CAShift when INDEX/SHIFT axes are
@@ -4316,6 +4363,5 @@ Init_ca_kernel_iterator (void)
   rb_define_const(rb_cCArray, "T1_ITER_ALIAS_CONTIG",    INT2NUM(CA_ITER_ALIAS_CONTIG));
   rb_define_const(rb_cCArray, "T1_ITER_ALIAS_STRIDED",   INT2NUM(CA_ITER_ALIAS_STRIDED));
   rb_define_const(rb_cCArray, "T1_ITER_ALIAS_ATTACH",    INT2NUM(CA_ITER_ALIAS_ATTACH));
-  rb_define_const(rb_cCArray, "T1_ITER_ERR_UNBOUND_SHAPE", INT2NUM(CA_ITER_ERR_UNBOUND_SHAPE));
 #endif /* CARRAY_DEV_BUILD */
 }

data/ext/ca_kernel_iterator.h

@@ -198,15 +198,9 @@ typedef enum {
 #define CA_ITER_ERR_READONLY    4    /* WRITE on readonly view (CARepeat etc.) */
 #define CA_ITER_ERR_MASK        5    /* masked source — step 4-5 only, lifted in step 6 */
 #define CA_ITER_ERR_MASK_NOT_ALLOWED 6  /* NO_MASK flag set on a masked source (step 7) */
-#define CA_ITER_ERR_UNBOUND_SHAPE 7  /* CAUnboundRepeat passed before bind() — reserved for
-                                        sub-step 9.3 (= used iff unbound CAUbrep smoke shows
-                                        unsafe behavior on the existing SRC_CASTRIDE path) */
-
 /* ---- source kind (step 5+, internal routing) ------------------------- */
 #define CA_ITER_SRC_NONE       0
-#define CA_ITER_SRC_CASTRIDE   1     /* entity / CAStride family (step 1-4).
-                                        CAUnboundRepeat is also classified
-                                        here via ca_ubrep_func = ca_stride_func. */
+#define CA_ITER_SRC_CASTRIDE   1     /* entity / CAStride family (step 1-4) */
 #define CA_ITER_SRC_DESCRIPTOR 2     /* CSA / CAGrid / CASelect / CAMapping / CAWindow / CAShift (step 5+) */
 #define CA_ITER_SRC_ATTACH     3     /* CAFake / CAByteSwap / CABitfield /
                                         CABitarray / CAReduce — view's own
@@ -1100,8 +1094,7 @@ void ca_iter_state_finish (ca_iter_state *st);
  *
  *   PoC (2026-06-12): N=1M f64 sum 906 us -> 116 us (= 7.8x, 68.8 GB/s).
  *   Parity: ε-close (relative error < 2e-16 for f64 sum), bit-exact
- *   not guaranteed (= reassoc license, documented in CLAUDE.md
- *   ε-close policy section, SL.1.5).
+ *   not guaranteed (= the SIMD license; see guides/devel/11_kernel_iterator.md).
  *
  *   Other state vars referenced inside REDUCE (induction counters
  *   like `cnt`, position counters like `idx`) are auto-vectorised
@@ -1217,7 +1210,7 @@ void ca_iter_state_finish (ca_iter_state *st);
  *   EXPR(x) is a function-like macro producing the per-element contribution
  *   (Pass 1: (double)(x); Pass 2: ((double)(x)-mean)*((double)(x)-mean)).
  *   Reassoc across the 8 lanes is the same ε-close license as _PLUS_EX
- *   (bit-exact not guaranteed; CLAUDE.md ε-close policy, SL.1.5).
+ *   (bit-exact not guaranteed; see guides/devel/11_kernel_iterator.md).
  *
  *   Only the no-mask + contig branch is 8-way; masked / non-contig
  *   branches stay single-accumulator (not the hot path).  Position