carray 3.0.2 → 3.0.4

data/ext/carray_kernels_scan.c

@@ -24,6 +24,13 @@
    probed by operation-table function pointer (obj_type is runtime-
    assigned, so no CA_OBJ_STACK compile-time constant exists). */
 extern ca_operation_function_t ca_stack_func;
+/* The square root of a variance: an ε-negative from rounding becomes 0,
+   a NaN stays NaN (fmax(NaN, 0.0) is 0.0). */
+#ifndef CARRAY_SQRT_CLAMP_DEFINED
+#define CARRAY_SQRT_CLAMP_DEFINED
+static inline double ca_sqrt_clamp (double v) { return sqrt(v < 0.0 ? 0.0 : v); }
+#endif
+
 /* BOOL2VAL: bool -> Ruby (Qtrue/Qfalse).  Used as ruby_scalar wrapper
    for the all/any flat-reduction Ruby surface so `a.all` / `a.any`
    return real true/false, not Integer 0/1.  (BOOL2OBJ already exists
@@ -57,14 +64,14 @@ cumsum_ki_native_i8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -99,14 +106,14 @@ cumsum_ki_native_u8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -141,14 +148,14 @@ cumsum_ki_native_i16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -183,14 +190,14 @@ cumsum_ki_native_u16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -225,14 +232,14 @@ cumsum_ki_native_i32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -267,14 +274,14 @@ cumsum_ki_native_u32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -309,14 +316,14 @@ cumsum_ki_native_i64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -351,14 +358,14 @@ cumsum_ki_native_u64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -393,14 +400,14 @@ cumsum_ki_native_f32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -435,14 +442,14 @@ cumsum_ki_native_f64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -477,14 +484,14 @@ cumsum_ki_native_cmplx64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -519,14 +526,14 @@ cumsum_ki_native_cmplx128 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -561,14 +568,14 @@ cumsum_ki_native_bool (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -584,9 +591,28 @@ cumsum_ki_native_bool (VALUE self, CArray *ca, int axis)
   return vout;
 }
 
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+} cumsum_ki_native_object_frame;
+
 static VALUE
-cumsum_ki_native_object (VALUE self, CArray *ca, int axis)
+cumsum_ki_native_object_body (VALUE arg)
 {
+  cumsum_ki_native_object_frame *fr = (cumsum_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
   VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_OBJECT),
                                           INT2NUM(sizeof(VALUE)));
   CArray *co;
@@ -597,20 +623,19 @@ cumsum_ki_native_object (VALUE self, CArray *ca, int axis)
      INIT inside the macro. */
   int8_t slab_axes[CA_RANK_MAX];
   slab_axes[0] = (int8_t) axis;
-  ca_iter_state st_in, st_out;
   int rc;
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumsum_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -624,70 +649,479 @@ cumsum_ki_native_object (VALUE self, CArray *ca, int axis)
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
+#undef st_in
+#undef st_out
 }
 
