carray 3.0.3 → 3.0.4

data/ext/carray_kernels_reduce_variance.c

@@ -0,0 +1,3849 @@
+/* ---------------------------------------------------------------------------
+
+   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;
+/* The square root of a variance: an ε-negative from rounding becomes 0,
+   a NaN stays NaN (fmax(NaN, 0.0) is 0.0). */
+#ifndef CARRAY_SQRT_CLAMP_DEFINED
+#define CARRAY_SQRT_CLAMP_DEFINED
+static inline double ca_sqrt_clamp (double v) { return sqrt(v < 0.0 ? 0.0 : v); }
+#endif
+
+/* 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"
+
+/* ===== variancep_ki ============================================ */
+
+#define __variancep_i8_P1EXPR(__x) ((double)(__x))
+#define __variancep_i8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variancep_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, sum, 0.0, __variancep_i8_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, M2, 0.0, __variancep_i8_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_i8_P1EXPR
+#undef __variancep_i8_P2EXPR
+
+#define __variancep_u8_P1EXPR(__x) ((double)(__x))
+#define __variancep_u8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variancep_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, sum, 0.0, __variancep_u8_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, M2, 0.0, __variancep_u8_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_u8_P1EXPR
+#undef __variancep_u8_P2EXPR
+
+#define __variancep_i16_P1EXPR(__x) ((double)(__x))
+#define __variancep_i16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variancep_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int16_t, double, st, p, m, sum, 0.0, __variancep_i16_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int16_t, double, st, p, m, M2, 0.0, __variancep_i16_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_i16_P1EXPR
+#undef __variancep_i16_P2EXPR
+
+#define __variancep_u16_P1EXPR(__x) ((double)(__x))
+#define __variancep_u16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variancep_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint16_t, double, st, p, m, sum, 0.0, __variancep_u16_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint16_t, double, st, p, m, M2, 0.0, __variancep_u16_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_u16_P1EXPR
+#undef __variancep_u16_P2EXPR
+
+#define __variancep_i32_P1EXPR(__x) ((double)(__x))
+#define __variancep_i32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variancep_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int32_t, double, st, p, m, sum, 0.0, __variancep_i32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int32_t, double, st, p, m, M2, 0.0, __variancep_i32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_i32_P1EXPR
+#undef __variancep_i32_P2EXPR
+
+#define __variancep_u32_P1EXPR(__x) ((double)(__x))
+#define __variancep_u32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variancep_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint32_t, double, st, p, m, sum, 0.0, __variancep_u32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint32_t, double, st, p, m, M2, 0.0, __variancep_u32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_u32_P1EXPR
+#undef __variancep_u32_P2EXPR
+
+#define __variancep_i64_P1EXPR(__x) ((double)(__x))
+#define __variancep_i64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variancep_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int64_t, double, st, p, m, sum, 0.0, __variancep_i64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int64_t, double, st, p, m, M2, 0.0, __variancep_i64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_i64_P1EXPR
+#undef __variancep_i64_P2EXPR
+
+#define __variancep_u64_P1EXPR(__x) ((double)(__x))
+#define __variancep_u64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variancep_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint64_t, double, st, p, m, sum, 0.0, __variancep_u64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint64_t, double, st, p, m, M2, 0.0, __variancep_u64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_u64_P1EXPR
+#undef __variancep_u64_P2EXPR
+
+#define __variancep_f32_P1EXPR(__x) ((double)(__x))
+#define __variancep_f32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variancep_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(float, double, st, p, m, sum, 0.0, __variancep_f32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(float, double, st, p, m, M2, 0.0, __variancep_f32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_f32_P1EXPR
+#undef __variancep_f32_P2EXPR
+
+#define __variancep_f64_P1EXPR(__x) ((double)(__x))
+#define __variancep_f64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variancep_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(double, double, st, p, m, sum, 0.0, __variancep_f64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(double, double, st, p, m, M2, 0.0, __variancep_f64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_f64_P1EXPR
+#undef __variancep_f64_P2EXPR
+
+#define __variancep_cmplx64_P1EXPR(__x) (__x)
+#define __variancep_cmplx64_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+static VALUE
+variancep_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    cmplx64_t sum = 0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(cmplx64_t, cmplx64_t, st, p, m, sum, 0, __variancep_cmplx64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      cmplx64_t mean = sum / (cmplx64_t)(double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(cmplx64_t, double, st, p, m, M2, 0.0, __variancep_cmplx64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_cmplx64_P1EXPR
+#undef __variancep_cmplx64_P2EXPR
+
+#define __variancep_cmplx128_P1EXPR(__x) (__x)
+#define __variancep_cmplx128_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+static VALUE
+variancep_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    cmplx128_t sum = 0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(cmplx128_t, cmplx128_t, st, p, m, sum, 0, __variancep_cmplx128_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      cmplx128_t mean = sum / (cmplx128_t)(double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(cmplx128_t, double, st, p, m, M2, 0.0, __variancep_cmplx128_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_cmplx128_P1EXPR
+#undef __variancep_cmplx128_P2EXPR
+
+#define __variancep_bool_P1EXPR(__x) ((double)(__x))
+#define __variancep_bool_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variancep_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(boolean8_t, double, st, p, m, sum, 0.0, __variancep_bool_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(boolean8_t, double, st, p, m, M2, 0.0, __variancep_bool_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variancep_bool_P1EXPR
+#undef __variancep_bool_P2EXPR
+
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} variancep_ki_native_object_frame;
+
+static VALUE
+variancep_ki_native_object_body (VALUE arg)
+{
+  variancep_ki_native_object_frame *fr = (variancep_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_OBJECT, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  VALUE *op = (VALUE *) co->ptr;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    VALUE sum = INT2FIX(0);
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_T_EX(VALUE, st, p, m, sum, INT2FIX(0), sum = rb_funcall(sum, rb_intern("+"), 1, v), masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (VALUE) INT2FIX(0);
+    } else {
+      VALUE mean = rb_funcall(sum, rb_intern("/"), 1, LONG2NUM(n_valid));
+      /* Pass 2: M2 = Σ (x - mean)² */
+      VALUE M2 = INT2FIX(0);
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_T_EX(VALUE, st, p, m, M2, INT2FIX(0), VALUE __d = rb_funcall(v, rb_intern("-"), 1, mean);
+M2 = rb_funcall(M2, rb_intern("+"), 1, rb_funcall(__d, rb_intern("*"), 1, __d)), __unused_mc);
+      op[out_i++] = (VALUE)(rb_funcall(M2, rb_intern("/"), 1, LONG2NUM(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return (VALUE)(op[0]);
+  }
+  return vout;
+#undef st
+}
+
+static VALUE
+variancep_ki_native_object (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variancep_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, variancep_ki_native_object_body, (VALUE) &fr);
+}
+
+
+VALUE
+rb_ca_variancep_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil, rkeep_axis = Qnil, rmin_count = Qnil, rfval = Qnil;
+  rb_scan_options(ropt, "axis,keep_axis,min_count,fill_value", &raxis, &rkeep_axis, &rmin_count, &rfval);
+  int keep_axis = RTEST(rkeep_axis);
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = rb_ca_parse_reduce_axes_kw(raxis, src, slab_axes);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  ca_size_t min_count = ca_min_count_arg(rmin_count, NULL);
+  if ( rfval == CA_UNDEF ) rfval = Qnil;
+  int fill_whole = 0;
+  if ( ! NIL_P(rfval) && naxes == src->ndim && ! keep_axis ) {
+    keep_axis  = 1;
+    fill_whole = 1;
+  }
+  VALUE result;
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis arguments are no longer accepted (got %d); use the axis: keyword, e.g. a.%s(axis: 0) or a.%s(axis: [0, 1])", ca_calling_method_name(), argc, ca_calling_method_name(), ca_calling_method_name());
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: {
+      result = variancep_ki_native_i8(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT8: {
+      result = variancep_ki_native_u8(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT16: {
+      result = variancep_ki_native_i16(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT16: {
+      result = variancep_ki_native_u16(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT32: {
+      result = variancep_ki_native_i32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT32: {
+      result = variancep_ki_native_u32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT64: {
+      result = variancep_ki_native_i64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT64: {
+      result = variancep_ki_native_u64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_FLOAT32: {
+      result = variancep_ki_native_f32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_FLOAT64: {
+      result = variancep_ki_native_f64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_CMPLX64: {
+      result = variancep_ki_native_cmplx64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_CMPLX128: {
+      result = variancep_ki_native_cmplx128(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_BOOLEAN: {
+      result = variancep_ki_native_bool(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_OBJECT: {
+      result = variancep_ki_native_object(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  if ( ! NIL_P(rfval) ) {
+    result = ca_reduce_fill(result, rfval, fill_whole);
+  }
+  return result;
+}
+
+/* ===== variance_ki ============================================ */
+
+#define __variance_i8_P1EXPR(__x) ((double)(__x))
+#define __variance_i8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variance_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, sum, 0.0, __variance_i8_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, M2, 0.0, __variance_i8_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_i8_P1EXPR
+#undef __variance_i8_P2EXPR
+
+#define __variance_u8_P1EXPR(__x) ((double)(__x))
+#define __variance_u8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variance_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, sum, 0.0, __variance_u8_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, M2, 0.0, __variance_u8_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_u8_P1EXPR
+#undef __variance_u8_P2EXPR
+
+#define __variance_i16_P1EXPR(__x) ((double)(__x))
+#define __variance_i16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variance_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int16_t, double, st, p, m, sum, 0.0, __variance_i16_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int16_t, double, st, p, m, M2, 0.0, __variance_i16_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_i16_P1EXPR
+#undef __variance_i16_P2EXPR
+
+#define __variance_u16_P1EXPR(__x) ((double)(__x))
+#define __variance_u16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variance_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint16_t, double, st, p, m, sum, 0.0, __variance_u16_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint16_t, double, st, p, m, M2, 0.0, __variance_u16_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_u16_P1EXPR
+#undef __variance_u16_P2EXPR
+
+#define __variance_i32_P1EXPR(__x) ((double)(__x))
+#define __variance_i32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variance_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int32_t, double, st, p, m, sum, 0.0, __variance_i32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int32_t, double, st, p, m, M2, 0.0, __variance_i32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_i32_P1EXPR
+#undef __variance_i32_P2EXPR
+
+#define __variance_u32_P1EXPR(__x) ((double)(__x))
+#define __variance_u32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variance_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint32_t, double, st, p, m, sum, 0.0, __variance_u32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint32_t, double, st, p, m, M2, 0.0, __variance_u32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_u32_P1EXPR
+#undef __variance_u32_P2EXPR
+
+#define __variance_i64_P1EXPR(__x) ((double)(__x))
+#define __variance_i64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variance_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int64_t, double, st, p, m, sum, 0.0, __variance_i64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int64_t, double, st, p, m, M2, 0.0, __variance_i64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_i64_P1EXPR
+#undef __variance_i64_P2EXPR
+
+#define __variance_u64_P1EXPR(__x) ((double)(__x))
+#define __variance_u64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variance_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint64_t, double, st, p, m, sum, 0.0, __variance_u64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint64_t, double, st, p, m, M2, 0.0, __variance_u64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_u64_P1EXPR
+#undef __variance_u64_P2EXPR
+
+#define __variance_f32_P1EXPR(__x) ((double)(__x))
+#define __variance_f32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variance_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(float, double, st, p, m, sum, 0.0, __variance_f32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(float, double, st, p, m, M2, 0.0, __variance_f32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_f32_P1EXPR
+#undef __variance_f32_P2EXPR
+
+#define __variance_f64_P1EXPR(__x) ((double)(__x))
+#define __variance_f64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variance_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(double, double, st, p, m, sum, 0.0, __variance_f64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(double, double, st, p, m, M2, 0.0, __variance_f64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_f64_P1EXPR
+#undef __variance_f64_P2EXPR
+
+#define __variance_cmplx64_P1EXPR(__x) (__x)
+#define __variance_cmplx64_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+static VALUE
+variance_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    cmplx64_t sum = 0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(cmplx64_t, cmplx64_t, st, p, m, sum, 0, __variance_cmplx64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      cmplx64_t mean = sum / (cmplx64_t)(double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(cmplx64_t, double, st, p, m, M2, 0.0, __variance_cmplx64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_cmplx64_P1EXPR
+#undef __variance_cmplx64_P2EXPR
+
+#define __variance_cmplx128_P1EXPR(__x) (__x)
+#define __variance_cmplx128_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+static VALUE
+variance_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    cmplx128_t sum = 0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(cmplx128_t, cmplx128_t, st, p, m, sum, 0, __variance_cmplx128_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      cmplx128_t mean = sum / (cmplx128_t)(double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(cmplx128_t, double, st, p, m, M2, 0.0, __variance_cmplx128_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_cmplx128_P1EXPR
+#undef __variance_cmplx128_P2EXPR
+
+#define __variance_bool_P1EXPR(__x) ((double)(__x))
+#define __variance_bool_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+variance_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(boolean8_t, double, st, p, m, sum, 0.0, __variance_bool_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(boolean8_t, double, st, p, m, M2, 0.0, __variance_bool_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(M2 / (double)(n_valid - 1));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __variance_bool_P1EXPR
+#undef __variance_bool_P2EXPR
+
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} variance_ki_native_object_frame;
+
+static VALUE
+variance_ki_native_object_body (VALUE arg)
+{
+  variance_ki_native_object_frame *fr = (variance_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_OBJECT, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  VALUE *op = (VALUE *) co->ptr;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    VALUE sum = INT2FIX(0);
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_T_EX(VALUE, st, p, m, sum, INT2FIX(0), sum = rb_funcall(sum, rb_intern("+"), 1, v), masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (VALUE) INT2FIX(0);
+    } else {
+      VALUE mean = rb_funcall(sum, rb_intern("/"), 1, LONG2NUM(n_valid));
+      /* Pass 2: M2 = Σ (x - mean)² */
+      VALUE M2 = INT2FIX(0);
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_T_EX(VALUE, st, p, m, M2, INT2FIX(0), VALUE __d = rb_funcall(v, rb_intern("-"), 1, mean);
+M2 = rb_funcall(M2, rb_intern("+"), 1, rb_funcall(__d, rb_intern("*"), 1, __d)), __unused_mc);
+      op[out_i++] = (VALUE)(rb_funcall(M2, rb_intern("/"), 1, LONG2NUM(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return (VALUE)(op[0]);
+  }
+  return vout;
+#undef st
+}
+
+static VALUE
+variance_ki_native_object (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  variance_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, variance_ki_native_object_body, (VALUE) &fr);
+}
+
+
+VALUE
+rb_ca_variance_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil, rkeep_axis = Qnil, rmin_count = Qnil, rfval = Qnil;
+  rb_scan_options(ropt, "axis,keep_axis,min_count,fill_value", &raxis, &rkeep_axis, &rmin_count, &rfval);
+  int keep_axis = RTEST(rkeep_axis);
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = rb_ca_parse_reduce_axes_kw(raxis, src, slab_axes);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  ca_size_t min_count = ca_min_count_arg(rmin_count, NULL);
+  if ( rfval == CA_UNDEF ) rfval = Qnil;
+  int fill_whole = 0;
+  if ( ! NIL_P(rfval) && naxes == src->ndim && ! keep_axis ) {
+    keep_axis  = 1;
+    fill_whole = 1;
+  }
+  VALUE result;
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis arguments are no longer accepted (got %d); use the axis: keyword, e.g. a.%s(axis: 0) or a.%s(axis: [0, 1])", ca_calling_method_name(), argc, ca_calling_method_name(), ca_calling_method_name());
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: {
+      result = variance_ki_native_i8(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT8: {
+      result = variance_ki_native_u8(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT16: {
+      result = variance_ki_native_i16(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT16: {
+      result = variance_ki_native_u16(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT32: {
+      result = variance_ki_native_i32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT32: {
+      result = variance_ki_native_u32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT64: {
+      result = variance_ki_native_i64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT64: {
+      result = variance_ki_native_u64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_FLOAT32: {
+      result = variance_ki_native_f32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_FLOAT64: {
+      result = variance_ki_native_f64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_CMPLX64: {
+      result = variance_ki_native_cmplx64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_CMPLX128: {
+      result = variance_ki_native_cmplx128(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_BOOLEAN: {
+      result = variance_ki_native_bool(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_OBJECT: {
+      result = variance_ki_native_object(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  if ( ! NIL_P(rfval) ) {
+    result = ca_reduce_fill(result, rfval, fill_whole);
+  }
+  return result;
+}
+
+/* ===== stddevp_ki ============================================ */
+
+#define __stddevp_i8_P1EXPR(__x) ((double)(__x))
+#define __stddevp_i8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddevp_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, sum, 0.0, __stddevp_i8_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, M2, 0.0, __stddevp_i8_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_i8_P1EXPR
+#undef __stddevp_i8_P2EXPR
+
+#define __stddevp_u8_P1EXPR(__x) ((double)(__x))
+#define __stddevp_u8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddevp_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, sum, 0.0, __stddevp_u8_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, M2, 0.0, __stddevp_u8_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_u8_P1EXPR
+#undef __stddevp_u8_P2EXPR
+
+#define __stddevp_i16_P1EXPR(__x) ((double)(__x))
+#define __stddevp_i16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddevp_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int16_t, double, st, p, m, sum, 0.0, __stddevp_i16_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int16_t, double, st, p, m, M2, 0.0, __stddevp_i16_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_i16_P1EXPR
+#undef __stddevp_i16_P2EXPR
+
+#define __stddevp_u16_P1EXPR(__x) ((double)(__x))
+#define __stddevp_u16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddevp_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint16_t, double, st, p, m, sum, 0.0, __stddevp_u16_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint16_t, double, st, p, m, M2, 0.0, __stddevp_u16_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_u16_P1EXPR
+#undef __stddevp_u16_P2EXPR
+
+#define __stddevp_i32_P1EXPR(__x) ((double)(__x))
+#define __stddevp_i32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddevp_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int32_t, double, st, p, m, sum, 0.0, __stddevp_i32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int32_t, double, st, p, m, M2, 0.0, __stddevp_i32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_i32_P1EXPR
+#undef __stddevp_i32_P2EXPR
+
+#define __stddevp_u32_P1EXPR(__x) ((double)(__x))
+#define __stddevp_u32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddevp_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint32_t, double, st, p, m, sum, 0.0, __stddevp_u32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint32_t, double, st, p, m, M2, 0.0, __stddevp_u32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_u32_P1EXPR
+#undef __stddevp_u32_P2EXPR
+
+#define __stddevp_i64_P1EXPR(__x) ((double)(__x))
+#define __stddevp_i64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddevp_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int64_t, double, st, p, m, sum, 0.0, __stddevp_i64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int64_t, double, st, p, m, M2, 0.0, __stddevp_i64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_i64_P1EXPR
+#undef __stddevp_i64_P2EXPR
+
+#define __stddevp_u64_P1EXPR(__x) ((double)(__x))
+#define __stddevp_u64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddevp_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint64_t, double, st, p, m, sum, 0.0, __stddevp_u64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint64_t, double, st, p, m, M2, 0.0, __stddevp_u64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_u64_P1EXPR
+#undef __stddevp_u64_P2EXPR
+
+#define __stddevp_f32_P1EXPR(__x) ((double)(__x))
+#define __stddevp_f32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddevp_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(float, double, st, p, m, sum, 0.0, __stddevp_f32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(float, double, st, p, m, M2, 0.0, __stddevp_f32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_f32_P1EXPR
+#undef __stddevp_f32_P2EXPR
+
+#define __stddevp_f64_P1EXPR(__x) ((double)(__x))
+#define __stddevp_f64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddevp_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(double, double, st, p, m, sum, 0.0, __stddevp_f64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(double, double, st, p, m, M2, 0.0, __stddevp_f64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_f64_P1EXPR
+#undef __stddevp_f64_P2EXPR
+
+#define __stddevp_cmplx64_P1EXPR(__x) (__x)
+#define __stddevp_cmplx64_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+static VALUE
+stddevp_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    cmplx64_t sum = 0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(cmplx64_t, cmplx64_t, st, p, m, sum, 0, __stddevp_cmplx64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      cmplx64_t mean = sum / (cmplx64_t)(double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(cmplx64_t, double, st, p, m, M2, 0.0, __stddevp_cmplx64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_cmplx64_P1EXPR
+#undef __stddevp_cmplx64_P2EXPR
+
+#define __stddevp_cmplx128_P1EXPR(__x) (__x)
+#define __stddevp_cmplx128_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+static VALUE
+stddevp_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    cmplx128_t sum = 0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(cmplx128_t, cmplx128_t, st, p, m, sum, 0, __stddevp_cmplx128_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      cmplx128_t mean = sum / (cmplx128_t)(double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(cmplx128_t, double, st, p, m, M2, 0.0, __stddevp_cmplx128_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_cmplx128_P1EXPR
+#undef __stddevp_cmplx128_P2EXPR
+
+#define __stddevp_bool_P1EXPR(__x) ((double)(__x))
+#define __stddevp_bool_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddevp_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(boolean8_t, double, st, p, m, sum, 0.0, __stddevp_bool_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(boolean8_t, double, st, p, m, M2, 0.0, __stddevp_bool_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddevp_bool_P1EXPR
+#undef __stddevp_bool_P2EXPR
+
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} stddevp_ki_native_object_frame;
+
+static VALUE
+stddevp_ki_native_object_body (VALUE arg)
+{
+  stddevp_ki_native_object_frame *fr = (stddevp_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    VALUE sum = INT2FIX(0);
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_T_EX(VALUE, st, p, m, sum, INT2FIX(0), sum = rb_funcall(sum, rb_intern("+"), 1, v), masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 1);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      VALUE mean = rb_funcall(sum, rb_intern("/"), 1, LONG2NUM(n_valid));
+      /* Pass 2: M2 = Σ (x - mean)² */
+      VALUE M2 = INT2FIX(0);
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_T_EX(VALUE, st, p, m, M2, INT2FIX(0), VALUE __d = rb_funcall(v, rb_intern("-"), 1, mean);
+M2 = rb_funcall(M2, rb_intern("+"), 1, rb_funcall(__d, rb_intern("*"), 1, __d)), __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(NUM2DBL(rb_funcall(M2, rb_intern("/"), 1, LONG2NUM(n_valid)))));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+#undef st
+}
+
+static VALUE
+stddevp_ki_native_object (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddevp_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, stddevp_ki_native_object_body, (VALUE) &fr);
+}
+
+
+VALUE
+rb_ca_stddevp_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil, rkeep_axis = Qnil, rmin_count = Qnil, rfval = Qnil;
+  rb_scan_options(ropt, "axis,keep_axis,min_count,fill_value", &raxis, &rkeep_axis, &rmin_count, &rfval);
+  int keep_axis = RTEST(rkeep_axis);
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = rb_ca_parse_reduce_axes_kw(raxis, src, slab_axes);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  ca_size_t min_count = ca_min_count_arg(rmin_count, NULL);
+  if ( rfval == CA_UNDEF ) rfval = Qnil;
+  int fill_whole = 0;
+  if ( ! NIL_P(rfval) && naxes == src->ndim && ! keep_axis ) {
+    keep_axis  = 1;
+    fill_whole = 1;
+  }
+  VALUE result;
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis arguments are no longer accepted (got %d); use the axis: keyword, e.g. a.%s(axis: 0) or a.%s(axis: [0, 1])", ca_calling_method_name(), argc, ca_calling_method_name(), ca_calling_method_name());
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: {
+      result = stddevp_ki_native_i8(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT8: {
+      result = stddevp_ki_native_u8(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT16: {
+      result = stddevp_ki_native_i16(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT16: {
+      result = stddevp_ki_native_u16(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT32: {
+      result = stddevp_ki_native_i32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT32: {
+      result = stddevp_ki_native_u32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT64: {
+      result = stddevp_ki_native_i64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT64: {
+      result = stddevp_ki_native_u64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_FLOAT32: {
+      result = stddevp_ki_native_f32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_FLOAT64: {
+      result = stddevp_ki_native_f64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_CMPLX64: {
+      result = stddevp_ki_native_cmplx64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_CMPLX128: {
+      result = stddevp_ki_native_cmplx128(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_BOOLEAN: {
+      result = stddevp_ki_native_bool(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_OBJECT: {
+      result = stddevp_ki_native_object(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  if ( ! NIL_P(rfval) ) {
+    result = ca_reduce_fill(result, rfval, fill_whole);
+  }
+  return result;
+}
+
+/* ===== stddev_ki ============================================ */
+
+#define __stddev_i8_P1EXPR(__x) ((double)(__x))
+#define __stddev_i8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddev_ki_native_i8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, sum, 0.0, __stddev_i8_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int8_t, double, st, p, m, M2, 0.0, __stddev_i8_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_i8_P1EXPR
+#undef __stddev_i8_P2EXPR
+
+#define __stddev_u8_P1EXPR(__x) ((double)(__x))
+#define __stddev_u8_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddev_ki_native_u8 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, sum, 0.0, __stddev_u8_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint8_t, double, st, p, m, M2, 0.0, __stddev_u8_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_u8_P1EXPR
+#undef __stddev_u8_P2EXPR
+
+#define __stddev_i16_P1EXPR(__x) ((double)(__x))
+#define __stddev_i16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddev_ki_native_i16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int16_t, double, st, p, m, sum, 0.0, __stddev_i16_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int16_t, double, st, p, m, M2, 0.0, __stddev_i16_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_i16_P1EXPR
+#undef __stddev_i16_P2EXPR
+
+#define __stddev_u16_P1EXPR(__x) ((double)(__x))
+#define __stddev_u16_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddev_ki_native_u16 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint16_t, double, st, p, m, sum, 0.0, __stddev_u16_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint16_t, double, st, p, m, M2, 0.0, __stddev_u16_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_u16_P1EXPR
+#undef __stddev_u16_P2EXPR
+
+#define __stddev_i32_P1EXPR(__x) ((double)(__x))
+#define __stddev_i32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddev_ki_native_i32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int32_t, double, st, p, m, sum, 0.0, __stddev_i32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int32_t, double, st, p, m, M2, 0.0, __stddev_i32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_i32_P1EXPR
+#undef __stddev_i32_P2EXPR
+
+#define __stddev_u32_P1EXPR(__x) ((double)(__x))
+#define __stddev_u32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddev_ki_native_u32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint32_t, double, st, p, m, sum, 0.0, __stddev_u32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint32_t, double, st, p, m, M2, 0.0, __stddev_u32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_u32_P1EXPR
+#undef __stddev_u32_P2EXPR
+
+#define __stddev_i64_P1EXPR(__x) ((double)(__x))
+#define __stddev_i64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddev_ki_native_i64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(int64_t, double, st, p, m, sum, 0.0, __stddev_i64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(int64_t, double, st, p, m, M2, 0.0, __stddev_i64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_i64_P1EXPR
+#undef __stddev_i64_P2EXPR
+
+#define __stddev_u64_P1EXPR(__x) ((double)(__x))
+#define __stddev_u64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddev_ki_native_u64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(uint64_t, double, st, p, m, sum, 0.0, __stddev_u64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(uint64_t, double, st, p, m, M2, 0.0, __stddev_u64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_u64_P1EXPR
+#undef __stddev_u64_P2EXPR
+
+#define __stddev_f32_P1EXPR(__x) ((double)(__x))
+#define __stddev_f32_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddev_ki_native_f32 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(float, double, st, p, m, sum, 0.0, __stddev_f32_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(float, double, st, p, m, M2, 0.0, __stddev_f32_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_f32_P1EXPR
+#undef __stddev_f32_P2EXPR
+
+#define __stddev_f64_P1EXPR(__x) ((double)(__x))
+#define __stddev_f64_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddev_ki_native_f64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(double, double, st, p, m, sum, 0.0, __stddev_f64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(double, double, st, p, m, M2, 0.0, __stddev_f64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_f64_P1EXPR
+#undef __stddev_f64_P2EXPR
+
+#define __stddev_cmplx64_P1EXPR(__x) (__x)
+#define __stddev_cmplx64_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+static VALUE
+stddev_ki_native_cmplx64 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    cmplx64_t sum = 0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(cmplx64_t, cmplx64_t, st, p, m, sum, 0, __stddev_cmplx64_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      cmplx64_t mean = sum / (cmplx64_t)(double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(cmplx64_t, double, st, p, m, M2, 0.0, __stddev_cmplx64_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_cmplx64_P1EXPR
+#undef __stddev_cmplx64_P2EXPR
+
+#define __stddev_cmplx128_P1EXPR(__x) (__x)
+#define __stddev_cmplx128_P2EXPR(__x) (creal((__x) - mean) * creal((__x) - mean) + cimag((__x) - mean) * cimag((__x) - mean))
+static VALUE
+stddev_ki_native_cmplx128 (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    cmplx128_t sum = 0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(cmplx128_t, cmplx128_t, st, p, m, sum, 0, __stddev_cmplx128_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      cmplx128_t mean = sum / (cmplx128_t)(double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(cmplx128_t, double, st, p, m, M2, 0.0, __stddev_cmplx128_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_cmplx128_P1EXPR
+#undef __stddev_cmplx128_P2EXPR
+
+#define __stddev_bool_P1EXPR(__x) ((double)(__x))
+#define __stddev_bool_P2EXPR(__x) (((double)(__x) - mean) * ((double)(__x) - mean))
+static VALUE
+stddev_ki_native_bool (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  ca_iter_state st;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    double sum = 0.0;
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_SUM8_EX(boolean8_t, double, st, p, m, sum, 0.0, __stddev_bool_P1EXPR, masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      double mean = sum / (double) n_valid;
+      /* Pass 2: M2 = Σ (x - mean)² */
+      double M2 = 0.0;
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_SUM8_EX(boolean8_t, double, st, p, m, M2, 0.0, __stddev_bool_P2EXPR, __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(M2 / (double)(n_valid - 1)));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+}
+#undef __stddev_bool_P1EXPR
+#undef __stddev_bool_P2EXPR
+
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[1];
+  VALUE self;
+  CArray *ca;
+  int8_t *slab_axes;
+  int8_t naxes;
+  int keep_axis;
+  ca_size_t min_count;
+} stddev_ki_native_object_frame;
+
+static VALUE
+stddev_ki_native_object_body (VALUE arg)
+{
+  stddev_ki_native_object_frame *fr = (stddev_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int8_t *slab_axes = fr->slab_axes;
+  (void) slab_axes;
+  int8_t naxes = fr->naxes;
+  (void) naxes;
+  int keep_axis = fr->keep_axis;
+  (void) keep_axis;
+  ca_size_t min_count = fr->min_count;
+  (void) min_count;
+#define st (fr->states[0])
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_FLOAT64, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  double *op = (double *) co->ptr;
+  int rc = ca_iter_state_init_l2(&st, ca, CA_SLAB_AXES,
+                                 slab_axes, naxes, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: kernel_iterator init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  char       *p;
+  boolean8_t *m;
+  ca_size_t   out_i = 0;
+  boolean8_t *op_mask = NULL;   /* lazily allocated on first UNDEF */
+  while ( ca_iter_state_next_slab_axes(&st, &p, &m) ) {
+    /* Pass 1: sum = Σx (+ masked_cnt) */
+    VALUE sum = INT2FIX(0);
+    ca_size_t masked_cnt = 0;
+    CA_SLAB_REDUCE_T_EX(VALUE, st, p, m, sum, INT2FIX(0), sum = rb_funcall(sum, rb_intern("+"), 1, v), masked_cnt);
+    ca_size_t n_valid = st.slab_elements - masked_cnt;
+    int __trigger = ca_too_few_present(n_valid, min_count, 2);
+    if ( __trigger ) {
+      if ( ! op_mask ) {
+        ca_create_mask(co);
+        op_mask = (boolean8_t *) co->mask->ptr;
+      }
+      op_mask[out_i] = 1;
+      op[out_i++] = (double) 0.0;
+    } else {
+      VALUE mean = rb_funcall(sum, rb_intern("/"), 1, LONG2NUM(n_valid));
+      /* Pass 2: M2 = Σ (x - mean)² */
+      VALUE M2 = INT2FIX(0);
+      ca_size_t __unused_mc = 0;
+      CA_SLAB_REDUCE_T_EX(VALUE, st, p, m, M2, INT2FIX(0), VALUE __d = rb_funcall(v, rb_intern("-"), 1, mean);
+M2 = rb_funcall(M2, rb_intern("+"), 1, rb_funcall(__d, rb_intern("*"), 1, __d)), __unused_mc);
+      op[out_i++] = (double)(ca_sqrt_clamp(NUM2DBL(rb_funcall(M2, rb_intern("/"), 1, LONG2NUM(n_valid - 1)))));
+    }
+  }
+  ca_iter_state_finish(&st);
+  /* Full-reduction scalar shortcut: naxes == ca->ndim and no
+     keep_axis means the output is a 1-element CArray; unwrap it to
+     the ruby scalar (matches the standard reduce emit path lines
+     1811-1817).  Full reduction with all-masked returns CA_UNDEF. */
+  if ( naxes == ca->ndim && !keep_axis ) {
+    if ( op_mask && op_mask[0] ) return CA_UNDEF;
+    return rb_float_new(op[0]);
+  }
+  return vout;
+#undef st
+}
+
+static VALUE
+stddev_ki_native_object (VALUE self, CArray *ca, int8_t *slab_axes, int8_t naxes, int keep_axis, ca_size_t min_count)
+{
+  stddev_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.slab_axes = slab_axes;
+  fr.naxes = naxes;
+  fr.keep_axis = keep_axis;
+  fr.min_count = min_count;
+  return ca_iter_ensure(1, fr.states, stddev_ki_native_object_body, (VALUE) &fr);
+}
+
+
+VALUE
+rb_ca_stddev_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil, rkeep_axis = Qnil, rmin_count = Qnil, rfval = Qnil;
+  rb_scan_options(ropt, "axis,keep_axis,min_count,fill_value", &raxis, &rkeep_axis, &rmin_count, &rfval);
+  int keep_axis = RTEST(rkeep_axis);
+  int8_t slab_axes[CA_RANK_MAX];
+  int8_t naxes = rb_ca_parse_reduce_axes_kw(raxis, src, slab_axes);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  ca_size_t min_count = ca_min_count_arg(rmin_count, NULL);
+  if ( rfval == CA_UNDEF ) rfval = Qnil;
+  int fill_whole = 0;
+  if ( ! NIL_P(rfval) && naxes == src->ndim && ! keep_axis ) {
+    keep_axis  = 1;
+    fill_whole = 1;
+  }
+  VALUE result;
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis arguments are no longer accepted (got %d); use the axis: keyword, e.g. a.%s(axis: 0) or a.%s(axis: [0, 1])", ca_calling_method_name(), argc, ca_calling_method_name(), ca_calling_method_name());
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: {
+      result = stddev_ki_native_i8(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT8: {
+      result = stddev_ki_native_u8(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT16: {
+      result = stddev_ki_native_i16(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT16: {
+      result = stddev_ki_native_u16(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT32: {
+      result = stddev_ki_native_i32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT32: {
+      result = stddev_ki_native_u32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_INT64: {
+      result = stddev_ki_native_i64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_UINT64: {
+      result = stddev_ki_native_u64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_FLOAT32: {
+      result = stddev_ki_native_f32(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_FLOAT64: {
+      result = stddev_ki_native_f64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_CMPLX64: {
+      result = stddev_ki_native_cmplx64(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_CMPLX128: {
+      result = stddev_ki_native_cmplx128(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_BOOLEAN: {
+      result = stddev_ki_native_bool(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    case CA_OBJECT: {
+      result = stddev_ki_native_object(self, src, slab_axes, naxes, keep_axis, min_count);
+      RB_GC_GUARD(self);
+      break;
+    }
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  if ( ! NIL_P(rfval) ) {
+    result = ca_reduce_fill(result, rfval, fill_whole);
+  }
+  return result;
+}
+
+void
+Init_carray_kernels_reduce_variance (void)
+{
+  /* Phase E rewire: legacy 'variancep' now dispatches via variancep_ki */
+  rb_define_method(rb_cCArray, "variancep", rb_ca_variancep_ki, -1);
+  /* Phase E rewire: legacy 'variance' now dispatches via variance_ki */
+  rb_define_method(rb_cCArray, "variance", rb_ca_variance_ki, -1);
+  /* Phase E rewire: legacy 'stddevp' now dispatches via stddevp_ki */
+  rb_define_method(rb_cCArray, "stddevp", rb_ca_stddevp_ki, -1);
+  /* Phase E rewire: legacy 'stddev' now dispatches via stddev_ki */
+  rb_define_method(rb_cCArray, "stddev", rb_ca_stddev_ki, -1);
+}