carray 3.0.4 → 3.0.6

data/ext/ca_categorical_iterator.c

@@ -457,20 +457,23 @@ rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
 
 /* ---------------------------------------------------------------------------
 
-  __reduceat_variance__ — centred two-pass SAMPLE variance (ddof=1) reduceat.
-  The means (from the cached moments: sum/count) drive a second walk that
-  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 or 1 -> masked (the sample variance is undefined), count >= 2 ->
-  SS / (count-1).
-
-  Surface (private): grouped.__reduceat_variance__(offsets, means, counts, out)
+  __reduceat_variance__ — centred two-pass variance reduceat, sample (ddof=1)
+  or population (ddof=0).  The means (from the cached moments: sum/count)
+  drive a second walk that accumulates the per-segment centred sum of
+  squares; variance = SS / (n - ddof).  Centred (not the one-pass
+  sum-of-squares) so the ε-close contract holds — a one-pass formula cancels
+  catastrophically.  Matches CArray#variance / #variancep per group: count
+  <= ddof (or 0) -> masked, otherwise SS / (count - ddof), divided once as
+  the core does.
+
+  Surface (private):
+    grouped.__reduceat_variance__(offsets, means, counts, out, ddof)
     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
-    out     = float64[k] output: variance; count 0 or 1 masked
+    out     = float64[k] output: variance; count <= ddof masked
+    ddof    = 1 (sample) or 0 (population)
 
 --------------------------------------------------------------------------- */
 
@@ -479,7 +482,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 < 2 ) { outp[c] = 0.0; outm[c] = 1; continue; }  /* undefined */ \
+      if ( cnt <= ddof || cnt < 1 ) { outp[c] = 0.0; outm[c] = 1; continue; }   \
       { 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;              \
@@ -494,14 +497,15 @@ rb_ca_reduceat_percentile (VALUE self, VALUE roffsets, VALUE rp, VALUE rout)
             double d = (double) gp[j] - mean; ss += d * d;                      \
           }                                                                     \
         }                                                                       \