+static VALUE
+cumsum_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  cumsum_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  return ca_iter_ensure(2, fr.states, cumsum_ki_native_object_body, (VALUE) &fr);
+}
+
+
 static VALUE
 rb_ca_cumsum_ki (int argc, VALUE *argv, VALUE self)
 {
   CArray *src;
   GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
   volatile VALUE ropt = rb_pop_options(&argc, &argv);
   volatile VALUE raxis = Qnil;
   rb_scan_options(ropt, "axis", &raxis);
   if ( argc > 0 ) {
-    rb_raise(rb_eArgError, "cumsum_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumsum(axis: 0)", argc);
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumsum(axis: 0)", ca_calling_method_name(), argc);
   }
   if ( NIL_P(raxis) ) {
     volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
     CArray *fsrc;
     GetCArray(vflat, fsrc);
     switch ( fsrc->data_type ) {
-      case CA_INT8: return cumsum_ki_native_i8(vflat, fsrc, 0);
-      case CA_UINT8: return cumsum_ki_native_u8(vflat, fsrc, 0);
-      case CA_INT16: return cumsum_ki_native_i16(vflat, fsrc, 0);
-      case CA_UINT16: return cumsum_ki_native_u16(vflat, fsrc, 0);
-      case CA_INT32: return cumsum_ki_native_i32(vflat, fsrc, 0);
-      case CA_UINT32: return cumsum_ki_native_u32(vflat, fsrc, 0);
-      case CA_INT64: return cumsum_ki_native_i64(vflat, fsrc, 0);
-      case CA_UINT64: return cumsum_ki_native_u64(vflat, fsrc, 0);
-      case CA_FLOAT32: return cumsum_ki_native_f32(vflat, fsrc, 0);
-      case CA_FLOAT64: return cumsum_ki_native_f64(vflat, fsrc, 0);
-      case CA_CMPLX64: return cumsum_ki_native_cmplx64(vflat, fsrc, 0);
-      case CA_CMPLX128: return cumsum_ki_native_cmplx128(vflat, fsrc, 0);
-      case CA_BOOLEAN: return cumsum_ki_native_bool(vflat, fsrc, 0);
-      case CA_OBJECT: return cumsum_ki_native_object(vflat, fsrc, 0);
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cumsum_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cumsum_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cumsum_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cumsum_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cumsum_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cumsum_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cumsum_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cumsum_ki_native_u64(vflat, fsrc, 0));
+      case CA_FLOAT32: CA_RETURN_KEEPING(vflat, cumsum_ki_native_f32(vflat, fsrc, 0));
+      case CA_FLOAT64: CA_RETURN_KEEPING(vflat, cumsum_ki_native_f64(vflat, fsrc, 0));
+      case CA_CMPLX64: CA_RETURN_KEEPING(vflat, cumsum_ki_native_cmplx64(vflat, fsrc, 0));
+      case CA_CMPLX128: CA_RETURN_KEEPING(vflat, cumsum_ki_native_cmplx128(vflat, fsrc, 0));
+      case CA_BOOLEAN: CA_RETURN_KEEPING(vflat, cumsum_ki_native_bool(vflat, fsrc, 0));
+      case CA_OBJECT: CA_RETURN_KEEPING(vflat, cumsum_ki_native_object(vflat, fsrc, 0));
       default:
-        rb_raise(rb_eCADataTypeError, "cumsum_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[fsrc->data_type]);
+        ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+        rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[fsrc->data_type]);
     }
   }
   if ( TYPE(raxis) == T_ARRAY ) {
-    rb_raise(rb_eArgError, "cumsum_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.cumsum(axis: 0).cumsum(axis: 1)");
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cumsum(axis: 0).cumsum(axis: 1)", ca_calling_method_name());
+  }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
+  switch ( src->data_type ) {
+    case CA_INT8: CA_RETURN_KEEPING(self, cumsum_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cumsum_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cumsum_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cumsum_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cumsum_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cumsum_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cumsum_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cumsum_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, cumsum_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, cumsum_ki_native_f64(self, src, axis));
+    case CA_CMPLX64: CA_RETURN_KEEPING(self, cumsum_ki_native_cmplx64(self, src, axis));
+    case CA_CMPLX128: CA_RETURN_KEEPING(self, cumsum_ki_native_cmplx128(self, src, axis));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, cumsum_ki_native_bool(self, src, axis));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, cumsum_ki_native_object(self, src, axis));
+    default:
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
+  }
+  return Qnil;  /* unreachable */
+}
+
+/* ===== cumsum_in_own_type_ki ============================================ */
+
+static VALUE
+cumsum_in_own_type_ki_native_i8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT8),
+                                          INT2NUM(sizeof(int8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int8_t, int8_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_u8 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT8),
+                                          INT2NUM(sizeof(uint8_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint8_t, uint8_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_i16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT16),
+                                          INT2NUM(sizeof(int16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int16_t, int16_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_u16 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT16),
+                                          INT2NUM(sizeof(uint16_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint16_t, uint16_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_i32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT32),
+                                          INT2NUM(sizeof(int32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
-    rb_raise(rb_eTypeError, "cumsum_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
-  int axis = NUM2INT(raxis);
-  if ( axis < 0 ) axis += src->ndim;
-  if ( axis < 0 || axis >= src->ndim ) {
-    rb_raise(rb_eArgError, "cumsum_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int32_t, int32_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
   }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_u32 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT32),
+                                          INT2NUM(sizeof(uint32_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint32_t, uint32_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_i64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_INT64),
+                                          INT2NUM(sizeof(int64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(int64_t, int64_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+cumsum_in_own_type_ki_native_u64 (VALUE self, CArray *ca, int axis)
+{
+  VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_UINT64),
+                                          INT2NUM(sizeof(uint64_t)));
+  CArray *co;
+  GetCArray(vout, co);
+
+  /* 1-axis scan: slab = the scan axis only.  Each next_slab_axes
+     iteration is one "fiber" along that axis with acc reset to
+     INIT inside the macro. */
+  int8_t slab_axes[CA_RANK_MAX];
+  slab_axes[0] = (int8_t) axis;
+  ca_iter_state st_in, st_out;
+  int rc;
+  rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
+                             slab_axes, 1, 0);
+  if ( rc != CA_ITER_OK ) {
+    rb_raise(rb_eRuntimeError,
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
+  }
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
+                             slab_axes, 1, CA_KERNEL_WRITE);
+  if ( rc != CA_ITER_OK ) {
+    ca_iter_state_finish(&st_in);
+    rb_raise(rb_eRuntimeError,
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
+  }
+
+  char       *pi, *po;
+  boolean8_t *mi, *mo;
+  while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
+          ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
+    CA_SLAB_SCAN_T(uint64_t, uint64_t, st_in, pi, mi,
+                         st_out, po, 0, acc += v; r = acc);
+    ca_iter_state_sync_slab(&st_out);
+  }
+  ca_iter_state_finish(&st_in);
+  ca_iter_state_finish(&st_out);
+  return vout;
+}
+
+static VALUE
+rb_ca_cumsum_in_own_type_ki (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
+  volatile VALUE ropt = rb_pop_options(&argc, &argv);
+  volatile VALUE raxis = Qnil;
+  rb_scan_options(ropt, "axis", &raxis);
+  if ( argc > 0 ) {
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumsum_in_own_type(axis: 0)", ca_calling_method_name(), argc);
+  }
+  if ( NIL_P(raxis) ) {
+    volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
+    CArray *fsrc;
+    GetCArray(vflat, fsrc);
+    switch ( fsrc->data_type ) {
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cumsum_in_own_type_ki_native_u64(vflat, fsrc, 0));
+      default:
+        ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+        rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64)", ca_calling_method_name(), ca_type_name[fsrc->data_type]);
+    }
+  }
+  if ( TYPE(raxis) == T_ARRAY ) {
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cumsum_in_own_type(axis: 0).cumsum_in_own_type(axis: 1)", ca_calling_method_name());
+  }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
   switch ( src->data_type ) {
-    case CA_INT8: return cumsum_ki_native_i8(self, src, axis);
-    case CA_UINT8: return cumsum_ki_native_u8(self, src, axis);
-    case CA_INT16: return cumsum_ki_native_i16(self, src, axis);
-    case CA_UINT16: return cumsum_ki_native_u16(self, src, axis);
-    case CA_INT32: return cumsum_ki_native_i32(self, src, axis);
-    case CA_UINT32: return cumsum_ki_native_u32(self, src, axis);
-    case CA_INT64: return cumsum_ki_native_i64(self, src, axis);
-    case CA_UINT64: return cumsum_ki_native_u64(self, src, axis);
-    case CA_FLOAT32: return cumsum_ki_native_f32(self, src, axis);
-    case CA_FLOAT64: return cumsum_ki_native_f64(self, src, axis);
-    case CA_CMPLX64: return cumsum_ki_native_cmplx64(self, src, axis);
-    case CA_CMPLX128: return cumsum_ki_native_cmplx128(self, src, axis);
-    case CA_BOOLEAN: return cumsum_ki_native_bool(self, src, axis);
-    case CA_OBJECT: return cumsum_ki_native_object(self, src, axis);
+    case CA_INT8: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cumsum_in_own_type_ki_native_u64(self, src, axis));
     default:
-      rb_raise(rb_eCADataTypeError, "cumsum_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]);
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64)", ca_calling_method_name(), ca_type_name[src->data_type]);
   }
   return Qnil;  /* unreachable */
 }
@@ -713,14 +1147,14 @@ cumprod_ki_native_i8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -755,14 +1189,14 @@ cumprod_ki_native_u8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -797,14 +1231,14 @@ cumprod_ki_native_i16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -839,14 +1273,14 @@ cumprod_ki_native_u16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -881,14 +1315,14 @@ cumprod_ki_native_i32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -923,14 +1357,14 @@ cumprod_ki_native_u32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -965,14 +1399,14 @@ cumprod_ki_native_i64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -1007,14 +1441,14 @@ cumprod_ki_native_u64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -1049,14 +1483,14 @@ cumprod_ki_native_f32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -1091,14 +1525,14 @@ cumprod_ki_native_f64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -1133,14 +1567,14 @@ cumprod_ki_native_cmplx64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -1175,14 +1609,14 @@ cumprod_ki_native_cmplx128 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -1217,14 +1651,14 @@ cumprod_ki_native_bool (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -1240,9 +1674,28 @@ cumprod_ki_native_bool (VALUE self, CArray *ca, int axis)
   return vout;
 }
 
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+} cumprod_ki_native_object_frame;
+
 static VALUE
-cumprod_ki_native_object (VALUE self, CArray *ca, int axis)
+cumprod_ki_native_object_body (VALUE arg)
 {
+  cumprod_ki_native_object_frame *fr = (cumprod_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
   VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_OBJECT),
                                           INT2NUM(sizeof(VALUE)));
   CArray *co;
@@ -1253,20 +1706,19 @@ cumprod_ki_native_object (VALUE self, CArray *ca, int axis)
      INIT inside the macro. */
   int8_t slab_axes[CA_RANK_MAX];
   slab_axes[0] = (int8_t) axis;
-  ca_iter_state st_in, st_out;
   int rc;
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumprod_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -1280,70 +1732,85 @@ cumprod_ki_native_object (VALUE self, CArray *ca, int axis)
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
+#undef st_in
+#undef st_out
 }
 
+static VALUE
+cumprod_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  cumprod_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  return ca_iter_ensure(2, fr.states, cumprod_ki_native_object_body, (VALUE) &fr);
+}
+
+
 static VALUE
 rb_ca_cumprod_ki (int argc, VALUE *argv, VALUE self)
 {
   CArray *src;
   GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
   volatile VALUE ropt = rb_pop_options(&argc, &argv);
   volatile VALUE raxis = Qnil;
   rb_scan_options(ropt, "axis", &raxis);
   if ( argc > 0 ) {
-    rb_raise(rb_eArgError, "cumprod_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumprod(axis: 0)", argc);
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumprod(axis: 0)", ca_calling_method_name(), argc);
   }
   if ( NIL_P(raxis) ) {
     volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
     CArray *fsrc;
     GetCArray(vflat, fsrc);
     switch ( fsrc->data_type ) {
-      case CA_INT8: return cumprod_ki_native_i8(vflat, fsrc, 0);
-      case CA_UINT8: return cumprod_ki_native_u8(vflat, fsrc, 0);
-      case CA_INT16: return cumprod_ki_native_i16(vflat, fsrc, 0);
-      case CA_UINT16: return cumprod_ki_native_u16(vflat, fsrc, 0);
-      case CA_INT32: return cumprod_ki_native_i32(vflat, fsrc, 0);
-      case CA_UINT32: return cumprod_ki_native_u32(vflat, fsrc, 0);
-      case CA_INT64: return cumprod_ki_native_i64(vflat, fsrc, 0);
-      case CA_UINT64: return cumprod_ki_native_u64(vflat, fsrc, 0);
-      case CA_FLOAT32: return cumprod_ki_native_f32(vflat, fsrc, 0);
-      case CA_FLOAT64: return cumprod_ki_native_f64(vflat, fsrc, 0);
-      case CA_CMPLX64: return cumprod_ki_native_cmplx64(vflat, fsrc, 0);
-      case CA_CMPLX128: return cumprod_ki_native_cmplx128(vflat, fsrc, 0);
-      case CA_BOOLEAN: return cumprod_ki_native_bool(vflat, fsrc, 0);
-      case CA_OBJECT: return cumprod_ki_native_object(vflat, fsrc, 0);
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cumprod_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cumprod_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cumprod_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cumprod_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cumprod_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cumprod_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cumprod_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cumprod_ki_native_u64(vflat, fsrc, 0));
+      case CA_FLOAT32: CA_RETURN_KEEPING(vflat, cumprod_ki_native_f32(vflat, fsrc, 0));
+      case CA_FLOAT64: CA_RETURN_KEEPING(vflat, cumprod_ki_native_f64(vflat, fsrc, 0));
+      case CA_CMPLX64: CA_RETURN_KEEPING(vflat, cumprod_ki_native_cmplx64(vflat, fsrc, 0));
+      case CA_CMPLX128: CA_RETURN_KEEPING(vflat, cumprod_ki_native_cmplx128(vflat, fsrc, 0));
+      case CA_BOOLEAN: CA_RETURN_KEEPING(vflat, cumprod_ki_native_bool(vflat, fsrc, 0));
+      case CA_OBJECT: CA_RETURN_KEEPING(vflat, cumprod_ki_native_object(vflat, fsrc, 0));
       default:
-        rb_raise(rb_eCADataTypeError, "cumprod_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[fsrc->data_type]);
+        ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+        rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[fsrc->data_type]);
     }
   }
   if ( TYPE(raxis) == T_ARRAY ) {
-    rb_raise(rb_eArgError, "cumprod_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.cumprod(axis: 0).cumprod(axis: 1)");
-  }
-  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
-    rb_raise(rb_eTypeError, "cumprod_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
-  }
-  int axis = NUM2INT(raxis);
-  if ( axis < 0 ) axis += src->ndim;
-  if ( axis < 0 || axis >= src->ndim ) {
-    rb_raise(rb_eArgError, "cumprod_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cumprod(axis: 0).cumprod(axis: 1)", ca_calling_method_name());
   }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
   switch ( src->data_type ) {
-    case CA_INT8: return cumprod_ki_native_i8(self, src, axis);
-    case CA_UINT8: return cumprod_ki_native_u8(self, src, axis);
-    case CA_INT16: return cumprod_ki_native_i16(self, src, axis);
-    case CA_UINT16: return cumprod_ki_native_u16(self, src, axis);
-    case CA_INT32: return cumprod_ki_native_i32(self, src, axis);
-    case CA_UINT32: return cumprod_ki_native_u32(self, src, axis);
-    case CA_INT64: return cumprod_ki_native_i64(self, src, axis);
-    case CA_UINT64: return cumprod_ki_native_u64(self, src, axis);
-    case CA_FLOAT32: return cumprod_ki_native_f32(self, src, axis);
-    case CA_FLOAT64: return cumprod_ki_native_f64(self, src, axis);
-    case CA_CMPLX64: return cumprod_ki_native_cmplx64(self, src, axis);
-    case CA_CMPLX128: return cumprod_ki_native_cmplx128(self, src, axis);
-    case CA_BOOLEAN: return cumprod_ki_native_bool(self, src, axis);
-    case CA_OBJECT: return cumprod_ki_native_object(self, src, axis);
+    case CA_INT8: CA_RETURN_KEEPING(self, cumprod_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cumprod_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cumprod_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cumprod_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cumprod_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cumprod_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cumprod_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cumprod_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, cumprod_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, cumprod_ki_native_f64(self, src, axis));
+    case CA_CMPLX64: CA_RETURN_KEEPING(self, cumprod_ki_native_cmplx64(self, src, axis));
+    case CA_CMPLX128: CA_RETURN_KEEPING(self, cumprod_ki_native_cmplx128(self, src, axis));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, cumprod_ki_native_bool(self, src, axis));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, cumprod_ki_native_object(self, src, axis));
     default:
-      rb_raise(rb_eCADataTypeError, "cumprod_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]);
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, cmplx64, cmplx128, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
   }
   return Qnil;  /* unreachable */
 }
