carray 3.0.6 → 3.0.7

data/ext/ca_obj_stack.c

@@ -854,8 +854,8 @@ ca_stack_func_allocate (void *ap)
 {
   CAStack *ca = (CAStack *) ap;
   ca_stack_mask_refresh(ca);
-  ca_attach_all(ca->parents, ca->n_parents);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, ca->n_parents,
+                                       ca->parents);
 }
 
 static VALUE
@@ -1408,7 +1408,7 @@ rb_ca_stack_new_with_axis (VALUE parents_ary, int8_t k_axis)
   }
   parents = ALLOCV_N(CArray *, holder, n);
   for ( i = 0; i < n; i++ ) {
-    VALUE p = rb_ary_entry(parents_ary, i);
+    volatile VALUE p = rb_ary_entry(parents_ary, i);
     rb_check_carray_object(p);
     TypedData_Get_Struct(p, CArray, &carray_data_type, parents[i]);
     ca_multi_parent_check_part(parents[i], "stack");
@@ -1485,7 +1485,7 @@ rb_ca_stack_initialize (int argc, VALUE *argv, VALUE self)
     /* Resolve k_axis against the first parent's ndim (= insertion position
        range [0, parent_ndim], i.e. half-open [0, parent_ndim + 1)). */
     CArray *ref;
-    VALUE first = rb_ary_entry(list, 0);
+    volatile VALUE first = rb_ary_entry(list, 0);
     rb_check_carray_object(first);
     TypedData_Get_Struct(first, CArray, &carray_data_type, ref);
     k_axis = (int8_t) ca_normalize_axis_arg(
@@ -1495,7 +1495,7 @@ rb_ca_stack_initialize (int argc, VALUE *argv, VALUE self)
   ca_check_uninitialized(ca);
   parents = ALLOCV_N(CArray *, holder, n);
   for ( i = 0; i < n; i++ ) {
-    VALUE p = rb_ary_entry(list, i);
+    volatile VALUE p = rb_ary_entry(list, i);
     rb_check_carray_object(p);
     TypedData_Get_Struct(p, CArray, &carray_data_type, parents[i]);
     ca_multi_parent_check_part(parents[i], "stack");

data/ext/ca_obj_stride.c

@@ -1145,7 +1145,10 @@ static int ca_layout_is_contiguous (int8_t ndim, const ca_size_t *dim,
    Entities hold their own buffer.  A CAStride-family root is one the fold
    declined to walk through (a reshape over a transpose); its own attach
    folds onward from itself, so the answer is the one for the root it folds
-   to.  What is left is the
+   to -- unless two of its cells share memory (sliding windows).  Its buffer
+   then holds several copies of a cell, and sending the buffer back would
+   let a stale copy overwrite one a view wrote, so it has nothing to lend
+   either.  What is left is the
    boundary views that compute or fetch their contents -- CAObject, the lazy
    per-element transforms, whatever a companion gem installed.  All of them
    answer a region request: through their xfer_stride slot, or, when a type
@@ -1153,6 +1156,39 @@ static int ca_layout_is_contiguous (int8_t ndim, const ca_size_t *dim,
    addresses to xfer_addrs.  Attaching one instead would produce all of it
    and write all of it back, so a cell nobody touched would go through the
    view's conversion both ways. */
+/* May two cells of this layout land on the same bytes?  With the axes in
+   order of stride, none can when each stride clears everything the smaller
+   ones reach.  The test is sufficient, not exact: a layout that interleaves
+   its axes answers yes and takes the longer way. */
+static int
+ca_layout_cells_may_overlap (int8_t ndim, const ca_size_t *dim,
+                             const ca_size_t *strides, ca_size_t bytes)
+{
+  ca_size_t s[CA_RANK_MAX], d[CA_RANK_MAX];
+  ca_size_t reach = bytes;
+  int n = 0;
+  int8_t k;
+  int i, j;
+
+  for (k = 0; k < ndim; k++) {
+    if ( dim[k] > 1 ) {
+      ca_size_t a = strides[k] < 0 ? -strides[k] : strides[k];
+      for (i = n; i > 0 && s[i-1] > a; i--) {
+        s[i] = s[i-1];
+        d[i] = d[i-1];
+      }
+      s[i] = a;
+      d[i] = dim[k];
+      n++;
+    }
+  }
+  for (j = 0; j < n; j++) {
+    if ( s[j] < reach ) return 1;
+    reach += s[j] * (d[j] - 1);
+  }
+  return 0;
+}
+
 int
 ca_root_lends_no_memory (void *ap)
 {
@@ -1168,7 +1204,8 @@ ca_root_lends_no_memory (void *ap)
     ca_size_t cs[CA_RANK_MAX];
     ca_size_t base;
     ca_stride_compose_to_root((CAStride *) root, &below, cs, &base);
-    return ca_root_lends_no_memory(below);
+    return ca_root_lends_no_memory(below)
+        || ca_layout_cells_may_overlap(root->ndim, root->dim, cs, root->bytes);
   }
   return 1;
 }
@@ -1176,7 +1213,7 @@ ca_root_lends_no_memory (void *ap)
 /* The same question for the parent of a view that is not itself in the
    CAStride family (CAGrid, ...): whether the array its cells come from --
    the parent, or the root a CAStride parent folds to -- has no memory to
-   lend.  Like ca_root_lends_no_memory it asks only what those arrays are,
+   lend, or the parent has cells that share memory.  Like ca_root_lends_no_memory it asks only what those arrays are,
    so the lifecycle slots can rely on getting the same answer from attach
    to detach. */
 int
@@ -1189,7 +1226,8 @@ ca_parent_lends_no_memory (void *ap)
     ca_size_t cs[CA_RANK_MAX];
     ca_size_t base;
     ca_stride_compose_to_root((CAStride *) parent, &root, cs, &base);
-    return ca_root_lends_no_memory(root);
+    return ca_root_lends_no_memory(root)
+        || ca_layout_cells_may_overlap(parent->ndim, parent->dim, cs, parent->bytes);
   }
   return ca_root_lends_no_memory(parent);
 }
@@ -1238,11 +1276,11 @@ ca_stride_func_allocate (void *ap)
     ca->ptr = ca_alloc_cells((CArray *) ca);
     return;
   }
-  ca_attach(root);
   if (ca_layout_is_contiguous(ca->ndim, ca->dim, composed_strides, ca->bytes)) {
+    ca_attach(root);
     ca->ptr = root->ptr + composed_base;
   } else {
-    ca->ptr = ca_alloc_cells((CArray *) ca);
+    ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &root);
   }
 }
 
