carray 3.0.0 → 3.0.2

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,18 +127,31 @@ 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.
 
 --------------------------------------------------------------------------- */
 
-#define REDUCEAT_MOMENTS_BODY(T)                                                 \
+/* 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, ISNAN)                                          \
   do {                                                                          \
     const T *gp = (const T *) grouped->ptr;                                     \
     T *minv = (T *) minp, *maxv = (T *) maxp;                                   \
@@ -147,13 +160,17 @@ rb_ca_categorical_scatter (VALUE self, VALUE rvalue, VALUE rcursor,
       ca_size_t hi = (c + 1 < k) ? (ca_size_t) offs[c+1] : n;                   \
       ca_size_t j, cnt = 0;                                                     \
       double sacc = 0.0;                                                        \
-      T mn = 0, mx = 0; int seen = 0;                                           \
+      T mn = 0, mx = 0; int seen = 0, seen_num = 0;                             \
       for ( j = lo; j < hi; j++ ) {                                             \
         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 ( ! ISNAN(v) ) {                                                   \
+            if ( ! seen_num ) { mn = v; mx = v; seen_num = 1; }                 \
+            else { if ( v < mn ) mn = v; if ( v > mx ) mx = v; }                \
+          }                                                                     \
+          else if ( ! seen ) { mn = v; mx = v; }  /* held until a number lands */\
+          seen = 1;                                                             \
           cnt++; }                                                              \
       }                                                                         \
       countp[c] = (int64_t) cnt;                                                \
@@ -190,7 +207,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;
@@ -205,16 +222,16 @@ rb_ca_reduceat_moments (VALUE self, VALUE roffsets, VALUE rcounts,
   maxm = (boolean8_t *) maxs->mask->ptr;
 
   switch ( grouped->data_type ) {
-  case CA_INT8:    REDUCEAT_MOMENTS_BODY(int8_t);    break;
-  case CA_UINT8:   REDUCEAT_MOMENTS_BODY(uint8_t);   break;
-  case CA_INT16:   REDUCEAT_MOMENTS_BODY(int16_t);   break;
-  case CA_UINT16:  REDUCEAT_MOMENTS_BODY(uint16_t);  break;
-  case CA_INT32:   REDUCEAT_MOMENTS_BODY(int32_t);   break;
-  case CA_UINT32:  REDUCEAT_MOMENTS_BODY(uint32_t);  break;
-  case CA_INT64:   REDUCEAT_MOMENTS_BODY(int64_t);   break;
-  case CA_UINT64:  REDUCEAT_MOMENTS_BODY(uint64_t);  break;
-  case CA_FLOAT32: REDUCEAT_MOMENTS_BODY(float32_t); break;
-  case CA_FLOAT64: REDUCEAT_MOMENTS_BODY(float64_t); break;
+  case CA_INT8:    REDUCEAT_MOMENTS_BODY(int8_t, CAT_NAN_NEVER);    break;
+  case CA_UINT8:   REDUCEAT_MOMENTS_BODY(uint8_t, CAT_NAN_NEVER);   break;
+  case CA_INT16:   REDUCEAT_MOMENTS_BODY(int16_t, CAT_NAN_NEVER);   break;
+  case CA_UINT16:  REDUCEAT_MOMENTS_BODY(uint16_t, CAT_NAN_NEVER);  break;
+  case CA_INT32:   REDUCEAT_MOMENTS_BODY(int32_t, CAT_NAN_NEVER);   break;
+  case CA_UINT32:  REDUCEAT_MOMENTS_BODY(uint32_t, CAT_NAN_NEVER);  break;
+  case CA_INT64:   REDUCEAT_MOMENTS_BODY(int64_t, CAT_NAN_NEVER);   break;
+  case CA_UINT64:  REDUCEAT_MOMENTS_BODY(uint64_t, CAT_NAN_NEVER);  break;
+  case CA_FLOAT32: REDUCEAT_MOMENTS_BODY(float32_t, CAT_NAN_CHECK); break;
+  case CA_FLOAT64: REDUCEAT_MOMENTS_BODY(float64_t, CAT_NAN_CHECK); break;
   default:
     rb_raise(rb_eCADataTypeError,
              "__reduceat_moments__: numeric value required (got data_type %d)",
@@ -235,7 +252,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
@@ -278,11 +295,27 @@ 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, and a position landing in the tail  \
+           answers NaN. The upper neighbour is clamped into the prefix too: a  \
+           position whose neighbour would be a NaN interpolates against itself \
+           and answers vlo, which is why the median of [NaN, -9.0] is -9.0. */ \
+        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); }                      \
@@ -354,7 +387,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
@@ -510,7 +543,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 +553,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 +594,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)",
@@ -577,7 +613,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)
@@ -631,6 +667,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 +690,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)
 
@@ -817,12 +864,12 @@ 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__).
 --------------------------------------------------------------------------- */
 
-#define FIBER_SCATTER_BODY(H_T, C_T)                                          \
+#define FIBER_SCATTER_BODY(H_T, C_T, ISNAN)                                   \
   do {                                                                        \
     const H_T *hp   = (const H_T *) h->ptr;                                   \
     const C_T *cp   = (const C_T *) codes->ptr;                               \
@@ -844,11 +891,18 @@ rb_ca_reduceat_wsum_wmean (VALUE self, VALUE roffsets, VALUE rwg,
           if ( c < 0 || c >= K ) continue;  /* out-of-vocabulary */           \
           out_off = c * band_size + out_outer + inn;                          \
           v = hp[off];                                                        \
+          /* NaN loses every contest, as in the flat twin and the core. min \
+             and max are seeded together and only ever move on a number, so a \
+             NaN sitting in min means this cell has met nothing but NaN yet. */\
           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;                       \
+          } else if ( ! ISNAN(v) ) {                                          \
+            if ( ISNAN(minv[out_off]) ) {                                     \
+              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;                     \
+            }                                                                 \
           }                                                                   \
           countp[out_off]++;                                                  \
           sump[out_off] += (double) v;                                        \
@@ -857,16 +911,16 @@ rb_ca_reduceat_wsum_wmean (VALUE self, VALUE roffsets, VALUE rwg,
     }                                                                         \
   } while (0)
 
