carray 3.0.3 → 3.0.5

data/ext/carray_generate.c

@@ -9,14 +9,16 @@
 
 #include "ruby.h"
 #include "carray.h"
-#include "carray_internal.h"   /* ca_attach_window, ca_axis_integer */
+#include "carray_internal.h"   /* ca_attach_window, ca_normalize_axis_arg */
+#include "ca_obj_face.h"      /* ca_face_element_to_storage */
 
 /* ----------------------------------------------------------------- */
 
 /* CArray#where -- collect the flat addresses of all non-zero (or
-   true) cells in self into a fresh 1-D CA_SIZE array.  Non-boolean
-   inputs are first coerced to boolean via rb_ca_to_boolean.  Masked
-   cells are excluded.
+   true) cells in self into a fresh 1-D CA_SIZE array.  An integer,
+   float or complex array selects its non-zero cells (NaN is non-zero);
+   any other non-boolean array is cast to boolean, which takes only
+   0 / 1 / true / false.  Masked cells are excluded.
 
    Also used internally by ext/ca_obj_grid.c when it needs to extract
    the addresses of true cells from a boolean axis selector. */
@@ -27,28 +29,44 @@ rb_ca_where (VALUE self)
   CArray *ca, *co;
   boolean8_t *p, *m;
   ca_size_t *q;
-  ca_size_t i, count;
+  ca_size_t i, j, n, last, count;
 
-  bool0 = ( ! rb_ca_is_boolean_type(self) ) ? rb_ca_to_boolean(self) : self;
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  if ( ca_is_boolean_type(ca) ) {
+    bool0 = self;
+  }
+  else if ( ! ca_is_face(ca) &&
+            ( ca_is_integer_type(ca) || ca_is_float_type(ca) ||
+              ca_is_complex_type(ca) ) ) {
+    bool0 = rb_funcall(self, rb_intern("ne"), 1, INT2FIX(0));
+  }
+  else {
+    bool0 = rb_ca_to_boolean(self);
+  }
 
   TypedData_Get_Struct(bool0, CArray, &carray_data_type, ca);
 
   ca_attach(ca);   /* window: nothing raises inside */
 
-  /* calculate elements of output array */
+  /* calculate elements of output array, and the last selected cell */
   p = (boolean8_t *) ca->ptr;
   m = ca_mask_ptr(ca);
