carray 2.0.1 → 3.0.1

data/ext/ca_op_byte_swap.c

@@ -0,0 +1,175 @@
+/* ---------------------------------------------------------------------------
+
+  Per-data_type kernel table for the CAMonOp `byte_swap` op
+  (`CA_MONOP_BYTE_SWAP`): reverses the byte order of each cell in place
+  after copying src to dst.  byte_swap is data_type-preserving
+  (output.bytes == input.bytes).
+
+  Sibling of ca_monop_dispatch.c (looks up `ca_monop_byte_swap[in_dt]`)
+  and ca_obj_byte_swap.c (the eager CAByteSwap view + `ca_swap_bytes`
+  primitive that this file delegates to for the actual reversal).
+
+  Dispatch by data_type:
+    1-byte cells (boolean / int8 / uint8) -> 1byte kernel (memcpy only)
+    fixed-width numeric (int16..float64)  -> nbyte kernel (memcpy + reverse)
+    CA_CMPLX64 / CA_CMPLX128              -> cmplx kernel (half-independent)
+    CA_FIXLEN / CA_FLOAT128 / CA_CMPLX256 -> not_impl trampoline
+    CA_OBJECT                             -> not_impl trampoline
+
+  CMPLX cells are byte-swapped as two independent halves (real / imag),
+  not as one wide cell — this matches the eager `ca_byte_swap_buffer`
+  contract in ca_obj_byte_swap.c.
+
+  CA_FIXLEN is excluded here: bytes-per-cell is parent-specific and
+  data_class field-recursion requires a Ruby callback path; the CAByteSwap
+  view handles those.  CA_OBJECT byte-swap on VALUE refs is meaningless.
+
+---------------------------------------------------------------------------- */
+
+#include "carray.h"
+#include "ca_monop_dispatch.h"
+#include <string.h>
+
+/* Reverses `bytes` bytes per cell across `elements` cells in place.
+ * Defined in ca_obj_byte_swap.c. */
+extern void ca_swap_bytes (char *ptr, ca_size_t bytes, ca_size_t elements);
+
+/* ------------------------------------------------------------------- */
+/* per-data_type kernels                                                */
+/* ------------------------------------------------------------------- */
+
+/* 1-byte cell: byte-swap is a no-op on a single byte.  The kernel just
+   copies src to dst when they differ; included so boolean / int8 / uint8
+   share the dispatch shape with the wider kernels.  */
+#define DEFINE_BYTE_SWAP_1BYTE(name) \
+  static void \
+  name (ca_size_t n, boolean8_t *m, \
+        char *ptr1, ca_size_t i1, char *ptr2, ca_size_t i2) \
+  { \
+    ca_size_t k; \
+    if ( m ) { \
+      for (k = 0; k < n; k++) { \
+        if (!m[k]) { \
+          *(ptr2 + k*i2) = *(ptr1 + k*i1); \
+        } \
+      } \
+    } else { \
+      for (k = 0; k < n; k++) { \
+        *(ptr2 + k*i2) = *(ptr1 + k*i1); \
+      } \
+    } \
+  }
+
+/* N-byte cell: copy src to dst (if different) then reverse the N
+   bytes within the cell.  */
+#define DEFINE_BYTE_SWAP_NBYTE(name, BYTES) \
+  static void \
+  name (ca_size_t n, boolean8_t *m, \
+        char *ptr1, ca_size_t i1, char *ptr2, ca_size_t i2) \
+  { \
+    ca_size_t k; \
+    if ( m ) { \
+      for (k = 0; k < n; k++) { \
+        if (!m[k]) { \
+          char *p1 = ptr1 + k*i1*(BYTES); \
+          char *p2 = ptr2 + k*i2*(BYTES); \
+          if (p2 != p1) memcpy(p2, p1, (BYTES)); \
+          ca_swap_bytes(p2, (BYTES), 1); \
+        } \
+      } \
+    } else { \
+      for (k = 0; k < n; k++) { \
+        char *p1 = ptr1 + k*i1*(BYTES); \
+        char *p2 = ptr2 + k*i2*(BYTES); \
+        if (p2 != p1) memcpy(p2, p1, (BYTES)); \
+        ca_swap_bytes(p2, (BYTES), 1); \
+      } \
+    } \
+  }
+
+/* CMPLX cell (TOTAL bytes = 2 * HALF): swap the real half and the imag
+   half independently rather than reversing the whole TOTAL-byte cell. */
+#define DEFINE_BYTE_SWAP_CMPLX(name, TOTAL, HALF) \
+  static void \
+  name (ca_size_t n, boolean8_t *m, \
+        char *ptr1, ca_size_t i1, char *ptr2, ca_size_t i2) \
+  { \
+    ca_size_t k; \
+    if ( m ) { \
+      for (k = 0; k < n; k++) { \
+        if (!m[k]) { \
+          char *p1 = ptr1 + k*i1*(TOTAL); \
+          char *p2 = ptr2 + k*i2*(TOTAL); \
+          if (p2 != p1) memcpy(p2, p1, (TOTAL)); \
+          ca_swap_bytes(p2, (HALF), 2); \
+        } \
+      } \
+    } else { \
+      for (k = 0; k < n; k++) { \
+        char *p1 = ptr1 + k*i1*(TOTAL); \
+        char *p2 = ptr2 + k*i2*(TOTAL); \
+        if (p2 != p1) memcpy(p2, p1, (TOTAL)); \
+        ca_swap_bytes(p2, (HALF), 2); \
+      } \
+    } \
+  }
+
+DEFINE_BYTE_SWAP_1BYTE(ca_monop_byte_swap_boolean_t)
+DEFINE_BYTE_SWAP_1BYTE(ca_monop_byte_swap_int8_t)
+DEFINE_BYTE_SWAP_1BYTE(ca_monop_byte_swap_uint8_t)
+
+DEFINE_BYTE_SWAP_NBYTE(ca_monop_byte_swap_int16_t,  2)
+DEFINE_BYTE_SWAP_NBYTE(ca_monop_byte_swap_uint16_t, 2)
+
+DEFINE_BYTE_SWAP_NBYTE(ca_monop_byte_swap_int32_t,  4)
+DEFINE_BYTE_SWAP_NBYTE(ca_monop_byte_swap_uint32_t, 4)
+
+DEFINE_BYTE_SWAP_NBYTE(ca_monop_byte_swap_int64_t,  8)
+DEFINE_BYTE_SWAP_NBYTE(ca_monop_byte_swap_uint64_t, 8)
+
+DEFINE_BYTE_SWAP_NBYTE(ca_monop_byte_swap_float32_t, 4)
+DEFINE_BYTE_SWAP_NBYTE(ca_monop_byte_swap_float64_t, 8)
+
+DEFINE_BYTE_SWAP_CMPLX(ca_monop_byte_swap_cmplx64_t,  8, 4)
+DEFINE_BYTE_SWAP_CMPLX(ca_monop_byte_swap_cmplx128_t, 16, 8)
+
+/* Trampoline installed at unsupported data_type slots in the dispatch
+   table below.  Raises rather than returning so the caller never sees
+   silent no-op behaviour on an out-of-scope data_type.  */
+NORETURN(static void ca_monop_byte_swap_not_impl (ca_size_t n, boolean8_t *m,
+                                                  char *ptr1, ca_size_t i1,
+                                                  char *ptr2, ca_size_t i2));
+static void
+ca_monop_byte_swap_not_impl (ca_size_t n, boolean8_t *m,
+                             char *ptr1, ca_size_t i1,
+                             char *ptr2, ca_size_t i2)
+{
+  (void) n; (void) m; (void) ptr1; (void) i1; (void) ptr2; (void) i2;
+  rb_raise(rb_eRuntimeError,
+           "CAMonOp(byte_swap): not implemented for this data_type");
+}
+
+/* ------------------------------------------------------------------- */
+/* dispatch table                                                       */
+/* ------------------------------------------------------------------- */
+
+ca_monop_func_t
+ca_monop_byte_swap[CA_NTYPE] = {
+  /* CA_FIXLEN   */ ca_monop_byte_swap_not_impl,
+  /* CA_BOOLEAN  */ ca_monop_byte_swap_boolean_t,
+  /* CA_INT8     */ ca_monop_byte_swap_int8_t,
+  /* CA_UINT8    */ ca_monop_byte_swap_uint8_t,
+  /* CA_INT16    */ ca_monop_byte_swap_int16_t,
+  /* CA_UINT16   */ ca_monop_byte_swap_uint16_t,
+  /* CA_INT32    */ ca_monop_byte_swap_int32_t,
+  /* CA_UINT32   */ ca_monop_byte_swap_uint32_t,
+  /* CA_INT64    */ ca_monop_byte_swap_int64_t,
+  /* CA_UINT64   */ ca_monop_byte_swap_uint64_t,
+  /* CA_FLOAT32  */ ca_monop_byte_swap_float32_t,
+  /* CA_FLOAT64  */ ca_monop_byte_swap_float64_t,
+  /* CA_FLOAT128 */ ca_monop_byte_swap_not_impl,  /* reserved hole */
+  /* CA_CMPLX64  */ ca_monop_byte_swap_cmplx64_t,
+  /* CA_CMPLX128 */ ca_monop_byte_swap_cmplx128_t,
+  /* CA_CMPLX256 */ ca_monop_byte_swap_not_impl,  /* reserved hole */
+  /* CA_OBJECT   */ ca_monop_byte_swap_not_impl,
+};

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