@@ -1369,18 +1836,17 @@ cummax_ki_native_i8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1391,7 +1857,7 @@ cummax_ki_native_i8 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(int8_t, int8_t, st_in, pi, mi,
                          st_out, po, mo_fiber, INT8_MIN, if (v > acc) acc = v; r = acc);
@@ -1421,18 +1887,17 @@ cummax_ki_native_u8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1443,7 +1908,7 @@ cummax_ki_native_u8 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(uint8_t, uint8_t, st_in, pi, mi,
                          st_out, po, mo_fiber, 0, if (v > acc) acc = v; r = acc);
@@ -1473,18 +1938,17 @@ cummax_ki_native_i16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1495,7 +1959,7 @@ cummax_ki_native_i16 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(int16_t, int16_t, st_in, pi, mi,
                          st_out, po, mo_fiber, INT16_MIN, if (v > acc) acc = v; r = acc);
@@ -1525,18 +1989,17 @@ cummax_ki_native_u16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1547,7 +2010,7 @@ cummax_ki_native_u16 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(uint16_t, uint16_t, st_in, pi, mi,
                          st_out, po, mo_fiber, 0, if (v > acc) acc = v; r = acc);
@@ -1577,18 +2040,17 @@ cummax_ki_native_i32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1599,7 +2061,7 @@ cummax_ki_native_i32 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(int32_t, int32_t, st_in, pi, mi,
                          st_out, po, mo_fiber, INT32_MIN, if (v > acc) acc = v; r = acc);
@@ -1629,18 +2091,17 @@ cummax_ki_native_u32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1651,7 +2112,7 @@ cummax_ki_native_u32 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(uint32_t, uint32_t, st_in, pi, mi,
                          st_out, po, mo_fiber, 0, if (v > acc) acc = v; r = acc);
@@ -1681,18 +2142,17 @@ cummax_ki_native_i64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1703,7 +2163,7 @@ cummax_ki_native_i64 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(int64_t, int64_t, st_in, pi, mi,
                          st_out, po, mo_fiber, INT64_MIN, if (v > acc) acc = v; r = acc);
@@ -1733,18 +2193,17 @@ cummax_ki_native_u64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1755,7 +2214,7 @@ cummax_ki_native_u64 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(uint64_t, uint64_t, st_in, pi, mi,
                          st_out, po, mo_fiber, 0, if (v > acc) acc = v; r = acc);
