carray 3.0.1 → 3.0.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_binop_is_trapping 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;
 }
 
 /* ------------------------------------------------------------------- */
@@ -106,10 +123,12 @@ 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 / FMOD can SIGFPE on a zero divisor.  Float
-     DIV returns NaN/Inf and does NOT trap, so it is not classified
-     trapping.                                                          */
+  /* An object cell calls Ruby, which can raise for any op.  Integer
+     DIV / MOD / QUO / FMOD / RCP_MUL raise on a zero divisor, and POW /
+     IPOWER on zero to a negative power.  Float division returns NaN/Inf
+     and does not trap.                                                 */
   int is_integer = ( common_dt >= CA_INT8 && common_dt <= CA_UINT64 );
+  if ( common_dt == CA_OBJECT ) return 1;
   if ( ! is_integer ) return 0;
 
   switch (op_id) {
@@ -117,6 +136,9 @@ ca_binop_is_trapping (uint16_t op_id, int8_t common_dt)
     case CA_BINOP_MOD:
     case CA_BINOP_QUO:
     case CA_BINOP_FMOD:
+    case CA_BINOP_RCP_MUL:
+    case CA_BINOP_POW:
+    case CA_BINOP_IPOWER:
       return 1;
     default:
       return 0;

data/ext/ca_binop_dispatch.h

@@ -148,5 +148,6 @@ void ca_binop_kernel_input_data_types (uint16_t op_id, int8_t l_dt, int8_t r_dt,
    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 */

data/ext/ca_categorical_iterator.c

@@ -35,6 +35,7 @@
 --------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_internal.h"   /* CA_EXTREMUM_REPLACES */
 #include <stdlib.h>   /* qsort */
 #include <math.h>     /* floor */
 
@@ -82,8 +83,7 @@ rb_ca_categorical_scatter (VALUE self, VALUE rvalue, VALUE rcursor,
     rb_raise(rb_eArgError, "__categorical_scatter__: grouped/value data type mismatch");
   }
 
-  ca_attach(codes);
-  ca_attach(value);
+  ca_attach_n(2, codes, value);   /* window: detached before each raise inside */
   cmask = ca_mask_ptr(codes);
   vmask = ca_mask_ptr(value);
   cur   = (int64_t *) cursor->ptr;
@@ -138,6 +138,19 @@ rb_ca_categorical_scatter (VALUE self, VALUE rvalue, VALUE rcursor,
 
 --------------------------------------------------------------------------- */
 
+/* NaN loses every contest, which is what CArray#min / #max do (mkkernel
+   declares it as `all_nan_result: :nan`): a NaN never displaces a number, the
+   first number displaces a NaN that seeded the accumulator, and a segment
+   holding nothing but NaN answers NaN. Without this the answer depends on
+   where in the segment the NaN sits, and a reduction that is order-free
+   stopped being order-free.
+
+   The predicate is passed per instantiation rather than written inline so an
+   integer body never compares a value with itself, which is a tautology the
+   compiler is right to warn about. */
+#define CAT_NAN_NEVER(v)  (0)
+#define CAT_NAN_CHECK(v)  ((v) != (v))
+
 #define REDUCEAT_MOMENTS_BODY(T)                                                 \
   do {                                                                          \
     const T *gp = (const T *) grouped->ptr;                                     \
@@ -152,8 +165,11 @@ rb_ca_categorical_scatter (VALUE self, VALUE rvalue, VALUE rcursor,
         if ( gm && gm[j] ) continue;            /* masked value cell */         \
         { T v = gp[j];                                                          \
           sacc += (double) v;                                                   \
-          if ( ! seen ) { mn = v; mx = v; seen = 1; }                          \
-          else { if ( v < mn ) mn = v; if ( v > mx ) mx = v; }                  \
+          if ( ! seen ) { mn = v; mx = v; seen = 1; }                           \
+          else {                                                                \
+            if ( CA_EXTREMUM_REPLACES(v, mn, <) ) mn = v;                       \
+            if ( CA_EXTREMUM_REPLACES(v, mx, >) ) mx = v;                       \
+          }                                                                     \
           cnt++; }                                                              \
       }                                                                         \
       countp[c] = (int64_t) cnt;                                                \
@@ -278,14 +294,31 @@ ca_nth_element_double (double *a, ca_size_t n, ca_size_t kth)
       { double f = (double) (m - 1) * p / 100.0;                               \
         ca_size_t ki = (ca_size_t) floor(f);                                   \
         double vlo, vhi;                                                        \
-        ca_nth_element_double(scratch, m, ki);   /* scratch[ki] = ki-th */      \
-        vlo = scratch[ki];                                                      \
-        if ( ki + 1 < m ) {          /* (ki+1)-th = min of upper partition */   \
+        /* Push NaN to the tail, which is where CArray's sort puts it, so the  \
+           ki-th element here is the ki-th of the sorted segment. Selection    \
+           runs on the numeric prefix, since a comparison-based quickselect    \
+           has nothing to say about a NaN; a position or an upper neighbour    \
+           landing in the tail is NaN. The blend is CArray#percentile's, so    \
+           both answer alike for NaN and infinities. */                        \
+        ca_size_t nnum = m, t0 = 0;                                            \
+        while ( t0 < nnum ) {                                                  \
+          if ( scratch[t0] != scratch[t0] ) {                                  \
+            double tmp = scratch[--nnum];                                      \
+            scratch[nnum] = scratch[t0]; scratch[t0] = tmp;                    \
+          } else t0++;                                                         \
+        }                                                                      \
+        if ( ki < nnum ) {                                                     \
+          ca_nth_element_double(scratch, nnum, ki); /* scratch[ki] = ki-th */  \
+          vlo = scratch[ki];                                                   \
+        } else vlo = (double) NAN;                                             \
+        if ( ki + 1 < nnum ) {       /* (ki+1)-th = min of upper partition */  \
           double mn = scratch[ki+1]; ca_size_t t;                             \
-          for ( t = ki + 2; t < m; t++ ) if ( scratch[t] < mn ) mn = scratch[t]; \
+          for ( t = ki + 2; t < nnum; t++ ) if ( scratch[t] < mn ) mn = scratch[t]; \
           vhi = mn;                                                            \
-        } else vhi = vlo;                                                      \
-        outp[c] = vlo + (f - (double) ki) * (vhi - vlo); }                      \
+        } else vhi = (double) NAN;                                             \
+        { double r = f - (double) ki;                                          \
+          outp[c] = ( r == 0.0 || ki + 1 >= m ) ? vlo                          \
+                                                : vlo * (1.0 - r) + vhi * r; } } \
     }                                                                           \
   } while (0)
 
@@ -302,6 +335,11 @@ rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
   GetCArray(roffsets, offsets);
   GetCArray(rout,     out);
   p = NUM2DBL(rp);
+  if ( !(p >= 0.0 && p <= 100.0) ) {
+    rb_raise(rb_eArgError,
+             "percentile: p must be Numeric in [0,100] (got %"PRIsVALUE")",
+             rb_inspect(rp));
+  }
   k = (int64_t) offsets->elements;
   n = grouped->elements;
   if ( offsets->data_type != CA_INT64 || out->data_type != CA_FLOAT64 ||
@@ -350,7 +388,7 @@ rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
   accumulates the per-segment centred sum of squares; variance = SS / (n-1).
   Centred (not the one-pass sum-of-squares) so the ε-close contract holds — a
   one-pass formula cancels catastrophically.  Matches CArray#variance per group:
-  count 0 -> masked (undefined), count 1 -> 0.0 (the n=1 contract), count >= 2 ->
+  count 0 or 1 -> masked (the sample variance is undefined), count >= 2 ->
   SS / (count-1).
 
   Surface (private): grouped.__reduceat_variance__(offsets, means, counts, out)
@@ -358,7 +396,7 @@ rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
     offsets = int64[k] segment STARTS
     means   = float64[k] per-segment mean (ignored where count < 2)
     counts  = int64[k]   per-segment present count
-    out     = float64[k] output: variance; count 0 masked, count 1 -> 0.0
+    out     = float64[k] output: variance; count 0 or 1 masked
 
 --------------------------------------------------------------------------- */
 
@@ -367,8 +405,7 @@ rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
     const T *gp = (const T *) grouped->ptr;                                     \
     for ( c = 0; c < k; c++ ) {                                                 \
       int64_t cnt = countp[c];                                                  \
-      if ( cnt == 0 ) { outp[c] = 0.0; outm[c] = 1; continue; } /* -> masked */ \
-      if ( cnt == 1 ) { outp[c] = 0.0; continue; }  /* n=1 contract: 0.0 */     \
+      if ( cnt < 2 ) { outp[c] = 0.0; outm[c] = 1; continue; }  /* undefined */ \
       { double mean = meanp[c], ss = 0.0;                                       \
         ca_size_t lo = (ca_size_t) offs[c];                                     \
         ca_size_t hi = (c + 1 < k) ? (ca_size_t) offs[c+1] : n, j;              \
@@ -510,7 +547,7 @@ rb_ca_reduceat_prod (VALUE self, VALUE roffsets, VALUE rout)
 /* __reduceat_argminmax__(offsets, min_idx, max_idx) — per-segment GROUP-LOCAL
    index of the min / max (position within the segment, first occurrence on
    ties). Empty / all-masked segments are masked. */
-#define REDUCEAT_ARGMINMAX_BODY(T)                                              \
+#define REDUCEAT_ARGMINMAX_BODY(T, ISNAN)                                       \
   do {                                                                          \
     const T *gp = (const T *) grouped->ptr;                                     \
     for ( c = 0; c < k; c++ ) {                                                 \
@@ -520,10 +557,13 @@ rb_ca_reduceat_prod (VALUE self, VALUE roffsets, VALUE rout)
       for ( j = lo; j < hi; j++ ) {                                             \
         if ( gm && gm[j] ) continue;                                            \
         { T v = gp[j]; ca_size_t li = j - lo;                                  \
+          if ( ISNAN(v) ) continue;   /* wins no contest, so marks no position */\
           if ( ! seen ) { mn = mx = v; mni = mxi = li; seen = 1; }             \
           else { if ( v < mn ) { mn = v; mni = li; }                           \
                  if ( v > mx ) { mx = v; mxi = li; } } }                       \
       }                                                                         \
+      /* A segment of nothing but NaN has no position to report, the same as a \
+         segment with no present cell at all -- both are UNDEF, as in the core.*/\
       if ( seen ) { minp[c] = (int64_t) mni; maxp[c] = (int64_t) mxi; }        \
       else { minp[c] = 0; maxp[c] = 0; minm[c] = 1; maxm[c] = 1; }             \
     }                                                                           \
@@ -558,16 +598,16 @@ rb_ca_reduceat_argminmax (VALUE self, VALUE roffsets, VALUE rminidx, VALUE rmaxi
   maxm = (boolean8_t *) maxidx->mask->ptr;
 
   switch ( grouped->data_type ) {
-  case CA_INT8:    REDUCEAT_ARGMINMAX_BODY(int8_t);    break;
-  case CA_UINT8:   REDUCEAT_ARGMINMAX_BODY(uint8_t);   break;
-  case CA_INT16:   REDUCEAT_ARGMINMAX_BODY(int16_t);   break;
-  case CA_UINT16:  REDUCEAT_ARGMINMAX_BODY(uint16_t);  break;
-  case CA_INT32:   REDUCEAT_ARGMINMAX_BODY(int32_t);   break;
-  case CA_UINT32:  REDUCEAT_ARGMINMAX_BODY(uint32_t);  break;
-  case CA_INT64:   REDUCEAT_ARGMINMAX_BODY(int64_t);   break;
-  case CA_UINT64:  REDUCEAT_ARGMINMAX_BODY(uint64_t);  break;
-  case CA_FLOAT32: REDUCEAT_ARGMINMAX_BODY(float32_t); break;
-  case CA_FLOAT64: REDUCEAT_ARGMINMAX_BODY(float64_t); break;
+  case CA_INT8:    REDUCEAT_ARGMINMAX_BODY(int8_t, CAT_NAN_NEVER);    break;
+  case CA_UINT8:   REDUCEAT_ARGMINMAX_BODY(uint8_t, CAT_NAN_NEVER);   break;
+  case CA_INT16:   REDUCEAT_ARGMINMAX_BODY(int16_t, CAT_NAN_NEVER);   break;
+  case CA_UINT16:  REDUCEAT_ARGMINMAX_BODY(uint16_t, CAT_NAN_NEVER);  break;
+  case CA_INT32:   REDUCEAT_ARGMINMAX_BODY(int32_t, CAT_NAN_NEVER);   break;
+  case CA_UINT32:  REDUCEAT_ARGMINMAX_BODY(uint32_t, CAT_NAN_NEVER);  break;
+  case CA_INT64:   REDUCEAT_ARGMINMAX_BODY(int64_t, CAT_NAN_NEVER);   break;
+  case CA_UINT64:  REDUCEAT_ARGMINMAX_BODY(uint64_t, CAT_NAN_NEVER);  break;
+  case CA_FLOAT32: REDUCEAT_ARGMINMAX_BODY(float32_t, CAT_NAN_CHECK); break;
+  case CA_FLOAT64: REDUCEAT_ARGMINMAX_BODY(float64_t, CAT_NAN_CHECK); break;
   default:
     rb_raise(rb_eCADataTypeError,
              "__reduceat_argminmax__: numeric value required (got data_type %d)",
@@ -631,6 +671,12 @@ static int
 cmp_double (const void *a, const void *b)
 {
   double x = *(const double *) a, y = *(const double *) b;
+  /* NaN sorts last, which is where CArray's own sort puts it, so picking a
+     position out of the sorted segment gives the core's answer. A bare
+     < / > comparison returns 0 for every pair involving a NaN, which is not
+     a strict weak ordering and leaves qsort free to produce anything. */
+  if ( x != x ) return (y != y) ? 0 : 1;
+  if ( y != y ) return -1;
   return (x < y) ? -1 : (x > y) ? 1 : 0;
 }
 
@@ -648,13 +694,18 @@ cmp_double (const void *a, const void *b)
       }                                                                         \
       if ( m == 0 ) { for ( t = 0; t < 5; t++ ) { outp[t][c] = 0.0; outm[t][c] = 1; } continue; } \
       qsort(scratch, (size_t) m, sizeof(double), cmp_double);                   \
+      { ca_size_t nnum = m;                                                     \
+        while ( nnum > 0 && scratch[nnum-1] != scratch[nnum-1] ) nnum--;        \
       for ( t = 0; t < 5; t++ ) {                                               \
         double f = (double) (m - 1) * P[t] / 100.0;                            \
         ca_size_t ki = (ca_size_t) floor(f);                                   \
         double vlo = scratch[ki];                                              \
-        double vhi = (ki + 1 < m) ? scratch[ki+1] : vlo;                       \
+        /* Clamp the upper neighbour into the numeric prefix: with NaN sorted  \
+           last, a position whose neighbour is a NaN interpolates against      \
+           itself, which is what the core answers. */                          \
+        double vhi = (ki + 1 < nnum) ? scratch[ki+1] : vlo;                    \
         outp[t][c] = vlo + (f - (double) ki) * (vhi - vlo);                     \
-      }                                                                         \
+      } }                                                                       \
     }                                                                           \
   } while (0)
 
@@ -847,8 +898,8 @@ rb_ca_reduceat_wsum_wmean (VALUE self, VALUE roffsets, VALUE rwg,
           if ( countp[out_off] == 0 ) {                                       \
             minv[out_off] = v; maxv[out_off] = v;                             \
           } else {                                                            \
-            if ( v < minv[out_off] ) minv[out_off] = v;                       \
-            if ( v > maxv[out_off] ) maxv[out_off] = v;                       \
+            if ( CA_EXTREMUM_REPLACES(v, minv[out_off], <) ) minv[out_off] = v;\
+            if ( CA_EXTREMUM_REPLACES(v, maxv[out_off], >) ) maxv[out_off] = v;\
           }                                                                   \
           countp[out_off]++;                                                  \
           sump[out_off] += (double) v;                                        \
@@ -951,8 +1002,7 @@ rb_ca_fiber_scatter_moments (VALUE self, VALUE rcodes, VALUE raxis, VALUE rk,
   band_size  = outer_prod * inner_prod;
   total      = (ca_size_t)(K * band_size);
 
-  ca_attach(h);
-  ca_attach(codes);
+  ca_attach_n(2, h, codes);   /* window: detached before each raise inside */
   hm = ca_mask_ptr(h);
   cm = ca_mask_ptr(codes);
   countp = (int64_t *) counts->ptr;
@@ -1118,8 +1168,7 @@ rb_ca_fiber_scatter_prod (VALUE self, VALUE rcodes, VALUE raxis,
   band_size  = outer_prod * inner_prod;
   total      = (ca_size_t)(K * band_size);
 
-  ca_attach(h);
-  ca_attach(codes);
+  ca_attach_n(2, h, codes);   /* window: detached before each raise inside */
   hm   = ca_mask_ptr(h);
   cm   = ca_mask_ptr(codes);
   outp = (double *) out->ptr;
@@ -1227,6 +1276,7 @@ rb_ca_fiber_scatter_wsum_wmean (VALUE self, VALUE rcodes, VALUE rweights,
   ca_size_t   ax, inn, outer, cell;
   ca_size_t   axis_size, inner_prod, outer_prod, band_size, total;
   double     *wp, *wsp, *wsw, *wmp;
+  volatile VALUE hwsw = 0, hcnt = 0;
   boolean8_t *hm, *cm, *wm, *wmm;
   int8_t      i, j;
   int64_t    *cnt_scratch = NULL;
@@ -1287,9 +1337,7 @@ rb_ca_fiber_scatter_wsum_wmean (VALUE self, VALUE rcodes, VALUE rweights,
   band_size  = outer_prod * inner_prod;
   total      = (ca_size_t)(K * band_size);
 
-  ca_attach(h);
-  ca_attach(codes);
-  ca_attach(weights);
+  ca_attach_n(3, h, codes, weights);   /* window: detached before each raise inside */
   hm  = ca_mask_ptr(h);
   cm  = ca_mask_ptr(codes);
   wm  = ca_mask_ptr(weights);
@@ -1298,8 +1346,9 @@ rb_ca_fiber_scatter_wsum_wmean (VALUE self, VALUE rcodes, VALUE rweights,
   wmp = (double *) wmean->ptr;   /* wmean output (temp = sum-of-weights, then divide) */
 
   /* Two auxiliary scratches: sum-of-weights (per cell) and present-pair count. */
-  wsw = (double *) xmalloc((size_t) total * sizeof(double));
-  cnt_scratch = (int64_t *) xmalloc((size_t) total * sizeof(int64_t));
+  /* ALLOCV, so a raise below (codes of the wrong type) leaves nothing. */
+  wsw = ALLOCV_N(double, hwsw, total);
+  cnt_scratch = ALLOCV_N(int64_t, hcnt, total);
 
   memset(wsp,         0, (size_t) total * sizeof(double));
   memset(wsw,         0, (size_t) total * sizeof(double));
@@ -1318,7 +1367,7 @@ rb_ca_fiber_scatter_wsum_wmean (VALUE self, VALUE rcodes, VALUE rweights,
   case CA_FLOAT32: FIBER_SCATTER_WSUM_DISPATCH_C(float32_t); break;
   case CA_FLOAT64: FIBER_SCATTER_WSUM_DISPATCH_C(float64_t); break;
   default:
-    xfree(wsw); xfree(cnt_scratch);
+    ALLOCV_END(hwsw); ALLOCV_END(hcnt);
     ca_detach(h); ca_detach(codes); ca_detach(weights);
     rb_raise(rb_eCADataTypeError,
              "__fiber_scatter_wsum_wmean__: numeric value required (got %d)",
@@ -1337,8 +1386,8 @@ rb_ca_fiber_scatter_wsum_wmean (VALUE self, VALUE rcodes, VALUE rweights,
     }
   }
 
-  xfree(wsw);
-  xfree(cnt_scratch);
+  ALLOCV_END(hwsw);
+  ALLOCV_END(hcnt);
   ca_detach(h);
   ca_detach(codes);
   ca_detach(weights);

data/ext/ca_compare.c

@@ -14,6 +14,7 @@
 #include "ruby.h"
 #include "carray.h"
 #include "ca_compare.h"
+#include "carray_internal.h"   /* ca_obj_cmp, CA_OBJ_ISNAN */
 #include <math.h>
 
 #define DEFINE_ELEM_CMP(type)                          \
@@ -53,13 +54,18 @@ DEFINE_ELEM_CMP(uint64_t)
 DEFINE_ELEM_CMP_FLOAT(float32_t)
 DEFINE_ELEM_CMP_FLOAT(float64_t)
 
-/* CA_OBJECT: compare via Ruby Comparable (`<=>`). */
+/* CA_OBJECT: compare by `<=>`, as sort orders object cells: a Float NaN
+   after every other value, and a pair `<=>` cannot order raises
+   "comparison of A with B failed". */
 static int
 elem_cmp_VALUE (const void *va, const void *vb)
 {
   const VALUE *a = (const VALUE *) va;
   const VALUE *b = (const VALUE *) vb;
-  return NUM2INT(rb_funcall(*a, rb_intern("<=>"), 1, *b));
+  int nan_a = CA_OBJ_ISNAN(*a);
+  int nan_b = CA_OBJ_ISNAN(*b);
+  if ( nan_a || nan_b ) return nan_a - nan_b;
+  return ca_obj_cmp(*a, *b);
 }
 
 /* FIXLEN / retired / otherwise unorderable data_types: callers must handle

data/ext/ca_for_buffer.h

@@ -1,43 +1,33 @@
 /* ---------------------------------------------------------------------------
  *
- *  ca_for_buffer.h -- sweep WHOLE_BUFFER macro family (whole contig buffer
- *                    handed to author / third-party library)
+ *  ca_for_buffer.h -- whole contig buffer handed to author / third-party
+ *                     library
  *
- *  PROPOSAL_L0_AUTHOR_SURFACE L0.2c (2026-06-11).  C-side counterpart of
- *  Ruby's `ca.attach! { |a| ... }` block: scope the ca_attach + ca_sync +
- *  ca_detach lifecycle to a block, hand the author a contig buffer ptr
- *  and element count, let the author do whatever (typically pass the
- *  ptr to a third-party library: FFTW, akima init, fitpack surf1, ...).
+ *  C-side counterpart of Ruby's `ca.attach! { |a| ... }` block: the
+ *  attach / sync / detach lifecycle is scoped to a body function, which
+ *  receives a contig buffer ptr and element count and may do whatever
+ *  (typically pass the ptr to a third-party library: FFTW, akima init,
+ *  fitpack surf1, ...).
  *
- *  Two forms (Q8 = M1 alias-when-possible; non-contig source materialises
- *  into a transient buffer; writable form syncs back on exit):
+ *  The buffer aliases ca->ptr when the array is a contig entity and is a
+ *  materialised scratch otherwise.  A writable call syncs the buffer back
+ *  to the array's storage when the body returns.
  *
- *    CA_WITH_BUFFER(ca, T, ptr, n)
- *      Read-only access.  ptr : T const * pointing at native contig
- *      layout of `ca` (= ca->ptr alias when contig entity, scratch
- *      otherwise).  n : ca->elements.  No write-back on exit.
- *
- *    CA_WITH_BUFFER_WRITABLE(ca, T, ptr, n)
- *      Writable; same ptr/n semantics, plus ca_sync on block exit so
- *      author writes propagate back to the view's storage.
+ *  The body may raise.  The view is closed however the body is left: a
+ *  writable view is synced first, so what the body wrote before raising
+ *  reaches the view's storage, and the view is detached even if that sync
+ *  raises.  The body's exception is the one that propagates.
  *
  *  Author pattern:
  *
- *    double *ptr;
- *    ca_size_t n;
- *    CA_WITH_BUFFER_WRITABLE(ca, double, ptr, n) {
+ *    static void
+ *    fft_body (void *user_data, void *ptr, ca_size_t n)
+ *    {
+ *      fftw_plan plan = (fftw_plan) user_data;
  *      fftw_execute_dft(plan, ptr, ptr);
  *    }
  *
- *  Constraints (same as CA_FOR_EACH_FIBER family):
- *    - `break;` from body exits cleanly (= outer for's advance clause
- *      runs ca_sync / ca_detach).
- *    - `return;` from body LEAKS the attach; restructure to break.
- *    - Macros are NOT statement-equivalent (= nested for); no trailing
- *      `else`.
- *    - For Ruby-exception-safe lifecycle (e.g. when calling Ruby code or
- *      anything that may raise from inside the body), use the function
- *      form `rb_ca_call_with_buffer` instead (= rb_ensure-protected).
+ *    rb_ca_call_with_buffer(rca, 1, fft_body, plan);
  *
  *  --------------------------------------------------------------------------- */
 
@@ -47,46 +37,9 @@
 #include "carray.h"
 #include "ca_sweep_engine.h"
 
-/* ---------- macro forms ---------- */
-
-/* Read-only: ca_attach (alias-when-possible) + author body + ca_detach. */
-#define CA_WITH_BUFFER(_ca, T, _ptr, _n)                                  \
-  for ( CArray *__cwv_ca = (CArray *)(_ca);                             \
-        __cwv_ca;                                                       \
-        ca_detach(__cwv_ca), __cwv_ca = NULL )                          \
-    for ( int __cwv_once = (ca_attach(__cwv_ca),                        \
-                            (_ptr) = (T *)__cwv_ca->ptr,                \
-                            (_n)   = __cwv_ca->elements,                \
-                            1);                                         \
-          __cwv_once;                                                   \
-          __cwv_once = 0 )
-
-/* Writable: same as above + ca_sync on block exit. */
-#define CA_WITH_BUFFER_WRITABLE(_ca, T, _ptr, _n)                         \
-  for ( CArray *__cwvw_ca = (CArray *)(_ca);                            \
-        __cwvw_ca;                                                      \
-        ca_sync(__cwvw_ca), ca_detach(__cwvw_ca), __cwvw_ca = NULL )    \
-    for ( int __cwvw_once = (ca_attach(__cwvw_ca),                      \
-                             (_ptr) = (T *)__cwvw_ca->ptr,              \
-                             (_n)   = __cwvw_ca->elements,              \
-                             1);                                        \
-          __cwvw_once;                                                  \
-          __cwvw_once = 0 )
-
-/* ---------- function form (rb_ensure-protected, AC8) ----------
- *
- * Use this when the body may raise a Ruby exception (= calling rb_funcall,
- * type-checking with rb_check_type, indirect Ruby code, etc.).  The
- * engine ca_attach's the view, runs body via rb_ensure, then guarantees
- * ca_sync (if writable) and ca_detach run before the exception
- * propagates.
- *
- *   body_fn(user_data, ptr, n_elements) -> may raise
+/*   body_fn(user_data, ptr, n_elements) -> may raise
  *
- * Returns whatever body_fn returns via its own propagation (= the
- * function itself returns Qnil since rb_ensure body must be VALUE).
- * For richer return semantics, box your result in user_data.
- */
+ * Returns nothing; box a result in user_data. */
 typedef void (*ca_with_buffer_body_fn) (void *user_data, void *ptr,
                                       ca_size_t n_elements);
 

data/ext/ca_group_iter.c

@@ -40,10 +40,14 @@ static ID id_axis_group_reduce, id_reshape, id_transpose, id_labels;
 static VALUE
 rb_ca_register_axis_group_classes (VALUE klass, VALUE cat, VALUE ag)
 {
+  static int registered = 0;
   rb_cCategorical = cat;
   rb_cAxisGroup   = ag;
-  rb_gc_register_address(&rb_cCategorical);
-  rb_gc_register_address(&rb_cAxisGroup);
+  if ( ! registered ) {               /* one GC root per address, not per call */
+    rb_gc_register_address(&rb_cCategorical);
+    rb_gc_register_address(&rb_cAxisGroup);
+    registered = 1;
+  }
   return Qnil;
 }
 
@@ -172,7 +176,7 @@ group_iter_shape_output (VALUE result, VALUE group_dims, VALUE perm, VALUE squee
   nband = cr->ndim - 1;
   nd    = ng + nband;
   if ( nd > CA_RANK_MAX ) {
-    rb_raise(rb_eRuntimeError, "axis_group: output ndim %ld too large", nd);
+    rb_raise(rb_eArgError, "axis_group: output ndim %ld too large", nd);
   }
   for ( i = 0; i < ng; i++ ) {
     dims[i] = RARRAY_AREF(group_dims, i);
@@ -233,17 +237,19 @@ group_iter_reduce (int argc, VALUE *argv, VALUE self)
   parsed = rb_funcall(rb_cAxisGroup, id_parse_axis,
                       1, (vaxis == Qundef) ? Qnil : vaxis);
   if ( RTEST(RARRAY_AREF(parsed, 0)) == 0 ) {
-    /* no :group -> plain reduction on the value (grouping not engaged) */
-    if ( vaxis == Qundef ) {
+    /* no :group -> plain reduction on the value (grouping not engaged),
+       with every keyword the caller gave */
+    if ( NIL_P(kw) ) {
       return rb_funcall(value, op_id, 0);
     }
-    else {
-      VALUE h = rb_hash_new();
-      rb_hash_aset(h, ID2SYM(rb_intern("axis")), vaxis);
-      return rb_funcallv_kw(value, op_id, 1, &h, RB_PASS_KEYWORDS);
-    }
+    return rb_funcallv_kw(value, op_id, 1, &kw, RB_PASS_KEYWORDS);
   }
 
+  /* min_count: / fill_value: are applied to the grouped result; any other
+     keyword is refused before the work is done. */
+  rb_funcall(rb_cAxisGroup, rb_intern("__check_reduce_keywords__"), 2,
+             op_sym, NIL_P(kw) ? rb_hash_new() : kw);
+
   /* group reduction */
   fused = RARRAY_AREF(parsed, 1);
   plan  = rb_funcall(spec, id_reduce_plan, 1, fused);
@@ -253,9 +259,19 @@ group_iter_reduce (int argc, VALUE *argv, VALUE self)
   perm       = RARRAY_AREF(plan, 3);
   squeeze    = RARRAY_AREF(plan, 4);
 
+  /* a count reads only the mask, so a payload the kernel cannot read
+     (object, fixlen, ...) is counted through a boolean stand-in */
+  if ( op_id == rb_intern("count") || op_id == rb_intern("count_not_masked") ) {
+    value = rb_funcall(rb_cAxisGroup, rb_intern("__count_stand_in__"), 1, value);
+  }
   result = rb_funcall(value, id_axis_group_reduce, 3,
                       group_axes, bundles, op_sym);
-  return group_iter_shape_output(result, group_dims, perm, squeeze);
+  result = group_iter_shape_output(result, group_dims, perm, squeeze);
+  if ( ! NIL_P(kw) ) {
+    result = rb_funcall(rb_cAxisGroup, rb_intern("__finish_reduction__"), 4,
+                        self, op_sym, kw, result);
+  }
+  return result;
 }
 
 void