carray 3.0.2 → 3.0.4

data/ext/ca_axis_group.c

@@ -33,6 +33,7 @@
 --------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* CA_EXTREMUM_REPLACES, ca_obj_extremum_replaces */
 #include "ca_kernel_iterator.h"
 #include <math.h>
 
@@ -64,8 +65,8 @@ group_op_code (VALUE vop)
   else if ( id == rb_intern("max_addr") ) return GR_MAXADDR;
   else if ( id == rb_intern("all") )      return GR_ALL;
   else if ( id == rb_intern("any") )      return GR_ANY;
-  rb_raise(rb_eArgError, "axis_group_reduce: unsupported op :%s",
-           rb_id2name(id));
+  rb_raise(rb_eArgError, "axis_group_reduce: unsupported op :%"PRIsVALUE,
+           rb_id2str(id));
 }
 
 /* ---- per-slab-element composite-code walk, templated on the load type ----
@@ -206,16 +207,16 @@ group_op_code (VALUE vop)
    only while nothing else has landed, the first number displaces it, and a
    group of nothing but NaN answers NaN (for a position, UNDEF).  `v` is the
    widened load, so testing it for NaN is the same question for every source
-   type and costs an integer body nothing.  seen_num[] says whether a number
-   has landed; cnt[] still says whether anything has. */
+   type and costs an integer body nothing.  The replacement test is the
+   shared CA_EXTREMUM_REPLACES; the first member is taken whatever it is.
+   seen_num[] says whether a number has landed (the positions read it);
+   cnt[] says whether anything has. */
 #define GMINMAX(T, A, CMP)                                                     \
   do {                                                                         \
     A *acc = (A *) co->ptr;                                                     \
     A  av  = (A) rv;                                                            \
-    if ( v == v ) {                                                             \
-      if ( ! seen_num[o] ) { acc[o] = av; seen_num[o] = 1; }                     \
-      else if ( av CMP acc[o] ) acc[o] = av;                                     \
-    } else if ( cnt[o] == 0 ) acc[o] = av;                                       \
+    if ( cnt[o] == 0 || CA_EXTREMUM_REPLACES(av, acc[o], CMP) ) acc[o] = av;    \
+    if ( v == v ) seen_num[o] = 1;                                              \
     cnt[o] += 1;                                                                \
   } while (0)
 
@@ -282,7 +283,7 @@ group_op_code (VALUE vop)
 #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
+/* __reduce_by_axis_groups__(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)
  * axes.  Internal: the Ruby surface is CAGroupIterator.
@@ -310,7 +311,7 @@ group_op_code (VALUE vop)
    Empty / all-masked groups follow the CArray zero-contribution contract: an
    identity-bearing op returns its identity (sum 0, prod 1, count 0, all true,
    any false), a ratio / extremum returns UNDEF.  Sample variance / stddev:
-   n == 0 UNDEF, n == 1 -> 0.0, n >= 2 the formula.
+   n < 2 UNDEF, n >= 2 the formula.
 */
 static VALUE
 rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
@@ -321,7 +322,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   GetCArray(self, src);
 
   if ( src->ndim <= 0 ) {
-    rb_raise(rb_eRuntimeError, "axis_group_reduce: scalar source");
+    rb_raise(rb_eArgError, "axis_group_reduce: scalar source");
   }
 
   /* --- group (slab) axes --- */
@@ -351,7 +352,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   /* --- bundles: small per-group code tables (metadata, kept alive) --- */
   Check_Type(vbundles, T_ARRAY);
   int  n_bundles = (int) RARRAY_LEN(vbundles);