@@ -1785,18 +2244,17 @@ cummax_ki_native_f32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1807,7 +2265,7 @@ cummax_ki_native_f32 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(float, float, st_in, pi, mi,
                          st_out, po, mo_fiber, NAN, acc = fmax(acc, v); r = acc);
@@ -1837,18 +2295,17 @@ cummax_ki_native_f64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1859,7 +2316,7 @@ cummax_ki_native_f64 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(double, double, st_in, pi, mi,
                          st_out, po, mo_fiber, NAN, acc = fmax(acc, v); r = acc);
@@ -1889,18 +2346,17 @@ cummax_ki_native_bool (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1911,7 +2367,7 @@ cummax_ki_native_bool (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(boolean8_t, uint64_t, st_in, pi, mi,
                          st_out, po, mo_fiber, 0, if ((uint64_t) v > acc) acc = v; r = acc);
@@ -1922,9 +2378,28 @@ cummax_ki_native_bool (VALUE self, CArray *ca, int axis)
   return vout;
 }
 
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+} cummax_ki_native_object_frame;
+
 static VALUE
-cummax_ki_native_object (VALUE self, CArray *ca, int axis)
+cummax_ki_native_object_body (VALUE arg)
 {
+  cummax_ki_native_object_frame *fr = (cummax_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
   VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_OBJECT),
                                           INT2NUM(sizeof(VALUE)));
   CArray *co;
@@ -1935,24 +2410,22 @@ cummax_ki_native_object (VALUE self, CArray *ca, int axis)
      INIT inside the macro. */
   int8_t slab_axes[CA_RANK_MAX];
   slab_axes[0] = (int8_t) axis;
-  ca_iter_state st_in, st_out;
   int rc;
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummax_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -1963,75 +2436,143 @@ cummax_ki_native_object (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(VALUE, VALUE, st_in, pi, mi,
-                         st_out, po, mo_fiber, Qnil, if (acc == Qnil) acc = v; else if (RTEST(rb_funcall(v, rb_intern(">"), 1, acc))) acc = v; r = acc);
+                         st_out, po, mo_fiber, Qnil, if (acc == Qnil || ca_obj_extremum_replaces(v, acc, rb_intern(">"))) acc = v; r = acc);
     ca_iter_state_sync_slab(&st_out);
   }
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
+#undef st_in
+#undef st_out
 }
 
+static VALUE
+cummax_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  cummax_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  return ca_iter_ensure(2, fr.states, cummax_ki_native_object_body, (VALUE) &fr);
+}
+
+
+static VALUE rb_ca_cummax_ki_storage (int argc, VALUE *argv, VALUE self);
+
 static VALUE
 rb_ca_cummax_ki (int argc, VALUE *argv, VALUE self)
 {
   CArray *src;
+  VALUE result;
   GetCArray(self, src);
+  volatile VALUE _reduce_face = Qnil;   /* original Face, for output re-lift */
+  if ( ca_is_face(src) ) {
+    VALUE _face = self;
+    VALUE _st;
+    CArray *_sc;
+    ca_face_require_orderable(_face, ca_calling_method_name(), "order");
+    _st = rb_ca_strip_face_value(self);
+    GetCArray(_st, _sc);
+    _reduce_face = _face;
+    self = _st;
+    src = _sc;
+  }
+  result = rb_ca_cummax_ki_storage(argc, argv, self);
+  if ( _reduce_face != Qnil && RB_TYPE_P(result, T_ARRAY) ) {
+    /* a multi-output reduction (minmax): re-lift each output. */
+    long _i;
+    for ( _i = 0; _i < RARRAY_LEN(result); _i++ ) {
+      VALUE _r = rb_ary_entry(result, _i);
+      if ( _r == CA_UNDEF || _r == Qnil ) continue;
+      if ( rb_obj_is_kind_of(_r, rb_cCArray) ) {
+        _r = ca_face_relift_entity(_reduce_face, _r);
+      }
+      else {
+        CArray *_fca;
+        GetCArray(_reduce_face, _fca);
+        CA_FACE_STORAGE_TO_ELEMENT_IF_FACE(_r, _reduce_face, _fca);
+      }
+      rb_ary_store(result, _i, _r);
+    }
+  }
+  else if ( _reduce_face != Qnil && result != CA_UNDEF && result != Qnil ) {
+    if ( rb_obj_is_kind_of(result, rb_cCArray) ) {
+      /* per-axis: re-lift the storage result as a Face of the same class. */
+      result = ca_face_relift_entity(_reduce_face, result);
+    }
+    else {
+      /* full reduction: decode the scalar via the registered hook. */
+      CArray *_fca;
+      GetCArray(_reduce_face, _fca);
+      CA_FACE_STORAGE_TO_ELEMENT_IF_FACE(result, _reduce_face, _fca);
+    }
+  }
+  return result;
+}
+
+static VALUE
+rb_ca_cummax_ki_storage (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
   volatile VALUE ropt = rb_pop_options(&argc, &argv);
   volatile VALUE raxis = Qnil;
   rb_scan_options(ropt, "axis", &raxis);
   if ( argc > 0 ) {
-    rb_raise(rb_eArgError, "cummax_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cummax(axis: 0)", argc);
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cummax(axis: 0)", ca_calling_method_name(), argc);
   }
   if ( NIL_P(raxis) ) {
     volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
     CArray *fsrc;
     GetCArray(vflat, fsrc);
     switch ( fsrc->data_type ) {
-      case CA_INT8: return cummax_ki_native_i8(vflat, fsrc, 0);
-      case CA_UINT8: return cummax_ki_native_u8(vflat, fsrc, 0);
-      case CA_INT16: return cummax_ki_native_i16(vflat, fsrc, 0);
-      case CA_UINT16: return cummax_ki_native_u16(vflat, fsrc, 0);
-      case CA_INT32: return cummax_ki_native_i32(vflat, fsrc, 0);
-      case CA_UINT32: return cummax_ki_native_u32(vflat, fsrc, 0);
-      case CA_INT64: return cummax_ki_native_i64(vflat, fsrc, 0);
-      case CA_UINT64: return cummax_ki_native_u64(vflat, fsrc, 0);
-      case CA_FLOAT32: return cummax_ki_native_f32(vflat, fsrc, 0);
-      case CA_FLOAT64: return cummax_ki_native_f64(vflat, fsrc, 0);
-      case CA_BOOLEAN: return cummax_ki_native_bool(vflat, fsrc, 0);
-      case CA_OBJECT: return cummax_ki_native_object(vflat, fsrc, 0);
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cummax_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cummax_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cummax_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cummax_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cummax_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cummax_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cummax_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cummax_ki_native_u64(vflat, fsrc, 0));
+      case CA_FLOAT32: CA_RETURN_KEEPING(vflat, cummax_ki_native_f32(vflat, fsrc, 0));
+      case CA_FLOAT64: CA_RETURN_KEEPING(vflat, cummax_ki_native_f64(vflat, fsrc, 0));
+      case CA_BOOLEAN: CA_RETURN_KEEPING(vflat, cummax_ki_native_bool(vflat, fsrc, 0));
+      case CA_OBJECT: CA_RETURN_KEEPING(vflat, cummax_ki_native_object(vflat, fsrc, 0));
       default:
-        rb_raise(rb_eCADataTypeError, "cummax_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object)", ca_type_name[fsrc->data_type]);
+        ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+        rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object)", ca_calling_method_name(), ca_type_name[fsrc->data_type]);
     }
   }
   if ( TYPE(raxis) == T_ARRAY ) {
-    rb_raise(rb_eArgError, "cummax_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.cummax(axis: 0).cummax(axis: 1)");
-  }
-  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
-    rb_raise(rb_eTypeError, "cummax_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
-  }
-  int axis = NUM2INT(raxis);
-  if ( axis < 0 ) axis += src->ndim;
-  if ( axis < 0 || axis >= src->ndim ) {
-    rb_raise(rb_eArgError, "cummax_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cummax(axis: 0).cummax(axis: 1)", ca_calling_method_name());
   }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
   switch ( src->data_type ) {
-    case CA_INT8: return cummax_ki_native_i8(self, src, axis);
-    case CA_UINT8: return cummax_ki_native_u8(self, src, axis);
-    case CA_INT16: return cummax_ki_native_i16(self, src, axis);
-    case CA_UINT16: return cummax_ki_native_u16(self, src, axis);
-    case CA_INT32: return cummax_ki_native_i32(self, src, axis);
-    case CA_UINT32: return cummax_ki_native_u32(self, src, axis);
-    case CA_INT64: return cummax_ki_native_i64(self, src, axis);
-    case CA_UINT64: return cummax_ki_native_u64(self, src, axis);
-    case CA_FLOAT32: return cummax_ki_native_f32(self, src, axis);
-    case CA_FLOAT64: return cummax_ki_native_f64(self, src, axis);
-    case CA_BOOLEAN: return cummax_ki_native_bool(self, src, axis);
-    case CA_OBJECT: return cummax_ki_native_object(self, src, axis);
+    case CA_INT8: CA_RETURN_KEEPING(self, cummax_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cummax_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cummax_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cummax_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cummax_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cummax_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cummax_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cummax_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, cummax_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, cummax_ki_native_f64(self, src, axis));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, cummax_ki_native_bool(self, src, axis));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, cummax_ki_native_object(self, src, axis));
     default:
-      rb_raise(rb_eCADataTypeError, "cummax_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object)", ca_type_name[src->data_type]);
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
   }
   return Qnil;  /* unreachable */
 }
@@ -2057,18 +2598,17 @@ cummin_ki_native_i8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2079,7 +2619,7 @@ cummin_ki_native_i8 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(int8_t, int8_t, st_in, pi, mi,
                          st_out, po, mo_fiber, INT8_MAX, if (v < acc) acc = v; r = acc);
@@ -2109,18 +2649,17 @@ cummin_ki_native_u8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2131,7 +2670,7 @@ cummin_ki_native_u8 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(uint8_t, uint8_t, st_in, pi, mi,
                          st_out, po, mo_fiber, UINT8_MAX, if (v < acc) acc = v; r = acc);
@@ -2161,18 +2700,17 @@ cummin_ki_native_i16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2183,7 +2721,7 @@ cummin_ki_native_i16 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(int16_t, int16_t, st_in, pi, mi,
                          st_out, po, mo_fiber, INT16_MAX, if (v < acc) acc = v; r = acc);
@@ -2213,18 +2751,17 @@ cummin_ki_native_u16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2235,7 +2772,7 @@ cummin_ki_native_u16 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(uint16_t, uint16_t, st_in, pi, mi,
                          st_out, po, mo_fiber, UINT16_MAX, if (v < acc) acc = v; r = acc);
@@ -2265,18 +2802,17 @@ cummin_ki_native_i32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2287,7 +2823,7 @@ cummin_ki_native_i32 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(int32_t, int32_t, st_in, pi, mi,
                          st_out, po, mo_fiber, INT32_MAX, if (v < acc) acc = v; r = acc);
@@ -2317,18 +2853,17 @@ cummin_ki_native_u32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2339,7 +2874,7 @@ cummin_ki_native_u32 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(uint32_t, uint32_t, st_in, pi, mi,
                          st_out, po, mo_fiber, UINT32_MAX, if (v < acc) acc = v; r = acc);
@@ -2369,18 +2904,17 @@ cummin_ki_native_i64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2391,7 +2925,7 @@ cummin_ki_native_i64 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(int64_t, int64_t, st_in, pi, mi,
                          st_out, po, mo_fiber, INT64_MAX, if (v < acc) acc = v; r = acc);
@@ -2421,18 +2955,17 @@ cummin_ki_native_u64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2443,7 +2976,7 @@ cummin_ki_native_u64 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(uint64_t, uint64_t, st_in, pi, mi,
                          st_out, po, mo_fiber, UINT64_MAX, if (v < acc) acc = v; r = acc);
@@ -2473,18 +3006,17 @@ cummin_ki_native_f32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2495,7 +3027,7 @@ cummin_ki_native_f32 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(float, float, st_in, pi, mi,
                          st_out, po, mo_fiber, NAN, acc = fmin(acc, v); r = acc);
