carray 3.0.0 → 3.0.1

data/ext/ca_obj_string.c

@@ -192,7 +192,9 @@ ca_operation_function_t ca_string_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_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 ) {
@@ -1397,7 +1466,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;
 }
 

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;
 }
 
@@ -289,7 +287,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_sort_kernels.h

@@ -4,7 +4,7 @@
 
   Portable textbook sort kernels (PROPOSAL_PORTABLE_TEXTBOOK_SORT).
 
-    P.1 / P.2 : quicksort + mergesort over the 10 numeric dtypes
+    P.1 / P.2 : quicksort + mergesort over the 10 numeric data types
                 (i8 / u8 / i16 / u16 / i32 / u32 / i64 / u64 / f32 / f64)
     P.3       : NaN pre-partition for f32 / f64
     P.4       : pair (value + index) variants for argsort kernels —
@@ -33,7 +33,7 @@
    flight. */
 #include "carray.h"
 
-/* P.1 / P.2: quicksort over 10 numeric dtypes. */
+/* P.1 / P.2: quicksort over 10 numeric data types. */
 void ca_sort_quick_i8  (int8_t    *a, ca_size_t n);
 void ca_sort_quick_u8  (uint8_t   *a, ca_size_t n);
 void ca_sort_quick_i16 (int16_t   *a, ca_size_t n);
@@ -45,8 +45,8 @@ void ca_sort_quick_u64 (uint64_t  *a, ca_size_t n);
 void ca_sort_quick_f32 (float32_t *a, ca_size_t n);
 void ca_sort_quick_f64 (double    *a, ca_size_t n);
 
-/* P.1 / P.2: mergesort over 10 numeric dtypes (`aux` is caller-supplied
-   scratch buffer of the same length / dtype as `a`). */
+/* P.1 / P.2: mergesort over 10 numeric data types (`aux` is caller-supplied
+   scratch buffer of the same length / data type as `a`). */
 void ca_sort_merge_i8  (int8_t    *a, int8_t    *aux, ca_size_t n);
 void ca_sort_merge_u8  (uint8_t   *a, uint8_t   *aux, ca_size_t n);
 void ca_sort_merge_i16 (int16_t   *a, int16_t   *aux, ca_size_t n);
@@ -58,7 +58,7 @@ void ca_sort_merge_u64 (uint64_t  *a, uint64_t  *aux, ca_size_t n);
 void ca_sort_merge_f32 (float32_t *a, float32_t *aux, ca_size_t n);
 void ca_sort_merge_f64 (double    *a, double    *aux, ca_size_t n);
 
-/* P.3: NaN pre-partition for float dtypes (Hoare 1-pass, returns finite count). */
+/* 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);