-  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {
+  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {   /* rank-check: a count of key bundles */
     rb_raise(rb_eArgError, "axis_group_reduce: bad bundle count %d", n_bundles);
   }
   int32_t  *bundle_codes[CA_RANK_MAX];
@@ -361,7 +362,8 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   int       bundle_slot[CA_RANK_MAX][CA_RANK_MAX];
   ca_size_t bundle_cstride[CA_RANK_MAX][CA_RANK_MAX];
   CArray   *bundle_ca[CA_RANK_MAX];
-  volatile VALUE keep = rb_ary_new();   /* GC-pin int32 code views */
+  volatile VALUE keep = rb_ary_new();   /* keeps the int32 code views alive */
+  volatile VALUE h_codes[CA_RANK_MAX];  /* holders of the copied code tables */
 
   ca_size_t K_total = 1;
   long consumed_total = 0;
@@ -384,20 +386,16 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
        and the end of the walk can raise -- a validation just below, a gather
        that cannot convert a cell, an object-lane callback into Ruby -- and a
        raise jumps over every detach, leaving the source materialised with
-       nothing left to release it. The copy rides a temporary buffer that the
-       unwind collects. */
+       nothing left to release it. The copy rides ALLOCV, a temporary buffer
+       that the unwind collects. Not a String: a String held only by `keep`
+       can be moved by compaction, taking the bytes under bundle_codes with
+       it. */
     VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
     rb_ary_push((VALUE) keep, v32);
     GetCArray(v32, bundle_ca[bi]);
-    {
-      size_t nbytes = (size_t) bundle_ca[bi]->elements * sizeof(int32_t);
-      VALUE  vbuf   = rb_str_tmp_new((long) nbytes);
-      rb_ary_push((VALUE) keep, vbuf);
-      ca_attach(bundle_ca[bi]);
-      memcpy(RSTRING_PTR(vbuf), bundle_ca[bi]->ptr, nbytes);
-      ca_detach(bundle_ca[bi]);
-      bundle_codes[bi] = (int32_t *) RSTRING_PTR(vbuf);
-    }
+    h_codes[bi] = 0;
+    bundle_codes[bi] = ALLOCV_N(int32_t, h_codes[bi], bundle_ca[bi]->elements);
+    ca_copy_data(bundle_ca[bi], (char *) bundle_codes[bi]);
 
     int nb = (int) RARRAY_LEN(vbaxes);
     if ( nb <= 0 || nb > src->ndim ) {
@@ -477,9 +475,9 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   case CA_INT32:   case CA_UINT32: case CA_INT64: case CA_UINT64:
   case CA_FLOAT32: case CA_FLOAT64: break;
   default:
-    rb_raise(rb_eRuntimeError,
-             "axis_group_reduce: unsupported source data_type %d",
-             src->data_type);
+    rb_raise(rb_eCADataTypeError,
+             "axis_group: %"PRIsVALUE" over a group is not supported for data type %s",
+             rb_sym2str(vop), ca_type_name[src->data_type]);
   }
 
   /* output data type per op */
@@ -618,8 +616,8 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   /* Empty / all-masked groups follow the same zero-contribution contract as
      CArray reductions (ERI, matching the categorical sibling): an identity-
      bearing op returns its identity (sum 0, prod 1, count 0, all true, any
-     false), a ratio / extremum returns UNDEF. Sample variance/stddev: n==0
-     UNDEF, n==1 -> 0.0 (the n=1 contract), n>=2 the formula. */
+     false), a ratio / extremum returns UNDEF. Sample variance/stddev: n<2
+     UNDEF (n-1 is zero), n>=2 the formula. */
   if ( op == GR_COUNT ) {
     int64_t *out = (int64_t *) co->ptr;
     for ( ca_size_t o = 0; o < nout; o++ ) out[o] = (int64_t) cnt[o];
@@ -664,8 +662,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
         break;
       case GR_VARIANCE:
       case GR_STDDEV:
-        if ( cnt[o] == 0 ) { out[o] = 0.0; MARK_UNDEF(o); }
-        else if ( cnt[o] == 1 ) { out[o] = 0.0; }         /* n=1 contract */
+        if ( cnt[o] < 2 ) { out[o] = 0.0; MARK_UNDEF(o); }
         else { double var = sumsq[o] / ( (double) cnt[o] - 1.0 );
                out[o] = ( op == GR_STDDEV ) ? sqrt(var) : var; }
         break;
@@ -684,6 +681,7 @@ rb_ca_axis_group_reduce (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   ALLOCV_END(h_prod);   ALLOCV_END(h_seen);   ALLOCV_END(h_xbuf);
   ALLOCV_END(h_nz);     ALLOCV_END(h_mnaddr); ALLOCV_END(h_mxaddr);
   ALLOCV_END(h_band);
+  for ( int bi = 0; bi < n_bundles; bi++ ) ALLOCV_END(h_codes[bi]);
 
   RB_GC_GUARD(keep);
   return vout;
@@ -854,7 +852,9 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
    emits its own value: a per-group `seen` byte initialises the accumulator
    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
+   running extremum when CA_EXTREMUM_REPLACES (a NaN never does, and a
+   number displaces a leading NaN, as the core cummax / cummin and the
+   reduce twins above do).  A cell masked within its group holds the
    current extremum once a member has been seen (output NOT masked, like sum);
    before any member the extremum is undefined so the cell stays UNDEF (the
    CArray reduction contract: empty max/min has no value — deliberately NOT the
@@ -895,7 +895,9 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
           }                                                                   \
           T rv = *(T *)(p + sw_doff[e]);                                      \
           if ( ! seen[code] ) { acce[code] = rv; seen[code] = 1; }            \
-          else if ( rv CMP acce[code] ) { acce[code] = rv; }                  \
+          else if ( CA_EXTREMUM_REPLACES(rv, acce[code], CMP) ) {             \
+            acce[code] = rv;                                                  \
+          }                                                                   \
           outp[addr] = acce[code];                                            \
         }                                                                     \
       }                                                                       \
