carray 2.0.1 → 3.0.1

data/ext/carray_kernels_map.c

@@ -0,0 +1,3467 @@
+/* ---------------------------------------------------------------------------
+
+   carray_kernels.c -- GENERATED by ext/mkkernel.rb -- DO NOT EDIT
+
+   Kernel definitions live in mkkernel.rb (search for `MkKernel.reduce`).
+   Regenerate by running:
+
+     cd ext && ruby mkkernel.rb > carray_kernels.c
+
+   extconf.rb regenerates automatically when mkkernel.rb is touched.
+
+   --------------------------------------------------------------------------- */
+
+#include "carray.h"
+#include "ca_kernel_iterator.h"
+#include "ca_sort_kernels.h"   /* sort kernels: internal, not via the carray.h umbrella */
+#include "carray_internal.h"   /* ca_lazy_arena_*, ca_is_lazy_view (streaming reduce) */
+#include "ca_obj_face.h"       /* rb_ca_strip_face_value (Face ordering gate) */
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>   /* qsort, mergesort (HAVE_MERGESORT) -- for :sort kind */
+
+/* MEMO_REDUCTION_FASTPATH_ENTITY_ONLY_GUARD Tier 2: CAStack identity is
+   probed by operation-table function pointer (obj_type is runtime-
+   assigned, so no CA_OBJ_STACK compile-time constant exists). */
+extern ca_operation_function_t ca_stack_func;
+/* BOOL2VAL: bool -> Ruby (Qtrue/Qfalse).  Used as ruby_scalar wrapper
+   for the all/any flat-reduction Ruby surface so `a.all` / `a.any`
+   return real true/false, not Integer 0/1.  (BOOL2OBJ already exists
+   but returns Integer per CArray's boolean-as-int convention.)  */
+#ifndef CARRAY_BOOL2VAL_DEFINED
+#define CARRAY_BOOL2VAL_DEFINED
+static inline VALUE BOOL2VAL (boolean8_t x) { return x ? Qtrue : Qfalse; }
+#endif
+
+#include "ca_op_powi.h"
+#include "ca_op_cmplx64.h"
+
+/* ===== sqrt_ki ============================================ */
+
+static VALUE
+sqrt_ki_native_i8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int8_t, double, st_in, pi, st_out, po, r = sqrt((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sqrt_ki_native_u8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint8_t, double, st_in, pi, st_out, po, r = sqrt((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sqrt_ki_native_i16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int16_t, double, st_in, pi, st_out, po, r = sqrt((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sqrt_ki_native_u16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint16_t, double, st_in, pi, st_out, po, r = sqrt((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sqrt_ki_native_i32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int32_t, double, st_in, pi, st_out, po, r = sqrt((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sqrt_ki_native_u32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint32_t, double, st_in, pi, st_out, po, r = sqrt((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sqrt_ki_native_i64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int64_t, double, st_in, pi, st_out, po, r = sqrt((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sqrt_ki_native_u64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint64_t, double, st_in, pi, st_out, po, r = sqrt((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sqrt_ki_native_f32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(float, double, st_in, pi, st_out, po, r = sqrt((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sqrt_ki_native_f64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sqrt_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(double, double, st_in, pi, st_out, po, r = sqrt((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_sqrt_ki (VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  switch ( src->data_type ) {
+    case CA_INT8: return sqrt_ki_native_i8(self, src);
+    case CA_UINT8: return sqrt_ki_native_u8(self, src);
+    case CA_INT16: return sqrt_ki_native_i16(self, src);
+    case CA_UINT16: return sqrt_ki_native_u16(self, src);
+    case CA_INT32: return sqrt_ki_native_i32(self, src);
+    case CA_UINT32: return sqrt_ki_native_u32(self, src);
+    case CA_INT64: return sqrt_ki_native_i64(self, src);
+    case CA_UINT64: return sqrt_ki_native_u64(self, src);
+    case CA_FLOAT32: return sqrt_ki_native_f32(self, src);
+    case CA_FLOAT64: return sqrt_ki_native_f64(self, src);
+    default: {
+      /* Phase E: only wrap data_types that have a meaningful float64
+         representation.  Complex / fixlen / object would lose
+         structure (e.g. complex -> float strips imaginary part)
+         so reject explicitly, matching legacy DataTypeError. */
+      switch ( src->data_type ) {
+        case CA_BOOLEAN: break;   /* wrap: count-of-trues semantic */
+        default:
+          rb_raise(rb_eCADataTypeError, "sqrt_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, or boolean)", ca_type_name[src->data_type]);
+      }
+      VALUE   vsrc = rb_ca_wrap_readonly(self, INT2NUM(CA_FLOAT64));
+      CArray *casted;
+      GetCArray(vsrc, casted);
+      return sqrt_ki_native_f64(vsrc, casted);
+    }
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== sin_ki ============================================ */
+
+static VALUE
+sin_ki_native_i8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int8_t, double, st_in, pi, st_out, po, r = sin((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sin_ki_native_u8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint8_t, double, st_in, pi, st_out, po, r = sin((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sin_ki_native_i16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int16_t, double, st_in, pi, st_out, po, r = sin((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sin_ki_native_u16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint16_t, double, st_in, pi, st_out, po, r = sin((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sin_ki_native_i32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int32_t, double, st_in, pi, st_out, po, r = sin((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sin_ki_native_u32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint32_t, double, st_in, pi, st_out, po, r = sin((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sin_ki_native_i64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int64_t, double, st_in, pi, st_out, po, r = sin((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sin_ki_native_u64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint64_t, double, st_in, pi, st_out, po, r = sin((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sin_ki_native_f32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(float, double, st_in, pi, st_out, po, r = sin((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+sin_ki_native_f64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "sin_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(double, double, st_in, pi, st_out, po, r = sin((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_sin_ki (VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  switch ( src->data_type ) {
+    case CA_INT8: return sin_ki_native_i8(self, src);
+    case CA_UINT8: return sin_ki_native_u8(self, src);
+    case CA_INT16: return sin_ki_native_i16(self, src);
+    case CA_UINT16: return sin_ki_native_u16(self, src);
+    case CA_INT32: return sin_ki_native_i32(self, src);
+    case CA_UINT32: return sin_ki_native_u32(self, src);
+    case CA_INT64: return sin_ki_native_i64(self, src);
+    case CA_UINT64: return sin_ki_native_u64(self, src);
+    case CA_FLOAT32: return sin_ki_native_f32(self, src);
+    case CA_FLOAT64: return sin_ki_native_f64(self, src);
+    default: {
+      /* Phase E: only wrap data_types that have a meaningful float64
+         representation.  Complex / fixlen / object would lose
+         structure (e.g. complex -> float strips imaginary part)
+         so reject explicitly, matching legacy DataTypeError. */
+      switch ( src->data_type ) {
+        case CA_BOOLEAN: break;   /* wrap: count-of-trues semantic */
+        default:
+          rb_raise(rb_eCADataTypeError, "sin_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, or boolean)", ca_type_name[src->data_type]);
+      }
+      VALUE   vsrc = rb_ca_wrap_readonly(self, INT2NUM(CA_FLOAT64));
+      CArray *casted;
+      GetCArray(vsrc, casted);
+      return sin_ki_native_f64(vsrc, casted);
+    }
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== cos_ki ============================================ */
+
+static VALUE
+cos_ki_native_i8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int8_t, double, st_in, pi, st_out, po, r = cos((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cos_ki_native_u8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint8_t, double, st_in, pi, st_out, po, r = cos((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cos_ki_native_i16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int16_t, double, st_in, pi, st_out, po, r = cos((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cos_ki_native_u16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint16_t, double, st_in, pi, st_out, po, r = cos((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cos_ki_native_i32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int32_t, double, st_in, pi, st_out, po, r = cos((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cos_ki_native_u32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint32_t, double, st_in, pi, st_out, po, r = cos((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cos_ki_native_i64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int64_t, double, st_in, pi, st_out, po, r = cos((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cos_ki_native_u64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint64_t, double, st_in, pi, st_out, po, r = cos((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cos_ki_native_f32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(float, double, st_in, pi, st_out, po, r = cos((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cos_ki_native_f64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "cos_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(double, double, st_in, pi, st_out, po, r = cos((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_cos_ki (VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  switch ( src->data_type ) {
+    case CA_INT8: return cos_ki_native_i8(self, src);
+    case CA_UINT8: return cos_ki_native_u8(self, src);
+    case CA_INT16: return cos_ki_native_i16(self, src);
+    case CA_UINT16: return cos_ki_native_u16(self, src);
+    case CA_INT32: return cos_ki_native_i32(self, src);
+    case CA_UINT32: return cos_ki_native_u32(self, src);
+    case CA_INT64: return cos_ki_native_i64(self, src);
+    case CA_UINT64: return cos_ki_native_u64(self, src);
+    case CA_FLOAT32: return cos_ki_native_f32(self, src);
+    case CA_FLOAT64: return cos_ki_native_f64(self, src);
+    default: {
+      /* Phase E: only wrap data_types that have a meaningful float64
+         representation.  Complex / fixlen / object would lose
+         structure (e.g. complex -> float strips imaginary part)
+         so reject explicitly, matching legacy DataTypeError. */
+      switch ( src->data_type ) {
+        case CA_BOOLEAN: break;   /* wrap: count-of-trues semantic */
+        default:
+          rb_raise(rb_eCADataTypeError, "cos_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, or boolean)", ca_type_name[src->data_type]);
+      }
+      VALUE   vsrc = rb_ca_wrap_readonly(self, INT2NUM(CA_FLOAT64));
+      CArray *casted;
+      GetCArray(vsrc, casted);
+      return cos_ki_native_f64(vsrc, casted);
+    }
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== exp_ki ============================================ */
+
+static VALUE
+exp_ki_native_i8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int8_t, double, st_in, pi, st_out, po, r = exp((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+exp_ki_native_u8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint8_t, double, st_in, pi, st_out, po, r = exp((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+exp_ki_native_i16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int16_t, double, st_in, pi, st_out, po, r = exp((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+exp_ki_native_u16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint16_t, double, st_in, pi, st_out, po, r = exp((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+exp_ki_native_i32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int32_t, double, st_in, pi, st_out, po, r = exp((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+exp_ki_native_u32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint32_t, double, st_in, pi, st_out, po, r = exp((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+exp_ki_native_i64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int64_t, double, st_in, pi, st_out, po, r = exp((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+exp_ki_native_u64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint64_t, double, st_in, pi, st_out, po, r = exp((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+exp_ki_native_f32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(float, double, st_in, pi, st_out, po, r = exp((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+exp_ki_native_f64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "exp_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(double, double, st_in, pi, st_out, po, r = exp((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_exp_ki (VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  switch ( src->data_type ) {
+    case CA_INT8: return exp_ki_native_i8(self, src);
+    case CA_UINT8: return exp_ki_native_u8(self, src);
+    case CA_INT16: return exp_ki_native_i16(self, src);
+    case CA_UINT16: return exp_ki_native_u16(self, src);
+    case CA_INT32: return exp_ki_native_i32(self, src);
+    case CA_UINT32: return exp_ki_native_u32(self, src);
+    case CA_INT64: return exp_ki_native_i64(self, src);
+    case CA_UINT64: return exp_ki_native_u64(self, src);
+    case CA_FLOAT32: return exp_ki_native_f32(self, src);
+    case CA_FLOAT64: return exp_ki_native_f64(self, src);
+    default: {
+      /* Phase E: only wrap data_types that have a meaningful float64
+         representation.  Complex / fixlen / object would lose
+         structure (e.g. complex -> float strips imaginary part)
+         so reject explicitly, matching legacy DataTypeError. */
+      switch ( src->data_type ) {
+        case CA_BOOLEAN: break;   /* wrap: count-of-trues semantic */
+        default:
+          rb_raise(rb_eCADataTypeError, "exp_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, or boolean)", ca_type_name[src->data_type]);
+      }
+      VALUE   vsrc = rb_ca_wrap_readonly(self, INT2NUM(CA_FLOAT64));
+      CArray *casted;
+      GetCArray(vsrc, casted);
+      return exp_ki_native_f64(vsrc, casted);
+    }
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== log_ki ============================================ */
+
+static VALUE
+log_ki_native_i8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "log_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "log_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int8_t, double, st_in, pi, st_out, po, r = log((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+log_ki_native_u8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "log_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "log_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint8_t, double, st_in, pi, st_out, po, r = log((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+log_ki_native_i16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "log_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "log_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int16_t, double, st_in, pi, st_out, po, r = log((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+log_ki_native_u16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "log_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "log_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint16_t, double, st_in, pi, st_out, po, r = log((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+log_ki_native_i32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "log_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "log_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int32_t, double, st_in, pi, st_out, po, r = log((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+log_ki_native_u32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "log_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "log_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint32_t, double, st_in, pi, st_out, po, r = log((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+log_ki_native_i64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "log_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "log_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int64_t, double, st_in, pi, st_out, po, r = log((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+log_ki_native_u64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "log_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "log_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint64_t, double, st_in, pi, st_out, po, r = log((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+log_ki_native_f32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "log_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "log_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(float, double, st_in, pi, st_out, po, r = log((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+log_ki_native_f64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "log_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "log_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(double, double, st_in, pi, st_out, po, r = log((double) v));
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_log_ki (VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  switch ( src->data_type ) {
+    case CA_INT8: return log_ki_native_i8(self, src);
+    case CA_UINT8: return log_ki_native_u8(self, src);
+    case CA_INT16: return log_ki_native_i16(self, src);
+    case CA_UINT16: return log_ki_native_u16(self, src);
+    case CA_INT32: return log_ki_native_i32(self, src);
+    case CA_UINT32: return log_ki_native_u32(self, src);
+    case CA_INT64: return log_ki_native_i64(self, src);
+    case CA_UINT64: return log_ki_native_u64(self, src);
+    case CA_FLOAT32: return log_ki_native_f32(self, src);
+    case CA_FLOAT64: return log_ki_native_f64(self, src);
+    default: {
+      /* Phase E: only wrap data_types that have a meaningful float64
+         representation.  Complex / fixlen / object would lose
+         structure (e.g. complex -> float strips imaginary part)
+         so reject explicitly, matching legacy DataTypeError. */
+      switch ( src->data_type ) {
+        case CA_BOOLEAN: break;   /* wrap: count-of-trues semantic */
+        default:
+          rb_raise(rb_eCADataTypeError, "log_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, or boolean)", ca_type_name[src->data_type]);
+      }
+      VALUE   vsrc = rb_ca_wrap_readonly(self, INT2NUM(CA_FLOAT64));
+      CArray *casted;
+      GetCArray(vsrc, casted);
+      return log_ki_native_f64(vsrc, casted);
+    }
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== square_ki ============================================ */
+
+static VALUE
+square_ki_native_i8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT8),
+                                          INT2NUM(sizeof(int8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "square_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "square_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int8_t, int8_t, st_in, pi, st_out, po, r = v * v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+square_ki_native_u8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT8),
+                                          INT2NUM(sizeof(uint8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "square_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "square_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint8_t, uint8_t, st_in, pi, st_out, po, r = v * v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+square_ki_native_i16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT16),
+                                          INT2NUM(sizeof(int16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "square_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "square_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int16_t, int16_t, st_in, pi, st_out, po, r = v * v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+square_ki_native_u16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT16),
+                                          INT2NUM(sizeof(uint16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "square_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "square_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint16_t, uint16_t, st_in, pi, st_out, po, r = v * v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+square_ki_native_i32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT32),
+                                          INT2NUM(sizeof(int32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "square_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "square_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int32_t, int32_t, st_in, pi, st_out, po, r = v * v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+square_ki_native_u32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT32),
+                                          INT2NUM(sizeof(uint32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "square_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "square_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint32_t, uint32_t, st_in, pi, st_out, po, r = v * v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+square_ki_native_i64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "square_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "square_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int64_t, int64_t, st_in, pi, st_out, po, r = v * v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+square_ki_native_u64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT64),
+                                          INT2NUM(sizeof(uint64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "square_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "square_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(uint64_t, uint64_t, st_in, pi, st_out, po, r = v * v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+square_ki_native_f32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT32),
+                                          INT2NUM(sizeof(float)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "square_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "square_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(float, float, st_in, pi, st_out, po, r = v * v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+square_ki_native_f64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "square_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "square_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(double, double, st_in, pi, st_out, po, r = v * v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_square_ki (VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  switch ( src->data_type ) {
+    case CA_INT8: return square_ki_native_i8(self, src);
+    case CA_UINT8: return square_ki_native_u8(self, src);
+    case CA_INT16: return square_ki_native_i16(self, src);
+    case CA_UINT16: return square_ki_native_u16(self, src);
+    case CA_INT32: return square_ki_native_i32(self, src);
+    case CA_UINT32: return square_ki_native_u32(self, src);
+    case CA_INT64: return square_ki_native_i64(self, src);
+    case CA_UINT64: return square_ki_native_u64(self, src);
+    case CA_FLOAT32: return square_ki_native_f32(self, src);
+    case CA_FLOAT64: return square_ki_native_f64(self, src);
+    default:
+      rb_raise(rb_eCADataTypeError, "square_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64)", ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== abs_ki ============================================ */
+
+static VALUE
+abs_ki_native_i8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT8),
+                                          INT2NUM(sizeof(int8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int8_t, int8_t, st_in, pi, st_out, po, r = (v < 0) ? -v : v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+abs_ki_native_i16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT16),
+                                          INT2NUM(sizeof(int16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int16_t, int16_t, st_in, pi, st_out, po, r = (v < 0) ? -v : v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+abs_ki_native_i32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT32),
+                                          INT2NUM(sizeof(int32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int32_t, int32_t, st_in, pi, st_out, po, r = (v < 0) ? -v : v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+abs_ki_native_i64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int64_t, int64_t, st_in, pi, st_out, po, r = (v < 0) ? -v : v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+abs_ki_native_f32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT32),
+                                          INT2NUM(sizeof(float)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(float, float, st_in, pi, st_out, po, r = (v < 0) ? -v : v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+abs_ki_native_f64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "abs_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(double, double, st_in, pi, st_out, po, r = (v < 0) ? -v : v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_abs_ki (VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  switch ( src->data_type ) {
+    case CA_INT8: return abs_ki_native_i8(self, src);
+    case CA_INT16: return abs_ki_native_i16(self, src);
+    case CA_INT32: return abs_ki_native_i32(self, src);
+    case CA_INT64: return abs_ki_native_i64(self, src);
+    case CA_FLOAT32: return abs_ki_native_f32(self, src);
+    case CA_FLOAT64: return abs_ki_native_f64(self, src);
+    default:
+      rb_raise(rb_eCADataTypeError, "abs_ki: source data_type :%s not supported (expected one of: i8, i16, i32, i64, f32, f64)", ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== negate_ki ============================================ */
+
+static VALUE
+negate_ki_native_i8 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT8),
+                                          INT2NUM(sizeof(int8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int8_t, int8_t, st_in, pi, st_out, po, r = -v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+negate_ki_native_i16 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT16),
+                                          INT2NUM(sizeof(int16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int16_t, int16_t, st_in, pi, st_out, po, r = -v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+negate_ki_native_i32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT32),
+                                          INT2NUM(sizeof(int32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int32_t, int32_t, st_in, pi, st_out, po, r = -v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+negate_ki_native_i64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(int64_t, int64_t, st_in, pi, st_out, po, r = -v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+negate_ki_native_f32 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT32),
+                                          INT2NUM(sizeof(float)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(float, float, st_in, pi, st_out, po, r = -v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+negate_ki_native_f64 (VALUE self, CArray *ca)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_FLOAT64),
+                                          INT2NUM(sizeof(double)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* All-axes slab = whole array as one K-D walk via CA_SLAB_AXES.
+     CA_SLAB_WHOLE uses the flat next_slab path, which doesn't
+     populate slab_dims; CA_SLAB_AXES with naxes == ndim is the
+     K-D-walkable form. */
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = ca->ndim;
+  for ( int8_t k = 0; k < naxes; k++ ) slab_axes[k] = k;
+
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: input init failed rc=%d", rc);
+  }
+  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+                             slab_axes, naxes, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "negate_ki: output init failed rc=%d", rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_MAP_T(double, double, st_in, pi, st_out, po, r = -v);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_negate_ki (VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  switch ( src->data_type ) {
+    case CA_INT8: return negate_ki_native_i8(self, src);
+    case CA_INT16: return negate_ki_native_i16(self, src);
+    case CA_INT32: return negate_ki_native_i32(self, src);
+    case CA_INT64: return negate_ki_native_i64(self, src);
+    case CA_FLOAT32: return negate_ki_native_f32(self, src);
+    case CA_FLOAT64: return negate_ki_native_f64(self, src);
+    default:
+      rb_raise(rb_eCADataTypeError, "negate_ki: source data_type :%s not supported (expected one of: i8, i16, i32, i64, f32, f64)", ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+void
+Init_carray_kernels_map (void)
+{
+  rb_define_method(rb_cCArray, "sqrt_ki", rb_ca_sqrt_ki, 0);
+  rb_define_method(rb_cCArray, "sin_ki", rb_ca_sin_ki, 0);
+  rb_define_method(rb_cCArray, "cos_ki", rb_ca_cos_ki, 0);
+  rb_define_method(rb_cCArray, "exp_ki", rb_ca_exp_ki, 0);
+  rb_define_method(rb_cCArray, "log_ki", rb_ca_log_ki, 0);
+  rb_define_method(rb_cCArray, "square_ki", rb_ca_square_ki, 0);
+  rb_define_method(rb_cCArray, "abs_ki", rb_ca_abs_ki, 0);
+  rb_define_method(rb_cCArray, "negate_ki", rb_ca_negate_ki, 0);
+}