carray 3.0.0 → 3.0.2

data/ext/ca_obj_tile.c

@@ -214,10 +214,18 @@ ca_tile_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   s = ca->bytes;
   for (k = ndim - 1; k >= 0; k--) { dstride[k] = s; s *= counts[k]; }
 
-  for (k = 0; k < ndim; k++) {
-    if (strides[k] % tnative[k] != 0 || strides[k] / tnative[k] != 1) {
-      structural = 0;
-      break;
+  /* The request is over the view's addresses, so a transposed / flat request
+     is legal and must not be composed axis-by-axis; see
+     ca_xfer_stride_request_is_axis_box (carray.h). */
+  if ( ! ca_xfer_stride_request_is_axis_box(ca, starts, counts, strides) ) {
+    structural = 0;
+  }
+  else {
+    for (k = 0; k < ndim; k++) {
+      if (strides[k] % tnative[k] != 0 || strides[k] / tnative[k] != 1) {
+        structural = 0;
+        break;
+      }
     }
   }
 
@@ -546,7 +554,7 @@ rb_ca_tile (int argc, VALUE *argv, VALUE self)
 
   {
     VALUE obj = rb_ca_tile_new(self, reps);
-    CA_FACE_LIFT_IF_FACE(obj, self, ca);
+    CA_WRAPPER_LIFT(obj, self, ca);
     return obj;
   }
 }

data/ext/ca_obj_time.c

@@ -293,7 +293,9 @@ ca_operation_function_t ca_time_func = {
   ca_face_xfer_addrs,
   NULL,                              /* fold_stride: identity Face is not foldable */
   ca_face_xfer_stride,
-  ca_face_xfer_all
+  ca_face_xfer_all,
+  .fill_addrs  = ca_face_fill_addrs,
+  .fill_stride = ca_face_fill_stride,
 };
 
 /* ------------------------------------------------------------------- */

data/ext/ca_obj_timedelta.c

@@ -273,7 +273,9 @@ ca_operation_function_t ca_timedelta_func = {
   ca_face_xfer_addrs,
   NULL,                              /* fold_stride */
   ca_face_xfer_stride,
-  ca_face_xfer_all
+  ca_face_xfer_all,
+  .fill_addrs  = ca_face_fill_addrs,
+  .fill_stride = ca_face_fill_stride,
 };
 
 /* ------------------------------------------------------------------- */

data/ext/ca_obj_transpose.c

@@ -117,7 +117,7 @@ rb_ca_trans (int argc, VALUE *argv, VALUE self)
   }
 
   obj = rb_ca_trans_new(self, imap);
-  CA_FACE_LIFT_IF_FACE(obj, self, ca);
+  CA_WRAPPER_LIFT(obj, self, ca);
   return obj;
 }
 

data/ext/ca_obj_triop.c

@@ -61,12 +61,19 @@ typedef struct CATriOp {
   CArray   *parent;       /* = op1 */
   uint32_t  attach;
   uint8_t   nosync;
+  /* ---- CAMultiParent conformance (CA_FLAG_MULTI_PARENTS): n_parents and
+         parents[] sit immediately after the CAView header, as carray.h's
+         layout convention requires, so ca_has_mask can fold over both
+         operands and build the mask on demand instead of at setup. ---- */
+  int32_t   n_parents;        /* always 3 */
+  CArray  **parents;          /* = &operands[0]; no separate allocation */
   /* CATriOp-specific tail */
   CArray   *op2;
   CArray   *op3;
   uint16_t  op_id;
   uint8_t   op2_is_scalar;
   uint8_t   op3_is_scalar;
+  CArray   *operands[3];      /* {op1, op2, op3}; what parents points at */
 } CATriOp;
 
 static size_t