@@ -933,19 +935,19 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
    both unmasked (matching core object cumsum / cumprod); cummax / cummin hold
    the running VALUE only once a member has been seen and stay UNDEF before that
    (no identity for arbitrary objects).  GW_SKIP (excluded) stays UNDEF.  accn /
-   seen are reset at each band; acco carries the running VALUE. */
+   seen are reset at each band; acco carries the running VALUE.
+   Expanded only in group_scan_object_body, whose walk state is c->st. */
 #define GROUP_SCAN_OBJECT_WALK(EMIT, HOLD)                                    \
   do {                                                                        \
-    ca_iter_state st;                                                         \
     char       *p;                                                            \
     boolean8_t *m;                                                            \
     ca_size_t   b = 0;                                                        \
     int         ready = 0;                                                    \
-    CA_FOR_EACH_SLAB(st, ca, axes, (int8_t) ngroup, CA_KERNEL_READ, p, m) {   \
-      ca_size_t SE = st.slab_elements;                                        \
+    CA_FOR_EACH_SLAB(c->st, ca, axes, (int8_t) ngroup, CA_KERNEL_READ, p, m) {\
+      ca_size_t SE = c->st.slab_elements;                                     \
       if ( SE > 0 ) {                                                         \
         if ( ! ready ) {                                                      \
-          group_scan_build_plan(&st, m, n_bundles, bundle_codes, bundle_k,   \
+          group_scan_build_plan(&c->st, m, n_bundles, bundle_codes, bundle_k,\
                                 bundle_placeval, bundle_nconsumed,            \
                                 bundle_slot, bundle_cstride, ngroup,          \
                                 grstride, sw_code, sw_doff, sw_moff, sw_addr);\
@@ -970,6 +972,137 @@ group_scan_build_plan (ca_iter_state *st, boolean8_t *m,
     }                                                                         \
   } while (0)
 
+/* Marks output cell o UNDEF, creating the output mask on first use.  Used
+   by the scan walks, in functions that hold the output as `co` and the mask
+   pointer as `omask`. */
+#define MARK_OUT_UNDEF(o) do {                   \
+    if ( ! omask ) {                             \
+      ca_create_mask(co);                        \
+      omask = (boolean8_t *) co->mask->ptr;      \
+    }                                            \
+    omask[o] = 1;                                \
+  } while (0)
+
+/* The CA_OBJECT lane of __scan_by_axis_groups__.  Every cell calls into Ruby,
+   so the walk can raise part way; its state lives in the caller's frame, in
+   c->st, and ca_iter_ensure finishes it however this body leaves.  The
+   buffers are ALLOCV-backed, so the unwind collects them. */
+typedef struct {
+  ca_iter_state st;
+  CArray     *ca;
+  CArray     *co;
+  int         op;
+  int8_t     *axes;
+  long        ngroup;
+  int         n_bundles;
+  int32_t   **bundle_codes;
+  ca_size_t  *bundle_k;
+  ca_size_t  *bundle_placeval;
+  int        *bundle_nconsumed;
+  int       (*bundle_slot)[CA_RANK_MAX];
+  ca_size_t (*bundle_cstride)[CA_RANK_MAX];
+  ca_size_t  *grstride;
+  ca_size_t  *band_addr;
+  ca_size_t   K_total;
+  ca_size_t  *sw_code;
+  ca_size_t  *sw_doff;
+  ca_size_t  *sw_moff;
+  ca_size_t  *sw_addr;
+  ca_size_t  *accn;
+  char       *seen;
+  VALUE      *acco;
+} group_scan_object_t;
+
+static VALUE
+group_scan_object_body (VALUE arg)
+{
+  group_scan_object_t *c = (group_scan_object_t *) arg;
+  CArray     *ca               = c->ca;
+  CArray     *co               = c->co;
+  int         op               = c->op;
+  int8_t     *axes             = c->axes;
+  long        ngroup           = c->ngroup;
+  int         n_bundles        = c->n_bundles;
+  int32_t   **bundle_codes     = c->bundle_codes;
+  ca_size_t  *bundle_k         = c->bundle_k;
+  ca_size_t  *bundle_placeval  = c->bundle_placeval;
+  int        *bundle_nconsumed = c->bundle_nconsumed;
+  int       (*bundle_slot)[CA_RANK_MAX]    = c->bundle_slot;
+  ca_size_t (*bundle_cstride)[CA_RANK_MAX] = c->bundle_cstride;
+  ca_size_t  *grstride         = c->grstride;
+  ca_size_t  *band_addr        = c->band_addr;
+  ca_size_t   K_total          = c->K_total;
+  ca_size_t  *sw_code          = c->sw_code;
+  ca_size_t  *sw_doff          = c->sw_doff;
+  ca_size_t  *sw_moff          = c->sw_moff;
+  ca_size_t  *sw_addr          = c->sw_addr;
+  ca_size_t  *accn             = c->accn;
+  char       *seen             = c->seen;
+  VALUE      *acco             = c->acco;
+  boolean8_t *omask            = NULL;
+
+  if ( op == GS_CUMCOUNT ) {                    /* int64 1-based running count */
+    int64_t *outi = (int64_t *) co->ptr;
+    GROUP_SCAN_OBJECT_WALK(
+      accn[code] += 1; outi[addr] = (int64_t) accn[code];,
+      outi[addr] = (int64_t) accn[code];
+    );
+  }
+  else {                                        /* object running VALUE */
+    VALUE *outo = (VALUE *) co->ptr;
+    switch ( op ) {
+    case GS_CUMSUM:
+      /* Identity 0 (matching the core object cumsum): a group's acc is lazily
+         seeded to 0 (Fixnum, so 0 + ev promotes to ev's class), so a cell
+         masked before any present member holds 0 unmasked and an all-masked
+         group yields 0 everywhere.  seen doubles as the per-band init flag. */
+      GROUP_SCAN_OBJECT_WALK(
+        if ( ! seen[code] ) { acco[code] = INT2FIX(0); seen[code] = 1; }
+        acco[code] = rb_funcall(acco[code], rb_intern("+"), 1, ev);
+        outo[addr] = acco[code];,
+        if ( ! seen[code] ) { acco[code] = INT2FIX(0); seen[code] = 1; }
+        outo[addr] = acco[code];
+      );
+      break;
+    case GS_CUMPROD:
+      /* Identity 1, same lazy-init as cumsum. */
+      GROUP_SCAN_OBJECT_WALK(
+        if ( ! seen[code] ) { acco[code] = INT2FIX(1); seen[code] = 1; }
+        acco[code] = rb_funcall(acco[code], rb_intern("*"), 1, ev);
+        outo[addr] = acco[code];,
+        if ( ! seen[code] ) { acco[code] = INT2FIX(1); seen[code] = 1; }
+        outo[addr] = acco[code];
+      );
+      break;
+    case GS_CUMMAX:
+      /* No identity: seed from the first member, hold only once seen; a cell
+         masked before any member stays UNDEF (empty-max contract). */
+      GROUP_SCAN_OBJECT_WALK(
+        if ( ! seen[code] ) { acco[code] = ev; seen[code] = 1; }
+        else if ( ca_obj_extremum_replaces(ev, acco[code], rb_intern(">")) ) {
+          acco[code] = ev;
+        }
+        outo[addr] = acco[code];,
+        if ( seen[code] ) { outo[addr] = acco[code]; }
+        else { MARK_OUT_UNDEF(addr); }
+      );
+      break;
+    case GS_CUMMIN:
+      GROUP_SCAN_OBJECT_WALK(
+        if ( ! seen[code] ) { acco[code] = ev; seen[code] = 1; }
+        else if ( ca_obj_extremum_replaces(ev, acco[code], rb_intern("<")) ) {
+          acco[code] = ev;
+        }
+        outo[addr] = acco[code];,
+        if ( seen[code] ) { outo[addr] = acco[code]; }
+        else { MARK_OUT_UNDEF(addr); }
+      );
+      break;
+    }
+  }
+  return Qnil;
+}
+
 static int
 group_scan_op_code (VALUE vop)
 {
@@ -979,12 +1112,12 @@ group_scan_op_code (VALUE vop)
   else if ( id == rb_intern("cummax") )   return GS_CUMMAX;
   else if ( id == rb_intern("cummin") )   return GS_CUMMIN;
   else if ( id == rb_intern("cumprod") )  return GS_CUMPROD;
-  rb_raise(rb_eArgError, "axis_group_scan: unsupported op :%s", rb_id2name(id));
+  rb_raise(rb_eArgError, "axis_group_scan: unsupported op :%"PRIsVALUE, rb_id2str(id));
 }
 
-/* __axis_group_scan__(group_axes, bundles, op) — group-keyed segment scan of
+/* __scan_by_axis_groups__(group_axes, bundles, op) — group-keyed segment scan of
  * self over the union of `group_axes` into composite groups described by
- * `bundles` (same argument shape as __axis_group_reduce__).  Internal.
+ * `bundles` (same argument shape as __reduce_by_axis_groups__).  Internal.
  *
  * Unlike the reduce the grouped axes are not collapsed: the result is a new
  * CArray of the same shape as self, each cell holding the running statistic of
@@ -1022,7 +1155,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   GetCArray(self, src);
 
   if ( src->ndim <= 0 ) {
-    rb_raise(rb_eRuntimeError, "axis_group_scan: scalar source");
+    rb_raise(rb_eArgError, "axis_group_scan: scalar source");
   }
 
   /* --- group (slab) axes (same validation as reduce) --- */
@@ -1054,7 +1187,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   /* --- bundles: small per-group code tables (same as reduce) --- */
   Check_Type(vbundles, T_ARRAY);
   int  n_bundles = (int) RARRAY_LEN(vbundles);
-  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {
+  if ( n_bundles <= 0 || n_bundles > CA_RANK_MAX ) {   /* rank-check: a count of key bundles */
     rb_raise(rb_eArgError, "axis_group_scan: bad bundle count %d", n_bundles);
   }
   int32_t  *bundle_codes[CA_RANK_MAX];
@@ -1065,6 +1198,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   ca_size_t bundle_cstride[CA_RANK_MAX][CA_RANK_MAX];
   CArray   *bundle_ca[CA_RANK_MAX];
   volatile VALUE keep = rb_ary_new();
+  volatile VALUE h_codes[CA_RANK_MAX];
 
   ca_size_t K_total = 1;
   long consumed_total = 0;
@@ -1087,20 +1221,16 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
        and the end of the walk can raise -- a validation just below, a gather
        that cannot convert a cell, an object-lane callback into Ruby -- and a
        raise jumps over every detach, leaving the source materialised with
-       nothing left to release it. The copy rides a temporary buffer that the
-       unwind collects. */
+       nothing left to release it. The copy rides ALLOCV, a temporary buffer
+       that the unwind collects. Not a String: a String held only by `keep`
+       can be moved by compaction, taking the bytes under bundle_codes with
+       it. */
     VALUE v32 = rb_ca_wrap_readonly(vcodes, INT2NUM(CA_INT32));
     rb_ary_push((VALUE) keep, v32);
     GetCArray(v32, bundle_ca[bi]);
-    {
-      size_t nbytes = (size_t) bundle_ca[bi]->elements * sizeof(int32_t);
-      VALUE  vbuf   = rb_str_tmp_new((long) nbytes);
-      rb_ary_push((VALUE) keep, vbuf);
-      ca_attach(bundle_ca[bi]);
-      memcpy(RSTRING_PTR(vbuf), bundle_ca[bi]->ptr, nbytes);
-      ca_detach(bundle_ca[bi]);
-      bundle_codes[bi] = (int32_t *) RSTRING_PTR(vbuf);
-    }
+    h_codes[bi] = 0;
+    bundle_codes[bi] = ALLOCV_N(int32_t, h_codes[bi], bundle_ca[bi]->elements);
+    ca_copy_data(bundle_ca[bi], (char *) bundle_codes[bi]);
 
     int nb = (int) RARRAY_LEN(vbaxes);
     if ( nb <= 0 || nb > src->ndim ) {
@@ -1160,7 +1290,7 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   case CA_INT32:   case CA_UINT32: case CA_INT64: case CA_UINT64:
   case CA_FLOAT32: case CA_FLOAT64: case CA_OBJECT: break;
   default:
-    rb_raise(rb_eRuntimeError,
+    rb_raise(rb_eCADataTypeError,
              "axis_group_scan: unsupported source data_type %d",
              src->data_type);
   }
@@ -1232,75 +1362,23 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
   double     acc_init = ( op == GS_CUMPROD ) ? 1.0 : 0.0;
 
   boolean8_t *omask = NULL;
-  #define MARK_OUT_UNDEF(o) do {                   \
-      if ( ! omask ) {                             \
-        ca_create_mask(co);                        \
-        omask = (boolean8_t *) co->mask->ptr;      \
-      }                                            \
-      omask[o] = 1;                                \
-    } while (0)
 
   if ( src->data_type == CA_OBJECT ) {
-    if ( op == GS_CUMCOUNT ) {                    /* int64 1-based running count */
-      int64_t *outi = (int64_t *) co->ptr;
-      GROUP_SCAN_OBJECT_WALK(
-        accn[code] += 1; outi[addr] = (int64_t) accn[code];,
-        outi[addr] = (int64_t) accn[code];
-      );
-    }
-    else {                                        /* object running VALUE */
-      VALUE *outo = (VALUE *) co->ptr;
+    group_scan_object_t c;
+    if ( op != GS_CUMCOUNT ) {
       acco = ALLOCV_N(VALUE, h_acco, K_total);
-      switch ( op ) {
-      case GS_CUMSUM:
-        /* Identity 0 (matching the core object cumsum): a group's acc is lazily
-           seeded to 0 (Fixnum, so 0 + ev promotes to ev's class), so a cell
-           masked before any present member holds 0 unmasked and an all-masked
-           group yields 0 everywhere.  seen doubles as the per-band init flag. */
-        GROUP_SCAN_OBJECT_WALK(
-          if ( ! seen[code] ) { acco[code] = INT2FIX(0); seen[code] = 1; }
-          acco[code] = rb_funcall(acco[code], rb_intern("+"), 1, ev);
-          outo[addr] = acco[code];,
-          if ( ! seen[code] ) { acco[code] = INT2FIX(0); seen[code] = 1; }
-          outo[addr] = acco[code];
-        );
-        break;
-      case GS_CUMPROD:
-        /* Identity 1, same lazy-init as cumsum. */
-        GROUP_SCAN_OBJECT_WALK(
-          if ( ! seen[code] ) { acco[code] = INT2FIX(1); seen[code] = 1; }
-          acco[code] = rb_funcall(acco[code], rb_intern("*"), 1, ev);
-          outo[addr] = acco[code];,
-          if ( ! seen[code] ) { acco[code] = INT2FIX(1); seen[code] = 1; }
-          outo[addr] = acco[code];
-        );
-        break;
-      case GS_CUMMAX:
-        /* No identity: seed from the first member, hold only once seen; a cell
-           masked before any member stays UNDEF (empty-max contract). */
-        GROUP_SCAN_OBJECT_WALK(
-          if ( ! seen[code] ) { acco[code] = ev; seen[code] = 1; }
-          else if ( NUM2INT(rb_funcall(ev, rb_intern("<=>"), 1, acco[code])) > 0 ) {
-            acco[code] = ev;
-          }
-          outo[addr] = acco[code];,
-          if ( seen[code] ) { outo[addr] = acco[code]; }
-          else { MARK_OUT_UNDEF(addr); }
-        );
-        break;
-      case GS_CUMMIN:
-        GROUP_SCAN_OBJECT_WALK(
-          if ( ! seen[code] ) { acco[code] = ev; seen[code] = 1; }
-          else if ( NUM2INT(rb_funcall(ev, rb_intern("<=>"), 1, acco[code])) < 0 ) {
-            acco[code] = ev;
-          }
-          outo[addr] = acco[code];,
-          if ( seen[code] ) { outo[addr] = acco[code]; }
-          else { MARK_OUT_UNDEF(addr); }
-        );
-        break;
-      }
     }
+    c.ca = ca;  c.co = co;  c.op = op;
+    c.axes = axes;  c.ngroup = ngroup;
+    c.n_bundles = n_bundles;  c.bundle_codes = bundle_codes;
+    c.bundle_k = bundle_k;  c.bundle_placeval = bundle_placeval;
+    c.bundle_nconsumed = bundle_nconsumed;
+    c.bundle_slot = bundle_slot;  c.bundle_cstride = bundle_cstride;
+    c.grstride = grstride;  c.band_addr = band_addr;  c.K_total = K_total;
+    c.sw_code = sw_code;  c.sw_doff = sw_doff;
+    c.sw_moff = sw_moff;  c.sw_addr = sw_addr;
+    c.accn = accn;  c.seen = seen;  c.acco = acco;
+    ca_iter_ensure(1, &c.st, group_scan_object_body, (VALUE) &c);
   }
   else {                                          /* native data type dispatch */
     switch ( op ) {
@@ -1330,11 +1408,11 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
       break;
     }
   }
-  #undef MARK_OUT_UNDEF
 
   ALLOCV_END(h_band2); ALLOCV_END(h_code);  ALLOCV_END(h_doff);
   ALLOCV_END(h_moff);  ALLOCV_END(h_addr);  ALLOCV_END(h_accd);
   ALLOCV_END(h_accn);  ALLOCV_END(h_seen);  ALLOCV_END(h_acco);
+  for ( int bi = 0; bi < n_bundles; bi++ ) ALLOCV_END(h_codes[bi]);
 
   RB_GC_GUARD(keep);
   return vout;
@@ -1343,8 +1421,8 @@ rb_ca_axis_group_scan (VALUE self, VALUE vgaxes, VALUE vbundles, VALUE vop)
 void
 Init_ca_axis_group (void)
 {
-  rb_define_method(rb_cCArray, "__axis_group_reduce__",
+  rb_define_method(rb_cCArray, "__reduce_by_axis_groups__",
                    rb_ca_axis_group_reduce, 3);
-  rb_define_method(rb_cCArray, "__axis_group_scan__",
+  rb_define_method(rb_cCArray, "__scan_by_axis_groups__",
                    rb_ca_axis_group_scan, 3);
 }

data/ext/ca_binop_dispatch.c

@@ -27,39 +27,56 @@
 /* vv kernel lookup                                                     */
 /* ------------------------------------------------------------------- */
 
+/* The kernel table of each op id.  The eager operators hold the tables
+   themselves; ca_binop_op_id_of_table maps one back to its op id, so that
+   both ask ca_op_raises_on_cell the same question. */
+static ca_binop_func_t * const ca_binop_tables[CA_BINOP_COUNT] = {
+  [CA_BINOP_ADD]       = ca_binop_add,
+  [CA_BINOP_SUB]       = ca_binop_sub,
+  [CA_BINOP_MUL]       = ca_binop_mul,
+  [CA_BINOP_DIV]       = ca_binop_div,
+  [CA_BINOP_POW]       = ca_binop_power,
+  [CA_BINOP_BIT_AND]   = ca_binop_bit_and_i,
+  [CA_BINOP_BIT_OR]    = ca_binop_bit_or_i,
+  [CA_BINOP_BIT_XOR]   = ca_binop_bit_xor_i,
+  [CA_BINOP_BIT_LSHIFT]= ca_binop_bit_lshift,
+  [CA_BINOP_BIT_RSHIFT]= ca_binop_bit_rshift,
+  [CA_BINOP_MOD]       = ca_binop_mod,
+  [CA_BINOP_QUO]       = ca_binop_quo_i,
+  [CA_BINOP_RCP_MUL]   = ca_binop_rcp_mul,
+  [CA_BINOP_IPOWER]    = ca_binop_ipower,
+  [CA_BINOP_COPYSIGN]  = ca_binop_copysign,
+  [CA_BINOP_LOGADDEXP] = ca_binop_logaddexp,
+  [CA_BINOP_NEXTAFTER] = ca_binop_nextafter,
+  [CA_BINOP_FMOD]      = ca_binop_fmod,
+  [CA_BINOP_ATAN2]     = ca_binop_atan2,
+  [CA_BINOP_HYPOT]     = ca_binop_hypot,
+  [CA_BINOP_PMAX]      = ca_binop_pmax,
+  [CA_BINOP_PMIN]      = ca_binop_pmin,
+  [CA_BINOP_MAXIMUM]   = ca_binop_maximum,
+  [CA_BINOP_MINIMUM]   = ca_binop_minimum,
+  [CA_BINOP_AND]       = ca_binop_and,
+  [CA_BINOP_OR]        = ca_binop_or,
+  [CA_BINOP_XOR]       = ca_binop_xor,
+};
+
 ca_binop_func_t
 ca_binop_kernel_lookup_vv (uint16_t op_id, int8_t common_dt)
 {
-  switch (op_id) {
-    case CA_BINOP_ADD:        return ca_binop_add        [common_dt];
-    case CA_BINOP_SUB:        return ca_binop_sub        [common_dt];
-    case CA_BINOP_MUL:        return ca_binop_mul        [common_dt];
-    case CA_BINOP_DIV:        return ca_binop_div        [common_dt];
-    case CA_BINOP_POW:        return ca_binop_power      [common_dt];
-    case CA_BINOP_BIT_AND:    return ca_binop_bit_and_i  [common_dt];
-    case CA_BINOP_BIT_OR:     return ca_binop_bit_or_i   [common_dt];
-    case CA_BINOP_BIT_XOR:    return ca_binop_bit_xor_i  [common_dt];
-    case CA_BINOP_BIT_LSHIFT: return ca_binop_bit_lshift [common_dt];
-    case CA_BINOP_BIT_RSHIFT: return ca_binop_bit_rshift [common_dt];
-    case CA_BINOP_MOD:        return ca_binop_mod        [common_dt];
-    case CA_BINOP_QUO:        return ca_binop_quo_i      [common_dt];
-    case CA_BINOP_RCP_MUL:    return ca_binop_rcp_mul    [common_dt];
-    case CA_BINOP_IPOWER:     return ca_binop_ipower     [common_dt];
-    case CA_BINOP_COPYSIGN:   return ca_binop_copysign   [common_dt];
-    case CA_BINOP_LOGADDEXP:  return ca_binop_logaddexp  [common_dt];
-    case CA_BINOP_NEXTAFTER:  return ca_binop_nextafter  [common_dt];
-    case CA_BINOP_FMOD:       return ca_binop_fmod       [common_dt];
-    case CA_BINOP_ATAN2:      return ca_binop_atan2      [common_dt];
-    case CA_BINOP_HYPOT:      return ca_binop_hypot      [common_dt];
-    case CA_BINOP_PMAX:       return ca_binop_pmax       [common_dt];
-    case CA_BINOP_PMIN:       return ca_binop_pmin       [common_dt];
-    case CA_BINOP_MAXIMUM:    return ca_binop_maximum    [common_dt];
-    case CA_BINOP_MINIMUM:    return ca_binop_minimum    [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];
-    default:                  return NULL;
+  if ( op_id >= CA_BINOP_COUNT || ! ca_binop_tables[op_id] ) return NULL;
+  return ca_binop_tables[op_id][common_dt];
+}
+
+/* The op id whose kernel table is `table`, or -1 for a table no op id
+   names. */
+int
+ca_binop_op_id_of_table (ca_binop_func_t table[])
+{
+  int op_id;
+  for ( op_id = 0; op_id < CA_BINOP_COUNT; op_id++ ) {
+    if ( ca_binop_tables[op_id] == table ) return op_id;
   }
+  return -1;
 }
 
 /* ------------------------------------------------------------------- */
@@ -99,26 +116,3 @@ ca_binop_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
   if ( out_r_in_dt ) *out_r_in_dt = common;
 }
 
-/* ------------------------------------------------------------------- */
-/* trapping-op predicate                                                */
-/* ------------------------------------------------------------------- */
-
-int
-ca_binop_is_trapping (uint16_t op_id, int8_t common_dt)
-{
-  /* 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;
-
-  switch (op_id) {
-    case CA_BINOP_DIV:
-    case CA_BINOP_MOD:
-    case CA_BINOP_QUO:
-    case CA_BINOP_FMOD:
-      return 1;
-    default:
-      return 0;
-  }
-}

data/ext/ca_binop_dispatch.h

@@ -147,6 +147,6 @@ void ca_binop_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
    When trapping AND either operand has a mask, xfer_stride must pass
    a slab mask to the kernel so masked cells are skipped (otherwise
    masked-zero divisors crash with SIGFPE).  See §3.4 rev3.            */
-int ca_binop_is_trapping (uint16_t op_id, int8_t common_dt);
+int ca_binop_op_id_of_table (ca_binop_func_t table[]);
 
 #endif /* CA_BINOP_DISPATCH_H */