@@ -0,0 +1,316 @@
+/* ---------------------------------------------------------------------------
+
+  Float/Complex ** Integer integer-exponent fast path via
+  binary exponentiation (O(log p)).
+
+  Contents:
+    (1) LAZY kernel table `ca_binop_ipower[CA_NTYPE]` — CABinOp dispatch
+        entry taken when lazy `**` sees an Integer exponent on a
+        Float / Complex receiver.  Called from ca_binop_dispatch.c.
+    (2) EAGER kernels + Ruby surface `pow` / `pow!` (alias `**`).
+        `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).
+
+---------------------------------------------------------------------------- */
+
+#include "carray.h"
+#include "ca_binop_dispatch.h"
+#include "ca_op_powi.h"
+
+/* Defined in ext/carray_kernels.c (mkkernel-generated general pow /
+   cpow binop).  Called by rb_ca_pow{,_bang} when the fast path does
+   not apply (rhs not Integer, or lhs not Float/Complex). */
+extern VALUE rb_ca_power (VALUE self, VALUE other);
+extern VALUE rb_ca_power_bang (VALUE self, VALUE other);
+
+/* ========================================================================== */
+/* (1) LAZY kernel table — CABinOp ipower dispatch                            */
+/* ========================================================================== */
+
+/* Kernel template: T = source/output data_type; right operand is
+   int64_t.  Signature (n, m, ptr1, i1, ptr2, i2, ptr3, i3) mirrors
+   the mkkernel binop kernels so the CABinOp xfer_stride dispatcher
+   calls it uniformly.
+
+   Heterogeneous binop:
+     ptr1 = left  (float32/float64/cmplx64/cmplx128, vector)
+     ptr2 = right (int64,                            scalar via i2=0)
+     ptr3 = dst   (same data_type as left,           vector)
+
+   Output data_type preserves the left data_type (= no cast-before
+   promotion).  CAREFUL: cast-before / promo are overridden for
+   CA_BINOP_IPOWER in ca_binop_dispatch.c; changing this file's
+   dispatch table shape without matching that override leaks integer
+   promotion into the output.
+
+   Non-Float / non-Complex slots are NULL: lazy `**` routes only
+   Float / Complex parents through IPOWER; Integer parents stay on
+   the general CA_BINOP_POW path. */
+
+#define DEFINE_LAZY_IPOWER_KERNEL(T)                                    \
+static void                                                             \
+ca_binop_ipower_##T (ca_size_t n, boolean8_t *m,                        \
+                     char *ptr1, ca_size_t i1,                          \
+                     char *ptr2, ca_size_t i2,                          \
+                     char *ptr3, ca_size_t i3)                          \
+{                                                                       \
+  T       *q1 = (T *) ptr1, *q3 = (T *) ptr3;                           \
+  int64_t *q2 = (int64_t *) ptr2;                                       \
+  T       *p1, *p3;                                                     \
+  int64_t *p2;                                                          \
+  ca_size_t k;                                                          \
+  (void) i2;  /* right is scalar broadcast (i2 == 0), q2 stays put */   \
+  if ( m ) {                                                            \
+    boolean8_t *pm;                                                     \
+    for (k = 0; k < n; k++) {                                           \
+      pm = m + k;                                                       \
+      if ( ! *pm ) {                                                    \
+        p1 = q1 + k*i1;                                                 \
+        p2 = q2 + k*i2;                                                 \
+        p3 = q3 + k*i3;                                                 \
+        *p3 = op_powi_##T(*p1, *p2);                                    \
+      }                                                                 \
+    }                                                                   \
+  } else {                                                              \
+    for (k = 0; k < n; k++) {                                           \
+      p1 = q1 + k*i1;                                                   \
+      p2 = q2 + k*i2;                                                   \
+      p3 = q3 + k*i3;                                                   \
+      *p3 = op_powi_##T(*p1, *p2);                                      \
+    }                                                                   \
+  }                                                                     \
+}
+
+DEFINE_LAZY_IPOWER_KERNEL(float32_t)
+DEFINE_LAZY_IPOWER_KERNEL(float64_t)
+DEFINE_LAZY_IPOWER_KERNEL(cmplx64_t)
+DEFINE_LAZY_IPOWER_KERNEL(cmplx128_t)
+
+#undef DEFINE_LAZY_IPOWER_KERNEL
+
+/* Per-data_type dispatch table — NULL for slots not covered (= integer /
+   bool / object / fixlen / VL).  Indexed by CA_FLOAT32 .. CA_CMPLX128. */
+ca_binop_func_t ca_binop_ipower[CA_NTYPE] = {
+  [CA_FLOAT32]  = ca_binop_ipower_float32_t,
+  [CA_FLOAT64]  = ca_binop_ipower_float64_t,
+  [CA_CMPLX64]  = ca_binop_ipower_cmplx64_t,
+  [CA_CMPLX128] = ca_binop_ipower_cmplx128_t,
+};
+
+/* ========================================================================== */
+/* (2) EAGER kernels + Ruby surface                                            */
+/* ========================================================================== */
+
+/* Per-data_type eager kernel: writes ipower(p1[k], ipow) → p2[k] for each
+   unmasked cell, using stride 1 on both input and output (= eager
+   driver materialises inputs to contig before calling). */
+
+static void
+ca_ipower_float32_t (ca_size_t n, boolean8_t *m,
+                     char *ptr1, int32_t ipow, char *ptr2)
+{
+  float32_t *p1 = (float32_t *) ptr1, *p2 = (float32_t *) ptr2;
+  if ( m ) {
+    while (n--) {
+      if ( ! *m++ ) { *p2 = op_powi_float32_t(*p1, ipow); }
+      p1++; p2++;
+    }
+  }
+  else
+    while (n--) { (*p2) = op_powi_float32_t(*p1, ipow); p1++; p2++; }
+}
+
+static void
+ca_ipower_float64_t (ca_size_t n, boolean8_t *m,
+                     char *ptr1, int32_t ipow, char *ptr2)
+{
+  float64_t *p1 = (float64_t *) ptr1, *p2 = (float64_t *) ptr2;
+  if ( m ) {
+    while (n--) {
+      if ( ! *m++ ) { *p2 = op_powi_float64_t(*p1, ipow); }
+      p1++; p2++;
+    }
+  }
+  else
+    while (n--) { (*p2) = op_powi_float64_t(*p1, ipow); p1++; p2++; }
+}
+
+static void
+ca_ipower_cmplx64_t (ca_size_t n, boolean8_t *m,
+                     char *ptr1, int32_t ipow, char *ptr2)
+{
+  cmplx64_t *p1 = (cmplx64_t *) ptr1, *p2 = (cmplx64_t *) ptr2;
+  if ( m ) {
+    while (n--) {
+      if ( ! *m++ ) { *p2 = op_powi_cmplx64_t(*p1, ipow); }
+      p1++; p2++;
+    }
+  }
+  else
+    while (n--) { (*p2) = op_powi_cmplx64_t(*p1, ipow); p1++; p2++; }
+}
+
+static void
+ca_ipower_cmplx128_t (ca_size_t n, boolean8_t *m,
+                     char *ptr1, int32_t ipow, char *ptr2)
+{
+  cmplx128_t *p1 = (cmplx128_t *) ptr1, *p2 = (cmplx128_t *) ptr2;
+  if ( m ) {
+    while (n--) {
+      if ( ! *m++ ) { *p2 = op_powi_cmplx128_t(*p1, ipow); }
+      p1++; p2++;
+    }
+  }
+  else
+    while (n--) { (*p2) = op_powi_cmplx128_t(*p1, ipow); p1++; p2++; }
+}
+
+/* Eager Float/Complex ** Integer producing a fresh entity output.
+ * ca is input-only, co is the write target.  Mirrors rb_ca_call_monop
+ * (see carray_math* / carray_kernels.c) so operand attach is elided:
+ *   alias-cheap ca -> 1-shot ca_attach, use ca->ptr directly
+ *   otherwise     -> ALLOCV + ca_xfer_all(CA_XFER_GET) into a scratch
+ *                    buffer, no operand attach
+ * Mask goes through ca_mask_overlay_safe (also without an operand
+ * mask attach).  Called by rb_ca_pow when the fast-path predicate
+ * matches. */
+static VALUE
+rb_ca_ipower (VALUE self, VALUE other)
+{
+  volatile VALUE obj;
+  CArray *ca, *co;
+  int32_t ipow;
+  boolean8_t *m;
+
+  ipow = NUM2INT(other);
+
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+
+  co = ca_has_mask(ca) ? ca_template_safe(ca) : ca_template(ca);
+  obj = ca_wrap_struct(co);
+
+  ca_mask_overlay_safe(co, 1, ca);
+  m = ( co->mask ) ? (boolean8_t *)co->mask->ptr : NULL;
+
+  if ( ca_attach_is_alias(ca) ) {
+    ca_attach(ca);
+    switch ( ca->data_type ) {
+    case CA_FLOAT32:
+      ca_ipower_float32_t(ca->elements, m, ca->ptr, ipow, co->ptr);  break;
+    case CA_FLOAT64:
+      ca_ipower_float64_t(ca->elements, m, ca->ptr, ipow, co->ptr);  break;
+    case CA_CMPLX64:
+      ca_ipower_cmplx64_t(ca->elements, m, ca->ptr, ipow, co->ptr);  break;
+    case CA_CMPLX128:
+      ca_ipower_cmplx128_t(ca->elements, m, ca->ptr, ipow, co->ptr); break;
+    default:
+      rb_raise(rb_eCADataTypeError, "invalid data type for ipower");
+    }
+    ca_detach(ca);
+  }
+  else {
+    volatile VALUE h1 = Qnil;
+    char *p1;
+    (void) h1;
+    p1 = ALLOCV_N(char, h1, ca->elements * ca->bytes);
+    ca_xfer_all(ca, p1, CA_XFER_GET);
+    switch ( ca->data_type ) {
+    case CA_FLOAT32:
+      ca_ipower_float32_t(ca->elements, m, p1, ipow, co->ptr);  break;
+    case CA_FLOAT64:
+      ca_ipower_float64_t(ca->elements, m, p1, ipow, co->ptr);  break;
+    case CA_CMPLX64:
+      ca_ipower_cmplx64_t(ca->elements, m, p1, ipow, co->ptr);  break;
+    case CA_CMPLX128:
+      ca_ipower_cmplx128_t(ca->elements, m, p1, ipow, co->ptr); break;
+    default:
+      ALLOCV_END(h1);
+      rb_raise(rb_eCADataTypeError, "invalid data type for ipower");
+    }
+    ALLOCV_END(h1);
+  }
+
+  return obj;
+}
+
+static VALUE
+rb_ca_ipower_bang (VALUE self, VALUE other)
+{
+  CArray *ca;
+  int32_t ipow;
+  boolean8_t *m;
+
+  ipow = NUM2INT(other);
+
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+
+  ca_attach(ca);
+
+  m = ( ca->mask ) ? (boolean8_t *)ca->mask->ptr : NULL;
+
+  switch ( ca->data_type ) {
+  case CA_FLOAT32:
+    ca_ipower_float32_t(ca->elements, m, ca->ptr, ipow, ca->ptr);  break;
+  case CA_FLOAT64:
+    ca_ipower_float64_t(ca->elements, m, ca->ptr, ipow, ca->ptr);  break;
+  case CA_CMPLX64:
+    ca_ipower_cmplx64_t(ca->elements, m, ca->ptr, ipow, ca->ptr);  break;
+  case CA_CMPLX128:
+    ca_ipower_cmplx128_t(ca->elements, m, ca->ptr, ipow, ca->ptr); break;
+  default:
+    rb_raise(rb_eRuntimeError, "invalid data type for ipower");
+  }
+
+  ca_sync(ca);
+  ca_detach(ca);
+
+  return self;
+}
+
+/* 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. */
+static VALUE rb_ca_pow (VALUE self, VALUE other)
+{
+  volatile VALUE obj;
+  CArray *ca;
+
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  if ( ( ca_is_float_type(ca) || ca_is_complex_type(ca) ) &&
+       rb_obj_is_kind_of(other, rb_cInteger) ) {
+    return rb_ca_ipower(self, other);
+  }
+  else {
+    obj = rb_ca_power(self, other);
+    return obj;
+  }
+}
+
+/* CArray#pow!(other) — in-place variant of #pow.  Dispatch mirrors
+ * rb_ca_pow (fast path for Float/Complex ** Integer, otherwise
+ * general rb_ca_power_bang). */
+static VALUE rb_ca_pow_bang (VALUE self, VALUE other)
+{
+  CArray *ca;
+  TypedData_Get_Struct(self, CArray, &carray_data_type, ca);
+  if ( ( ca_is_float_type(ca) || ca_is_complex_type(ca) ) &&
+       rb_obj_is_kind_of(other, rb_cInteger) ) {
+    return rb_ca_ipower_bang(self, other);
+  }
+  else {
+    return rb_ca_power_bang(self, other);
+  }
+}
+
+void
+Init_ca_op_ipower (void)
+{
+  rb_define_method(rb_cCArray, "pow",  rb_ca_pow,      1);
+  rb_define_method(rb_cCArray, "pow!", rb_ca_pow_bang, 1);
+  rb_define_alias(rb_cCArray, "**", "pow");
+}