@@ -2525,18 +3057,17 @@ cummin_ki_native_f64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2547,7 +3078,7 @@ cummin_ki_native_f64 (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(double, double, st_in, pi, mi,
                          st_out, po, mo_fiber, NAN, acc = fmin(acc, v); r = acc);
@@ -2577,18 +3108,17 @@ cummin_ki_native_bool (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2599,7 +3129,7 @@ cummin_ki_native_bool (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(boolean8_t, uint64_t, st_in, pi, mi,
                          st_out, po, mo_fiber, 1, if ((uint64_t) v < acc) acc = v; r = acc);
@@ -2610,9 +3140,28 @@ cummin_ki_native_bool (VALUE self, CArray *ca, int axis)
   return vout;
 }
 
+/* The object lane calls Ruby for every cell, so a walk can raise part
+   way.  Its states live in the caller's frame, and ca_iter_ensure
+   finishes them however the body leaves. */
+typedef struct {
+  ca_iter_state states[2];
+  VALUE self;
+  CArray *ca;
+  int axis;
+} cummin_ki_native_object_frame;
+
 static VALUE
-cummin_ki_native_object (VALUE self, CArray *ca, int axis)
+cummin_ki_native_object_body (VALUE arg)
 {
+  cummin_ki_native_object_frame *fr = (cummin_ki_native_object_frame *) arg;
+  VALUE self = fr->self;
+  (void) self;
+  CArray *ca = fr->ca;
+  (void) ca;
+  int axis = fr->axis;
+  (void) axis;
+#define st_in (fr->states[0])
+#define st_out (fr->states[1])
   VALUE   vout = rb_ca_template_with_type(self, INT2NUM(CA_OBJECT),
                                           INT2NUM(sizeof(VALUE)));
   CArray *co;
@@ -2623,24 +3172,22 @@ cummin_ki_native_object (VALUE self, CArray *ca, int axis)
      INIT inside the macro. */
   int8_t slab_axes[CA_RANK_MAX];
   slab_axes[0] = (int8_t) axis;
-  ca_iter_state st_in, st_out;
   int rc;
   rc = ca_iter_state_init_l2(&st_in,  ca, CA_SLAB_AXES,
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cummin_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
     boolean8_t *op_mask = NULL;
-    char       *co_root = (char *) co->ptr;
     if ( ca_has_mask(ca) ) {
       ca_create_mask(co);
       op_mask = (boolean8_t *) co->mask->ptr;
@@ -2651,75 +3198,143 @@ cummin_ki_native_object (VALUE self, CArray *ca, int axis)
   while ( ca_iter_state_next_slab_axes(&st_in,  &pi, &mi) &&
           ca_iter_state_next_slab_axes(&st_out, &po, &mo) ) {
     boolean8_t *mo_fiber = op_mask
-            ? op_mask + (ca_size_t)(po - co_root) / (ca_size_t) co->bytes
+            ? op_mask + (ca_size_t)(po - st_out.alias_ptr) / (ca_size_t) co->bytes
             : NULL;
           CA_SLAB_SCAN_T_GATED(VALUE, VALUE, st_in, pi, mi,
-                         st_out, po, mo_fiber, Qnil, if (acc == Qnil) acc = v; else if (RTEST(rb_funcall(v, rb_intern("<"), 1, acc))) acc = v; r = acc);
+                         st_out, po, mo_fiber, Qnil, if (acc == Qnil || ca_obj_extremum_replaces(v, acc, rb_intern("<"))) acc = v; r = acc);
     ca_iter_state_sync_slab(&st_out);
   }
   ca_iter_state_finish(&st_in);
   ca_iter_state_finish(&st_out);
   return vout;
+#undef st_in
+#undef st_out
 }
 
+static VALUE
+cummin_ki_native_object (VALUE self, CArray *ca, int axis)
+{
+  cummin_ki_native_object_frame fr;
+  fr.self = self;
+  fr.ca = ca;
+  fr.axis = axis;
+  return ca_iter_ensure(2, fr.states, cummin_ki_native_object_body, (VALUE) &fr);
+}
+
+
+static VALUE rb_ca_cummin_ki_storage (int argc, VALUE *argv, VALUE self);
+
 static VALUE
 rb_ca_cummin_ki (int argc, VALUE *argv, VALUE self)
 {
   CArray *src;
+  VALUE result;
   GetCArray(self, src);
+  volatile VALUE _reduce_face = Qnil;   /* original Face, for output re-lift */
+  if ( ca_is_face(src) ) {
+    VALUE _face = self;
+    VALUE _st;
+    CArray *_sc;
+    ca_face_require_orderable(_face, ca_calling_method_name(), "order");
+    _st = rb_ca_strip_face_value(self);
+    GetCArray(_st, _sc);
+    _reduce_face = _face;
+    self = _st;
+    src = _sc;
+  }
+  result = rb_ca_cummin_ki_storage(argc, argv, self);
+  if ( _reduce_face != Qnil && RB_TYPE_P(result, T_ARRAY) ) {
+    /* a multi-output reduction (minmax): re-lift each output. */
+    long _i;
+    for ( _i = 0; _i < RARRAY_LEN(result); _i++ ) {
+      VALUE _r = rb_ary_entry(result, _i);
+      if ( _r == CA_UNDEF || _r == Qnil ) continue;
+      if ( rb_obj_is_kind_of(_r, rb_cCArray) ) {
+        _r = ca_face_relift_entity(_reduce_face, _r);
+      }
+      else {
+        CArray *_fca;
+        GetCArray(_reduce_face, _fca);
+        CA_FACE_STORAGE_TO_ELEMENT_IF_FACE(_r, _reduce_face, _fca);
+      }
+      rb_ary_store(result, _i, _r);
+    }
+  }
+  else if ( _reduce_face != Qnil && result != CA_UNDEF && result != Qnil ) {
+    if ( rb_obj_is_kind_of(result, rb_cCArray) ) {
+      /* per-axis: re-lift the storage result as a Face of the same class. */
+      result = ca_face_relift_entity(_reduce_face, result);
+    }
+    else {
+      /* full reduction: decode the scalar via the registered hook. */
+      CArray *_fca;
+      GetCArray(_reduce_face, _fca);
+      CA_FACE_STORAGE_TO_ELEMENT_IF_FACE(result, _reduce_face, _fca);
+    }
+  }
+  return result;
+}
+
+static VALUE
+rb_ca_cummin_ki_storage (int argc, VALUE *argv, VALUE self)
+{
+  CArray *src;
+  GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
   volatile VALUE ropt = rb_pop_options(&argc, &argv);
   volatile VALUE raxis = Qnil;
   rb_scan_options(ropt, "axis", &raxis);
   if ( argc > 0 ) {
-    rb_raise(rb_eArgError, "cummin_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cummin(axis: 0)", argc);
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cummin(axis: 0)", ca_calling_method_name(), argc);
   }
   if ( NIL_P(raxis) ) {
     volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
     CArray *fsrc;
     GetCArray(vflat, fsrc);
     switch ( fsrc->data_type ) {
-      case CA_INT8: return cummin_ki_native_i8(vflat, fsrc, 0);
-      case CA_UINT8: return cummin_ki_native_u8(vflat, fsrc, 0);
-      case CA_INT16: return cummin_ki_native_i16(vflat, fsrc, 0);
-      case CA_UINT16: return cummin_ki_native_u16(vflat, fsrc, 0);
-      case CA_INT32: return cummin_ki_native_i32(vflat, fsrc, 0);
-      case CA_UINT32: return cummin_ki_native_u32(vflat, fsrc, 0);
-      case CA_INT64: return cummin_ki_native_i64(vflat, fsrc, 0);
-      case CA_UINT64: return cummin_ki_native_u64(vflat, fsrc, 0);
-      case CA_FLOAT32: return cummin_ki_native_f32(vflat, fsrc, 0);
-      case CA_FLOAT64: return cummin_ki_native_f64(vflat, fsrc, 0);
-      case CA_BOOLEAN: return cummin_ki_native_bool(vflat, fsrc, 0);
-      case CA_OBJECT: return cummin_ki_native_object(vflat, fsrc, 0);
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cummin_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cummin_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cummin_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cummin_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cummin_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cummin_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cummin_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cummin_ki_native_u64(vflat, fsrc, 0));
+      case CA_FLOAT32: CA_RETURN_KEEPING(vflat, cummin_ki_native_f32(vflat, fsrc, 0));
+      case CA_FLOAT64: CA_RETURN_KEEPING(vflat, cummin_ki_native_f64(vflat, fsrc, 0));
+      case CA_BOOLEAN: CA_RETURN_KEEPING(vflat, cummin_ki_native_bool(vflat, fsrc, 0));
+      case CA_OBJECT: CA_RETURN_KEEPING(vflat, cummin_ki_native_object(vflat, fsrc, 0));
       default:
-        rb_raise(rb_eCADataTypeError, "cummin_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object)", ca_type_name[fsrc->data_type]);
+        ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+        rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object)", ca_calling_method_name(), ca_type_name[fsrc->data_type]);
     }
   }
   if ( TYPE(raxis) == T_ARRAY ) {
-    rb_raise(rb_eArgError, "cummin_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.cummin(axis: 0).cummin(axis: 1)");
-  }
-  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
-    rb_raise(rb_eTypeError, "cummin_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
-  }
-  int axis = NUM2INT(raxis);
-  if ( axis < 0 ) axis += src->ndim;
-  if ( axis < 0 || axis >= src->ndim ) {
-    rb_raise(rb_eArgError, "cummin_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cummin(axis: 0).cummin(axis: 1)", ca_calling_method_name());
   }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
   switch ( src->data_type ) {
-    case CA_INT8: return cummin_ki_native_i8(self, src, axis);
-    case CA_UINT8: return cummin_ki_native_u8(self, src, axis);
-    case CA_INT16: return cummin_ki_native_i16(self, src, axis);
-    case CA_UINT16: return cummin_ki_native_u16(self, src, axis);
-    case CA_INT32: return cummin_ki_native_i32(self, src, axis);
-    case CA_UINT32: return cummin_ki_native_u32(self, src, axis);
-    case CA_INT64: return cummin_ki_native_i64(self, src, axis);
-    case CA_UINT64: return cummin_ki_native_u64(self, src, axis);
-    case CA_FLOAT32: return cummin_ki_native_f32(self, src, axis);
-    case CA_FLOAT64: return cummin_ki_native_f64(self, src, axis);
-    case CA_BOOLEAN: return cummin_ki_native_bool(self, src, axis);
-    case CA_OBJECT: return cummin_ki_native_object(self, src, axis);
+    case CA_INT8: CA_RETURN_KEEPING(self, cummin_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cummin_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cummin_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cummin_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cummin_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cummin_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cummin_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cummin_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, cummin_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, cummin_ki_native_f64(self, src, axis));
+    case CA_BOOLEAN: CA_RETURN_KEEPING(self, cummin_ki_native_bool(self, src, axis));
+    case CA_OBJECT: CA_RETURN_KEEPING(self, cummin_ki_native_object(self, src, axis));
     default:
-      rb_raise(rb_eCADataTypeError, "cummin_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64, bool, object)", ca_type_name[src->data_type]);
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64, boolean, object)", ca_calling_method_name(), ca_type_name[src->data_type]);
   }
   return Qnil;  /* unreachable */
 }
