carray 3.0.3 → 3.0.4

data/ext/carray_scatter.c

@@ -14,7 +14,9 @@
                (boolean / object / fixlen → CADataTypeError; the bang
                cannot widen self, same rationale as fma! / fms!)
                replace: numeric or boolean (assignment, no widening)
-    scalar     Integer / Float, and Complex when self is complex
+    scalar     any Numeric, true / false, or UNDEF; converted to self's
+               type as the indexer's store converts it (a value that does
+               not fit raises, as `self[i] = v` does)
 
 --------------------------------------------------------------------------- */
 
@@ -44,12 +46,19 @@
 #define OP_MIN_INT(qp, v) do { if ((v) < *(qp)) *(qp) = (v); } while (0)
 #define OP_MAX_INT(qp, v) do { if ((v) > *(qp)) *(qp) = (v); } while (0)
 
-/* The scalar operand as T.  An Integer goes to T directly, not through
-   double, so an int64 above 2**53 is exact.  A complex self also takes a
-   Ruby Complex scalar, whose parts sit in vd / vi; an Integer or Float
-   scalar leaves vi at 0. */
-#define SCALAR_REAL(T)  (v_is_float ? (T) vd : (T) vl)
-#define SCALAR_CMPLX(T) ((T) ((v_is_float ? (double)vd : (double)vl) + vi * I))
+/* The scalar operand, already converted to self's type by rb_ca_obj2ptr
+   (the indexer's store conversion) and held as one cell in vcell. */
+typedef union {
+  char       bytes[16];
+  double     d;
+  int64_t    l;
+#ifdef HAVE_COMPLEX_H
+  cmplx128_t z;
+#endif
+} ca_scatter_cell_t;
+
+#define SCALAR_REAL(T)  (*(const T *) vcell.bytes)
+#define SCALAR_CMPLX(T) (*(const T *) vcell.bytes)
 
 #define LOOP_SCALAR(T, APPLY) LOOP_SCALAR_V(T, APPLY, SCALAR_REAL(T))
 
@@ -105,8 +114,8 @@
        both value and mask (indexer contract, `self[addrs] = vals`).
      - masked vals[i] flips target to masked (writes UNDEF); valid
        vals[i] writes value and clears the target's mask bit.
-   Scalar vals is always valid (Fixnum / Float), so scalar path just
-   writes and clears target mask. */
+   A scalar UNDEF masks every target (self's mask exists by then); any
+   other scalar writes and clears the target's mask. */
 
 #define LOOP_SCALAR_REPLACE(T) LOOP_SCALAR_REPLACE_V(T, SCALAR_REAL(T))
 
@@ -117,6 +126,10 @@
     if ( maddrs && maddrs[i] ) continue; \
     addr = p[i]; \
     CA_CHECK_INDEX(addr, elements); \
+    if ( vals_undef ) { \
+      mself[addr] = 1; \
+      continue; \
+    } \
     q[addr] = vs; \
     if ( mself ) mself[addr] = 0; \
   } \
@@ -204,11 +217,21 @@
   } \
 } while (0)
 
+/* A value that is one cell for every address: a Numeric, true / false,
+   or UNDEF.  Anything else (a CArray, an Array, ...) is coerced to an
+   array of values. */
+static int
+ca_scatter_is_scalar (VALUE v)
+{
+  return v == CA_UNDEF || v == Qtrue || v == Qfalse
+      || rb_obj_is_kind_of(v, rb_cNumeric);
+}
+
 /* Setup boilerplate: parse args and wrap addrs/vals.
 
    Outputs into caller's locals:
      ca, ci, cv (CArray*), n (ca_size_t),
-     vals_scalar (int), v_is_float (int), vd, vi (double), vl (long).
+     vals_scalar, vals_undef (int), vcell (the scalar as one cell).
 
    The kernel then runs through AT_RUN, and an address out of range
    raising part way still leaves the cells already written.
@@ -218,9 +241,12 @@
 */
 /* Body shared by arithmetic and replace setups.  Caller precondition:
    the data_type gate has already run (arithmetic = numeric only, replace
-   = numeric or boolean).  For the replace variant, `true` / `false`
-   scalars are accepted as vals (bridged as vl = 1 / 0). */
-#define AT_SETUP_BODY(name, allow_bool_scalar) \
+   = numeric or boolean).  A scalar is converted the way `self[i] = v`
+   converts it, so true / false reach only a boolean self and a value that
+   does not fit raises.  A scalar UNDEF is a masked value: the arithmetic
+   family skips every pair, replace masks every target. */
+#define AT_SETUP_BODY(name) \
+  ca_check_index_array(raddrs); \
   raddrs = rb_ca_wrap_readonly(raddrs, INT2NUM(CA_SIZE)); \
   TypedData_Get_Struct(raddrs, CArray, &carray_data_type, ci); \
   if ( ca_shares_root(ci, ca) ) { \
@@ -229,20 +255,17 @@
   } \
   n = ci->elements; \
   if ( n == 0 ) return self; \