-#define FIBER_SCATTER_DISPATCH_C(H_T)                                         \
+#define FIBER_SCATTER_DISPATCH_C(H_T, ISNAN)                                  \
   switch ( codes->data_type ) {                                               \
-  case CA_INT8:    FIBER_SCATTER_BODY(H_T, int8_t);    break;                 \
-  case CA_UINT8:   FIBER_SCATTER_BODY(H_T, uint8_t);   break;                 \
-  case CA_INT16:   FIBER_SCATTER_BODY(H_T, int16_t);   break;                 \
-  case CA_UINT16:  FIBER_SCATTER_BODY(H_T, uint16_t);  break;                 \
-  case CA_INT32:   FIBER_SCATTER_BODY(H_T, int32_t);   break;                 \
-  case CA_UINT32:  FIBER_SCATTER_BODY(H_T, uint32_t);  break;                 \
-  case CA_INT64:   FIBER_SCATTER_BODY(H_T, int64_t);   break;                 \
-  case CA_UINT64:  FIBER_SCATTER_BODY(H_T, uint64_t);  break;                 \
+  case CA_INT8:    FIBER_SCATTER_BODY(H_T, int8_t, ISNAN);    break;                 \
+  case CA_UINT8:   FIBER_SCATTER_BODY(H_T, uint8_t, ISNAN);   break;                 \
+  case CA_INT16:   FIBER_SCATTER_BODY(H_T, int16_t, ISNAN);   break;                 \
+  case CA_UINT16:  FIBER_SCATTER_BODY(H_T, uint16_t, ISNAN);  break;                 \
+  case CA_INT32:   FIBER_SCATTER_BODY(H_T, int32_t, ISNAN);   break;                 \
+  case CA_UINT32:  FIBER_SCATTER_BODY(H_T, uint32_t, ISNAN);  break;                 \
+  case CA_INT64:   FIBER_SCATTER_BODY(H_T, int64_t, ISNAN);   break;                 \
+  case CA_UINT64:  FIBER_SCATTER_BODY(H_T, uint64_t, ISNAN);  break;                 \
   default:                                                                    \
     ca_detach(h); ca_detach(codes);                                           \
     rb_raise(rb_eCADataTypeError,                                             \
@@ -921,7 +975,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 ||
@@ -966,16 +1020,16 @@ rb_ca_fiber_scatter_moments (VALUE self, VALUE rcodes, VALUE raxis, VALUE rk,
   memset(maxp,   0, (size_t) total * (size_t) h->bytes);
 
   switch ( h->data_type ) {
-  case CA_INT8:    FIBER_SCATTER_DISPATCH_C(int8_t);    break;
-  case CA_UINT8:   FIBER_SCATTER_DISPATCH_C(uint8_t);   break;
-  case CA_INT16:   FIBER_SCATTER_DISPATCH_C(int16_t);   break;
-  case CA_UINT16:  FIBER_SCATTER_DISPATCH_C(uint16_t);  break;
-  case CA_INT32:   FIBER_SCATTER_DISPATCH_C(int32_t);   break;
-  case CA_UINT32:  FIBER_SCATTER_DISPATCH_C(uint32_t);  break;
-  case CA_INT64:   FIBER_SCATTER_DISPATCH_C(int64_t);   break;
-  case CA_UINT64:  FIBER_SCATTER_DISPATCH_C(uint64_t);  break;
-  case CA_FLOAT32: FIBER_SCATTER_DISPATCH_C(float32_t); break;
-  case CA_FLOAT64: FIBER_SCATTER_DISPATCH_C(float64_t); break;
+  case CA_INT8:    FIBER_SCATTER_DISPATCH_C(int8_t, CAT_NAN_NEVER);    break;
+  case CA_UINT8:   FIBER_SCATTER_DISPATCH_C(uint8_t, CAT_NAN_NEVER);   break;
+  case CA_INT16:   FIBER_SCATTER_DISPATCH_C(int16_t, CAT_NAN_NEVER);   break;
+  case CA_UINT16:  FIBER_SCATTER_DISPATCH_C(uint16_t, CAT_NAN_NEVER);  break;
+  case CA_INT32:   FIBER_SCATTER_DISPATCH_C(int32_t, CAT_NAN_NEVER);   break;
+  case CA_UINT32:  FIBER_SCATTER_DISPATCH_C(uint32_t, CAT_NAN_NEVER);  break;
+  case CA_INT64:   FIBER_SCATTER_DISPATCH_C(int64_t, CAT_NAN_NEVER);   break;
+  case CA_UINT64:  FIBER_SCATTER_DISPATCH_C(uint64_t, CAT_NAN_NEVER);  break;
+  case CA_FLOAT32: FIBER_SCATTER_DISPATCH_C(float32_t, CAT_NAN_CHECK); break;
+  case CA_FLOAT64: FIBER_SCATTER_DISPATCH_C(float64_t, CAT_NAN_CHECK); break;
   default:
     ca_detach(h); ca_detach(codes);
     rb_raise(rb_eCADataTypeError,

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 };