data/ext/ca_op_powi.h

@@ -0,0 +1,88 @@
+/* ---------------------------------------------------------------------------
+
+   ca_op_powi.h -- shared `op_powi_<type>` integer-power helpers
+
+   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.
+
+   --------------------------------------------------------------------------- */
+
+#ifndef CA_OP_POWI_H
+#define CA_OP_POWI_H
+
+#include "carray.h"
+#include <stdint.h>
+
+#define op_powi(type) \
+static inline type \
+op_powi_## type (type x, int64_t p) \
+{ \
+  type r=1; \
+\
+  switch(p) { \
+  case 2: return x*x; \
+  case 3: return x*x*x; \
+  case 0: return 1; \
+  case 1: return x; \
+  } \
+  if (p<0) { \
+    type den = op_powi_## type(x, -p); \
+    if (den==0) ca_zerodiv(); \
+    return 1/den; \
+  }\
+  while (p) { \
+    if ( (p%2) == 1 ) r *= x; \
+    x *= x; \
+    p /= 2; \
+  } \
+  return r; \
+}
+
+#define op_powi_fc(type) \
+static inline type \
+op_powi_## type (type x, int64_t p) \
+{ \
+  type r=1; \
+\
+  switch(p) { \
+  case 2: return x*x; \
+  case 3: return x*x*x; \
+  case 0: return 1; \
+  case 1: return x; \
+  } \
+  if (p<0) { \
+    type den = op_powi_## type(x, -p); \
+    return 1/den; \
+  }\
+  while (p) { \
+    if ( (p%2) == 1 ) r *= x; \
+    x *= x; \
+    p /= 2; \
+  } \
+  return r; \
+}
+
+op_powi(int8_t)
+op_powi(uint8_t)
+op_powi(int16_t)
+op_powi(uint16_t)
+op_powi(int32_t)
+op_powi(uint32_t)
+op_powi(int64_t)
+op_powi(uint64_t)
+op_powi_fc(float32_t)
+op_powi_fc(float64_t)
+op_powi_fc(cmplx64_t)
+op_powi_fc(cmplx128_t)
+
+#endif /* CA_OP_POWI_H */