carray 3.0.3 → 3.0.4

data/ext/carray_element.c

@@ -20,18 +20,35 @@
 #include "ca_obj_face.h"
 #include "carray_internal.h"   /* ca_obj_extremum_replaces */
 
+/* An element index is an Integer, as it is for `[]`; a Float would be cut
+   to an integer by NUM2SIZE. */
+static inline ca_size_t
+elem_index_value (VALUE v)
+{
+  if ( FIXNUM_P(v) ) return (ca_size_t) FIX2LONG(v);
+  if ( ! RB_INTEGER_TYPE_P(v) ) {
+    rb_raise(rb_eIndexError, "object '%"PRIsVALUE"' is invalid for an index",
+             rb_inspect(v));
+  }
+  return NUM2SIZE(v);
+}
+
 /* T_ARRAY index parser.  ridx is assumed already known to be T_ARRAY.
    Direct VALUE * access + FIXNUM_P fast path eliminates rb_ary_entry
    bounds check and NUM2SIZE Bignum branching for the common case. */
 static inline void
 elem_parse_idx_array (CArray *ca, VALUE rary, ca_size_t *idx)
 {
-  const VALUE *iarr = RARRAY_CONST_PTR(rary);
+  const VALUE *iarr;
   int8_t ndim = ca->ndim;
   int8_t i;
+  if ( RARRAY_LEN(rary) != ndim ) {
+    rb_raise(rb_eIndexError, "%ld indices given for a carray of ndim %i",
+             (long) RARRAY_LEN(rary), (int) ndim);
+  }
+  iarr = RARRAY_CONST_PTR(rary);
   for (i=0; i<ndim; i++) {
-    VALUE v = iarr[i];
-    ca_size_t k = FIXNUM_P(v) ? (ca_size_t)FIX2LONG(v) : NUM2SIZE(v);
+    ca_size_t k = elem_index_value(iarr[i]);
     CA_CHECK_INDEX(k, ca->dim[i]);
     idx[i] = k;
   }
@@ -41,7 +58,7 @@ elem_parse_idx_array (CArray *ca, VALUE rary, ca_size_t *idx)
 static inline ca_size_t
 elem_parse_idx_scalar (CArray *ca, VALUE ridx)
 {
-  ca_size_t k = FIXNUM_P(ridx) ? (ca_size_t)FIX2LONG(ridx) : NUM2SIZE(ridx);
+  ca_size_t k = elem_index_value(ridx);
   CA_CHECK_INDEX(k, ca->elements);
   return k;
 }
@@ -278,33 +295,56 @@ rb_ca_elem_store (VALUE self, VALUE ridx, VALUE obj)
         if ( FIXNUM_P(obj) )             { *(int64_t *)p = (int64_t)FIX2LONG(obj); return obj; }
         break;
       case CA_INT32:
-        if ( FIXNUM_P(obj) )             { *(int32_t *)p = (int32_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= INT32_MIN && FIX2LONG(obj) <= INT32_MAX ) {
+          /* fits: checked against the type's range above */
+          *(int32_t *)p = (int32_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_INT16:
-        if ( FIXNUM_P(obj) )             { *(int16_t *)p = (int16_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= INT16_MIN && FIX2LONG(obj) <= INT16_MAX ) {
+          /* fits: checked against the type's range above */
+          *(int16_t *)p = (int16_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_INT8:
-        if ( FIXNUM_P(obj) )             { *(int8_t *)p = (int8_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= INT8_MIN && FIX2LONG(obj) <= INT8_MAX ) {
+          /* fits: checked against the type's range above */
+          *(int8_t *)p = (int8_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_UINT64:
-        if ( FIXNUM_P(obj) )             { *(uint64_t *)p = (uint64_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= 0 ) {
+          *(uint64_t *)p = (uint64_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_UINT32:
-        if ( FIXNUM_P(obj) )             { *(uint32_t *)p = (uint32_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= 0 && FIX2LONG(obj) <= (long) UINT32_MAX ) {
+          /* fits: checked against the type's range above */
+          *(uint32_t *)p = (uint32_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_UINT16:
-        if ( FIXNUM_P(obj) )             { *(uint16_t *)p = (uint16_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= 0 && FIX2LONG(obj) <= (long) UINT16_MAX ) {
+          /* fits: checked against the type's range above */
+          *(uint16_t *)p = (uint16_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_UINT8:
-        if ( FIXNUM_P(obj) )             { *(uint8_t *)p = (uint8_t)FIX2LONG(obj); return obj; }
+        if ( FIXNUM_P(obj) && FIX2LONG(obj) >= 0 && FIX2LONG(obj) <= (long) UINT8_MAX ) {
+          /* fits: checked against the type's range above */
+          *(uint8_t *)p = (uint8_t)FIX2LONG(obj); return obj;
+        }
         break;
       case CA_BOOLEAN:
         if ( obj == Qtrue )              { *(uint8_t *)p = 1; return obj; }
         if ( obj == Qfalse )             { *(uint8_t *)p = 0; return obj; }
-        if ( FIXNUM_P(obj) )             { *(uint8_t *)p = (FIX2LONG(obj) != 0); return obj; }
+        if ( obj == INT2FIX(0) || obj == INT2FIX(1) ) {
+          *(uint8_t *)p = (obj == INT2FIX(1)); return obj;
+        }
         break;
       }
-      /* Fall through: data type matches but obj kind needs general coercion. */
+      /* Fall through: the value needs the general coercion, or does not fit
+         the cell, which the general path refuses. */
     }
   }
 
@@ -331,14 +371,12 @@ rb_ca_elem_fetch (VALUE self, VALUE ridx)
 
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
-  if ( ca_is_empty(ca) ) return Qnil;
-
   if ( TYPE(ridx) == T_ARRAY ) {
     volatile VALUE out;
     elem_parse_idx_array(ca, ridx, idx);
 
     /* Super-hot path: entity + common numeric data type + no mask.
-       Bypass ca_fetch_index dispatch AND rb_ca_ptr2obj cast-table dispatch.
+       Bypass ca_fetch_index dispatch AND rb_ca_ptr2obj_storage cast-table dispatch.
        Covers the bench's float64 / int64 / int32 cases. */
     if ( ca_is_entity(ca) && ! ca->mask ) {
       ca_size_t addr = elem_entity_addr(ca, idx);
@@ -370,13 +408,13 @@ rb_ca_elem_fetch (VALUE self, VALUE ridx)
       else {
         ca_fetch_index(ca, idx, v);
       }
-      out = rb_ca_ptr2obj(self, v);
+      out = rb_ca_ptr2obj_storage(self, v);
     }
     else {
       volatile VALUE holder;
       char *v = ALLOCV_N(char, holder, ca->bytes);
       ca_fetch_index(ca, idx, v);
-      out = rb_ca_ptr2obj(self, v);
+      out = rb_ca_ptr2obj_storage(self, v);
       ALLOCV_END(holder);
     }
 
@@ -749,6 +787,11 @@ rb_ca_elem_unmask (VALUE self, VALUE ridx)
  * rule (NaN is treated as missing: `min(NaN, v)` returns `v`,
  * `min(x, NaN)` returns `x`).  Raises for non-numeric data_type. */
 
+/* The entity fast path takes a Float into a float cell and an Integer
+   that fits the cell.  Anything else -- a Float into an integer cell, an
+   Integer out of the type's range, a Bignum or Rational -- goes to the
+   general path, which compares in Ruby and stores as `self[idx] = v`
+   does, so a value that wins but does not fit raises. */
 #define ELEM_MINMAX_BODY(OP) do { \
   if ( ca_is_entity(ca) ) { \
     ca_size_t addr; \
@@ -766,14 +809,6 @@ rb_ca_elem_unmask (VALUE self, VALUE ridx)
       switch ( ca->data_type ) { \
       case CA_FLOAT64: { double *q=(double *)p;  if (v OP *q || *q != *q) *q = v; return self; } \
       case CA_FLOAT32: { float  *q=(float  *)p;  float vf=(float)v; if (vf OP *q || *q != *q) *q = vf; return self; } \
-      case CA_INT64:   { int64_t *q=(int64_t *)p; if ((int64_t)v OP *q) *q = (int64_t)v; return self; } \
-      case CA_INT32:   { int32_t *q=(int32_t *)p; if ((int32_t)v OP *q) *q = (int32_t)v; return self; } \
-      case CA_INT16:   { int16_t *q=(int16_t *)p; if ((int16_t)v OP *q) *q = (int16_t)v; return self; } \
-      case CA_INT8:    { int8_t  *q=(int8_t  *)p; if ((int8_t )v OP *q) *q = (int8_t )v; return self; } \
-      case CA_UINT64:  { uint64_t *q=(uint64_t*)p; if ((uint64_t)v OP *q) *q = (uint64_t)v; return self; } \
-      case CA_UINT32:  { uint32_t *q=(uint32_t*)p; if ((uint32_t)v OP *q) *q = (uint32_t)v; return self; } \
-      case CA_UINT16:  { uint16_t *q=(uint16_t*)p; if ((uint16_t)v OP *q) *q = (uint16_t)v; return self; } \
-      case CA_UINT8:   { uint8_t  *q=(uint8_t *)p; if ((uint8_t )v OP *q) *q = (uint8_t )v; return self; } \
       } \
     } \
     else if ( FIXNUM_P(rval) ) { \
@@ -782,13 +817,13 @@ rb_ca_elem_unmask (VALUE self, VALUE ridx)
       case CA_FLOAT64: { double *q=(double *)p; double vd=(double)v; if (vd OP *q || *q != *q) *q = vd; return self; } \
       case CA_FLOAT32: { float  *q=(float  *)p; float  vf=(float )v; if (vf OP *q || *q != *q) *q = vf; return self; } \
       case CA_INT64:   { int64_t *q=(int64_t *)p; if ((int64_t)v OP *q) *q = (int64_t)v; return self; } \
-      case CA_INT32:   { int32_t *q=(int32_t *)p; if ((int32_t)v OP *q) *q = (int32_t)v; return self; } \
-      case CA_INT16:   { int16_t *q=(int16_t *)p; if ((int16_t)v OP *q) *q = (int16_t)v; return self; } \
-      case CA_INT8:    { int8_t  *q=(int8_t  *)p; if ((int8_t )v OP *q) *q = (int8_t )v; return self; } \
-      case CA_UINT64:  { uint64_t *q=(uint64_t*)p; if ((uint64_t)v OP *q) *q = (uint64_t)v; return self; } \
-      case CA_UINT32:  { uint32_t *q=(uint32_t*)p; if ((uint32_t)v OP *q) *q = (uint32_t)v; return self; } \
-      case CA_UINT16:  { uint16_t *q=(uint16_t*)p; if ((uint16_t)v OP *q) *q = (uint16_t)v; return self; } \
-      case CA_UINT8:   { uint8_t  *q=(uint8_t *)p; if ((uint8_t )v OP *q) *q = (uint8_t )v; return self; } \
+      case CA_INT32:   { if ( ! (v >= INT32_MIN && v <= INT32_MAX) ) break; int32_t *q=(int32_t *)p; if ((int32_t)v OP *q) *q = (int32_t)v; return self; } \
+      case CA_INT16:   { if ( ! (v >= INT16_MIN && v <= INT16_MAX) ) break; int16_t *q=(int16_t *)p; if ((int16_t)v OP *q) *q = (int16_t)v; return self; } \
+      case CA_INT8:    { if ( ! (v >= INT8_MIN && v <= INT8_MAX) ) break; int8_t  *q=(int8_t  *)p; if ((int8_t )v OP *q) *q = (int8_t )v; return self; } \
+      case CA_UINT64:  { if ( ! (v >= 0) ) break; uint64_t *q=(uint64_t*)p; if ((uint64_t)v OP *q) *q = (uint64_t)v; return self; } \
+      case CA_UINT32:  { if ( ! (v >= 0 && v <= (long) UINT32_MAX) ) break; uint32_t *q=(uint32_t*)p; if ((uint32_t)v OP *q) *q = (uint32_t)v; return self; } \
+      case CA_UINT16:  { if ( ! (v >= 0 && v <= (long) UINT16_MAX) ) break; uint16_t *q=(uint16_t*)p; if ((uint16_t)v OP *q) *q = (uint16_t)v; return self; } \
+      case CA_UINT8:   { if ( ! (v >= 0 && v <= (long) UINT8_MAX) ) break; uint8_t  *q=(uint8_t *)p; if ((uint8_t )v OP *q) *q = (uint8_t )v; return self; } \
       } \
     } \
   } \
@@ -808,6 +843,10 @@ rb_ca_elem_min (VALUE self, VALUE ridx, VALUE rval)
     rb_raise(rb_eCADataTypeError,
              "elem_min requires a numeric array");
   }
+  if ( ca_is_complex_type(ca) ) {
+    rb_raise(rb_eCADataTypeError,
+             "elem_min requires a real array (complex values have no order)");
+  }
 
   /* Super-hot path: entity + numeric data type + Fixnum/Float rval. */
   ELEM_MINMAX_BODY(<);
@@ -864,6 +903,10 @@ rb_ca_elem_max (VALUE self, VALUE ridx, VALUE rval)
     rb_raise(rb_eCADataTypeError,
              "elem_max requires a numeric array");
   }
+  if ( ca_is_complex_type(ca) ) {
+    rb_raise(rb_eCADataTypeError,
+             "elem_max requires a real array (complex values have no order)");
+  }
 
   ELEM_MINMAX_BODY(>);
 

data/ext/carray_factorize.c

@@ -50,7 +50,8 @@
   (Float#eql? treats them equal).  The object lane adds one deviation from Ruby
   Hash, aligning it with the numeric lane: every Float NaN collapses to one
   distinct value (a NaN takes a fixed canonical key and matches any stored Float
-  NaN), where Ruby Hash would keep distinct NaN objects apart.
+  NaN), where Ruby Hash would keep distinct NaN objects apart, and a Complex
+  with a NaN part is one value with any Complex whose parts match it that way.
   __factorize_appearance__ and the discovery members (unique, value_counts,
   mask_duplicates) all cover the numeric / object / fixlen lanes.
 
@@ -77,6 +78,7 @@
 
 #include "carray.h"
 #include "ca_obj_face.h"
+#include "carray_internal.h"   /* ca_object_cells_clear */
 #include <string.h>
 #include <math.h>
 
@@ -175,6 +177,7 @@ fz_complex_key (VALUE self)
   if ( ca_has_mask(ca) ) {
     ca_copy_mask(co, ca);
   }
+  RB_GC_GUARD(self);   /* read through ca after rb_carray_new allocates */
   return out;
 }
 
@@ -206,24 +209,19 @@ fz_face_descend (VALUE self, volatile VALUE *pface, const char *name)
   }
   if ( ca_is_face(ca) ) {
     /* A record is its bytes: two records are the same value exactly when
-       their bytes are, so the fixlen lane answers for it. */
-    if ( ca_test_flag(ca, CA_FLAG_FACE_ORDERABLE_STORAGE)
-         || ca->obj_type == CA_OBJ_RECORD ) {
-      *pface = self;
-      return rb_ca_strip_face_value(self);
+       their bytes are, so the fixlen lane answers for it.  Any other Face
+       is descended only when ORDERABLE.  One that cannot be descended must
+       not flow on undescended: whatever reads it next reads its storage
+       anyway, which is the encoding rather than the values.  A Face in this
+       position normally never arrives -- CAConstString and CACategorical
+       define their own members in Ruby -- but the overrides only fire when
+       the Face is the receiver, and this same helper descends the
+       *reference* for locate_addr, where it is the argument. */
+    if ( ca->obj_type != CA_OBJ_RECORD ) {
+      ca_face_require_orderable(self, name, "compare");
     }
-    /* A Face that cannot be descended must not flow on undescended: whatever
-       reads it next reads its storage anyway, which is the encoding rather
-       than the values.  A Face in this position normally never arrives --
-       CAConstString and CACategorical define their own members in Ruby -- but
-       the overrides only fire when the Face is the receiver, and this same
-       helper descends the *reference* for locate_addr, where it is the
-       argument. */
-    rb_raise(rb_eArgError,
-             "%s: %s is not orderable by storage (a cell encodes the value "
-             "rather than being it); convert it first -- %s -- or pass "
-             ".parent to work in storage space",
-             name, rb_obj_classname(self), ca_face_conversion_hint(self));
+    *pface = self;
+    return rb_ca_strip_face_value(self);
   }
   *pface = Qnil;
   return self;
@@ -250,6 +248,7 @@ fz_face_reconcile (VALUE reference, VALUE operand, const char *name)
     }
     GetCArray(operand, op);
     if ( op->data_type != ca->data_type ) {
+      /* coerce: the callers have met both sides at result_type already */
       operand = rb_ca_to_type(operand, INT2NUM(ca->data_type), Qnil);
     }
     return fz_complex_key(operand);
@@ -402,8 +401,7 @@ fz_hash_alloc (fz_hash *h, ca_size_t cap)
   h->cap  = cap;
   MEMZERO(h->used, uint8_t, cap);
   if ( has_val ) {
-    ca_size_t i;
-    for ( i = 0; i < cap; i++ ) h->val[i] = Qnil;
+    ca_object_cells_clear(h->val, cap);
     fz_tmp_values(h->hbuf, h->val, cap);
   }
 }
@@ -512,25 +510,84 @@ fz_is_float_nan (VALUE v)
   return RB_FLOAT_TYPE_P(v) && isnan(RFLOAT_VALUE(v));
 }
 
+/* True when v holds a NaN that eql? would keep apart from an equal value:
+   a Float NaN, or a Complex with a Float NaN part. */
+static int
+fz_obj_has_nan (VALUE v)
+{
+  if ( fz_is_float_nan(v) ) {
+    return 1;
+  }
+  return RB_TYPE_P(v, T_COMPLEX)
+         && ( fz_is_float_nan(rb_complex_real(v))
+              || fz_is_float_nan(rb_complex_imag(v)) );
+}
+
+/* A part of a NaN-bearing value: every NaN is one value, the rest go by
+   eql?, as in Ruby Hash. */
+static uint64_t
+fz_obj_part_key (VALUE v)
+{
+  return fz_is_float_nan(v) ? FZ_NAN_KEY_DOUBLE : (uint64_t) NUM2LL(rb_hash(v));
+}
+
+static int
+fz_obj_part_eql (VALUE a, VALUE b)
+{
+  if ( fz_is_float_nan(a) || fz_is_float_nan(b) ) {
+    return fz_is_float_nan(a) && fz_is_float_nan(b);
+  }
+  return rb_eql(a, b);
+}
+
+/* The hash key of an object cell.  A NaN-bearing value is keyed part by
+   part with every NaN as one value, so it matches the numeric lane: all
+   NaN are one value, and a complex value is one value when its parts are. */
+static uint64_t
+fz_obj_key (VALUE v, int has_nan)
+{
+  if ( ! has_nan ) {
+    return (uint64_t) NUM2LL(rb_hash(v));
+  }
+  if ( RB_TYPE_P(v, T_COMPLEX) ) {
+    return fz_obj_part_key(rb_complex_real(v)) * 31u
+           ^ fz_obj_part_key(rb_complex_imag(v)) ^ 0x9e3779b97f4a7c15ULL;
+  }
+  return FZ_NAN_KEY_DOUBLE;
+}
+
+/* Whether a stored cell is the same value as v (has_nan from fz_obj_has_nan). */
+static int
+fz_obj_same (VALUE stored, VALUE v, int has_nan)
+{
+  if ( ! has_nan ) {
+    return rb_eql(stored, v);
+  }
+  if ( RB_TYPE_P(v, T_COMPLEX) ) {
+    return RB_TYPE_P(stored, T_COMPLEX)
+           && fz_obj_part_eql(rb_complex_real(stored), rb_complex_real(v))
+           && fz_obj_part_eql(rb_complex_imag(stored), rb_complex_imag(v));
+  }
+  return fz_is_float_nan(stored);
+}
+
 /* Object-lane intern: key = rb_hash(v) (lossy), collision re-check via rb_eql.
    Matches Ruby Hash distinctness (`hash` + `eql?`) element for element, with one
    value-based exception aligning with the numeric lane: every Float NaN collapses
    to a single distinct value (Ruby Hash keeps distinct NaN objects apart via
-   eql?, but the discovery family unifies them).  A NaN takes a fixed canonical
-   key and matches any stored Float NaN, so its second and later occurrences fold
-   into the first. */
+   eql?, but the discovery family unifies them), and so does a Complex whose
+   parts are the same with every NaN as one (fz_obj_key / fz_obj_same). */
 static int32_t
 fz_hash_intern_obj (fz_hash *h, VALUE v, int *is_new)
 {
   if ( (h->n + 1) * 10 >= h->cap * 7 ) { fz_hash_grow(h); }   /* load factor 0.7 */
-  int v_nan = fz_is_float_nan(v);
-  uint64_t key = v_nan ? FZ_NAN_KEY_DOUBLE
-                       : (uint64_t) NUM2LL(rb_hash(v));
+  int v_nan = fz_obj_has_nan(v);
+  uint64_t key = fz_obj_key(v, v_nan);
   ca_size_t mask = h->cap - 1;
   ca_size_t slot = FZ_HOME(h, key);
   while ( h->used[slot] ) {
     if ( h->key[slot] == key &&
-         ( v_nan ? fz_is_float_nan(h->val[slot]) : rb_eql(h->val[slot], v) ) ) {
+         fz_obj_same(h->val[slot], v, v_nan) ) {
       *is_new = 0; return h->code[slot];
     }
     slot = (slot + 1) & mask;
@@ -621,14 +678,13 @@ fz_hash_lookup (fz_hash *h, uint64_t key, int32_t *code_out)
 static int
 fz_hash_lookup_obj (fz_hash *h, VALUE v, int32_t *code_out)
 {
-  int v_nan = fz_is_float_nan(v);
-  uint64_t key = v_nan ? FZ_NAN_KEY_DOUBLE
-                       : (uint64_t) NUM2LL(rb_hash(v));
+  int v_nan = fz_obj_has_nan(v);
+  uint64_t key = fz_obj_key(v, v_nan);
   ca_size_t mask = h->cap - 1;
   ca_size_t slot = FZ_HOME(h, key);
   while ( h->used[slot] ) {
     if ( h->key[slot] == key &&
-         ( v_nan ? fz_is_float_nan(h->val[slot]) : rb_eql(h->val[slot], v) ) ) {
+         fz_obj_same(h->val[slot], v, v_nan) ) {
       if ( code_out ) { *code_out = h->code[slot]; }
       return 1;
     }
@@ -669,9 +725,7 @@ typedef struct {
 static void
 fz_levels_values (fz_levels *l, ca_size_t from)
 {
-  VALUE    *v = (VALUE *) l->p;
-  ca_size_t i;
-  for ( i = from; i < l->cap; i++ ) v[i] = Qnil;
+  ca_object_cells_clear((VALUE *) l->p + from, l->cap - from);
   fz_tmp_values(l->hp, l->p, l->cap);
 }
 
@@ -717,7 +771,13 @@ fz_levels_free (fz_levels *l)
    in the middle of a walk.  The walks' states live in this frame, outside the
    method's body, and ca_iter_ensure finishes them however the body leaves;
    the tables have owners the unwind collects (fz_tmp_alloc).  Slots 0
-   and 1 hold a method's own walks, slot 2 the walk of fz_intern_all. */
+   and 1 hold a method's own walks, slot 2 the walk of fz_intern_all.
+
+   A body that replaces self or an operand with an array it made (complex
+   keys, a Face's storage, an operand brought into self's space) writes the
+   new VALUE back into the frame.  The walks read it only through its
+   CArray *, so a C local alone would leave it to the collector halfway
+   through. */
 
 typedef struct {
   ca_iter_state st[3];
@@ -761,7 +821,7 @@ fz_factorize_appearance_body (VALUE arg)
   VALUE self = fr->self;
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face, "categorize");
+  fr->self = self = fz_face_descend(self, &face, "categorize");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -1132,7 +1192,7 @@ fz_unique_flat_body (VALUE arg)
   VALUE self = fr->self;
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face, "unique");
+  fr->self = self = fz_face_descend(self, &face, "unique");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -1158,8 +1218,6 @@ fz_unique_flat_body (VALUE arg)
   else                        { fz_hash_init(&h); }
   fz_levels_init(&lv, (int) ca->bytes, ca->data_type == CA_OBJECT);
 
-  int8_t axis = (int8_t) (ca->ndim - 1);   /* innermost fiber; hash not reset =
-                                              one seen-set over the whole array */
   ca_iter_state *st_in = &fr->st[0];
   char       *p_in;
   boolean8_t *m;
@@ -1220,7 +1278,7 @@ fz_unique_flat_body (VALUE arg)
       }                                                                        \
     } while (0)
 
-  CA_FOR_EACH_FIBER_MASKED(*st_in, ca, axis, CA_KERNEL_READ, p_in, n, m) {
+  CA_FOR_EACH_WHOLE_MASKED(*st_in, ca, CA_KERNEL_READ, p_in, n, m) {
     switch ( dt ) {
     case CA_INT8:   UQ_LOOP(int8_t,   (int64_t));  break;
     case CA_INT16:  UQ_LOOP(int16_t,  (int64_t));  break;
@@ -1265,7 +1323,7 @@ rb_ca_unique_flat (VALUE self)
 }
 
 /* Intern every non-masked cell of cv into h, one seen-set over the whole array
-   (the hash is not reset between fibers).  When lv is non-NULL, the first-seen
+   walked in row-major order.  When lv is non-NULL, the first-seen
    raw element of each distinct value is pushed to it (appearance order), so the
    same pass builds both a probe set and the distinct-value list.  Dispatches the
    three key lanes exactly as the discovery family: numeric widen with all NaN
@@ -1276,7 +1334,6 @@ static void
 fz_intern_all (ca_iter_state *st_v, fz_hash *h, CArray *cv, fz_levels *lv)
 {
   int8_t dt = cv->data_type;
-  int8_t vaxis = (int8_t) (cv->ndim - 1);
   char       *p_v;
   boolean8_t *mv;
   ca_size_t   nv;
@@ -1329,7 +1386,7 @@ fz_intern_all (ca_iter_state *st_v, fz_hash *h, CArray *cv, fz_levels *lv)
       }                                                                        \
     } while (0)
 
-  CA_FOR_EACH_FIBER_MASKED(*st_v, cv, vaxis, CA_KERNEL_READ, p_v, nv, mv) {
+  CA_FOR_EACH_WHOLE_MASKED(*st_v, cv, CA_KERNEL_READ, p_v, nv, mv) {
     switch ( dt ) {
     case CA_INT8:   FZ_IA(int8_t,   (int64_t));  break;
     case CA_INT16:  FZ_IA(int16_t,  (int64_t));  break;
@@ -1376,8 +1433,8 @@ fz_is_in_body (VALUE arg)
   VALUE rvalues = fr->a;
   CArray *ca, *cv;
   volatile VALUE face;
-  self     = fz_face_descend(self, &face, "is_in");
-  rvalues  = fz_face_reconcile(face, rvalues, "is_in");
+  fr->self = self    = fz_face_descend(self, &face, "is_in");
+  fr->a    = rvalues = fz_face_reconcile(face, rvalues, "is_in");
   GetCArray(self, ca);
 
   int8_t dt = ca->data_type;
@@ -1543,8 +1600,8 @@ fz_locate_addr_body (VALUE arg)
      output is an address, so nothing is lifted back. */
   {
     volatile VALUE ref_face;
-    rref = fz_face_descend(rref, &ref_face, "locate_addr");
-    self = fz_face_reconcile(ref_face, self, "locate_addr");
+    fr->a    = rref = fz_face_descend(rref, &ref_face, "locate_addr");
+    fr->self = self = fz_face_reconcile(ref_face, self, "locate_addr");
   }
   GetCArray(self, ca);
 
@@ -1807,8 +1864,8 @@ fz_set_relation_body (VALUE arg)
   int keep_when_hit = fr->i;
   CArray *ca, *co;
   volatile VALUE face;
-  self   = fz_face_descend(self, &face, "set relation");
-  rother = fz_face_reconcile(face, rother, "set relation");
+  fr->self = self   = fz_face_descend(self, &face, "set relation");
+  fr->a    = rother = fz_face_reconcile(face, rother, "set relation");
   GetCArray(self, ca);
 
   int8_t dt = ca->data_type;
@@ -2002,8 +2059,8 @@ fz_set_union_body (VALUE arg)
   VALUE rother = fr->a;
   CArray *ca, *co;
   volatile VALUE face;
-  self   = fz_face_descend(self, &face, "union");
-  rother = fz_face_reconcile(face, rother, "union");
+  fr->self = self   = fz_face_descend(self, &face, "union");
+  fr->a    = rother = fz_face_reconcile(face, rother, "union");
   GetCArray(self, ca);
 
   int8_t dt = ca->data_type;
@@ -2095,7 +2152,7 @@ fz_value_counts_flat_body (VALUE arg)
   VALUE self = fr->self;
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face, "value_counts");
+  fr->self = self = fz_face_descend(self, &face, "value_counts");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;
@@ -2255,10 +2312,10 @@ rb_ca_value_counts_flat (VALUE self)
 
 /* @overload __nunique__(axis, keep_axis)
 
-   INTERNAL (CArray#nunique). Count the distinct values along axis, one linear
-   pass per fiber with an independent seen-set. Returns a reduced
-   CA_INT64 CArray of self.shape with axis removed (or kept as length-1 when
-   keep_axis). Masked cells do not participate; an all-masked fiber counts 0
+   INTERNAL (CArray#nunique). Count the distinct values along axis (an Integer
+   or an Array of them), one linear pass per fiber with an independent
+   seen-set. Returns a reduced CA_INT64 CArray of self.shape with the axes
+   removed (or kept as length-1 when keep_axis). Masked cells do not participate; an all-masked fiber counts 0
    (an empty set has zero distinct values, not UNDEF -- nunique has identity 0).
    Numeric distinctness collapses all NaN to one value and treats -0.0 == +0.0;
    object keys on rb_hash + rb_eql and fixlen on a byte-hash + memcmp, reproducing
@@ -2290,14 +2347,11 @@ fz_nunique_body (VALUE arg)
     rb_raise(rb_eRuntimeError, "__nunique__: need ndim >= 1");
   }
 
-  int axis = NUM2INT(vaxis);
-  if ( axis < 0 || axis >= ca->ndim ) {
-    rb_raise(rb_eArgError, "__nunique__: axis %d out of range", axis);
-  }
+  int8_t axes[CA_RANK_MAX];
+  int8_t naxes = rb_ca_parse_reduce_axes_kw_ctx(vaxis, ca, axes, "nunique");
   int keep_axis = RTEST(vkeep);
 
-  int8_t ax = (int8_t) axis;
-  VALUE vout = rb_ca_new_reduced(self, &ax, 1, CA_INT64, keep_axis);
+  VALUE vout = rb_ca_new_reduced(self, axes, naxes, CA_INT64, keep_axis);
   CArray *cout;
   TypedData_Get_Struct(vout, CArray, &carray_data_type, cout);
   int64_t *op = (int64_t *) cout->ptr;
@@ -2308,7 +2362,7 @@ fz_nunique_body (VALUE arg)
   else                        { fz_hash_init(&h); }
 
   ca_iter_state *st = &fr->st[0];
-  int rc = ca_iter_state_init_l2(st, ca, CA_SLAB_AXES, &ax, 1, 0);
+  int rc = ca_iter_state_init_l2(st, ca, CA_SLAB_AXES, axes, naxes, 0);
   if ( rc != CA_ITER_OK ) {
     fz_hash_free(&h);
     rb_raise(rb_eRuntimeError, "__nunique__: kernel_iterator init failed rc=%d", rc);
@@ -2641,7 +2695,7 @@ fz_mode_axis_body (VALUE arg)
   VALUE vaxis = fr->a;
   CArray *ca;
   volatile VALUE face;
-  self = fz_face_descend(self, &face, "mode");
+  fr->self = self = fz_face_descend(self, &face, "mode");
   TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
 
   int8_t dt = ca->data_type;