-  vals_scalar = (RB_FLOAT_TYPE_P(rvals) || FIXNUM_P(rvals) \
-                 || ((allow_bool_scalar) && (rvals == Qtrue || rvals == Qfalse)) \
-                 || (ca_is_complex_type(ca) && RB_TYPE_P(rvals, T_COMPLEX))); \
+  vals_scalar = ca_scatter_is_scalar(rvals); \
   if ( vals_scalar ) { \
-    if ( RB_TYPE_P(rvals, T_COMPLEX) ) { \
-      vd = NUM2DBL(rb_complex_real(rvals)); \
-      vi = NUM2DBL(rb_complex_imag(rvals)); \
-      v_is_float = 1; \
+    if ( rvals == CA_UNDEF ) { \
+      vals_undef = 1; \
+    } \
+    else { \
+      rb_ca_obj2ptr(self, rvals, vcell.bytes); \
     } \
-    else if ( RB_FLOAT_TYPE_P(rvals) ) { vd = RFLOAT_VALUE(rvals); v_is_float = 1; } \
-    else if ( FIXNUM_P(rvals) )   { vl = FIX2LONG(rvals);     v_is_float = 0; } \
-    else                          { vl = (rvals == Qtrue) ? 1 : 0; v_is_float = 0; } \
   } \
   else { \
+    /* coerce: a store into the receiver */ \
     rvals = rb_ca_wrap_readonly(rvals, INT2NUM(ca->data_type)); \
     TypedData_Get_Struct(rvals, CArray, &carray_data_type, cv); \
     if ( ca_shares_root(cv, ca) ) { \
@@ -259,8 +282,8 @@
 #define AT_SETUP_LOCALS \
   CArray  *ca, *ci, *cv = NULL; \
   ca_size_t n; \
-  int vals_scalar, v_is_float = 0; \
-  double vd = 0.0, vi = 0.0; long vl = 0;
+  int vals_scalar, vals_undef = 0; \
+  ca_scatter_cell_t vcell = {{0}};
 
 #define AT_SETUP_OR_RETURN(name, ordered) \
   AT_SETUP_LOCALS \
@@ -273,7 +296,8 @@
     rb_raise(rb_eCADataTypeError, \
       name " requires a real array (complex values have no order)"); \
   } \
-  AT_SETUP_BODY(name, 0)
+  AT_SETUP_BODY(name) \
+  if ( vals_undef ) return self;
 
 /* replace variant: accepts boolean self (assignment, no widening) and
    Ruby true / false as scalar vals. */
@@ -285,7 +309,8 @@
     rb_raise(rb_eCADataTypeError, \
       name " requires a numeric or boolean array"); \
   } \
-  AT_SETUP_BODY(name, 1)
+  AT_SETUP_BODY(name) \
+  if ( vals_undef ) ca_create_mask(ca);
 
 /* The kernel works either on self's own memory or on a compact region:
    the distinct cells the addresses touch, read out of self and written
@@ -305,9 +330,8 @@ typedef struct {
 typedef struct {
   CArray    *ca, *ci, *cv;
   ca_size_t  n;
-  int        vals_scalar, v_is_float;
-  double     vd, vi;
-  long       vl;
+  int        vals_scalar, vals_undef;
+  ca_scatter_cell_t vcell;
   ca_scatter_region_t *region;
 } ca_scatter_ctx_t;
 
@@ -330,10 +354,9 @@ fname (VALUE arg) \
   boolean8_t *mvals    = (cv && cv->mask) ? (boolean8_t *) cv->mask->ptr : NULL; \
   boolean8_t *mself    = rg_ ? rg_->mask \
                              : (ca->mask ? (boolean8_t *) ca->mask->ptr : NULL); \
-  int         vals_scalar = c_->vals_scalar, v_is_float = c_->v_is_float; \
-  double      vd = c_->vd, vi = c_->vi; \
-  long        vl = c_->vl; \
-  (void) cv; (void) mvals; (void) v_is_float; (void) vd; (void) vi; (void) vl; \
+  int         vals_scalar = c_->vals_scalar, vals_undef = c_->vals_undef; \
+  ca_scatter_cell_t vcell = c_->vcell; \
+  (void) cv; (void) mvals; (void) vals_undef; (void) vcell; \
   DISPATCH; \
   return Qnil; \
 }
@@ -460,8 +483,8 @@ ca_scatter_region_body (VALUE varg)
   ca_scatter_ctx_t c_; \
   CArray *list_[3]; \
   c_.ca = ca; c_.ci = ci; c_.cv = cv; c_.n = n; \
-  c_.vals_scalar = vals_scalar; c_.v_is_float = v_is_float; \
-  c_.vd = vd; c_.vi = vi; c_.vl = vl; \
+  c_.vals_scalar = vals_scalar; c_.vals_undef = vals_undef; \
+  c_.vcell = vcell; \
   c_.region = NULL; \
   if ( ca_attach_is_alias(ca) ) { \
     list_[0] = ca; list_[1] = ci; list_[2] = cv; \
@@ -474,6 +497,9 @@ ca_scatter_region_body (VALUE varg)
     ca_attach_window(vals_scalar ? 1 : 2, list_, "rr", \
                      ca_scatter_region_body, (VALUE) &ra_); \
   } \
+  /* the views AT_SETUP_BODY made are reached only through ci and cv */ \
+  RB_GC_GUARD(raddrs); \
+  RB_GC_GUARD(rvals); \
 } while (0)
 
 /* --------------------------------------------------------------- */