@@ -1277,11 +1315,11 @@ ca_stride_func_attach (void *ap)
     ca->ptr = buf;
     return;
   }
-  ca_attach(root);
   if (ca_layout_is_contiguous(ca->ndim, ca->dim, composed_strides, ca->bytes)) {
+    ca_attach(root);
     ca->ptr = root->ptr + composed_base;
   } else {
-    ca->ptr = ca_alloc_cells((CArray *) ca);
+    ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &root);
     ca_stride_xfer_with_layout(ca, 0, root->ptr + composed_base, composed_strides);
   }
 }

data/ext/ca_obj_string.c

@@ -212,8 +212,8 @@ ca_string_refuse_cell (VALUE v, const char *where)
              "UNDEF masks a cell)", where);
   }
   rb_raise(rb_eTypeError,
-           "%s is of class %s, not a String (a CAString holds Strings; "
-           "UNDEF masks a cell)", where, rb_obj_classname(v));
+           "%s is of class %"PRIsVALUE", not a String (a CAString holds Strings; "
+           "UNDEF masks a cell)", where, rb_obj_class(v));
 }
 
 /* Every cell of `parent` that is not masked is a String.  Under a masked

data/ext/ca_obj_tile.c

@@ -422,16 +422,14 @@ static void
 ca_tile_func_allocate (void *ap)
 {
   CATile *ca = (CATile *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
 }
 
 static void
 ca_tile_func_attach (void *ap)
 {
   CATile *ca = (CATile *) ap;
-  ca_attach(ca->parent);
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
   ca_tile_attach_into(ca, ca->ptr);
 }
 

data/ext/ca_obj_triop.c

@@ -139,8 +139,8 @@ ca_triop_setup (CATriOp *ca, CArray *op1, CArray *op2, CArray *op3,
   ca->op2       = op2;
   ca->op3       = op3;
   ca->op_id     = op_id;
-  ca->op2_is_scalar = ( op2->elements == 1 && op1->elements > 1 ) ? 1 : 0;
-  ca->op3_is_scalar = ( op3->elements == 1 && op1->elements > 1 ) ? 1 : 0;
+  ca->op2_is_scalar = ( op2->elements == 1 ) ? 1 : 0;
+  ca->op3_is_scalar = ( op3->elements == 1 ) ? 1 : 0;
   ca->operands[0] = op1;
   ca->operands[1] = op2;
   ca->operands[2] = op3;
@@ -503,8 +503,9 @@ insert_cast (VALUE cary, int8_t target_dt, CArray **ca_out)
    data_type differs from the common data_type, then resolves
    same-ndim size-1 broadcast pairwise against op1 (the walk anchor).
 
-   Broadcast: each of op2 / op3 is aligned against op1 via
-   ca_broadcast_pair.  After alignment, each must have either the
+   Broadcast: the three are aligned pairwise via ca_broadcast_pair
+   (op1 / op2 again last, as two of them can meet at a shape smaller than
+   the third's).  After alignment, op2 / op3 must each have either the
    same elements as op1 or be a 1-element CScalar (walked with
    element_step = 0 by the kernel).  If op1 itself is a 1-element
    CScalar and any of op2 / op3 is an array, op1 is lifted via
@@ -535,17 +536,16 @@ rb_ca_triop_build (VALUE cary1, VALUE cary2, VALUE cary3, uint16_t op_id)
   /* Scalar operands (clip's Numeric bounds, a CScalar) are wrapped and
      promoted pairwise in the order the eager triop uses. */
   else if ( ! rb_obj_is_carray(r1) || ! rb_obj_is_carray(r2) || ! rb_obj_is_carray(r3) ||
-       rb_obj_is_cscalar(r2) || rb_obj_is_cscalar(r3) ) {
+       rb_obj_is_cscalar(r1) || rb_obj_is_cscalar(r2) || rb_obj_is_cscalar(r3) ) {
     if ( ! rb_obj_is_carray(r1) ) {
       rb_raise(rb_eArgError,
                "CATriOp: the first operand must be a CArray");
     }
+    int r1_scalar = rb_obj_is_cscalar(r1);
     int r2_scalar = ! rb_obj_is_carray(r2) || rb_obj_is_cscalar(r2);
     int r3_scalar = ! rb_obj_is_carray(r3) || rb_obj_is_cscalar(r3);
-    rb_ca_cast_self_or_other(&r1, &r2);
-    rb_ca_cast_self_or_other(&r1, &r3);
-    rb_ca_cast_self_or_other(&r2, &r3);
-    rb_ca_cast_self_or_other(&r1, &r2);
+    rb_ca_cast_three(&r1, &r2, &r3);
+    r1 = ca_lazy_settle_scalar(r1, r1_scalar);
     r2 = ca_lazy_settle_scalar(r2, r2_scalar);
     r3 = ca_lazy_settle_scalar(r3, r3_scalar);
   }