@@ -2745,14 +3360,14 @@ cumcount_ki_native_i8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -2787,14 +3402,14 @@ cumcount_ki_native_u8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -2829,14 +3444,14 @@ cumcount_ki_native_i16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -2871,14 +3486,14 @@ cumcount_ki_native_u16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -2913,14 +3528,14 @@ cumcount_ki_native_i32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -2955,14 +3570,14 @@ cumcount_ki_native_u32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -2997,14 +3612,14 @@ cumcount_ki_native_i64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3039,14 +3654,14 @@ cumcount_ki_native_u64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3081,14 +3696,14 @@ cumcount_ki_native_f32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3123,14 +3738,14 @@ cumcount_ki_native_f64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "cumcount_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3151,63 +3766,55 @@ rb_ca_cumcount_ki (int argc, VALUE *argv, VALUE self)
 {
   CArray *src;
   GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
   volatile VALUE ropt = rb_pop_options(&argc, &argv);
   volatile VALUE raxis = Qnil;
   rb_scan_options(ropt, "axis", &raxis);
   if ( argc > 0 ) {
-    rb_raise(rb_eArgError, "cumcount_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumcount(axis: 0)", argc);
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.cumcount(axis: 0)", ca_calling_method_name(), argc);
   }
   if ( NIL_P(raxis) ) {
     volatile VALUE vflat = rb_funcall(self, rb_intern("flatten"), 0);
     CArray *fsrc;
     GetCArray(vflat, fsrc);
     switch ( fsrc->data_type ) {
-      case CA_INT8: return cumcount_ki_native_i8(vflat, fsrc, 0);
-      case CA_UINT8: return cumcount_ki_native_u8(vflat, fsrc, 0);
-      case CA_INT16: return cumcount_ki_native_i16(vflat, fsrc, 0);
-      case CA_UINT16: return cumcount_ki_native_u16(vflat, fsrc, 0);
-      case CA_INT32: return cumcount_ki_native_i32(vflat, fsrc, 0);
-      case CA_UINT32: return cumcount_ki_native_u32(vflat, fsrc, 0);
-      case CA_INT64: return cumcount_ki_native_i64(vflat, fsrc, 0);
-      case CA_UINT64: return cumcount_ki_native_u64(vflat, fsrc, 0);
-      case CA_FLOAT32: return cumcount_ki_native_f32(vflat, fsrc, 0);
-      case CA_FLOAT64: return cumcount_ki_native_f64(vflat, fsrc, 0);
-      default: {
-        VALUE   vsrc = rb_ca_wrap_readonly(vflat, INT2NUM(CA_FLOAT64));
-        CArray *casted;
-        GetCArray(vsrc, casted);
-        return cumcount_ki_native_f64(vsrc, casted, 0);
-      }
+      case CA_INT8: CA_RETURN_KEEPING(vflat, cumcount_ki_native_i8(vflat, fsrc, 0));
+      case CA_UINT8: CA_RETURN_KEEPING(vflat, cumcount_ki_native_u8(vflat, fsrc, 0));
+      case CA_INT16: CA_RETURN_KEEPING(vflat, cumcount_ki_native_i16(vflat, fsrc, 0));
+      case CA_UINT16: CA_RETURN_KEEPING(vflat, cumcount_ki_native_u16(vflat, fsrc, 0));
+      case CA_INT32: CA_RETURN_KEEPING(vflat, cumcount_ki_native_i32(vflat, fsrc, 0));
+      case CA_UINT32: CA_RETURN_KEEPING(vflat, cumcount_ki_native_u32(vflat, fsrc, 0));
+      case CA_INT64: CA_RETURN_KEEPING(vflat, cumcount_ki_native_i64(vflat, fsrc, 0));
+      case CA_UINT64: CA_RETURN_KEEPING(vflat, cumcount_ki_native_u64(vflat, fsrc, 0));
+      case CA_FLOAT32: CA_RETURN_KEEPING(vflat, cumcount_ki_native_f32(vflat, fsrc, 0));
+      case CA_FLOAT64: CA_RETURN_KEEPING(vflat, cumcount_ki_native_f64(vflat, fsrc, 0));
+      default:
+        return rb_ca_scan_mask_count(self, Qnil);
     }
   }
   if ( TYPE(raxis) == T_ARRAY ) {
-    rb_raise(rb_eArgError, "cumcount_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.cumcount(axis: 0).cumcount(axis: 1)");
-  }
-  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
-    rb_raise(rb_eTypeError, "cumcount_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
-  }
-  int axis = NUM2INT(raxis);
-  if ( axis < 0 ) axis += src->ndim;
-  if ( axis < 0 || axis >= src->ndim ) {
-    rb_raise(rb_eArgError, "cumcount_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.cumcount(axis: 0).cumcount(axis: 1)", ca_calling_method_name());
   }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
   switch ( src->data_type ) {
-    case CA_INT8: return cumcount_ki_native_i8(self, src, axis);
-    case CA_UINT8: return cumcount_ki_native_u8(self, src, axis);
-    case CA_INT16: return cumcount_ki_native_i16(self, src, axis);
-    case CA_UINT16: return cumcount_ki_native_u16(self, src, axis);
-    case CA_INT32: return cumcount_ki_native_i32(self, src, axis);
-    case CA_UINT32: return cumcount_ki_native_u32(self, src, axis);
-    case CA_INT64: return cumcount_ki_native_i64(self, src, axis);
-    case CA_UINT64: return cumcount_ki_native_u64(self, src, axis);
-    case CA_FLOAT32: return cumcount_ki_native_f32(self, src, axis);
-    case CA_FLOAT64: return cumcount_ki_native_f64(self, src, axis);
-    default: {
-      VALUE   vsrc = rb_ca_wrap_readonly(self, INT2NUM(CA_FLOAT64));
-      CArray *casted;
-      GetCArray(vsrc, casted);
-      return cumcount_ki_native_f64(vsrc, casted, axis);
-    }
+    case CA_INT8: CA_RETURN_KEEPING(self, cumcount_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, cumcount_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, cumcount_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, cumcount_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, cumcount_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, cumcount_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, cumcount_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, cumcount_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, cumcount_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, cumcount_ki_native_f64(self, src, axis));
+    default:
+      return rb_ca_scan_mask_count(self, INT2NUM(axis));
   }
   return Qnil;  /* unreachable */
 }