@@ -569,8 +595,7 @@ rb_ca_scatter_replace_bang (VALUE self, VALUE raddrs, VALUE rvals)
   /* Pre-scan: if vals is a masked CArray and self isn't yet masked,
      promote self so the kernel can flip target cells to masked (indexer
      `self[addrs] = vals` establishes self.mask lazily the same way). */
-  if ( ! (RB_FLOAT_TYPE_P(rvals) || FIXNUM_P(rvals))
-       && rb_obj_is_carray(rvals) ) {
+  if ( rb_obj_is_carray(rvals) ) {
     CArray *cv_pre;
     TypedData_Get_Struct(rvals, CArray, &carray_data_type, cv_pre);
     if ( ca_has_mask(cv_pre) ) {

data/ext/carray_segment.c

@@ -228,7 +228,7 @@ rb_ca_s_segment_index (int argc, VALUE *argv, VALUE klass)
   return rout;
 }
 
-/* CArray.__segment_bounds__(name, lengths: l | offsets: o) -> int64[k+1]
+/* CArray.__segment_boundaries_from_lengths_or_offsets__(name, lengths: l | offsets: o) -> int64[k+1]
 
    Internal: the validated boundaries, for a Ruby caller that takes the same
    two keywords (CArray#segments).  `name` heads the error messages. */
@@ -239,7 +239,7 @@ rb_ca_s_segment_bounds (int argc, VALUE *argv, VALUE klass)
   ca_size_t k;
   VALUE rname;
   if ( argc < 1 ) {
-    rb_raise(rb_eArgError, "__segment_bounds__: the caller's name is required");
+    rb_raise(rb_eArgError, "__segment_boundaries_from_lengths_or_offsets__: the caller's name is required");
   }
   rname = argv[0];
   StringValue(rname);
@@ -253,5 +253,5 @@ Init_carray_segment (void)
   id_offsets = rb_intern("offsets");
   rb_define_singleton_method(rb_cCArray, "segment_offsets", rb_ca_s_segment_offsets, -1);
   rb_define_singleton_method(rb_cCArray, "segment_index",   rb_ca_s_segment_index,   -1);
-  rb_define_singleton_method(rb_cCArray, "__segment_bounds__", rb_ca_s_segment_bounds, -1);
+  rb_define_singleton_method(rb_cCArray, "__segment_boundaries_from_lengths_or_offsets__", rb_ca_s_segment_bounds, -1);
 }

data/ext/carray_slab.c

@@ -28,8 +28,20 @@
   --------------------------------------------------------------------------- */
 
 #include "carray.h"
-#include "carray_internal.h"   /* ca_attach_window, ca_calling_method_name, ca_axis_integer */
+#include "carray_internal.h"   /* ca_attach_window, ca_calling_method_name, ca_normalize_axis_arg */
 #include "carray_slab.h"
+#include "ca_obj_face.h"
+
+/* Promise 8 of the kernel iterator: a slab may be lent to Ruby as a view
+   onto the source's own memory only when the source is an entity and the
+   walk reads that memory in place (alias_ptr is src->ptr, not a scratch or
+   a root it gathered from).  Any other slab is a copy, and a view built on
+   it would read memory the walk frees or reuses. */
+static int
+ca_slab_walk_reads_src_in_place (const ca_iter_state *it, CArray *src)
+{
+  return ca_is_entity(src) && it->alias_ptr == src->ptr;
+}
 
 /* Forward declarations: per-form loop bodies are defined later in this
    file and take a state pointer directly. */
@@ -66,21 +78,14 @@ ca_slab_parse_axes (ca_slab_iter_state_t *st, VALUE axis_arg, int8_t src_ndim)
   }
 
   n = (int) RARRAY_LEN(arr);