@@ -609,12 +609,15 @@ rb_ca_triop_build (VALUE cary1, VALUE cary2, VALUE cary3, uint16_t op_id)
     }
   }
 
-  /* Now align op2 / op3 against op1 for size-1 broadcast. */
+  /* Now bring the three to one shape for size-1 broadcast.  Every pair is
+     aligned, and the first again after the others: op1 and op2 may meet
+     at a shape smaller than op3's ([1,4] [1,4] [3,4]). */
   ca_broadcast_pair(&r1, &r2);
-  TypedData_Get_Struct(r1, CArray, &carray_data_type, op1);
-  TypedData_Get_Struct(r2, CArray, &carray_data_type, op2);
   ca_broadcast_pair(&r1, &r3);
+  ca_broadcast_pair(&r2, &r3);
+  ca_broadcast_pair(&r1, &r2);
   TypedData_Get_Struct(r1, CArray, &carray_data_type, op1);
+  TypedData_Get_Struct(r2, CArray, &carray_data_type, op2);
   TypedData_Get_Struct(r3, CArray, &carray_data_type, op3);
 
   /* Step 3: each of op2 / op3 must match op1's element count OR be a

data/ext/ca_obj_window.c

@@ -275,10 +275,11 @@ static int
 ca_window_func_fold_stride (void *ap, ca_fold_t *f, void **next_parent)
 {
   CAWindow *w = (CAWindow *) ap;
-  ca_window_mask_current(w);
-  /* A write folded through to a stand-in would bypass the settle in this
-     window's write slots. */
-  if ( ca_window_mask_reads_standin(w) ) {
+  /* A mask window never folds.  A write folded through to a stand-in would
+     bypass the settle in this window's write slots, and answering by what
+     the window reads now would change when a write settles: a view attached
+     over this window would detach a root it never attached. */
+  if ( w->mask_owner ) {
     return 0;
   }
   ca_size_t synth_strides[CA_RANK_MAX];
@@ -701,7 +702,8 @@ ca_window_setup (CAWindow *ca, CArray *parent,
   /* Under "ruby" or "strict" an index outside the parent raises.  The
      parent's shape is fixed, so a window that reaches outside it would raise
      on every whole read or write, and a write would have changed the cells
-     before the one that raised.  It is refused here instead. */
+     before the one that raised.  It is refused here instead.  Under
+     "nearest" an axis with no cells has no edge to replicate. */
   for (i=0; i<ndim; i++) {
     ca_size_t lo, hi, size = dim[i];
     if ( count[i] == 0 ) {
@@ -717,6 +719,9 @@ ca_window_setup (CAWindow *ca, CArray *parent,
       if ( lo < -size ) ca_index_out_of_range(lo, size, "index");
       if ( hi >= size ) ca_index_out_of_range(hi, size, "index");
     }
+    else if ( bounds[i] == CA_BOUNDS_NEAREST && size == 0 ) {
+      ca_index_out_of_range(lo, size, "index");
+    }
   }
 
   /* ca == NULL asks for the checks above only, so that a constructor can
@@ -1114,12 +1119,12 @@ ca_window_func_allocate (void *ap)
     ca->ptr = ca_alloc_cells((CArray *) ca);
     return;
   }
-  ca_attach(ca->parent);
   if ( ca->embed_alias_eligible ) {
+    ca_attach(ca->parent);
     ca->ptr = ca_window_alias_ptr(ca);
     return;
   }
-  ca->ptr = ca_alloc_cells((CArray *) ca);
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
 }
 
 /* The engine paths below emit a per-axis descriptor (ca_window_describe_axes)
@@ -1139,7 +1144,6 @@ ca_window_func_attach (void *ap)
     ca_axis_view_attach_owned(ca);
     return;
   }
-  ca_attach(ca->parent);
   if ( ca->embed_alias_eligible ) {
     /* Alias path: inner axes full + interior, so the embedded region is a
        contiguous run of parent storage.  Skip malloc/memcpy and point
@@ -1147,10 +1151,13 @@ ca_window_func_attach (void *ap)
        CAREFUL: sync and detach must agree with this — sync has nothing to
        scatter back (the writes already landed in the parent) and detach must
        not xfree a pointer it does not own. */
+    ca_attach(ca->parent);
     ca->ptr = ca_window_alias_ptr(ca);
-  } else if ( ca->embed_eligible ) {
-    /* Embed path: allocate, then 1 fill + 1 strided memcpy. */
-    ca->ptr = ca_alloc_cells((CArray *) ca);
+    return;
+  }
+  ca->ptr = ca_alloc_cells_then_attach((CArray *) ca, 1, &ca->parent);
+  if ( ca->embed_eligible ) {
+    /* Embed path: 1 fill + 1 strided memcpy. */
     ca_window_attach_embed(ca, ca->ptr);
   } else {
     /* Fallback: PERIODIC / REFLECT / NEAREST / RUBY / STRICT go through
@@ -1158,8 +1165,8 @@ ca_window_func_attach (void *ap)
     ca_axis_desc_t desc[CA_RANK_MAX];
     ca_size_t      pdims[CA_RANK_MAX];
     ca_window_describe_axes(ca, desc, pdims);
-    ca->ptr = ca_axis_dispatch_attach(ca->parent, pdims, desc, ca->ndim,
-                                      ca->bytes, ca->elements, ca->fill);
+    ca_axis_dispatch_gather(ca->parent, pdims, desc, ca->ndim,
+                            ca->bytes, ca->elements, ca->fill, ca->ptr);
   }
 }
 
@@ -1700,8 +1707,8 @@ rb_ca_window (int argc, VALUE *argv, VALUE self)
     }
     if ( ! RB_TYPE_P(rbounds, T_STRING) ) {
       rb_raise(rb_eTypeError,
-               "window: bounds: must be a Symbol or a String (got %s)",
-               rb_obj_classname(rbounds));
+               "window: bounds: must be a Symbol or a String (got %"PRIsVALUE")",
+               rb_obj_class(rbounds));
     }
     cbounds = StringValueCStr(rbounds);
     if ( ! strcmp(cbounds, "ruby") ) {

data/ext/ca_op_ipower.c

@@ -1,7 +1,10 @@
 /* ---------------------------------------------------------------------------
 
-  Float/Complex ** Integer integer-exponent fast path via
-  binary exponentiation (O(log p)).
+  Float/Complex ** Integer: the exponent stays an int64 (no cast of the
+  array to a wider type), and each cell is computed exactly as `a ** b`
+  computes it when b is an array of that integer: the exponents -2 .. 4
+  by at most two multiplications or divisions, the rest by pow / powf /
+  cpow.
 
   Contents:
     (1) LAZY kernel table `ca_binop_ipower[CA_NTYPE]` — CABinOp dispatch
@@ -11,14 +14,59 @@
         `rb_ca_pow{,_bang}` dispatch between ipower (Float/Complex **
         Integer) and mkkernel-generated `rb_ca_power` (general pow).
 
-  Both paths share `op_powi_<type>` from ca_op_powi.h (= repeated
-  squaring, ~1-3 mul/cell for typical p).
+  Both paths share `ca_ipow_<type>` below.  The exponent is converted
+  the way an int64 cell is converted to the base's type (through double
+  for float32 / cmplx64), so the answer is the one the general power
+  kernel gives for the same exponent held in an array.
 
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
 #include "ca_binop_dispatch.h"
-#include "ca_op_powi.h"
+#include <math.h>
+#include <complex.h>
+
+/* The exponents -2 .. 4 take at most two roundings, as in the power
+   kernel (MkKernel.pow_short). */
+#define CA_IPOW_SHORT(x, p) do {                \
+    switch ( p ) {                              \
+    case 2:  return (x) * (x);                  \
+    case 3:  return (x) * (x) * (x);            \
+    case 4:  return ((x) * (x)) * ((x) * (x));  \
+    case 1:  return (x);                        \
+    case 0:  return 1;                          \
+    case -1: return 1 / (x);                    \
+    case -2: return 1 / ((x) * (x));            \
+    }                                           \
+  } while (0)
+
+static inline float32_t
+ca_ipow_float32_t (float32_t x, int64_t p)
+{
+  CA_IPOW_SHORT(x, p);
+  return powf(x, (float) (double) p);
+}
+
+static inline float64_t
+ca_ipow_float64_t (float64_t x, int64_t p)
+{
+  CA_IPOW_SHORT(x, p);
+  return pow(x, (double) p);
+}
+
+static inline cmplx64_t
+ca_ipow_cmplx64_t (cmplx64_t x, int64_t p)
+{
+  CA_IPOW_SHORT(x, p);
+  return cpow(x, (float) (double) p);
+}
+
+static inline cmplx128_t
+ca_ipow_cmplx128_t (cmplx128_t x, int64_t p)
+{
+  CA_IPOW_SHORT(x, p);
+  return cpow(x, (double) p);
+}
 
 /* Defined in ext/carray_kernels.c (mkkernel-generated general pow /
    cpow binop).  Called by rb_ca_pow{,_bang} when the fast path does
@@ -71,7 +119,7 @@ ca_binop_ipower_##T (ca_size_t n, boolean8_t *m,                        \
         p1 = q1 + k*i1;                                                 \
         p2 = q2 + k*i2;                                                 \
         p3 = q3 + k*i3;                                                 \
-        *p3 = op_powi_##T(*p1, *p2);                                    \
+        *p3 = ca_ipow_##T(*p1, *p2);                                    \
       }                                                                 \
     }                                                                   \
   } else {                                                              \
@@ -79,7 +127,7 @@ ca_binop_ipower_##T (ca_size_t n, boolean8_t *m,                        \
       p1 = q1 + k*i1;                                                   \
       p2 = q2 + k*i2;                                                   \
       p3 = q3 + k*i3;                                                   \
-      *p3 = op_powi_##T(*p1, *p2);                                      \
+      *p3 = ca_ipow_##T(*p1, *p2);                                      \
     }                                                                   \
   }                                                                     \
 }
@@ -115,12 +163,12 @@ ca_ipower_float32_t (ca_size_t n, boolean8_t *m,
   ca_u_float32_t *p1 = (ca_u_float32_t *) ptr1, *p2 = (ca_u_float32_t *) ptr2;
   if ( m ) {
     while (n--) {
-      if ( ! *m++ ) { *p2 = op_powi_float32_t(*p1, ipow); }
+      if ( ! *m++ ) { *p2 = ca_ipow_float32_t(*p1, ipow); }
       p1++; p2++;
     }
   }
   else
-    while (n--) { (*p2) = op_powi_float32_t(*p1, ipow); p1++; p2++; }
+    while (n--) { (*p2) = ca_ipow_float32_t(*p1, ipow); p1++; p2++; }
 }
 
 static void
@@ -130,12 +178,12 @@ ca_ipower_float64_t (ca_size_t n, boolean8_t *m,
   ca_u_float64_t *p1 = (ca_u_float64_t *) ptr1, *p2 = (ca_u_float64_t *) ptr2;
   if ( m ) {
     while (n--) {
-      if ( ! *m++ ) { *p2 = op_powi_float64_t(*p1, ipow); }
+      if ( ! *m++ ) { *p2 = ca_ipow_float64_t(*p1, ipow); }
       p1++; p2++;
     }
   }
   else
-    while (n--) { (*p2) = op_powi_float64_t(*p1, ipow); p1++; p2++; }
+    while (n--) { (*p2) = ca_ipow_float64_t(*p1, ipow); p1++; p2++; }
 }
 
 static void
@@ -145,12 +193,12 @@ ca_ipower_cmplx64_t (ca_size_t n, boolean8_t *m,
   ca_u_cmplx64_t *p1 = (ca_u_cmplx64_t *) ptr1, *p2 = (ca_u_cmplx64_t *) ptr2;
   if ( m ) {
     while (n--) {
-      if ( ! *m++ ) { *p2 = op_powi_cmplx64_t(*p1, ipow); }
+      if ( ! *m++ ) { *p2 = ca_ipow_cmplx64_t(*p1, ipow); }
       p1++; p2++;
     }
   }
   else
-    while (n--) { (*p2) = op_powi_cmplx64_t(*p1, ipow); p1++; p2++; }
+    while (n--) { (*p2) = ca_ipow_cmplx64_t(*p1, ipow); p1++; p2++; }
 }
 
 static void
@@ -160,12 +208,12 @@ ca_ipower_cmplx128_t (ca_size_t n, boolean8_t *m,
   ca_u_cmplx128_t *p1 = (ca_u_cmplx128_t *) ptr1, *p2 = (ca_u_cmplx128_t *) ptr2;
   if ( m ) {
     while (n--) {
-      if ( ! *m++ ) { *p2 = op_powi_cmplx128_t(*p1, ipow); }
+      if ( ! *m++ ) { *p2 = ca_ipow_cmplx128_t(*p1, ipow); }
       p1++; p2++;
     }
   }
   else
-    while (n--) { (*p2) = op_powi_cmplx128_t(*p1, ipow); p1++; p2++; }
+    while (n--) { (*p2) = ca_ipow_cmplx128_t(*p1, ipow); p1++; p2++; }
 }
 
 /* The data types the ipower kernels cover; checked before any window

data/ext/ca_op_powi.h

@@ -1,19 +1,11 @@
 /* ---------------------------------------------------------------------------
 
-   ca_op_powi.h -- shared `op_powi_<type>` integer-power helpers
+   ca_op_powi.h -- `op_powi_<type>`, an integer to an integer power
 
-   Used by:
-     - ext/carray_kernels.c (generated from ext/mkkernel.rb)
-         the `power` binop kernel's integer variants call
-         `op_powi_<type>` to compute integer exponentiation by binary
-         exponentiation (O(log p) vs pow's general path).
-     - ext/carray_math.c (hand-written, P.5b.5)
-         the `ipower` family (rb_ca_ipower, rb_ca_ipower_bang) uses
-         `op_powi_<type>` for the Float**Integer / Complex**Integer
-         fast path when invoked via CArray#pow with an Integer rhs.
-
-   Both files include this header independently; each TU gets its own
-   `static inline` copy with no linker conflicts.
+   The `power` binop kernel's integer variants (generated from
+   ext/mkkernel.rb) call `op_powi_<type>`, binary exponentiation in the
+   integer type.  A float or complex base goes through pow / cpow
+   instead (ext/ca_op_ipower.c for an Integer exponent).
 
    --------------------------------------------------------------------------- */
 
@@ -27,7 +19,7 @@
    an evaluator that compiles a kernel body calling op_powi_<type>
    (CArray.__kernel_helpers__, written into the build by mkkernel.rb).  It
    may use only <stdint.h>, float32_t / float64_t and ca_zerodiv: what such
-   an evaluator's C declares.  The complex instantiations stay outside. */
+   an evaluator's C declares. */
 
 /* BEGIN kernel helpers */
 
@@ -85,17 +77,6 @@ op_powi_## type (type x, int64_t p) \
   return op_powi_mag_## type(x, (uint64_t) p); \
 }
 
-#define op_powi_fc(type) \
-op_powi_magnitude(type) \
-static inline type \
-op_powi_## type (type x, int64_t p) \
-{ \
-  if ( p < 0 ) { \
-    return 1 / op_powi_mag_## type(x, (uint64_t) 0 - (uint64_t) p); \
-  } \
-  return op_powi_mag_## type(x, (uint64_t) p); \
-}
-
 op_powi(int8_t)
 op_powi_u(uint8_t)
 op_powi(int16_t)
@@ -104,12 +85,8 @@ op_powi(int32_t)
 op_powi_u(uint32_t)
 op_powi(int64_t)
 op_powi_u(uint64_t)
-op_powi_fc(float32_t)
-op_powi_fc(float64_t)
 
 /* END kernel helpers */
 
-op_powi_fc(cmplx64_t)
-op_powi_fc(cmplx128_t)
 
 #endif /* CA_OP_POWI_H */

data/ext/ca_sort_kernels.h

@@ -61,6 +61,9 @@ void ca_sort_merge_f64 (double    *a, double    *aux, ca_size_t n);
 /* P.3: NaN pre-partition for float data types (Hoare 1-pass, returns finite count). */
 ca_size_t ca_partition_nan_f32 (float32_t *a, ca_size_t n);
 ca_size_t ca_partition_nan_f64 (double    *a, ca_size_t n);
+/* The same, keeping the order within both regions; scratch holds n values. */
+ca_size_t ca_partition_nan_stable_f32 (float32_t *a, ca_size_t n, float32_t *scratch);
+ca_size_t ca_partition_nan_stable_f64 (double    *a, ca_size_t n, double    *scratch);
 
 /* Pair variant of NaN pre-partition for float argsort kernels.  scratch
    holds n pairs; its contents on return are unspecified. */