@@ -117,7 +124,7 @@ ca_triop_setup (CATriOp *ca, CArray *op1, CArray *op2, CArray *op3,
 
   ca->obj_type  = CA_OBJ_TRIOP;
   ca->data_type = out_dt;
-  ca->flags     = CA_FLAG_READ_ONLY;
+  ca->flags     = CA_FLAG_READ_ONLY | CA_FLAG_MULTI_PARENTS;
   ca->ndim      = op1->ndim;
   ca->bytes     = out_bytes;
   ca->elements  = op1->elements;
@@ -134,12 +141,17 @@ ca_triop_setup (CATriOp *ca, CArray *op1, CArray *op2, CArray *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->operands[0] = op1;
+  ca->operands[1] = op2;
+  ca->operands[2] = op3;
+  ca->parents     = ca->operands;
+  ca->n_parents   = 3;
 
   memcpy(ca->dim, op1->dim, op1->ndim * sizeof(ca_size_t));
 
-  if ( ca_has_mask(op1) || ca_has_mask(op2) || ca_has_mask(op3) ) {
-    ca_create_mask(ca);
-  }
+  /* The mask is NOT built here.  ca_has_mask folds over parents[] for a
+     multi-parent view and creates it on demand, so an expression whose mask
+     nobody reads never allocates one. */
 
   if ( ca_is_scalar(op1) && ca_is_scalar(op2) && ca_is_scalar(op3) ) {
     ca_set_flag(ca, CA_FLAG_SCALAR);
@@ -253,7 +265,9 @@ pull_operand (CArray *op, int is_scalar, ca_size_t *starts,
       one_counts[k]  = 1;
       one_strides[k] = bytes;
     }
-    scratch = ca_lazy_arena_acquire(bytes);
+    scratch = ( op->data_type == CA_OBJECT )
+                ? ca_lazy_arena_acquire_object(1)
+                : ca_lazy_arena_acquire(bytes);
     ca_triop_scratch_acquire_count++;
     ca_xfer_stride(op, one_starts, one_counts, one_strides, scratch,
                    CA_XFER_GET);
@@ -266,7 +280,9 @@ pull_operand (CArray *op, int is_scalar, ca_size_t *starts,
       op_strides[k] = s;
       s *= counts[k];
     }
-    scratch = ca_lazy_arena_acquire(slab_n * bytes);
+    scratch = ( op->data_type == CA_OBJECT )
+                ? ca_lazy_arena_acquire_object(slab_n)
+                : ca_lazy_arena_acquire(slab_n * bytes);
     ca_triop_scratch_acquire_count++;
     ca_xfer_stride(op, starts, counts, op_strides, scratch, CA_XFER_GET);
     *step_out = 1;
@@ -343,6 +359,14 @@ ca_triop_func_allocate (void *ap)
 {
   CATriOp *ca = (CATriOp *) ap;
   ca->ptr = xmalloc(ca_length(ca));
+  /* CA_OBJECT cells are VALUEs and this buffer is about to be marked as
+     soon as the view is, so it must not be handed to the GC as raw
+     xmalloc garbage. */
+  if ( ca->data_type == CA_OBJECT ) {
+    VALUE *p = (VALUE *) ca->ptr;
+    ca_size_t i;
+    for ( i = 0; i < ca->elements; i++ ) *p++ = Qnil;
+  }
 }
 
 static void
@@ -362,6 +386,14 @@ ca_triop_func_attach (void *ap)
   s = ca->bytes;
   for ( k = ca->ndim - 1; k >= 0; k-- ) { native[k] = s; s *= ca->dim[k]; }
   for ( k = 0; k < ca->ndim; k++ ) starts[k] = 0;
+  /* CA_OBJECT cells are VALUEs and this buffer is about to be marked as
+     soon as the view is, so it must not be handed to the GC as raw
+     xmalloc garbage. */
+  if ( ca->data_type == CA_OBJECT ) {
+    VALUE *p = (VALUE *) ca->ptr;
+    ca_size_t i;
+    for ( i = 0; i < ca->elements; i++ ) *p++ = Qnil;
+  }
   ca_triop_func_xfer_stride(ca, starts, ca->dim, native, ca->ptr, CA_XFER_GET);
 }
 
@@ -405,13 +437,26 @@ ca_triop_func_create_mask (void *ap)
   has3 = ca_has_mask(op3);
   if ( ! has1 && ! has2 && ! has3 ) return;
 
+  /* Exactly one masked operand: the answer is that operand's mask, cell
+     for cell.  Share it rather than allocating a copy per node. */
+  if ( has1 + has2 + has3 == 1 ) {
+    CArray *src = has1 ? op1 : ( has2 ? op2 : op3 );
+    if ( src->elements == to->elements ) {
+      to->mask = (CArray *) ca_refer_new(src->mask, CA_BOOLEAN,
+                                         to->ndim, to->dim, 0, 0);
+      return;
+    }
+  }
+
   to->mask = (CArray *) carray_new(CA_BOOLEAN, to->ndim, to->dim, 0, NULL);
   dst = (boolean8_t *) to->mask->ptr;
   n = to->elements;
 
-  if ( has1 ) ca_attach(op1);
-  if ( has2 ) ca_attach(op2);
-  if ( has3 ) ca_attach(op3);
+  /* The masks are what is read here; attaching the operand instead
+     materialises the whole subexpression under it. */
+  if ( has1 ) ca_attach(op1->mask);
+  if ( has2 ) ca_attach(op2->mask);
+  if ( has3 ) ca_attach(op3->mask);
 
   m1 = has1 ? (boolean8_t *) op1->mask->ptr : NULL;
   m2 = has2 ? (boolean8_t *) op2->mask->ptr : NULL;
@@ -426,9 +471,9 @@ ca_triop_func_create_mask (void *ap)
     dst[i] = (boolean8_t) ( a | b | c );
   }
 
-  if ( has3 ) ca_detach(op3);
-  if ( has2 ) ca_detach(op2);
-  if ( has1 ) ca_detach(op1);
+  if ( has3 ) ca_detach(op3->mask);
+  if ( has2 ) ca_detach(op2->mask);
+  if ( has1 ) ca_detach(op1->mask);
 }
 
 ca_operation_function_t ca_triop_func = {
@@ -597,23 +642,17 @@ rb_ca_triop_build (VALUE cary1, VALUE cary2, VALUE cary3, uint16_t op_id)
   TypedData_Get_Struct(r1, CArray, &carray_data_type, op1);
   TypedData_Get_Struct(r3, CArray, &carray_data_type, op3);
 
-  /* Step 3: shape sanity — each of op2 / op3 must match op1's element
-     count OR be a 1-element CScalar (kernel walks with element_step
-     = 0 in that case). */
+  /* Step 3: each of op2 / op3 must match op1's element count OR be a
+     1-element CScalar (kernel walks with element_step = 0 in that case).
+     Unreachable from Ruby; see the note in ca_obj_binop.c. */
   if ( op2->elements != op1->elements && op2->elements != 1 ) {
     rb_raise(rb_eArgError,
-             "CATriOp: shape mismatch on op2 (%lld vs %lld) — only "
-             "same-ndim size-1 broadcast is supported; cross-ndim "
-             "promotion is not adopted in CArray "
-             "(reshape explicitly)",
+             "CATriOp: element count mismatch on op2 (%lld vs %lld)",
              (long long) op2->elements, (long long) op1->elements);
   }
   if ( op3->elements != op1->elements && op3->elements != 1 ) {
     rb_raise(rb_eArgError,
-             "CATriOp: shape mismatch on op3 (%lld vs %lld) — only "
-             "same-ndim size-1 broadcast is supported; cross-ndim "
-             "promotion is not adopted in CArray "
-             "(reshape explicitly)",
+             "CATriOp: element count mismatch on op3 (%lld vs %lld)",
              (long long) op3->elements, (long long) op1->elements);
   }
 

data/ext/ca_obj_window.c

@@ -334,12 +334,20 @@ ca_window_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
   for (k = ndim - 1; k >= 0; k--) { dstride[k] = s; s *= counts[k]; }
   for (k = 0; k < ndim; k++) n *= counts[k];
 
-  for (k = 0; k < ndim; k++) {
-    if ( (w->bounds[k] != CA_BOUNDS_FILL && w->bounds[k] != CA_BOUNDS_MASK)
-         || strides[k] % wnative[k] != 0
-         || strides[k] / wnative[k] != 1 ) {
-      structural = 0;
-      break;
+  /* The request is over the view's addresses, so a transposed / flat request
+     is legal and must not be composed axis-by-axis; see
+     ca_xfer_stride_request_is_axis_box (carray.h). */
+  if ( ! ca_xfer_stride_request_is_axis_box(w, starts, counts, strides) ) {
+    structural = 0;
+  }
+  else {
+    for (k = 0; k < ndim; k++) {
+      if ( (w->bounds[k] != CA_BOUNDS_FILL && w->bounds[k] != CA_BOUNDS_MASK)
+           || strides[k] % wnative[k] != 0
+           || strides[k] / wnative[k] != 1 ) {
+        structural = 0;
+        break;
+      }
     }
   }
 
@@ -374,12 +382,31 @@ ca_window_func_xfer_stride (void *ap, ca_size_t *starts, ca_size_t *counts,
     lo[k] = l; hi[k] = h;
   }
 
+  /* An unattached parent that ca_attach_is_alias accepts has memory to lend
+     and the attach neither allocates nor copies, so borrow it and re-enter
+     on the batched branch below.  The recursion runs at most once: the
+     second entry sees parent->ptr != NULL.  A parent with nothing to lend is
+     left alone — the per-row loop is the region protocol and must not be
+     traded for a whole-parent attach. */
+  if ( ! parent->ptr && ca_attach_is_alias(parent) ) {
+    ca_attach(parent);
+    if ( parent->ptr ) {
+      ca_window_func_xfer_stride(ap, starts, counts, strides, data, dir);
+      if ( dir == CA_XFER_PUT ) {
+        ca_sync(parent);
+      }
+      ca_detach(parent);
+      return;
+    }
+    ca_detach(parent);
+  }
+
   /* Fast path: when the parent is attached (ptr != NULL), drive
      ca_composite_region_* + fill_complement directly with the sub-region
      intersection geometry.  This collapses the outer per-row dispatch loop
      (one ca_xfer_stride per inner row) into a single batched routine.  An
-     unattached parent falls through to the per-row loop below, which is
-     equivalent but slower. */
+     unattached parent with nothing to lend falls through to the per-row loop
+     below, which is equivalent but slower. */
   if ( parent->ptr ) {
     ca_size_t any_empty = 0;
     ca_size_t alias_parent_start[CA_RANK_MAX];
@@ -1011,10 +1038,16 @@ ca_window_func_detach (void *ap)
    so the caller must have made it available.
 
    CAREFUL: neither this nor ca_window_func_xfer_all may call
-   ca_attach(parent).  A transfer slot that silently attaches its parent
-   materialises the whole parent behind the caller's back — the cold case
-   below instead materialises a parent-shaped scratch through ca_xfer_all,
-   which recurses under the same rule. */
+   ca_attach(parent) on a parent that would have to materialise to answer.
+   A transfer slot that silently does that duplicates the whole parent
+   behind the caller's back — the cold case below instead materialises a
+   parent-shaped scratch through ca_xfer_all, which recurses under the
+   same rule.
+
+   The exception is a parent that ca_attach_is_alias accepts: there the
+   attach hands back parent (or root) memory that already exists, so
+   nothing is allocated or copied and the rule has nothing to protect.
+   ca_window_func_fill_data draws the same line. */
 static void
 ca_window_func_run_fast_path (CAWindow *ca, char *data, int dir)
 {
@@ -1049,8 +1082,44 @@ ca_window_func_xfer_all (void *ap, void *data, int dir)
     ca_window_func_run_fast_path(ca, (char *) data, dir);
     return;
   }
-  /* Cold parent: materialise it into a scratch buffer via ca_xfer_all, then
-     run the normal fast path with the scratch standing in for parent->ptr. */
+  /* Cold parent that has memory to lend (entity, or a CAStride-family view
+     whose composed strides alias a ptr-bearing root): borrow it.  The attach
+     costs no allocation and no copy, and on the alias path ca->parent->ptr
+     points into the root, so a PUT lands where the scratch path would have
+     had to copy it back.  Without this the window duplicates the entire
+     parent on every transfer, which is what an ordinary `a[nil, nil]`,
+     `a.refer` or `a.transpose.transpose` parent used to pay. */
+  if ( ca_attach_is_alias(ca->parent) ) {
+    ca_attach(ca->parent);
+    ca_window_func_run_fast_path(ca, (char *) data, dir);
+    if ( dir == CA_XFER_PUT ) {
+      ca_sync(ca->parent);
+    }
+    ca_detach(ca->parent);
+    return;
+  }
+  /* Second chance: ca_attach_is_alias reads the leaf view's own strides, so
+     it declines a chain that is only contiguous once composed (a.transpose
+     .transpose is the plain case).  ca_resolve_attached_root_via_identity
+     folds the chain and answers the same question about the root, and when
+     it succeeds the parent's flat byte addressing IS the root's — so the
+     root ptr can stand in for the parent's exactly as the scratch does
+     below, with no copy in either direction.  ca_window_func_xfer_addrs
+     already resolves its parent this way. */
+  {
+    CArray *root = ca_resolve_attached_root_via_identity(ca->parent);
+    if ( root != ca->parent && root->ptr ) {
+      CArray *parent = ca->parent;
+      parent->ptr = root->ptr;
+      ca_window_func_run_fast_path(ca, (char *) data, dir);
+      parent->ptr = NULL;
+      return;
+    }
+  }
+
+  /* Cold parent with nothing to lend: materialise it into a scratch buffer
+     via ca_xfer_all, then run the normal fast path with the scratch standing
+     in for parent->ptr. */
   {
     volatile VALUE holder;
     CArray   *parent = ca->parent;
@@ -1296,7 +1365,7 @@ rb_ca_window_new (VALUE cary,
 VALUE
 rb_ca_window (int argc, VALUE *argv, VALUE self)
 {
-  volatile VALUE obj, ropt, rfval = CA_NIL, rbounds = Qnil, rcs;
+  volatile VALUE obj, ropt, rfval = CA_UNSPECIFIED, rbounds = Qnil, rcs;
   CArray *ca;
   CScalar *cs;
   ca_size_t start[CA_RANK_MAX];
@@ -1334,7 +1403,7 @@ rb_ca_window (int argc, VALUE *argv, VALUE self)
              "use fill_value: kwarg (e.g. window(-1..1, fill_value: UNDEF))");
   }
 
-  if ( rfval == CA_NIL ) {
+  if ( rfval == CA_UNSPECIFIED ) {
     ;
   }
   else if ( rfval == CA_UNDEF ) {
@@ -1347,6 +1416,12 @@ rb_ca_window (int argc, VALUE *argv, VALUE self)
   }
 
   if ( ! NIL_P(rbounds) ) {
+    /* A Symbol says the same thing as the String, and is what the window
+       iterator (CArray#windows) is given -- accept both so the two spellings
+       of one policy do not diverge. */
+    if ( SYMBOL_P(rbounds) ) {
+      rbounds = rb_sym2str(rbounds);
+    }
     switch ( TYPE(rbounds) ) {
     case T_STRING:
       cbounds = StringValuePtr(rbounds);
@@ -1397,7 +1472,7 @@ rb_ca_window (int argc, VALUE *argv, VALUE self)
 
   obj = rb_ca_window_new(self, start, count, bounds, fill);
 
-  CA_FACE_LIFT_IF_FACE(obj, self, ca);
+  CA_WRAPPER_LIFT(obj, self, ca);
   return obj;
 }
 
@@ -1528,7 +1603,6 @@ rb_ca_window_get_bounds (VALUE self)
 }
 
 static VALUE rb_cw_get_attr_ary(start);
-static VALUE rb_cw_get_attr_ary(count);
 static VALUE rb_cw_get_attr_ary(size0);
 
 #ifdef CARRAY_DEV_BUILD
@@ -1611,8 +1685,9 @@ Init_ca_obj_window (void)
 
   rb_define_method(rb_cCAWindow, "bounds", rb_ca_window_get_bounds, 0);
 
+  /* No `count` accessor: the per-axis window widths are what `shape`
+     already answers, and the name belongs to CArray#count. */
   rb_define_method(rb_cCAWindow, "start",  rb_cw_start, 0);
-  rb_define_method(rb_cCAWindow, "count",  rb_cw_count, 0);
   rb_define_method(rb_cCAWindow, "size0",  rb_cw_size0, 0);
 
 #ifdef CARRAY_DEV_BUILD

data/ext/ca_op_cmplx64.h

@@ -0,0 +1,123 @@
+/* ---------------------------------------------------------------------------
+
+   ca_op_cmplx64.h -- the cmplx64 products and quotients, computed in
+                      double and rounded once
+
+   Used by:
+     - ext/carray_kernels_binop.c and ext/carray_kernels_monop.c
+       (generated from ext/mkkernel.rb): the `*`, `/`, `rcp` and
+       `rcp_mul` kernels for CA_CMPLX64.
+
+   Why these are not just `x * y` and `x / y`.  Both the product and the
+   quotient of two complex numbers subtract two products of the parts, so
+   the result cancels whenever those two are close.  Done at the operands'
+   own width there are no bits left underneath to absorb the cancellation.
+   Divide has a second cost: the compiler turns a `float _Complex` divide
+   into a call to `__divsc3`, which is Smith's algorithm (scale by the
+   larger component so the intermediate squares cannot overflow) plus the
+   C99 Annex G recovery for infinities -- branches and a call per cell.
+
+   For a cmplx64 the scaling is not needed at all: the operands are
+   floats, so a product of two parts reaches about 1.2e77 where a double
+   reaches 1.8e308.  Computing the textbook formulas in double therefore
+   cannot overflow, and the double carries 29 extra mantissa bits, which
+   is what the cancellation needs.  Measured against an exact rational
+   reference, the double route was correctly rounded on every sample
+   where the width-native route was off by up to 1806 ulp (divide) and
+   1679 ulp (multiply).
+
+   The two are not the same trade.  Divide gets faster as well, because
+   the call and the scaling both go away.  Multiply gets slower, because
+   the compiler already inlines a naive float product and only calls
+   `__mulsc3` when a NaN appears -- so the wider arithmetic is pure cost
+   there, and is paid for the accuracy alone.
+
+   Annex G is preserved by falling back rather than by reimplementing it.
+   The fallback is chosen from the *result*, not from a classification of
+   the inputs: if the quick answer is not an ordinary number, hand the
+   pair to the compiler's helper and return whatever it says.  Writing an
+   input classification here would mean transcribing the Annex G table,
+   and a transcription drifts from what the runtime actually does.
+
+   cmplx128 has no wider type to borrow (`long double` is a double on
+   Apple ARM64 and a slow 80-bit on x86-64), so it keeps `__mulsc3` /
+   `__divdc3`.
+
+   --------------------------------------------------------------------------- */
+
+#ifndef CA_OP_CMPLX64_H
+#define CA_OP_CMPLX64_H
+
+#include "carray.h"
+#include <math.h>
+
+#ifdef HAVE_COMPLEX_H
+
+/* CMPLXF is the float sibling of the CMPLX defined in carray.h, and is
+   here for the same reason: `re + I * im` evaluates `I * im` first, so an
+   im of +0.0 loses the sign of a -0.0 real part.  CMPLXF is C11; provide
+   it when the toolchain predates that. */
+#ifndef CMPLXF
+#  if defined(__clang__) || (defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7)))
+#    define CMPLXF(re, im) __builtin_complex((float)(re), (float)(im))
+#  else
+#    define CMPLXF(re, im) \
+       (((union { float _parts[2]; float complex _value; }) \
+           { { (float)(re), (float)(im) } })._value)
+#  endif
+#endif
+
+/* The real part is `xr*yr - xi*yi`, which cancels when the two products
+   are close; the double keeps the bits that cancellation eats.  Only a
+   NaN can appear here that the naive form gets wrong, since a product of
+   two floats cannot overflow a double -- an infinite part in the answer
+   is the true answer.  */
+static inline cmplx64_t
+op_cmul_cmplx64 (cmplx64_t x, cmplx64_t y)
+{
+  double xr = crealf(x), xi = cimagf(x);
+  double yr = crealf(y), yi = cimagf(y);
+  float  rr = (float) (xr * yr - xi * yi);
+  float  ri = (float) (xr * yi + xi * yr);
+  if ( isnan(rr) || isnan(ri) ) {
+    return x * y;   /* __mulsc3: an infinity met a zero (Annex G) */
+  }
+  return CMPLXF(rr, ri);
+}
+
+static inline cmplx64_t
+op_cdiv_cmplx64 (cmplx64_t x, cmplx64_t y)
+{
+  double yr = crealf(y), yi = cimagf(y);
+  double d  = yr * yr + yi * yi;
+  if ( d > 0.0 && d < INFINITY ) {
+    double xr = crealf(x), xi = cimagf(x);
+    float  rr = (float) ((xr * yr + xi * yi) / d);
+    float  ri = (float) ((xi * yr - xr * yi) / d);
+    if ( isfinite(rr) && isfinite(ri) ) {
+      return CMPLXF(rr, ri);
+    }
+  }
+  return x / y;   /* __divsc3: zero, infinite or NaN operands (Annex G) */
+}
+
+/* 1 / y.  Same shape with the numerator's parts folded in, so that
+   `rcp` and `1 / z` keep giving the same answer. */
+static inline cmplx64_t
+op_crcp_cmplx64 (cmplx64_t y)
+{
+  double yr = crealf(y), yi = cimagf(y);
+  double d  = yr * yr + yi * yi;
+  if ( d > 0.0 && d < INFINITY ) {
+    float rr = (float) (yr / d);
+    float ri = (float) (-yi / d);
+    if ( isfinite(rr) && isfinite(ri) ) {
+      return CMPLXF(rr, ri);
+    }
+  }
+  return 1 / y;
+}
+
+#endif /* HAVE_COMPLEX_H */
+
+#endif /* CA_OP_CMPLX64_H */

data/ext/ca_op_ipower.c

@@ -233,8 +233,6 @@ rb_ca_ipower (VALUE self, VALUE other)
     ALLOCV_END(h1);
   }
 
-  obj = rb_ca_rewrap_unbound_repeat(self, obj);
-
   return obj;
 }
 
@@ -275,8 +273,7 @@ rb_ca_ipower_bang (VALUE self, VALUE other)
 /* CArray#pow(other) (alias `**`) — Float/Complex ** Integer takes the
  * ipower fast path in this file; everything else falls through to the
  * mkkernel-generated general pow/cpow (rb_ca_power in
- * ext/carray_kernels.c).  Non-bang variant preserves UnboundRepeat
- * wrapping on the result. */
+ * ext/carray_kernels.c). */
 static VALUE rb_ca_pow (VALUE self, VALUE other)
 {
   volatile VALUE obj;
@@ -289,7 +286,6 @@ static VALUE rb_ca_pow (VALUE self, VALUE other)
   }
   else {
     obj = rb_ca_power(self, other);
-    obj = rb_ca_rewrap_unbound_repeat(self, obj);
     return obj;
   }
 }

data/ext/ca_rng_normal.h

@@ -0,0 +1,42 @@
+/* ---------------------------------------------------------------------------
+
+   ca_rng_normal.h -- uniform to standard normal, as text
+
+   Read the two ways ca_rng_xoshiro256pp.h is read: compiled into this
+   extension, and handed out through CArray::Rng::COMMON_SOURCE for
+   another gem to paste.  The same rules apply -- no include guard,
+   nothing beyond <math.h>, `static inline` only.
+
+   Separate from any generator's file because it belongs to none of
+   them: it takes two uniforms and gives a normal, whichever generator
+   the uniforms came from.  Whoever pastes it pastes it once however
+   many generators are drawing, which is why it is not simply repeated
+   inside each generator's text.
+
+   --------------------------------------------------------------------------- */
+
+/* One standard normal from two uniforms in [0.0, 1.0), by Box-Muller.
+ *
+ * Exactly two, always.  The classical form takes two uniforms and gives
+ * two normals, and keeping the second would make the cost one uniform
+ * apiece -- but the spare has to live somewhere between calls, and the
+ * place it would live is the generator's state.  A kernel draws one
+ * number per cell and `CArray#random!` fills whole arrays, so a spare
+ * held across that boundary is a second kind of state to keep in step,
+ * on top of the one this design exists to keep in step.  Two uniforms
+ * and no spare costs an extra draw, at about a nanosecond, and buys a
+ * rule with nothing behind it: one normal is two draws, wherever it is
+ * taken.
+ *
+ * `1.0 - u1` rather than `u1`, so the argument to log is in (0.0, 1.0]
+ * and never zero.  Redrawing on a zero -- which is what the paired form
+ * does -- would make the number of uniforms per normal depend on the
+ * draw, and then "where is this generator" has no answer that can be
+ * worked out rather than run. */
+static inline double
+ca_rng_normal (double u1, double u2)
+{
+  const double radius = sqrt(-2.0 * log(1.0 - u1));
+  const double theta = 2.0 * M_PI * u2;
+  return radius * cos(theta);
+}