-  if ( n < 1 || n > CA_RANK_MAX ) {
+  if ( n < 1 || n > CA_RANK_MAX ) {   /* rank-check: a list of axes, no longer than the rank */
     rb_raise(rb_eArgError,
              "%s: axis count %d out of range [1..%d]",
              ca_calling_method_name(), n, CA_RANK_MAX);
   }
 
   for ( i = 0; i < n; i++ ) {
-    int k = (int) ca_axis_integer(rb_ary_entry(arr, i), NULL);
-    if ( k < 0 ) k += src_ndim;
-    if ( k < 0 || k >= src_ndim ) {
-      rb_raise(rb_eArgError,
-               "%s: axis %d out of range for ndim %d",
-               ca_calling_method_name(), NUM2INT(rb_ary_entry(arr, i)),
-               src_ndim);
-    }
+    int k = ca_normalize_axis_arg(rb_ary_entry(arr, i), src_ndim, NULL);
     for ( j = 0; j < i; j++ ) {
       if ( st->slab_axes[j] == (int8_t) k ) {
         rb_raise(rb_eArgError,
@@ -370,12 +375,13 @@ ca_slab_setup_input_slab_view (ca_slab_iter_state_t *st, CArray *src,
            p_in via slab_strides into the scratch, present slab_view as
            a CAStride over the carrier with contig strides.
 
-       Path (a) needs p_in to lie in src's own buffer, which holds only
-       when src is an entity.  Any other source -- a view, whose cells the
-       iterator hands out from the root, a parent or its own scratch --
+       Path (a) needs p_in to lie in src's own buffer: src is an entity
+       and the iterator walks that buffer (alias_ptr is src->ptr, not a
+       scratch it gathered into).  Any other source -- a view, whose cells
+       the iterator hands out from the root, a parent or its own scratch --
        takes path (b): the iterator describes every slab by p_in and
        slab_strides, whatever its mode.                                  */
-    int contig = ca_is_entity(src)
+    int contig = ca_slab_walk_reads_src_in_place(st->t1, src)
                  && ca_slab_strides_are_row_major_contig(slab_ndim,
                                                          st->t1->slab_dims,
                                                          st->t1->slab_strides,
@@ -436,9 +442,10 @@ ca_slab_setup_input_slab_view (ca_slab_iter_state_t *st, CArray *src,
     dim[0]     = fiber_len;
     strides[0] = src->bytes;
     /* A window onto src only when the fiber lies in src's own buffer:
-       an entity whose fiber is contiguous.  A view's fiber comes from
-       the root or the iterator's scratch, so it goes through a carrier. */
-    in_alias   = ca_is_entity(src) && (in_stride == src->bytes);
+       an entity the iterator walks in place, whose fiber is contiguous.
+       A view's fiber comes from the root or the iterator's scratch, so it
+       goes through a carrier. */
+    in_alias   = ca_slab_walk_reads_src_in_place(st->t1, src) && (in_stride == src->bytes);
 
     if ( in_alias ) {
       /* ALIAS: parent = src.  ca_stride_setup auto-creates slab_view->mask
@@ -494,8 +501,18 @@ ca_slab_advance_slab_view (ca_slab_iter_state_t *st,
     slab_cs->base_offset = (ca_size_t) (p_in - src->ptr);
     if ( slab_cs->mask != NULL ) {
       CAStride *mask_cs = (CAStride *) slab_cs->mask;
-      mask_cs->ptr         = (char *) m_in;
-      mask_cs->base_offset = (ca_size_t) ((char *) m_in - src->mask->ptr);
+      if ( m_in != NULL ) {
+        mask_cs->ptr         = (char *) m_in;
+        mask_cs->base_offset = (ca_size_t) ((char *) m_in - src->mask->ptr);
+      }
+      else {
+        /* The walk was opened on a source without a mask and the block
+           has given it one since: there is no mask cursor, so the slab's
+           mask reads the source's mask at the cell the data starts on. */
+        mask_cs->ptr         = NULL;
+        mask_cs->base_offset = (ca_size_t) ((p_in - src->ptr) / src->bytes)
+                               * src->mask->bytes;
+      }
     }
   } else if ( st->own_data_scratch != NULL ) {
     /* Non-contig multi-axis: K-D gather from src memory (via
@@ -515,7 +532,7 @@ ca_slab_advance_slab_view (ca_slab_iter_state_t *st,
        both slab_view and carrier at the iter's delivered addr.         */
     slab_cs->ptr    = p_in;
     carrier_cw->ptr = p_in;
-    if ( slab_cs->mask != NULL ) {
+    if ( slab_cs->mask != NULL && m_in != NULL ) {
       CAStride *mask_cs = (CAStride *) slab_cs->mask;
       mask_cs->ptr           = (char *) m_in;
       carrier_cw->mask->ptr  = (char *) m_in;
@@ -626,10 +643,26 @@ ca_map_slab_cast_body (VALUE arg)
   return Qnil;
 }
 
+/* What the block sees of the slab: the slab view itself, or, over a Face,
+   the slab view under that Face, as `a[...]` would give it.  The slab
+   view is moved per slab in place, and the Face reads through it, so one
+   is built per walk. */
+static VALUE
+ca_slab_piece (ca_slab_iter_state_t *st)
+{
+  CArray *src;
+  TypedData_Get_Struct(st->self, CArray, &carray_data_type, src);
+  if ( ! ca_is_face(src) ) {
+    return st->slab_view;
+  }
+  return ca_face_lift(st->slab_view, st->self);
+}
+
 static VALUE
 ca_slab_run_map (ca_slab_iter_state_t *st)
 {
   CArray *src;
+  volatile VALUE piece;
   CArray *out;
   uint32_t flags_in;
   uint32_t flags_out;
@@ -715,6 +748,7 @@ ca_slab_run_map (ca_slab_iter_state_t *st)
     TypedData_Get_Struct(st->output_slab_view, CAWrap,
                          &cawrap_data_type, out_slab_cw);
 
+    piece = ca_slab_piece(st);
     while ( ca_iter_state_next_slab_axes(st->t1,     &p_in,  &m_in) &&
             ca_iter_state_next_slab_axes(st->t1_out, &p_out, &m_out) ) {
       VALUE result;
@@ -732,7 +766,7 @@ ca_slab_run_map (ca_slab_iter_state_t *st)
                              ? st->own_out_scratch : p_out;
         out_slab_cw->ptr = write_target;
 
-        result = rb_yield(st->slab_view);
+        result = rb_yield(piece);
 
         /* Strict shape check. */
         if ( rb_obj_is_kind_of(result, rb_cCArray) ) {
@@ -898,10 +932,36 @@ ca_slab_reduce_setup (ca_slab_iter_state_t *st, CArray **out_src,
 /* Per-slab block form: block receives the slab CArray, returns a
    scalar; each scalar is cast into the corresponding output cell.
    (`init:` absent ⇒ this path) */
+/* Write one reduced value into the reduction output.  UNDEF from the
+   block masks the cell, as storing UNDEF into an array does; obj2ptr
+   would read it as 0. */
+static void
+ca_slab_store_reduced (ca_slab_iter_state_t *st, CArray *out,
+                       ca_size_t out_idx, VALUE value, char *scratch)
+{
+  char *dst = out->ptr + out_idx * st->out_bytes;
+  if ( value == CA_UNDEF ) {
+    if ( out->mask == NULL ) {
+      ca_create_mask(out);
+    }
+    ((boolean8_t *) out->mask->ptr)[out_idx] = 1;
+    if ( out->data_type == CA_OBJECT ) {
+      *(VALUE *) dst = INT2FIX(0);
+    }
+    else {
+      memset(dst, 0, st->out_bytes);
+    }
+    return;
+  }
+  rb_ca_obj2ptr(st->output, value, scratch);
+  memcpy(dst, scratch, st->out_bytes);
+}
+
 static VALUE
 ca_slab_run_reduce_slab (ca_slab_iter_state_t *st)
 {
   CArray *src;
+  volatile VALUE piece;
   CArray *out;
   ca_size_t fiber_len;
   char *p_in;
@@ -927,13 +987,14 @@ ca_slab_run_reduce_slab (ca_slab_iter_state_t *st)
   scratch = (st->out_bytes <= (ca_size_t) sizeof(buf))
               ? buf : ALLOCV_N(char, scratch_holder, st->out_bytes);
 
+  piece = ca_slab_piece(st);
   while ( ca_iter_state_next_slab_axes(st->t1, &p_in, &m_in) ) {
     VALUE result;
 
     ca_slab_advance_slab_view(st, slab_cs, carrier_cw,
                               src, p_in, m_in, in_alias);
 
-    result = rb_yield(st->slab_view);
+    result = rb_yield(piece);
 
     /* Strict scalar contract: block must return a scalar Ruby value
        (Numeric / Object / etc.).  A CArray is a
@@ -952,8 +1013,7 @@ ca_slab_run_reduce_slab (ca_slab_iter_state_t *st)
                res->elements == 1 ? "" : "s");
     }
 
-    rb_ca_obj2ptr(st->output, result, scratch);
-    memcpy(out->ptr + out_idx * st->out_bytes, scratch, st->out_bytes);
+    ca_slab_store_reduced(st, out, out_idx, result, scratch);
     out_idx++;
   }
 
@@ -968,6 +1028,7 @@ static VALUE
 ca_slab_run_reduce_fiber (ca_slab_iter_state_t *st)
 {
   CArray *src;
+  volatile VALUE piece;
   CArray *out;
   ca_size_t fiber_len;
   char *p_in;
@@ -993,6 +1054,7 @@ ca_slab_run_reduce_fiber (ca_slab_iter_state_t *st)
   scratch = (st->out_bytes <= (ca_size_t) sizeof(buf))
               ? buf : ALLOCV_N(char, scratch_holder, st->out_bytes);
 
+  piece = ca_slab_piece(st);
   while ( ca_iter_state_next_slab_axes(st->t1, &p_in, &m_in) ) {
     VALUE acc;
     ca_size_t i;
@@ -1010,7 +1072,7 @@ ca_slab_run_reduce_fiber (ca_slab_iter_state_t *st)
       ca_size_t total = st->t1->slab_elements;
       for ( i = 0; i < total; i++ ) {
         VALUE x;
-        x = rb_ca_fetch_index(st->slab_view, kidx);
+        x = rb_ca_fetch_index(piece, kidx);
         acc = rb_yield_values(2, acc, x);
         /* Increment kidx[] row-major. */
         for ( k = slab_cs->ndim - 1; k >= 0; k-- ) {
@@ -1021,8 +1083,7 @@ ca_slab_run_reduce_fiber (ca_slab_iter_state_t *st)
       (void) fiber_len;
     }
 
-    rb_ca_obj2ptr(st->output, acc, scratch);
-    memcpy(out->ptr + out_idx * st->out_bytes, scratch, st->out_bytes);
+    ca_slab_store_reduced(st, out, out_idx, acc, scratch);
     out_idx++;
   }
 
@@ -1049,6 +1110,7 @@ static VALUE
 ca_slab_run_each (ca_slab_iter_state_t *st)
 {
   CArray *src;
+  volatile VALUE piece;
   char *p_in;
   boolean8_t *m_in;
   CAStride *slab_cs;
@@ -1082,10 +1144,11 @@ ca_slab_run_each (ca_slab_iter_state_t *st)
     TypedData_Get_Struct(st->carrier, CAWrap, &cawrap_data_type, carrier_cw);
   }
 
+  piece = ca_slab_piece(st);
   while ( ca_iter_state_next_slab_axes(st->t1, &p_in, &m_in) ) {
     ca_slab_advance_slab_view(st, slab_cs, carrier_cw,
                               src, p_in, m_in, in_alias);
-    rb_yield(st->slab_view);    /* return value discarded */
+    rb_yield(piece);    /* return value discarded */
   }
 
   return st->self;

data/ext/carray_sort.c

@@ -172,31 +172,10 @@ rb_ca_s_sort_addr_kw (int argc, VALUE *argv, VALUE ropt, VALUE self)
     if ( elements != NUM2SIZE(rb_ca_elements(argv[j])) ) {
       rb_raise(rb_eArgError, "elements mismatch");
     }
-    /* Face gate: an ORDERABLE Face sorts by its storage, so it descends to
-       it (attach / comparator / template output then run on plain storage,
-       which also avoids a face-lifted NULL-ptr index output).  A fixlen
-       storage that is not ORDERABLE (CAConstString's offsets, a record's
-       bytes) has no order in its bytes; the Face's own order stands in for
-       it, as a dense rank, so ties stay ties for the next key.  A Face that
-       has no order (CARecord without order_by:) raises there.  Any other
-       storage raises here. */
     TypedData_Get_Struct(argv[j], CArray, &carray_data_type, ca_j);
     if ( ca_is_face(ca_j) ) {
-      int orderable = ca_test_flag(ca_j, CA_FLAG_FACE_ORDERABLE_STORAGE);
-      VALUE stripped = rb_ca_strip_face_value(argv[j]);
-      CArray *sc;
-      TypedData_Get_Struct(stripped, CArray, &carray_data_type, sc);
-      if ( sc->data_type == CA_FIXLEN && ! orderable ) {
-        VALUE opts = rb_hash_new();
-        rb_hash_aset(opts, ID2SYM(rb_intern("method")), ID2SYM(rb_intern("dense")));
-        argv[j] = rb_funcallv_kw(argv[j], rb_intern("order"), 1, &opts,
-                                 RB_PASS_KEYWORDS);
-        continue;
-      }
-      if ( ! orderable ) {
-        ca_face_refuse_order("sort_addr", argv[j], "order");
-      }
-      argv[j] = stripped;
+      argv[j] = ca_order_key(argv[j], "sort_addr");
+      continue;
     }
     {
       CArray *k;
@@ -442,14 +421,9 @@ rb_ca_axis2addr_c (VALUE self, VALUE vindices, VALUE vaxis)
   TypedData_Get_Struct(self,     CArray, &carray_data_type, ca);
   TypedData_Get_Struct(vindices, CArray, &carray_data_type, idx_ca);
 
-  /* axis normalization + range check. */
-  int axis_raw = NIL_P(vaxis) ? 0 : (int) ca_axis_integer(vaxis, NULL);
-  int axis = (axis_raw < 0) ? ((int) ca->ndim + axis_raw) : axis_raw;
-  if ( axis < 0 || axis >= ca->ndim ) {
-    rb_raise(rb_eArgError,
-             "%s: axis %d out of range for ndim %d",
-             ca_calling_method_name(), axis_raw, (int) ca->ndim);
-  }
+  long axis_l = ca_normalize_axis_arg(NIL_P(vaxis) ? INT2FIX(0) : vaxis,
+                                      (int) ca->ndim, NULL);
+  int axis = (int) axis_l;
 
   /* Shape rule: indices.ndim == self.ndim, dims match except at axis. */
   if ( idx_ca->ndim != ca->ndim ) {
@@ -470,10 +444,11 @@ rb_ca_axis2addr_c (VALUE self, VALUE vindices, VALUE vaxis)
 
   /* indices data_type: integer kind accepted; cast to CA_SIZE if needed
      (zero-copy when already CA_SIZE via to_type identity). */
+  ca_check_index_array(vindices);
   if ( ! ca_is_integer_type(idx_ca) ) {
     rb_raise(rb_eArgError,
-             "%s: indices data_type must be integer kind (got %d)",
-             ca_calling_method_name(), (int) idx_ca->data_type);
+             "%s: indices data_type must be integer kind (got %s)",
+             ca_calling_method_name(), ca_type_name[idx_ca->data_type]);
   }
   volatile VALUE vidx_cast = vindices;
   CArray         *idx_cast = idx_ca;
@@ -535,6 +510,31 @@ rb_ca_axis2addr (int argc, VALUE *argv, VALUE self)
 }
 
 
+/* The array the order of v is read from, for a method that orders v's
+   cells (a sort, a selection, a ranking, an extremum by key).  A plain
+   array is its own key.  An ORDERABLE Face orders by its storage, so the
+   key is the storage.  A Face that is not ORDERABLE but defines its own
+   #order (CAConstString, whose cells are offsets; CARecord, whose bytes
+   are no order) is keyed by that order, as a dense rank, so ties stay ties
+   and a masked cell stays masked.  A Face that has no order (a CARecord
+   without order_by:) raises in that order; any other Face raises here. */
+VALUE
+ca_order_key (VALUE v, const char *name)
+{
+  CArray *ca;
+  TypedData_Get_Struct(v, CArray, &carray_data_type, ca);
+  if ( ! ca_is_face(ca) ) {
+    return v;
+  }
+  if ( ca_face_orders_by_itself(v) ) {
+    VALUE opts = rb_hash_new();
+    rb_hash_aset(opts, ID2SYM(rb_intern("method")), ID2SYM(rb_intern("dense")));
+    return rb_funcallv_kw(v, rb_intern("order"), 1, &opts, RB_PASS_KEYWORDS);
+  }
+  ca_face_require_orderable(v, name, "order");
+  return rb_ca_strip_face_value(v);
+}
+
 /* ===== sort / sort_copy (value & view surface, sibling of the
    sort_addr / axis2addr block above). =============== */
 
@@ -717,8 +717,7 @@ rb_ca_sort_copy (int argc, VALUE *argv, VALUE self)
   TypedData_Get_Struct(target, CArray, &carray_data_type, cat);
 
   /* Normalize axis (negative -> +ndim, range check). */
-  int axis = rb_ca_normalize_axis_for_ndim(ca_axis_integer(vaxis_use, NULL),
-                                           cat->ndim, NULL);
+  int axis = ca_normalize_axis_arg(vaxis_use, cat->ndim, NULL);
 
   /* Allocate output: same shape and data_type as target
      (bytes=0 = preserve native bytes). */
@@ -805,6 +804,7 @@ rb_ca_sort_copy (int argc, VALUE *argv, VALUE self)
   ALLOCV_END(aux_holder);
 
   RB_GC_GUARD(target);
+  rb_ca_inherit_attr(vout, self);
   return vout;
 }