-        outp[c] = ss / (double) (cnt - 1); }                                    \
+        outp[c] = ss / (double) (cnt - ddof); }                                 \
     }                                                                           \
   } while (0)
 
 static VALUE
 rb_ca_reduceat_variance (VALUE self, VALUE roffsets, VALUE rmeans,
-                         VALUE rcounts, VALUE rout)
+                         VALUE rcounts, VALUE rout, VALUE rddof)
 {
+  int64_t     ddof = NUM2LL(rddof);
   CArray     *grouped, *offsets, *means, *counts, *out;
   int64_t     k, *offs, *countp;
   ca_size_t   n, c;
@@ -518,8 +522,9 @@ rb_ca_reduceat_variance (VALUE self, VALUE roffsets, VALUE rmeans,
   n = grouped->elements;
   if ( offsets->data_type != CA_INT64 || counts->data_type != CA_INT64 ||
        means->data_type != CA_FLOAT64 || out->data_type != CA_FLOAT64 ||
-       means->elements != k || counts->elements != k || out->elements != k ) {
-    rb_raise(rb_eArgError, "__reduceat_variance__: offsets/counts int64, means/out float64[k]");
+       means->elements != k || counts->elements != k || out->elements != k ||
+       ( ddof != 0 && ddof != 1 ) ) {
+    rb_raise(rb_eArgError, "__reduceat_variance__: offsets/counts int64, means/out float64[k], ddof 0 or 1");
   }
 
   offs   = (int64_t *) offsets->ptr;
@@ -845,9 +850,8 @@ rb_ca_reduceat_quantile (VALUE self, VALUE roffsets, VALUE rp0, VALUE rp25,
    group order (float64, weight mask propagated). A cell contributes iff its
    value AND its weight are present. wsum_out = Sum(v*w) (0.0 for a segment with
    no present pair, the additive identity). wmean_out = Sum(v*w)/Sum(w), masked
-   when the segment has no present pair (matching CArray#wmean UNDEF); a present
-   segment whose weights sum to zero yields NaN/Inf from the division (core's
-   0/0 contract). */
+   when the segment has no present pair or its weights sum to zero, as
+   CArray#wmean leaves both undefined. */
 #define REDUCEAT_WSUM_BODY(T)                                                   \
   do {                                                                          \
     const T *gp = (const T *) grouped->ptr;                                     \
@@ -861,7 +865,7 @@ rb_ca_reduceat_quantile (VALUE self, VALUE roffsets, VALUE rp0, VALUE rp25,
         { double wv = wp[j]; svw += (double) gp[j] * wv; sw += wv; cnt++; }     \
       }                                                                         \
       wsp[c] = svw;                                                             \
-      if ( cnt == 0 ) { wmp[c] = 0.0; wmm[c] = 1; }     /* no present pair */    \
+      if ( cnt == 0 || sw == 0.0 ) { wmp[c] = 0.0; wmm[c] = 1; }  /* undefined */ \
       else wmp[c] = svw / sw;                                                   \
     }                                                                           \
   } while (0)
@@ -1104,8 +1108,13 @@ rb_ca_fiber_scatter_moments (VALUE self, VALUE rcodes, VALUE raxis, VALUE rk,
              h->data_type);
   }
 
+  ca_detach(h);
+  ca_detach(codes);
+
   /* Mask empty (count == 0) cells in mins/maxs: value slot is 0 but meaningless.
-     Matches __reduceat_moments__ contract for empty segments. */
+     Matches __reduceat_moments__ contract for empty segments.  After the
+     detach: creating a mask allocates, and a raise must not leave h and
+     codes attached. */
   ca_create_mask(mins);
   ca_create_mask(maxs);
   minm = (boolean8_t *) mins->mask->ptr;
@@ -1113,9 +1122,6 @@ rb_ca_fiber_scatter_moments (VALUE self, VALUE rcodes, VALUE raxis, VALUE rk,
   for ( cell = 0; cell < total; cell++ ) {
     if ( countp[cell] == 0 ) { minm[cell] = 1; maxm[cell] = 1; }
   }
-
-  ca_detach(h);
-  ca_detach(codes);
   return Qnil;
 }
 
@@ -1445,15 +1451,16 @@ rb_ca_fiber_scatter_wsum_wmean (VALUE self, VALUE rcodes, VALUE rweights,
              h->data_type);
   }
 
-  /* Compute wmean = wsum / sum-of-weights; mask cells with no present pair. */
+  /* Compute wmean = wsum / sum-of-weights; mask cells with no present pair
+     and cells whose weights sum to zero, as CArray#wmean does. */
   ca_create_mask(wmean);
   wmm = (boolean8_t *) wmean->mask->ptr;
   for ( cell = 0; cell < total; cell++ ) {
-    if ( cntp[cell] == 0 ) {
+    if ( cntp[cell] == 0 || wsw[cell] == 0.0 ) {
       wmp[cell] = 0.0;
       wmm[cell] = 1;
     } else {
-      wmp[cell] = wsp[cell] / wsw[cell];    /* 0/0 -> NaN naturally (core contract) */
+      wmp[cell] = wsp[cell] / wsw[cell];
     }
   }
 
@@ -1481,7 +1488,7 @@ Init_ca_categorical_iterator (void)
   rb_define_private_method(rb_cCArray, "__reduceat_percentile__",
                            rb_ca_reduceat_percentile, 3);
   rb_define_private_method(rb_cCArray, "__reduceat_variance__",
-                           rb_ca_reduceat_variance, 4);
+                           rb_ca_reduceat_variance, 5);
   rb_define_private_method(rb_cCArray, "__reduceat_prod__",
                            rb_ca_reduceat_prod, 2);
   rb_define_private_method(rb_cCArray, "__reduceat_argminmax__",

data/ext/ca_compare.c

@@ -21,8 +21,8 @@
 static int                                             \
 elem_cmp_## type (const void *va, const void *vb)      \
 {                                                      \
-  const type *a = (const type *) va;                   \
-  const type *b = (const type *) vb;                   \
+  const CA_U(type) *a = (const CA_U(type) *) va;       \
+  const CA_U(type) *b = (const CA_U(type) *) vb;       \
   if ( *a > *b ) return  1;                            \
   if ( *a < *b ) return -1;                            \
   return 0;                                            \
@@ -33,8 +33,8 @@ elem_cmp_## type (const void *va, const void *vb)      \
 static int                                             \
 elem_cmp_## type (const void *va, const void *vb)      \
 {                                                      \
-  const type a = *(const type *) va;                   \
-  const type b = *(const type *) vb;                   \
+  const type a = *(const CA_U(type) *) va;             \
+  const type b = *(const CA_U(type) *) vb;             \
   return CA_FLOAT_ORDER_CMP(a, b);                     \
 }
 

data/ext/ca_composite_dispatch.c

@@ -32,29 +32,29 @@ ca_fill_typed (char *dst, const char *val, ca_size_t bytes, ca_size_t n)
       break;
     }
     case 2: {
-      uint16_t  v = *(const uint16_t *)val;
-      uint16_t *p = (uint16_t *)dst;
+      uint16_t  v = *(const ca_u_uint16_t *)val;
+      ca_u_uint16_t *p = (ca_u_uint16_t *)dst;
       for ( i = 0; i < n; i++ ) p[i] = v;
       break;
     }
     case 4: {
-      uint32_t  v = *(const uint32_t *)val;
-      uint32_t *p = (uint32_t *)dst;
+      uint32_t  v = *(const ca_u_uint32_t *)val;
+      ca_u_uint32_t *p = (ca_u_uint32_t *)dst;
       for ( i = 0; i < n; i++ ) p[i] = v;
       break;
     }
     case 8: {
-      uint64_t  v = *(const uint64_t *)val;
-      uint64_t *p = (uint64_t *)dst;
+      uint64_t  v = *(const ca_u_uint64_t *)val;
+      ca_u_uint64_t *p = (ca_u_uint64_t *)dst;
       for ( i = 0; i < n; i++ ) p[i] = v;
       break;
     }
     case 16: {
       /* complex128 etc.  Two uint64_t stores per element.  Compiler
          pairs them into a NEON 128-bit or SSE2 store. */
-      uint64_t v0 = ((const uint64_t *)val)[0];
-      uint64_t v1 = ((const uint64_t *)val)[1];
-      uint64_t *p = (uint64_t *)dst;
+      uint64_t v0 = ((const ca_u_uint64_t *)val)[0];
+      uint64_t v1 = ((const ca_u_uint64_t *)val)[1];
+      ca_u_uint64_t *p = (ca_u_uint64_t *)dst;
       for ( i = 0; i < n; i++ ) {
         p[2*i]     = v0;
         p[2*i + 1] = v1;