+  n = ca->elements;
   count = 0;
   if ( m ) {
-    for (i=0; i<ca->elements; i++) {
-      if ( ( ! *m ) && ( *p ) ) { count++; }    /* not-masked && true */
-      m++; p++;
+    for (i=0; i<n; i++) {
+      count += ( ! m[i] ) & ( p[i] != 0 );     /* not-masked && true */
     }
   }
   else {
-    for (i=0; i<ca->elements; i++) {
-      if ( *p ) { count++; }                    /* true */ 
-      p++;
+    for (i=0; i<n; i++) {
+      count += ( p[i] != 0 );                   /* true */
+    }
+  }
+  last = n - 1;
+  if ( count > 0 ) {
+    while ( m ? ( m[last] || ! p[last] ) : ! p[last] ) {
+      last--;
     }
   }
 
@@ -56,20 +74,25 @@ rb_ca_where (VALUE self)
   obj = rb_carray_new(CA_SIZE, 1, &count, 0, NULL);
   TypedData_Get_Struct(obj, CArray, &carray_data_type, co);
 
-  /* store address which elements is true to output array */
-  p = (boolean8_t *) ca->ptr;
+  /* Store the address of each selected cell.  Every cell up to the last
+     selected one is written and the output position advances only on a
+     selected cell, so a selection with true and false mixed at random
+     does not mispredict a branch on most cells.  Stopping at the last
+     selected cell keeps the writes inside the count slots. */
   q = (ca_size_t *) co->ptr;
-  m = ca_mask_ptr(ca);
-  if ( m )  {
-    for (i=0; i<ca->elements; i++) {  /* not-masked && true */
-      if ( ( ! *m ) && ( *p ) ) { *q = i; q++; }
-      m++; p++; 
+  j = 0;
+  if ( count > 0 ) {
+    if ( m ) {
+      for (i=0; i<=last; i++) {           /* not-masked && true */
+        q[j] = i;
+        j += ( ! m[i] ) & ( p[i] != 0 );
+      }
     }
-  }
-  else {                              /* true */
-    for (i=0; i<ca->elements; i++) {
-      if ( *p ) { *q = i; q++; }
-      p++;
+    else {                                /* true */
+      for (i=0; i<=last; i++) {
+        q[j] = i;
+        j += ( p[i] != 0 );
+      }
     }
   }
 
@@ -80,19 +103,29 @@ rb_ca_where (VALUE self)
 
 /* ----------------------------------------------------------------- */
 
+/* A number that is not an Integer (a Float, a Rational, a BigDecimal) makes
+   the progression a real one: every cell is offset + step*i computed in
+   double, and an integer array takes it as a store takes a float (cut
+   toward zero; the run is checked to fit before anything is written). */
+static int
+ca_seq_is_real (VALUE v)
+{
+  return ! NIL_P(v) && ! RB_INTEGER_TYPE_P(v) && ! RB_TYPE_P(v, T_COMPLEX)
+      && RTEST(rb_obj_is_kind_of(v, rb_cNumeric));
+}
+
 /* Fill the whole array in row-major order with `step*i + offset`. */
 #define proc_seq_bang(type, from, to)       \
   {                                         \
-    type *p = (type *)ca->ptr;              \
+    CA_U(type) *p = (CA_U(type) *)ca->ptr;              \
     ca_size_t i;                              \
     if ( NIL_P(roffset) && NIL_P(rstep) ) { \
       for (i=0; i<ca->elements; i++) {    \
         *p++ = (type) to(i);                     \
       }                                   \
     }                                     \
-    else if ( rb_obj_is_kind_of(rstep, rb_cFloat) ||              \
-              rb_obj_is_kind_of(roffset, rb_cFloat) ) {            \
-      type offset = (NIL_P(roffset)) ? (type) 0 : (type) from(roffset);  \
+    else if ( ca_seq_is_real(rstep) || ca_seq_is_real(roffset) ) { \
+      double offset = (NIL_P(roffset)) ? 0 : NUM2DBL(roffset);    \
       double step = (NIL_P(rstep)) ? 1 : NUM2DBL(rstep);          \
       for (i=0; i<ca->elements; i++) {    \
         *p++ = (type) to(step*i+offset);         \
@@ -116,11 +149,10 @@ rb_ca_where (VALUE self)
    `outer_size` come from the enclosing scope (ca_seq_geometry). */
 #define proc_seq_bang_axis(type, from, to)                              \
   {                                                                     \
-    type *p = (type *)ca->ptr;                                          \
+    CA_U(type) *p = (CA_U(type) *)ca->ptr;                                          \
     ca_size_t o, k, in;                                                 \
-    if ( rb_obj_is_kind_of(rstep, rb_cFloat) ||                         \
-         rb_obj_is_kind_of(roffset, rb_cFloat) ) {                      \
-      type offset = (NIL_P(roffset)) ? (type) 0 : (type) from(roffset); \
+    if ( ca_seq_is_real(rstep) || ca_seq_is_real(roffset) ) {           \
+      double offset = (NIL_P(roffset)) ? 0 : NUM2DBL(roffset);          \
       double step = (NIL_P(rstep)) ? 1 : NUM2DBL(rstep);                \
       for (o=0; o<outer_size; o++) {                                    \
         for (k=0; k<len; k++) {                                         \
@@ -183,7 +215,7 @@ ca_seq_resolve_axis (CArray *ca, VALUE raxis)
              "%s: axis must be a single Integer (a seq over several axes is not supported)",
              ca_calling_method_name());
   }
-  axis = rb_ca_normalize_axis_for_ndim(ca_axis_integer(raxis, NULL), ca->ndim, NULL);
+  axis = ca_normalize_axis_arg(raxis, ca->ndim, NULL);
   return axis;
 }
 
@@ -209,6 +241,7 @@ ca_seq_geometry (CArray *ca, int axis,
    left as they were, as they would for an entity. */
 
 typedef struct {
+  VALUE   self;
   CArray *ca;
   VALUE   roffset;
   VALUE   rstep;
@@ -216,6 +249,14 @@ typedef struct {
   int     axis;
 } ca_seq_ctx_t;
 
+/* A value of the progression as it goes into a cell: a Face receiver (a
+   CAString) checks it as it checks any value stored into it. */
+static VALUE
+ca_seq_cell (ca_seq_ctx_t *c, VALUE v)
+{
+  return ca_face_element_to_storage(c->self, c->ca, v);
+}
+
 static VALUE
 ca_seq_bang_object_body (VALUE arg)
 {
@@ -227,10 +268,6 @@ ca_seq_bang_object_body (VALUE arg)
   VALUE *p;
   ca_size_t i;
 
-  if ( ca_has_mask(ca) ) {
-    ca_clear_mask(ca);                            /* clear all mask */
-  }
-
   if ( axis < 0 ) {                               /* flat fill */
     p = (VALUE *)ca->ptr;
     if ( rb_obj_is_kind_of(roffset, rb_cFloat) ||
@@ -238,7 +275,7 @@ ca_seq_bang_object_body (VALUE arg)
       double offset = ( NIL_P(roffset) ) ? 0 : NUM2DBL(roffset);
       double step = ( NIL_P(rstep) ) ? 1 : NUM2DBL(rstep);
       for (i=0; i<ca->elements; i++) {
-        *p++ = rb_float_new(step*i+offset);
+        *p++ = ca_seq_cell(c, rb_float_new(step*i+offset));
       }
     }
     else if ( NIL_P(roffset) ) {
@@ -247,22 +284,28 @@ ca_seq_bang_object_body (VALUE arg)
                  "nil is invalid as offset for seq([offset[,step])");
       }
       for (i=0; i<ca->elements; i++) {            /* a.seq() */
-        *p++ = LL2NUM(i);
+        *p++ = ca_seq_cell(c, LL2NUM(i));
       }
     }
     else if ( ! NIL_P(rmethod) ) {                /* a.seq(obj, :method) */
       ID id_method = SYM2ID(rmethod);
-      *p++ = rval = roffset;
+      if ( ca->elements == 0 ) {                  /* no first cell to write */
+        return Qnil;
+      }
+      *p++ = ca_seq_cell(c, rval = roffset);
       for (i=1; i<ca->elements; i++) {
-        *p++ = rval = rb_funcall(rval, id_method, 0);
+        *p++ = ca_seq_cell(c, rval = rb_funcall(rval, id_method, 0));
       }
     }
     else {                                        /* a.seq(obj, step) */
       ID id_plus = rb_intern("+");
       rstep   = ( NIL_P(rstep) ) ? INT2NUM(1) : rstep;
-      *p++ = rval = roffset;
+      if ( ca->elements == 0 ) {                  /* no first cell to write */
+        return Qnil;
+      }
+      *p++ = ca_seq_cell(c, rval = roffset);
       for (i=1; i<ca->elements; i++) {
-        *p++ = rval = rb_funcall(rval, id_plus, 1, rstep);
+        *p++ = ca_seq_cell(c, rval = rb_funcall(rval, id_plus, 1, rstep));
       }
     }
   }
@@ -280,7 +323,7 @@ ca_seq_bang_object_body (VALUE arg)
       double offset = ( NIL_P(roffset) ) ? 0 : NUM2DBL(roffset);
       double step = ( NIL_P(rstep) ) ? 1 : NUM2DBL(rstep);
       for (k=0; k<len; k++) {
-        rb_ary_push(vtbl, rb_float_new(step*k+offset));
+        rb_ary_push(vtbl, ca_seq_cell(c, rb_float_new(step*k+offset)));
       }
     }
     else if ( NIL_P(roffset) ) {
@@ -289,26 +332,26 @@ ca_seq_bang_object_body (VALUE arg)
                  "nil is invalid as offset for seq([offset[,step])");
       }
       for (k=0; k<len; k++) {
-        rb_ary_push(vtbl, LL2NUM(k));
+        rb_ary_push(vtbl, ca_seq_cell(c, LL2NUM(k)));
       }
     }
     else if ( ! NIL_P(rmethod) ) {
       ID id_method = SYM2ID(rmethod);
       rval = roffset;
-      rb_ary_push(vtbl, rval);
+      rb_ary_push(vtbl, ca_seq_cell(c, rval));
       for (k=1; k<len; k++) {
         rval = rb_funcall(rval, id_method, 0);
-        rb_ary_push(vtbl, rval);
+        rb_ary_push(vtbl, ca_seq_cell(c, rval));
       }
     }
     else {
       ID id_plus = rb_intern("+");
       rstep = ( NIL_P(rstep) ) ? INT2NUM(1) : rstep;
       rval = roffset;
-      rb_ary_push(vtbl, rval);
+      rb_ary_push(vtbl, ca_seq_cell(c, rval));
       for (k=1; k<len; k++) {
         rval = rb_funcall(rval, id_plus, 1, rstep);
-        rb_ary_push(vtbl, rval);
+        rb_ary_push(vtbl, ca_seq_cell(c, rval));
       }
     }
     p = (VALUE *)ca->ptr;
@@ -320,6 +363,10 @@ ca_seq_bang_object_body (VALUE arg)
     }
   }
 
+  /* Cleared last, so a fill that raises leaves the mask as it was. */
+  if ( ca_has_mask(ca) ) {
+    ca_clear_mask(ca);
+  }
   return Qnil;
 }
 
@@ -330,6 +377,7 @@ rb_ca_seq_bang_object (VALUE self, VALUE roffset, VALUE rstep, int axis)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, c.ca);
 
+  c.self    = self;
   c.rmethod = Qnil;
   if ( TYPE(rstep) == T_SYMBOL ) {                /* e.g. a.seq("a", :succ) */
     c.rmethod = rstep;
@@ -344,8 +392,9 @@ rb_ca_seq_bang_object (VALUE self, VALUE roffset, VALUE rstep, int axis)
   return self;
 }
 
-/* The numeric fill converts offset and step before it writes a cell, so
-   a raise there leaves nothing to push back: an allocate window. */
+/* The numeric fill runs in an allocate window, which clears an entity's
+   mask as it opens (an entity has no separate buffer), so nothing in it may
+   raise: offset and step are checked to be numbers before it opens. */
 static VALUE
 ca_seq_bang_numeric_body (VALUE arg)
 {
@@ -368,6 +417,76 @@ ca_seq_bang_numeric_body (VALUE arg)
   return Qnil;
 }
 
+/* An integer array refuses a first value it cannot hold, as a store does,
+   and an Integer step whose size it cannot hold.  An unsigned array takes
+   a negative step (a descending run).  A run that passes the end of the
+   type wraps, as integer arithmetic does. */
+static void
+ca_seq_check_integer_args (CArray *ca, VALUE roffset, VALUE rstep)
+{
+  int8_t dt = ca->data_type;
+  /* Only a number is checked here; anything else is left to the fill's
+     own conversion, which refuses it with TypeError. */
+  if ( RB_INTEGER_TYPE_P(roffset) || RB_FLOAT_TYPE_P(roffset) ) {
+    VALUE first = RB_INTEGER_TYPE_P(roffset) ? roffset : rb_Integer(roffset);
+    if ( ca_integer_range_side(first, dt) != 0 ) {
+      rb_raise(rb_eRangeError, "%s: first value %"PRIsVALUE" is out of range for %s",
+               ca_calling_method_name(), rb_inspect(roffset), ca_type_name[dt]);
+    }
+  }
+  if ( RB_INTEGER_TYPE_P(rstep) ) {
+    int is_unsigned = ( dt == CA_UINT8  || dt == CA_UINT16 ||
+                        dt == CA_UINT32 || dt == CA_UINT64 );
+    VALUE size = rstep;
+    if ( is_unsigned && RTEST(rb_funcall(rstep, rb_intern("negative?"), 0)) ) {
+      size = rb_funcall(rstep, rb_intern("-@"), 0);
+    }
+    if ( ca_integer_range_side(size, dt) != 0 ) {
+      rb_raise(rb_eRangeError, "%s: step %"PRIsVALUE" is out of range for %s",
+               ca_calling_method_name(), rb_inspect(rstep), ca_type_name[dt]);
+    }
+  }
+}
+
+/* A real progression on an integer array: each cell takes offset + step*i
+   cut toward zero, as a store takes a float, so the first and the last
+   value (the extremes of a linear run) must fit the type, and NaN raises
+   as it does in a store.  Checked before the fill writes anything. */
+static void
+ca_seq_check_real_run (CArray *ca, VALUE roffset, VALUE rstep, ca_size_t n)
+{
+  int8_t dt = ca->data_type;
+  double offset = NIL_P(roffset) ? 0.0 : NUM2DBL(roffset);
+  double step   = NIL_P(rstep)   ? 1.0 : NUM2DBL(rstep);
+  double ends[2];
+  double lo, hi_excl;
+  int k;
+  if ( n == 0 ) return;
+  ends[0] = offset;
+  ends[1] = step * (double) (n - 1) + offset;
+  switch ( dt ) {
+  case CA_INT8:   lo = INT8_MIN;  hi_excl = (double) INT8_MAX + 1;   break;
+  case CA_UINT8:  lo = 0;         hi_excl = (double) UINT8_MAX + 1;  break;
+  case CA_INT16:  lo = INT16_MIN; hi_excl = (double) INT16_MAX + 1;  break;
+  case CA_UINT16: lo = 0;         hi_excl = (double) UINT16_MAX + 1; break;
+  case CA_INT32:  lo = INT32_MIN; hi_excl = (double) INT32_MAX + 1;  break;
+  case CA_UINT32: lo = 0;         hi_excl = (double) UINT32_MAX + 1; break;
+  case CA_INT64:  lo = -ldexp(1.0, 63); hi_excl = ldexp(1.0, 63);    break;
+  default:        lo = 0;         hi_excl = ldexp(1.0, 64);          break;
+  }
+  for (k = 0; k < 2; k++) {
+    double t = trunc(ends[k]);
+    if ( isnan(ends[k]) || ( step != 0.0 && isnan(step) ) ) {
+      rb_raise(rb_eFloatDomainError, "%s: the run has NaN",
+               ca_calling_method_name());
+    }
+    if ( ! ( t >= lo && t < hi_excl ) ) {
+      rb_raise(rb_eRangeError, "%s: value %g is out of range for %s",
+               ca_calling_method_name(), ends[k], ca_type_name[dt]);
+    }
+  }
+}
+
 /* CArray#seq!(init_val=0, step=1, axis: nil) -- arithmetic-progression
    fill, in place.  Without `axis:` the fill runs in row-major order
    over the whole array; with `axis: k` the progression runs along axis
@@ -397,6 +516,34 @@ rb_ca_seq_bang_method (int argc, VALUE *argv, VALUE self)
     return rb_ca_seq_bang_object(self, roffset, rstep, axis);
   }
 
+  {
+    VALUE args[2];
+    const char *names[2] = { "offset", "step" };
+    int k;
+    args[0] = roffset;
+    args[1] = rstep;
+    for (k = 0; k < 2; k++) {
+      VALUE v = args[k];
+      if ( NIL_P(v) ) continue;
+      if ( ! RTEST(rb_obj_is_kind_of(v, rb_cNumeric)) ||
+           ( RB_TYPE_P(v, T_COMPLEX) && ! ca_is_complex_type(ca) ) ) {
+        rb_raise(rb_eTypeError, "%s: %s must be a %snumber (got %"PRIsVALUE")",
+                 ca_calling_method_name(), names[k],
+                 ca_is_complex_type(ca) ? "" : "real ", rb_inspect(v));
+      }
+    }
+  }
+
+  if ( ca_is_integer_type(ca) ) {
+    if ( ca_seq_is_real(roffset) || ca_seq_is_real(rstep) ) {
+      ca_seq_check_real_run(ca, roffset, rstep,
+                            axis < 0 ? ca->elements : ca->dim[axis]);
+    }
+    else {
+      ca_seq_check_integer_args(ca, roffset, rstep);
+    }
+  }
+
   {
     ca_seq_ctx_t c;
     c.ca      = ca;

data/ext/carray_histogram.c

@@ -26,11 +26,38 @@
 #include "carray_internal.h"   /* ca_attach_window */
 #include <math.h>
 
-/* Resolve `redges` to a 1-D float64 CArray of at least two edges.  The
-   caller copies the edges out (ca_xfer_all into its own buffer) rather
-   than attaching them: the walk that follows reads the caller's array,
-   and a raise there must not leave the edges attached. */
-static CArray *
+/* Edges are the bin boundaries and must read as such: no masked edge (its
+   stored value is no boundary), no NaN, and no edge below the one before
+   it.  Equal edges (a bin of zero width) and infinite ones are kept. */
+static void
+histbin_check_edge_mask (CArray *ce, const char *name)
+{
+  if ( ca_has_mask(ce) && ca_is_any_masked(ce) ) {
+    rb_raise(rb_eArgError, "%s: edges has a masked value", name);
+  }
+}
+
+static void
+histbin_check_edge_order (const double *ep, ca_size_t n, const char *name)
+{
+  ca_size_t i;
+  for (i = 0; i < n; i++) {
+    if ( isnan(ep[i]) ) {
+      rb_raise(rb_eArgError, "%s: edges has NaN at %lld", name, (long long) i);
+    }
+    if ( i > 0 && ep[i] < ep[i-1] ) {
+      rb_raise(rb_eArgError, "%s: edges must not decrease "
+               "(%g at %lld after %g)", name, ep[i], (long long) i, ep[i-1]);
+    }
+  }
+}
+
+/* Resolve `redges` to a 1-D float64 CArray of at least two edges, and
+   return it: it may be a view made here, which only the caller can keep
+   alive.  The caller copies the edges out (ca_xfer_all into its own
+   buffer) rather than attaching them: the walk that follows reads the
+   caller's array, and a raise there must not leave the edges attached. */
+static VALUE
 histbin_resolve_edges (VALUE self, VALUE redges)
 {
   CArray *ce;
@@ -50,8 +77,9 @@ histbin_resolve_edges (VALUE self, VALUE redges)
   if ( ce->elements < 2 ) {
     rb_raise(rb_eArgError, "histbin_ki: edges needs at least 2 values");
   }
+  histbin_check_edge_mask(ce, "bin_to");
 
-  return ce;
+  return redges;
 }
 
 /* ---- shared binning helpers (used by histbin_ki + the fused kernel) ---- */
@@ -144,10 +172,13 @@ rb_ca_histbin_ki (VALUE self, VALUE redges, VALUE rinclude_max)
              ca_type_name[ca->data_type]);
   }
 
-  ce = histbin_resolve_edges(self, redges);
+  redges = histbin_resolve_edges(self, redges);
+  GetCArray(redges, ce);
   ep = ALLOCV_N(double, hedges, ce->elements);
   ca_xfer_all(ce, ep, CA_XFER_GET);
+  histbin_check_edge_order(ep, ce->elements, "bin_to");
   histbin_axis_setup(&ax, ep, ce->elements, RTEST(rinclude_max));
+  RB_GC_GUARD(redges);   /* a view made by histbin_resolve_edges is read through ce */
 
   /* output: fresh contiguous int64, same shape as self. */
   vout = rb_carray_new(CA_INT64, ca->ndim, ca->dim, 0, NULL);
@@ -281,7 +312,7 @@ histogram_scatter_walk (VALUE arg)
       ca_size_t off = fiber_base;
       int       masked = 0;
       for ( kk = 0; kk < (ca_size_t) M; kk++ ) {
-        double v = *(const double *)(p + a * ss + kk * cs);
+        double v = *(const ca_u_float64_t *)(p + a * ss + kk * cs);
         if ( (m && m[a * sms + kk * cms]) || isnan(v) ) { masked = 1; break; }
         off += histbin_index(&axes[kk], v) * ext_stride[kk];
       }
@@ -314,6 +345,10 @@ histogram_scatter_edges (VALUE arg)
 {
   histogram_scatter_t *c = (histogram_scatter_t *) arg;
   long k;
+  for ( k = 0; k < c->M; k++ ) {
+    histbin_check_edge_order((const double *) c->edge_ca[k]->ptr,
+                             c->edge_ca[k]->elements, "histogram");
+  }
   for ( k = 0; k < c->M; k++ ) {
     histbin_axis_setup(&c->axes[k], (const double *) c->edge_ca[k]->ptr,
                        c->edge_ca[k]->elements,
@@ -382,6 +417,7 @@ rb_ca_histogram_scatter_ki (VALUE self, VALUE rcounts, VALUE redges,
   for ( k = 0; k < M; k++ ) {
     VALUE e = RARRAY_AREF(redges, k);
     GetCArray(e, edge_ca[k]);
+    histbin_check_edge_mask(edge_ca[k], "histogram");
   }
 
   /* ext strides (row-major within the trailing M bin axes of counts). */
@@ -428,7 +464,16 @@ rb_ca_histogram_scatter_ki (VALUE self, VALUE rcounts, VALUE redges,
      weights = nil OR float64 [fiber..., A] (second iterator in lockstep).
    =========================================================================== */
 
-#define BINCOUNT_ND_BODY(LABEL_T)                                              \
+/* A label at or above the last bin lands in the overflow cell.  An unsigned
+   64-bit label above INT64_MAX must be clamped before it becomes an int64,
+   or it turns negative and indexes before the counts. */
+static inline int64_t
+bincount_nd_label_u64 (uint64_t x)
+{
+  return ( x > (uint64_t) INT64_MAX ) ? INT64_MAX : (int64_t) x;
+}
+
+#define BINCOUNT_ND_BODY(LABEL_T, TO_INT64)                                    \
   do {                                                                         \
     while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {                      \
       ca_size_t fiber_base = 0, A, a, kk, ss, cs, sms, cms, ws = 0, wms = 0;   \
@@ -441,7 +486,7 @@ rb_ca_histogram_scatter_ki (VALUE self, VALUE rcounts, VALUE redges,
       for ( a = 0; a < A; a++ ) {                                             \
         ca_size_t off = fiber_base; int masked = 0;                           \
         for ( kk = 0; kk < (ca_size_t) M; kk++ ) {                            \
-          int64_t v = (int64_t) *(const LABEL_T *)(p + a * ss + kk * cs);     \
+          int64_t v = TO_INT64(*(const LABEL_T *)(p + a * ss + kk * cs));     \
           if ( m && m[a * sms + kk * cms] ) { masked = 1; break; }            \
           if ( v >= ext_dim[kk] - 1 ) v = ext_dim[kk] - 1;                    \
           off += (ca_size_t) v * ext_stride[kk];                             \
@@ -515,14 +560,14 @@ rb_ca_bincount_nd_count_ki (VALUE self, VALUE rcounts, VALUE rweights)
     for ( mm = 0; mm < st.outer_ndim; mm++ ) cur_outer_idx[mm] = 0;
 
     switch ( ca->data_type ) {
-    case CA_INT8:   BINCOUNT_ND_BODY(int8_t);   break;
-    case CA_UINT8:  BINCOUNT_ND_BODY(uint8_t);  break;
-    case CA_INT16:  BINCOUNT_ND_BODY(int16_t);  break;
-    case CA_UINT16: BINCOUNT_ND_BODY(uint16_t); break;
-    case CA_INT32:  BINCOUNT_ND_BODY(int32_t);  break;
-    case CA_UINT32: BINCOUNT_ND_BODY(uint32_t); break;
-    case CA_INT64:  BINCOUNT_ND_BODY(int64_t);  break;
-    case CA_UINT64: BINCOUNT_ND_BODY(uint64_t); break;
+    case CA_INT8:   BINCOUNT_ND_BODY(int8_t, (int64_t));   break;
+    case CA_UINT8:  BINCOUNT_ND_BODY(uint8_t, (int64_t));  break;
+    case CA_INT16:  BINCOUNT_ND_BODY(int16_t, (int64_t));  break;
+    case CA_UINT16: BINCOUNT_ND_BODY(uint16_t, (int64_t)); break;
+    case CA_INT32:  BINCOUNT_ND_BODY(int32_t, (int64_t));  break;
+    case CA_UINT32: BINCOUNT_ND_BODY(uint32_t, (int64_t)); break;
+    case CA_INT64:  BINCOUNT_ND_BODY(int64_t, (int64_t));  break;
+    case CA_UINT64: BINCOUNT_ND_BODY(uint64_t, bincount_nd_label_u64); break;
     default:
       ca_iter_state_finish(&st);
       if ( weighted ) ca_iter_state_finish(&stw);

data/ext/carray_hold.c

@@ -20,6 +20,7 @@
 #include "carray.h"
 #include "ca_kernel_iterator.h"
 #include "ca_obj_face.h"
+#include "carray_internal.h"   /* ca_normalize_axis_arg */
 
 /* Forward hold along `axis`.  Per fiber along the scan axis:
      - present cell         -> output = cell value, becomes the held value;
@@ -47,22 +48,24 @@ rb_ca_hold_forward (VALUE self, int axis)
   ca_iter_state st_in, st_out;
   int rc = ca_iter_state_init_l2(&st_in, ca, CA_SLAB_AXES, slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
-    rb_raise(rb_eRuntimeError, "__hold__: input init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "hold_forward: input init failed rc=%d", rc);
   }
   rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                                     slab_axes, 1,
                              CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
-    rb_raise(rb_eRuntimeError, "__hold__: output init failed rc=%d", rc);
+    rb_raise(rb_eRuntimeError, "hold_forward: output init failed rc=%d", rc);
   }
 
   /* Output mask allocated lazily on the first leading-masked (UNDEF) cell:
      a fiber can only go UNDEF on a leading masked run, so a fully filled
-     result carries no mask at all.  op_mask parallels the fresh contiguous
-     output value buffer co->ptr. */
+     result carries no mask at all.  The output is a fresh row-major entity
+     and the walk cuts its slabs from a buffer laid out the same way (the
+     output's memory, or the walk's scratch when it delivers by transfer),
+     so a slab's offset from st_out.alias_ptr is its offset in co, which
+     op_mask parallels. */
   boolean8_t *op_mask = NULL;
-  char       *co_root = (char *) co->ptr;
 
   char       *pi, *po;
   boolean8_t *mi, *mo;
@@ -73,7 +76,7 @@ rb_ca_hold_forward (VALUE self, int axis)
     ca_size_t   oS   = st_out.slab_strides[0];       /* output data byte stride */
     ca_size_t   iMS  = st_in.slab_mask_strides[0];   /* input mask element stride */
     ca_size_t   oMStep = oS / K;                     /* output mask element step */
-    ca_size_t   oMBase = (ca_size_t)(po - co_root) / K;
+    ca_size_t   oMBase = (ca_size_t)(po - st_out.alias_ptr) / K;
     const char *held = NULL;   /* last valid cell (points into input slab) */
 
     for ( ca_size_t j = 0; j < N; j++ ) {
@@ -104,7 +107,7 @@ rb_ca_hold_forward (VALUE self, int axis)
   return vout;
 }
 
-/* __hold__(axis): private forward-hold primitive.  axis is a required
+/* hold_forward(axis): private forward-hold primitive.  axis is a required
    Integer (negative counts from the end).  The Ruby wrapper composes
    backward / flatten / linear on top of this. */
 static VALUE
@@ -112,13 +115,7 @@ rb_ca_hold_method (VALUE self, VALUE raxis)
 {
   CArray *ca;
   GetCArray(self, ca);
-  int axis = NUM2INT(raxis);
-  if ( axis < 0 ) axis += ca->ndim;
-  if ( axis < 0 || axis >= ca->ndim ) {
-    rb_raise(rb_eArgError, "__hold__: axis %d out of range for ndim %d",
-             NUM2INT(raxis), ca->ndim);
-  }
-  return rb_ca_hold_forward(self, axis);
+  return rb_ca_hold_forward(self, ca_normalize_axis_arg(raxis, ca->ndim, NULL));
 }
 
 /* first / last: the reduction sibling of hold.  Reduce each fiber to its
@@ -223,7 +220,7 @@ rb_ca_last (int argc, VALUE *argv, VALUE self)
 void
 Init_carray_hold (void)
 {
-  rb_define_private_method(rb_cCArray, "__hold__", rb_ca_hold_method, 1);
+  rb_define_private_method(rb_cCArray, "hold_forward", rb_ca_hold_method, 1);
   rb_define_method(rb_cCArray, "first", rb_ca_first, -1);
   rb_define_method(rb_cCArray, "last",  rb_ca_last,  -1);
 }