@@ -3233,14 +3840,14 @@ uniq_scan_ki_native_i8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3275,14 +3882,14 @@ uniq_scan_ki_native_u8 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3317,14 +3924,14 @@ uniq_scan_ki_native_i16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3359,14 +3966,14 @@ uniq_scan_ki_native_u16 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3401,14 +4008,14 @@ uniq_scan_ki_native_i32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3443,14 +4050,14 @@ uniq_scan_ki_native_u32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3485,14 +4092,14 @@ uniq_scan_ki_native_i64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3527,14 +4134,14 @@ uniq_scan_ki_native_u64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3569,14 +4176,14 @@ uniq_scan_ki_native_f32 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3611,14 +4218,14 @@ uniq_scan_ki_native_f64 (VALUE self, CArray *ca, int axis)
                              slab_axes, 1, 0);
   if ( rc != CA_ITER_OK ) {
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: input init failed rc=%d", rc);
+             "%s: input init failed rc=%d", ca_calling_method_name(), rc);
   }
-  rc = ca_iter_state_init_l2(&st_out, co, CA_SLAB_AXES,
+  rc = ca_iter_state_init_l2_paired(&st_out, &st_in, co, CA_SLAB_AXES,
                              slab_axes, 1, CA_KERNEL_WRITE);
   if ( rc != CA_ITER_OK ) {
     ca_iter_state_finish(&st_in);
     rb_raise(rb_eRuntimeError,
-             "uniq_scan_ki: output init failed rc=%d", rc);
+             "%s: output init failed rc=%d", ca_calling_method_name(), rc);
   }
 
   char       *pi, *po;
@@ -3639,39 +4246,40 @@ rb_ca_uniq_scan_ki (int argc, VALUE *argv, VALUE self)
 {
   CArray *src;
   GetCArray(self, src);
+  if ( ca_is_lazy_view(src) ) {
+    volatile VALUE evaluated = ca_lazy_evaluated(self);
+    if ( ! NIL_P(evaluated) ) {
+      self = evaluated;
+      GetCArray(self, src);
+    }
+  }
   volatile VALUE ropt = rb_pop_options(&argc, &argv);
   volatile VALUE raxis = Qnil;
   rb_scan_options(ropt, "axis", &raxis);
   if ( argc > 0 ) {
-    rb_raise(rb_eArgError, "uniq_scan_ki: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.uniq_scan(axis: 0)", argc);
+    rb_raise(rb_eArgError, "%s: positional axis is no longer accepted (got %d); use axis: kwarg, e.g. a.uniq_scan(axis: 0)", ca_calling_method_name(), argc);
   }
   if ( NIL_P(raxis) ) {
-    rb_raise(rb_eArgError, "uniq_scan_ki: axis: kwarg is required (single axis Integer; multi-axis scan is semantically ambiguous)");
+    rb_raise(rb_eArgError, "%s: axis: is required (a single Integer; a scan over several axes is ambiguous)", ca_calling_method_name());
   }
   if ( TYPE(raxis) == T_ARRAY ) {
-    rb_raise(rb_eArgError, "uniq_scan_ki: axis: must be Integer (got Array); multi-axis scan is semantically ambiguous, chain explicitly: a.uniq_scan(axis: 0).uniq_scan(axis: 1)");
-  }
-  if ( ! rb_obj_is_kind_of(raxis, rb_cInteger) ) {
-    rb_raise(rb_eTypeError, "uniq_scan_ki: axis: must be Integer (got %"PRIsVALUE")", rb_obj_class(raxis));
-  }
-  int axis = NUM2INT(raxis);
-  if ( axis < 0 ) axis += src->ndim;
-  if ( axis < 0 || axis >= src->ndim ) {
-    rb_raise(rb_eArgError, "uniq_scan_ki: axis %d out of range for ndim %d", NUM2INT(raxis), src->ndim);
+    rb_raise(rb_eArgError, "%s: axis must be a single Integer (got Array); a scan over several axes is ambiguous, chain explicitly: a.uniq_scan(axis: 0).uniq_scan(axis: 1)", ca_calling_method_name());
   }
+  int axis = ca_normalize_axis_arg(raxis, src->ndim, NULL);
   switch ( src->data_type ) {
-    case CA_INT8: return uniq_scan_ki_native_i8(self, src, axis);
-    case CA_UINT8: return uniq_scan_ki_native_u8(self, src, axis);
-    case CA_INT16: return uniq_scan_ki_native_i16(self, src, axis);
-    case CA_UINT16: return uniq_scan_ki_native_u16(self, src, axis);
-    case CA_INT32: return uniq_scan_ki_native_i32(self, src, axis);
-    case CA_UINT32: return uniq_scan_ki_native_u32(self, src, axis);
-    case CA_INT64: return uniq_scan_ki_native_i64(self, src, axis);
-    case CA_UINT64: return uniq_scan_ki_native_u64(self, src, axis);
-    case CA_FLOAT32: return uniq_scan_ki_native_f32(self, src, axis);
-    case CA_FLOAT64: return uniq_scan_ki_native_f64(self, src, axis);
+    case CA_INT8: CA_RETURN_KEEPING(self, uniq_scan_ki_native_i8(self, src, axis));
+    case CA_UINT8: CA_RETURN_KEEPING(self, uniq_scan_ki_native_u8(self, src, axis));
+    case CA_INT16: CA_RETURN_KEEPING(self, uniq_scan_ki_native_i16(self, src, axis));
+    case CA_UINT16: CA_RETURN_KEEPING(self, uniq_scan_ki_native_u16(self, src, axis));
+    case CA_INT32: CA_RETURN_KEEPING(self, uniq_scan_ki_native_i32(self, src, axis));
+    case CA_UINT32: CA_RETURN_KEEPING(self, uniq_scan_ki_native_u32(self, src, axis));
+    case CA_INT64: CA_RETURN_KEEPING(self, uniq_scan_ki_native_i64(self, src, axis));
+    case CA_UINT64: CA_RETURN_KEEPING(self, uniq_scan_ki_native_u64(self, src, axis));
+    case CA_FLOAT32: CA_RETURN_KEEPING(self, uniq_scan_ki_native_f32(self, src, axis));
+    case CA_FLOAT64: CA_RETURN_KEEPING(self, uniq_scan_ki_native_f64(self, src, axis));
     default:
-      rb_raise(rb_eCADataTypeError, "uniq_scan_ki: source data_type :%s not supported (expected one of: i8, u8, i16, u16, i32, u32, i64, u64, f32, f64)", ca_type_name[src->data_type]);
+      ca_face_refuse_numeric(self, ca_calling_method_name(), rb_eCADataTypeError);
+      rb_raise(rb_eCADataTypeError, "%s: source data_type :%s not supported (expected one of: int8, uint8, int16, uint16, int32, uint32, int64, uint64, float32, float64)", ca_calling_method_name(), ca_type_name[src->data_type]);
   }
   return Qnil;  /* unreachable */
 }
@@ -3681,6 +4289,7 @@ Init_carray_kernels_scan (void)
 {
   rb_define_method(rb_cCArray, "cumsum_ki", rb_ca_cumsum_ki, -1);
   rb_define_method(rb_cCArray, "cumsum", rb_ca_cumsum_ki, -1);
+  rb_define_private_method(rb_cCArray, "cumsum_in_own_type", rb_ca_cumsum_in_own_type_ki, -1);
   rb_define_method(rb_cCArray, "cumprod_ki", rb_ca_cumprod_ki, -1);
   rb_define_method(rb_cCArray, "cumprod", rb_ca_cumprod_ki, -1);
   rb_define_method(rb_cCArray, "cummax_ki", rb_ca_cummax_ki, -1);