carray 2.0.1 → 3.0.1

data/ext/carray_kernels_reduce_variance.c

@@ -0,0 +1,3910 @@
+/* ---------------------------------------------------------------------------
+
+   carray_kernels.c -- GENERATED by ext/mkkernel.rb -- DO NOT EDIT
+
+   Kernel definitions live in mkkernel.rb (search for `MkKernel.reduce`).
+   Regenerate by running:
+
+     cd ext && ruby mkkernel.rb > carray_kernels.c
+
+   extconf.rb regenerates automatically when mkkernel.rb is touched.
+
+   --------------------------------------------------------------------------- */
+
+#include "carray.h"
+#include "ca_kernel_iterator.h"
+#include "ca_sort_kernels.h"   /* sort kernels: internal, not via the carray.h umbrella */
+#include "carray_internal.h"   /* ca_lazy_arena_*, ca_is_lazy_view (streaming reduce) */
+#include "ca_obj_face.h"       /* rb_ca_strip_face_value (Face ordering gate) */
+#include <math.h>
+#include <stdint.h>
+#include <stdlib.h>   /* qsort, mergesort (HAVE_MERGESORT) -- for :sort kind */
+
+/* MEMO_REDUCTION_FASTPATH_ENTITY_ONLY_GUARD Tier 2: CAStack identity is
+   probed by operation-table function pointer (obj_type is runtime-
+   assigned, so no CA_OBJ_STACK compile-time constant exists). */
+extern ca_operation_function_t ca_stack_func;
+/* BOOL2VAL: bool -> Ruby (Qtrue/Qfalse).  Used as ruby_scalar wrapper
+   for the all/any flat-reduction Ruby surface so `a.all` / `a.any`
+   return real true/false, not Integer 0/1.  (BOOL2OBJ already exists
+   but returns Integer per CArray's boolean-as-int convention.)  */
+#ifndef CARRAY_BOOL2VAL_DEFINED
+#define CARRAY_BOOL2VAL_DEFINED
+static inline VALUE BOOL2VAL (boolean8_t x) { return x ? Qtrue : Qfalse; }
+#endif
+
+#include "ca_op_powi.h"
+#include "ca_op_cmplx64.h"
+
+/* ===== 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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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
+
+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)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_OBJECT, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  VALUE *op = (VALUE *) 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,
+             "variancep_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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;
+}
+
+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);
+  ca_size_t min_count = -1;
+  if ( ! NIL_P(rmin_count) ) {
+    ca_size_t mc_user = NUM2SIZE(rmin_count);
+    if ( mc_user < 0 ) {
+      rb_raise(rb_eArgError, "variancep_ki: :min_count must be non-negative, got %lld", (long long) mc_user);
+    }
+    /* :min_count = 0 collapses to legacy default (any 1 valid). */
+    if ( mc_user > 0 ) min_count = mc_user;
+  }
+  VALUE result;
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "variancep_ki: positional axis arguments are no longer accepted (got %d); use axis: kwarg, e.g. a.variancep(axis: 0) or a.variancep(axis: [0, 1])", argc);
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: {
+      result = variancep_ki_native_i8(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT8: {
+      result = variancep_ki_native_u8(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT16: {
+      result = variancep_ki_native_i16(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT16: {
+      result = variancep_ki_native_u16(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT32: {
+      result = variancep_ki_native_i32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT32: {
+      result = variancep_ki_native_u32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT64: {
+      result = variancep_ki_native_i64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT64: {
+      result = variancep_ki_native_u64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_FLOAT32: {
+      result = variancep_ki_native_f32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_FLOAT64: {
+      result = variancep_ki_native_f64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_CMPLX64: {
+      result = variancep_ki_native_cmplx64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_CMPLX128: {
+      result = variancep_ki_native_cmplx128(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_BOOLEAN: {
+      result = variancep_ki_native_bool(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_OBJECT: {
+      result = variancep_ki_native_object(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    default:
+      rb_raise(rb_eCADataTypeError, "variancep_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, cmplx64, cmplx128, bool, object)", ca_type_name[src->data_type]);
+  }
+  if ( ! NIL_P(rfval) ) {
+    if ( result == CA_UNDEF ) {
+      result = rfval;
+    } else if ( TYPE(result) != T_FLOAT && rb_obj_is_kind_of(result, rb_cCArray) ) {
+      CArray *cr;
+      GetCArray(result, cr);
+      if ( ca_has_mask(cr) ) {
+        result = rb_ca_mask_fill_copy(result, rfval);
+      }
+    }
+  }
+  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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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
+
+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)
+{
+  VALUE   vout  = rb_ca_new_reduced(self, slab_axes, naxes, CA_OBJECT, keep_axis);
+  CArray *co;
+  GetCArray(vout, co);
+  VALUE *op = (VALUE *) 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,
+             "variance_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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;
+}
+
+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);
+  ca_size_t min_count = -1;
+  if ( ! NIL_P(rmin_count) ) {
+    ca_size_t mc_user = NUM2SIZE(rmin_count);
+    if ( mc_user < 0 ) {
+      rb_raise(rb_eArgError, "variance_ki: :min_count must be non-negative, got %lld", (long long) mc_user);
+    }
+    /* :min_count = 0 collapses to legacy default (any 1 valid). */
+    if ( mc_user > 0 ) min_count = mc_user;
+  }
+  VALUE result;
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "variance_ki: positional axis arguments are no longer accepted (got %d); use axis: kwarg, e.g. a.variance(axis: 0) or a.variance(axis: [0, 1])", argc);
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: {
+      result = variance_ki_native_i8(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT8: {
+      result = variance_ki_native_u8(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT16: {
+      result = variance_ki_native_i16(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT16: {
+      result = variance_ki_native_u16(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT32: {
+      result = variance_ki_native_i32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT32: {
+      result = variance_ki_native_u32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT64: {
+      result = variance_ki_native_i64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT64: {
+      result = variance_ki_native_u64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_FLOAT32: {
+      result = variance_ki_native_f32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_FLOAT64: {
+      result = variance_ki_native_f64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_CMPLX64: {
+      result = variance_ki_native_cmplx64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_CMPLX128: {
+      result = variance_ki_native_cmplx128(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_BOOLEAN: {
+      result = variance_ki_native_bool(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_OBJECT: {
+      result = variance_ki_native_object(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    default:
+      rb_raise(rb_eCADataTypeError, "variance_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, cmplx64, cmplx128, bool, object)", ca_type_name[src->data_type]);
+  }
+  if ( ! NIL_P(rfval) ) {
+    if ( result == CA_UNDEF ) {
+      result = rfval;
+    } else if ( TYPE(result) != T_FLOAT && rb_obj_is_kind_of(result, rb_cCArray) ) {
+      CArray *cr;
+      GetCArray(result, cr);
+      if ( ca_has_mask(cr) ) {
+        result = rb_ca_mask_fill_copy(result, rfval);
+      }
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid), 0.0)));
+    }
+  }
+  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
+
+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)
+{
+  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,
+             "stddevp_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 1 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(NUM2DBL(rb_funcall(M2, rb_intern("/"), 1, LONG2NUM(n_valid))), 0.0)));
+    }
+  }
+  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;
+}
+
+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);
+  ca_size_t min_count = -1;
+  if ( ! NIL_P(rmin_count) ) {
+    ca_size_t mc_user = NUM2SIZE(rmin_count);
+    if ( mc_user < 0 ) {
+      rb_raise(rb_eArgError, "stddevp_ki: :min_count must be non-negative, got %lld", (long long) mc_user);
+    }
+    /* :min_count = 0 collapses to legacy default (any 1 valid). */
+    if ( mc_user > 0 ) min_count = mc_user;
+  }
+  VALUE result;
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "stddevp_ki: positional axis arguments are no longer accepted (got %d); use axis: kwarg, e.g. a.stddevp(axis: 0) or a.stddevp(axis: [0, 1])", argc);
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: {
+      result = stddevp_ki_native_i8(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT8: {
+      result = stddevp_ki_native_u8(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT16: {
+      result = stddevp_ki_native_i16(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT16: {
+      result = stddevp_ki_native_u16(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT32: {
+      result = stddevp_ki_native_i32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT32: {
+      result = stddevp_ki_native_u32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT64: {
+      result = stddevp_ki_native_i64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT64: {
+      result = stddevp_ki_native_u64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_FLOAT32: {
+      result = stddevp_ki_native_f32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_FLOAT64: {
+      result = stddevp_ki_native_f64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_CMPLX64: {
+      result = stddevp_ki_native_cmplx64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_CMPLX128: {
+      result = stddevp_ki_native_cmplx128(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_BOOLEAN: {
+      result = stddevp_ki_native_bool(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_OBJECT: {
+      result = stddevp_ki_native_object(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    default:
+      rb_raise(rb_eCADataTypeError, "stddevp_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, cmplx64, cmplx128, bool, object)", ca_type_name[src->data_type]);
+  }
+  if ( ! NIL_P(rfval) ) {
+    if ( result == CA_UNDEF ) {
+      result = rfval;
+    } else if ( TYPE(result) != T_FLOAT && rb_obj_is_kind_of(result, rb_cCArray) ) {
+      CArray *cr;
+      GetCArray(result, cr);
+      if ( ca_has_mask(cr) ) {
+        result = rb_ca_mask_fill_copy(result, rfval);
+      }
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(M2 / (double)(n_valid - 1), 0.0)));
+    }
+  }
+  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
+
+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)
+{
+  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,
+             "stddev_ki: kernel_iterator init failed rc=%d", 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 = (min_count < 0 ? masked_cnt == st.slab_elements : n_valid < min_count);
+    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 if ( n_valid < 2 ) {
+      /* Legacy degenerate case (e.g. sample variance with 1 unmasked
+         cell): return zero rather than UNDEF, matching pre-migration
+         behaviour of `cnt > 1 ? formula : 0`. */
+      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)(sqrt(fmax(NUM2DBL(rb_funcall(M2, rb_intern("/"), 1, LONG2NUM(n_valid - 1))), 0.0)));
+    }
+  }
+  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;
+}
+
+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);
+  ca_size_t min_count = -1;
+  if ( ! NIL_P(rmin_count) ) {
+    ca_size_t mc_user = NUM2SIZE(rmin_count);
+    if ( mc_user < 0 ) {
+      rb_raise(rb_eArgError, "stddev_ki: :min_count must be non-negative, got %lld", (long long) mc_user);
+    }
+    /* :min_count = 0 collapses to legacy default (any 1 valid). */
+    if ( mc_user > 0 ) min_count = mc_user;
+  }
+  VALUE result;
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "stddev_ki: positional axis arguments are no longer accepted (got %d); use axis: kwarg, e.g. a.stddev(axis: 0) or a.stddev(axis: [0, 1])", argc);
+  }
+  switch ( src->data_type ) {
+    case CA_INT8: {
+      result = stddev_ki_native_i8(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT8: {
+      result = stddev_ki_native_u8(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT16: {
+      result = stddev_ki_native_i16(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT16: {
+      result = stddev_ki_native_u16(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT32: {
+      result = stddev_ki_native_i32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT32: {
+      result = stddev_ki_native_u32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_INT64: {
+      result = stddev_ki_native_i64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_UINT64: {
+      result = stddev_ki_native_u64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_FLOAT32: {
+      result = stddev_ki_native_f32(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_FLOAT64: {
+      result = stddev_ki_native_f64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_CMPLX64: {
+      result = stddev_ki_native_cmplx64(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_CMPLX128: {
+      result = stddev_ki_native_cmplx128(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_BOOLEAN: {
+      result = stddev_ki_native_bool(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    case CA_OBJECT: {
+      result = stddev_ki_native_object(self, src, slab_axes, naxes, keep_axis, min_count);
+      break;
+    }
+    default:
+      rb_raise(rb_eCADataTypeError, "stddev_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, cmplx64, cmplx128, bool, object)", ca_type_name[src->data_type]);
+  }
+  if ( ! NIL_P(rfval) ) {
+    if ( result == CA_UNDEF ) {
+      result = rfval;
+    } else if ( TYPE(result) != T_FLOAT && rb_obj_is_kind_of(result, rb_cCArray) ) {
+      CArray *cr;
+      GetCArray(result, cr);
+      if ( ca_has_mask(cr) ) {
+        result = rb_ca_mask_fill_copy(result, rfval);
+      }
+    }
+  }
+  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);
+}