carray 3.0.0 → 3.0.1

data/lib/carray/lazy.rb

@@ -73,11 +73,11 @@ class CArray
     rad_2pi: CAMonOp::OP_RAD_2PI,
     rad_pi:  CAMonOp::OP_RAD_PI,
 
-    # Sign function (preserve dtype).  bool/uint → 0/1, sint → -1/0/1,
+    # Sign function (preserves the data type).  bool/uint → 0/1, sint → -1/0/1,
     # float → -1/0/1 NaN-preserving, complex → unit vector or 0.
     sign:    CAMonOp::OP_SIGN,
 
-    # imag_i: preserve-dtype primitive (0 for numeric, cimag for complex
+    # imag_i: type-preserving primitive (0 for numeric, cimag for complex
     # in the real slot).  Primarily consumed by the `imag` special case
     # below but also directly callable via `a.lazy.imag_i`; entry here
     # so the direct call fuses instead of falling to eager.
@@ -118,24 +118,28 @@ class CArray
   # complex-specific dispatch (= magnitude as float).  Re-express that
   # dispatch via chain composition over existing lazy ops so abs rides
   # the lazy substrate fully:
-  #   numeric parent: CAMonOp(OP_ABS_I)                        (1 node)
-  #   complex parent: CAMonOp(cast_f64) ∘ CAMonOp(OP_ABS_I)    (2 nodes)
-  # The complex chain works because ca_monop_abs_i for cmplx128 stores
-  # |z| in the real slot with imag=0, then cast cmplx128->f64 picks up
-  # the real part — semantically identical to rb_ca_abs (= abs_i + .real
-  # + copy).  No new C kernel, no new op_id required.
+  #   numeric parent: CAMonOp(OP_ABS_I)                            (1 node)
+  #   complex parent: CAMonOp(cast_<float>) ∘ CAMonOp(OP_ABS_I)    (2 nodes)
+  # The complex chain works because ca_monop_abs_i stores |z| in the
+  # real slot with imag=0, then the cast picks up the real part —
+  # semantically identical to the eager abs.  The cast target is the
+  # real component width of the operand (cmplx64 -> f32, cmplx128 ->
+  # f64), matching the eager kernel's `complex: :real_of_source`.
+  # No new C kernel, no new op_id required.
   # ---------------------------------------------------------------------------
 
+  # @private
   alias_method :__abs_eager__, :abs
   __abs_eager_um__ = instance_method(:__abs_eager__)
   define_method(:abs) do
     if __lazy_view__?
       abs_i_node = CAMonOp.__build__(self, CAMonOp::OP_ABS_I)
       if complex?
-        # CA_FLOAT64 is a Symbol; convert via data_type_code so the cast
+        # float_dt is a Symbol; convert via data_type_code so the cast
         # op_id can be computed by Integer arithmetic.
+        float_dt = (data_type == CA_CMPLX64) ? CA_FLOAT32 : CA_FLOAT64
         CAMonOp.__build__(abs_i_node,
-                          CAMonOp::CAST_BASE + CArray.data_type_code(CA_FLOAT64))
+                          CAMonOp::CAST_BASE + CArray.data_type_code(float_dt))
       else
         abs_i_node
       end
@@ -174,6 +178,7 @@ class CArray
   # mutability on the lazy path is not a regression.
   # ---------------------------------------------------------------------------
 
+  # @private
   alias_method :__real_eager__, :real
   __real_eager_um__ = instance_method(:__real_eager__)
   define_method(:real) do
@@ -216,11 +221,11 @@ class CArray
   end
 
   # ---------------------------------------------------------------------------
-  # arg lazy fuse: eager `arg` always returns f64 regardless of input
-  # dtype (data_type-changing monop; see MkKernel.monop :arg output rule).
-  # CAMonOp's cast-before invariant requires input dtype == output dtype
+  # arg lazy fuse: eager `arg` is a data_type-changing monop (see
+  # MkKernel.monop :arg output rule).
+  # CAMonOp's cast-before invariant requires input data type == output data type
   # at each in-place step, so `arg` can't sit directly in the substrate.
-  # Chain compose via the preserve-dtype `arg_i` primitive:
+  # Chain compose via the type-preserving `arg_i` primitive:
   #
   #   integer / bool parent → cast_f64 ∘ arg_i (result f64)
   #   float parent         → arg_i             (result same float)
@@ -228,14 +233,13 @@ class CArray
   #                          component of complex slot; cast extracts
   #                          the real part, same trick as abs / imag)
   #
-  # Note: eager `arg` always widens to f64.  The lazy path preserves
-  # the operand's float / complex width (f32 → f32, cmplx64 → f32)
-  # rather than always going to f64 — matches the general lazy-substrate
-  # rule "scalar keeps operand's precision" (see ca_lazy_wrap_scalar
-  # header).  A user needing exact eager-parity can wrap with
-  # `.to_type(:float64)` before / after.
+  # Both paths keep the operand's float / complex width (f32 → f32,
+  # cmplx64 → f32), and both send integers to f64 since pi does not fit
+  # an integer slot.  That agrees with the general lazy-substrate rule
+  # "scalar keeps operand's precision" (see ca_lazy_wrap_scalar header).
   # ---------------------------------------------------------------------------
 
+  # @private
   alias_method :__arg_eager__, :arg
   __arg_eager_um__ = instance_method(:__arg_eager__)
   define_method(:arg) do
@@ -307,7 +311,6 @@ class CArray
 
     # IEEE 754 remainder (distinct semantics from `%` / `mod`: float
     # branch uses C99 `remainder`, round-half-to-even).
-    :reminder  => CABinOp::OP_REMINDER,
   }.freeze
 
   LAZY_BINOP_OP_IDS.each do |method_name, op_id|
@@ -533,7 +536,7 @@ class CArray
     if __lazy_view__?
       dt_name = data_type_name
       if CScalar.respond_to?(dt_name)
-        s = CScalar.send(dt_name)
+        s = CScalar.public_send(dt_name)
         s[0] = other
         [s, self]
       else
@@ -801,6 +804,15 @@ end
       end
       copy
     end
+
+    # Where something is registered to compute an expression -- a compiler,
+    # say -- it is asked here, and the walk below is what happens when it
+    # declines, when nothing is registered, or when the array is small
+    # enough that walking is the faster answer.
+    def copy
+      return super unless CArray.expression_evaluator
+      CArray::Fusion.evaluate(self) || super
+    end
   end
 end
 
@@ -825,65 +837,105 @@ end
 #   - A bare lazy return auto-materialises; escaping the lazy view (e.g.
 #     stashing it in an Array) is the user's responsibility.
 # ---------------------------------------------------------------------------
+# CArray.fuse
+#
+# Builds an expression instead of evaluating it, so that it is computed in
+# one pass with no array standing for a step along the way.  The block is
+# read rather than called; see CArray::FuseSource for why, and for what
+# happens where its source cannot be read.
+# ---------------------------------------------------------------------------
 class << CArray
-  # @overload fuse(*args) { |*shadows| ... }
-  #   Runs a transient lazy-fusion scope: wraps each CArray argument
-  #   with `.lazy`, yields the wrappers (and any non-CArray args)
-  #   to the block, then auto-materialises a bare lazy return value
-  #   into an entity. Non-lazy returns pass through as-is.
-  #   @param args [Array<CArray, Object>] operands.
-  #   @yieldparam shadows [Array<CArray, Object>] lazy wrappers
-  #     paired with pass-through non-CArray operands.
-  #   @return [Object]
-  #   @raise [LocalJumpError] when no block is given.
-  def fuse(*args)
-    raise LocalJumpError, "CArray.fuse requires a block" unless block_given?
-    shadows = args.map { |a| a.is_a?(CArray) ? a.lazy : a }
-    result = yield(*shadows)
-    case result
-    when CAMonOp, CABinOp, CAMonCmp, CABinCmp, CALazyMarker
-      result.to_ca
-    else
-      result
+  # The object asked to compute an expression, or nil.  CArray can always
+  # walk one, so nothing has to be registered and nothing changes when
+  # nothing is; what a registered evaluator adds is a second way to arrive
+  # at the same answer, and it may decline.
+  #
+  # It is called as `call(plan, out)` -- see {CArray::Fusion} for what a
+  # plan holds -- and answers by filling `out` and returning something
+  # true, or by returning something false having written nothing.  Raising
+  # is not an answer: one that raises is dropped, with a warning, and
+  # expressions are walked from there on.
+  #
+  # @return [#call, nil]
+  attr_reader :expression_evaluator
+
+  # @param object [#call, nil] see {#expression_evaluator}
+  # @raise [ArgumentError] when it cannot be called.
+  def expression_evaluator= (object)
+    if object && ! object.respond_to?(:call)
+      raise ArgumentError,
+            "an expression evaluator must respond to #call(plan, out)"
     end
+    @expression_evaluator = object
   end
 
-  # CArray.lazy(*args) { |lazies| ... }  —  dual of fuse
+  # @overload fuse { <expression> }
+  #   Builds the expression rather than evaluating it, so that it is
+  #   computed in one pass with no array standing for a step along the way.
   #
-  # Like `fuse`, wraps each CArray argument with `.lazy` and yields it to
-  # the block, but **does not auto-materialise at block exit** (= returns
-  # the lazy structure as-is). If the block return is non-lazy (= Numeric
-  # / entity CArray / Array etc.) it's pass-through (= same polymorphic
-  # semantics as fuse).
+  #   The block is not called.  Its source is read, every name in it that
+  #   holds a CArray is given `.lazy`, and the result is evaluated back in
+  #   the block's own binding -- so `self`, instance variables, methods and
+  #   constants are what they were where it was written.
   #
-  # Use cases:
-  #   - Passing a chain between functions: build the lazy expression
-  #     inside the function and materialise at the caller
-  #     (= `.to_ca` / `.sum` / `.mean(axis:)` etc.)
-  #   - Reusable expressions: apply the same expr to multiple datasets
-  #   - debug / dump_tree: observe the lazy structure as-is
-  #   - Pick the materialise form later: full materialise or reduction
+  #     out[] = CArray.fuse { (a + b) * (c - a) }
+  #     total = CArray.fuse { a * weight }.sum
   #
-  # Example:
-  #   expr = CArray.lazy(a, b) { |s, o| (s + o) * 2 }
-  #   expr.class           #=> CABinOp (lazy view)
-  #   expr.to_ca           # full materialise
-  #   expr.sum             # reduction (= chain + reduce in 1 pass)
+  #   What comes back is the expression, not an array: it is computed where
+  #   it is used -- stored into an array, reduced, or asked for one with
+  #   `to_ca`.  A block holding anything but an expression over arrays comes
+  #   back as whatever it evaluated to.
   #
-  # Polymorphic semantics (= symmetric with fuse):
-  #   CArray.lazy(25.0, b) { |s, o| s + o }   # s=25.0 Float pass-through
-  #   CArray.lazy(arr, b)  { |s, o| s + o }   # s=arr.lazy
-  # @overload lazy(*args) { |*shadows| ... }
-  #   Like {.fuse} but does not auto-materialise: returns whatever
-  #   the block yields (typically a lazy view) so the expression
-  #   can be materialised later via `.to_ca`, `.sum`, `.mean`, etc.
-  #   @param args [Array<CArray, Object>] operands.
-  #   @yieldparam shadows [Array<CArray, Object>] lazy wrappers.
-  #   @return [Object]
+  #   @return [Object] the expression, as a lazy view
   #   @raise [LocalJumpError] when no block is given.
-  def lazy(*args)
-    raise LocalJumpError, "CArray.lazy requires a block" unless block_given?
-    shadows = args.map { |a| a.is_a?(CArray) ? a.lazy : a }
-    yield(*shadows)
+  #   @raise [ArgumentError] when the block's source cannot be read -- in
+  #     irb, in `eval`, or from a file that is gone.  Write `.lazy` on the
+  #     operands there: `a.lazy + b.lazy`.
+  def fuse (*args, &block)
+    raise LocalJumpError, "CArray.fuse requires a block" unless block
+    unless args.empty?
+      raise ArgumentError,
+            "CArray.fuse takes no arguments: write the expression itself, " \
+            "`CArray.fuse { a + b }`, and the names in it are read from " \
+            "where the block was written"
+    end
+    CArray::FuseSource.evaluate(block)
+  end
+
+  # @overload jit_for (*extents) { |i, j, ...| ... }
+  #   Runs a block over an index space, so that a cell may reach the ones
+  #   around it -- a recurrence, a stencil.  The block is compiled, and the
+  #   compiler is the carray-jit gem.
+  #   @raise [NotImplementedError] when that gem is not installed.
+  def jit_for (*extents, **options)
+    raise NotImplementedError, no_compiler("jit_for")
+  end
+
+  # @overload jit_each { ... }
+  #   Runs a block over the cells of arrays at once, naming each cell by the
+  #   array it came from, and writing what it computes into arrays of yours:
+  #   `CArray.jit_each { out = a + b * c }`.  The block is compiled, and the
+  #   compiler is the carray-jit gem.
+  #   @raise [NotImplementedError] when that gem is not installed.
+  def jit_each (&block)
+    raise NotImplementedError, no_compiler("jit_each")
+  end
+
+  # @overload jit_map { ... }
+  #   The same block with its value asked for: the last statement is what
+  #   every cell of the result gets, and the result comes back.  The block is
+  #   compiled, and the compiler is the carray-jit gem.
+  #   @raise [NotImplementedError] when that gem is not installed.
+  def jit_map (&block)
+    raise NotImplementedError, no_compiler("jit_map")
+  end
+
+  private
+
+  def no_compiler (name)
+    "CArray.#{name} compiles its block, and the compiler is the carray-jit " \
+    "gem, which is not installed.  An expression over whole arrays can be " \
+    "written as `CArray.fuse { ... }` instead, which needs no compiler; " \
+    "reaching a neighbouring cell, or writing the loop itself, does."
   end
 end

data/lib/carray/meld_reduce.rb

@@ -190,7 +190,7 @@ class CAMeld
   # is unchanged.  (Reduced axis == meld_axis is handled by the callers'
   # meld_axis branch and never reaches here.)
   def non_meld_axis_decompose(op, axis)
-    parts = parents.map { |p| p.send(op, axis: axis) }
+    parts = parents.map { |p| p.public_send(op, axis: axis) }
     axis_norm = axis < 0 ? axis + ndim : axis
     new_meld_axis = axis_norm < meld_axis ? meld_axis - 1 : meld_axis
     CArray.meld(parts, axis: new_meld_axis).copy
@@ -202,7 +202,7 @@ class CAMeld
     # Empty-parent / short-parent handling — Welford needs n >= 2 per parent
     # to recover m2 from p.variance for sample, n >= 1 for variancep (n=1
     # gives m2=0, fine).  Any parent below its threshold punts to super,
-    # which handles UNDEF / 0-count per CLAUDE.md contract.
+    # which handles the UNDEF / zero-count cases.
     min_n = sample ? 2 : 1
     if axis.nil?
       return yield if parents.any? { |p| p.elements < min_n }

data/lib/carray/methods/align_addr.rb

@@ -33,7 +33,7 @@ class CArray
   #
   #   Value equality follows the value-hash discovery family (numeric `==` with
   #   NaN collapsed and `-0.0 == +0.0`; object `hash` / `eql?`; fixlen byte
-  #   equality). Arrays are coerced to the first array's dtype within the same
+  #   equality). Arrays are coerced to the first array's data type within the same
   #   family (cross-family raises). Masked cells do not enter `common`.
   #
   #   @param arrays [Array<CArray>] two or more arrays (Array / Range coerced

data/lib/carray/methods/composition.rb

@@ -12,7 +12,7 @@
 # (`stack` / `meld` / `montage`, plus `CArray#stack` and `CAStack#append`)
 # lives in carray/stack.rb.  The cheat sheet below covers the whole family.
 #
-#                       | view (same dtype)      | eager (auto-cast)
+#                       | view (same data type)      | eager (auto-cast)
 #   -------------------+------------------------+-----------------------
 #   concat existing    | meld  (CAMeld view)    | concatenate (materialised)
 #   axis (ndim same)   |                        |

data/lib/carray/methods/is_in.rb

@@ -10,12 +10,12 @@ class CArray
   #   argument is accepted; to test a few immediate values pass an
   #   Array (`a.is_in([0, -1])`).
   #
-  #   When `self` and `values` have different numeric dtypes they are
+  #   When `self` and `values` have different numeric data types they are
   #   promoted to a common type first (the same promotion binops use,
   #   {CArray.result_type}), so membership is value-correct across
-  #   dtypes (e.g. an int cell equals a float set element of the same
+  #   data types (e.g. an int cell equals a float set element of the same
   #   value, and a fractional set element never truncates onto an int
-  #   cell). Genuinely incompatible dtypes (e.g. numeric vs fixlen)
+  #   cell). Genuinely incompatible data types (e.g. numeric vs fixlen)
   #   raise.
   #
   #   Membership is value-based and shares the distinctness of the
@@ -32,7 +32,7 @@ class CArray
   #   reduction, compose with {#any}: `a.is_in(values).any(axis: k)`.
   #
   #   @param values [CArray, Array, Range] the set to test membership
-  #     against. Promoted with `self` to a common dtype.
+  #     against. Promoted with `self` to a common data type.
   #   Between two time arrays the question is about instants, not ticks:
   #   `values` is reconciled into `self`'s unit first, so a `:D` array and an
   #   `:h` array match on the instants they share.  The same holds for the set
@@ -49,7 +49,7 @@ class CArray
   #   `self` and `other`, in `self`'s first-appearance order.
   #
   #   Value-based, sharing the distinctness of the discovery family
-  #   (see {#is_in}); `self` and `other` are promoted to a common dtype.
+  #   (see {#is_in}); `self` and `other` are promoted to a common data type.
   #   Masked cells of either array do not participate. The result is
   #   always flat, like {#unique}, because the distinct values of a
   #   fiber vary in number.
@@ -97,18 +97,18 @@ class CArray
 
   # Reconcile a set-valued argument with self to a common data_type via
   # CArray.result_type (the single-source promotion rule the eager binop and
-  # lazy CABinOp share), returning [self', set']. Only dtypes are reconciled,
+  # lazy CABinOp share), returning [self', set']. Only data types are reconciled,
   # never shapes: unlike the binop coercion (cast_self_or_other) the set's
   # shape never broadcasts against self's, so a size-1 self keeps its shape.
-  # result_type raises for genuinely incompatible dtypes (numeric vs fixlen).
+  # result_type raises for genuinely incompatible data types (numeric vs fixlen).
   #
-  # A bare Array / Range has no intrinsic dtype, so the common type is inferred
+  # A bare Array / Range has no intrinsic data type, so the common type is inferred
   # from self and the individual elements (result_type classifies each scalar).
   # This keeps a fractional literal from truncating onto an int self, and an
   # int literal from boxing a float self into the object lane (where Float 2.0
-  # is not eql? Integer 2). A CArray argument uses its own dtype; any other
+  # is not eql? Integer 2). A CArray argument uses its own data type; any other
   # operand (Numo, a MemoryView producer, ...) comes in through wrap_readonly,
-  # the canonical type-coercion entry, so its format's dtype drives the promote.
+  # the canonical type-coercion entry, so its format's data type drives the promote.
   def promote_value_set (values)
     case values
     when Array then return promote_elements(values)
@@ -123,8 +123,8 @@ class CArray
   # Bare Array / Range against numeric self: infer the common numeric type
   # from self and the elements (each classified by result_type), so a
   # fractional literal promotes self to float instead of truncating. Against
-  # object / fixlen self the elements are values, not dtype specifiers (a
-  # String is a value, not a type name), so build the set in self's dtype.
+  # object / fixlen self the elements are values, not data type specifiers (a
+  # String is a value, not a type name), so build the set in self's data type.
   def promote_elements (elems)
     if data_type == CA_OBJECT || data_type == CA_FIXLEN
       [self, elems.to_ca.to_type(data_type)]

data/lib/carray/methods/locate_addr.rb

@@ -35,7 +35,12 @@ class CArray
       fill[] = sec.nil? ? UNDEF : sec
       sec = fill
     end
-    si = sec.mask_invalid.send(direction).int64
+    masked = sec.mask_invalid
+    si = case direction
+         when :round then masked.round
+         when :floor then masked.floor
+         when :ceil  then masked.ceil
+         end.int64
     idx = ri.project(si)
     if tolerance
       dist = (ref.project(idx) - self).abs

data/lib/carray/methods/mask_duplicates.rb

@@ -30,7 +30,7 @@ class CArray
         flatten.send(:__mask_duplicates__, 0).reshape(*shape)
       else
         # Per-fiber single-pass seen-set hash (C __mask_duplicates__): one lane
-        # per dtype family (integer widen, float bitwise key with NaN collapse,
+        # per data type family (integer widen, float bitwise key with NaN collapse,
         # object rb_hash + rb_eql, fixlen byte-hash + memcmp, boolean via the
         # uint8 lane). O(distinct) memory, no sort/gather/scatter buffers.
         __mask_duplicates__(normalize_axis(axis, "mask_duplicates"))

data/lib/carray/methods/meshgrid.rb

@@ -17,10 +17,9 @@ class CArray
   #   input order in both modes.
   #
   #   When `copy` is true (default) each output is a materialised
-  #   CArray; when false, view chains (CARepeat / CAUnboundRepeat)
-  #   are returned. When `sparse` is true the outputs are
-  #   CAUnboundRepeat views that broadcast on demand, saving memory
-  #   for large grids.
+  #   CArray; when false, a view is returned. When `sparse` is true
+  #   each output keeps a size-1 axis wherever the full grid would
+  #   repeat, and broadcasts on demand, saving memory for large grids.
   #
   #   If a block is given, yields the resulting arrays as splat
   #   arguments and returns the block's value.
@@ -77,7 +76,7 @@ class CArray
     list = axes.map.with_index do |axis, k|
       d = dest[k]
       idx = if sparse
-              Array.new(ndim) { |i| i == d ? nil : :* }
+              Array.new(ndim) { |i| i == d ? nil : :_ }
             else
               out_shape.dup.tap { |s| s[d] = :% }
             end

data/lib/carray/methods/mode.rb

@@ -33,7 +33,7 @@ class CArray
   #     the whole array.
   #   @return [CArray] boolean CArray of `self.shape`.
   def is_mode (axis: nil)
-    # Per-fiber two-pass frequency table (C __is_mode__), one lane per dtype
+    # Per-fiber two-pass frequency table (C __is_mode__), one lane per data type
     # family (numeric widen / NaN collapse, object rb_hash + rb_eql, fixlen
     # byte-hash + memcmp). Ties are all marked; masked cells stay false.
     if axis.nil?
@@ -112,7 +112,7 @@ class CArray
 
   private
 
-  # Flat mode: the distinct modal values ascending, 1-D CArray of self's dtype.
+  # Flat mode: the distinct modal values ascending, 1-D CArray of self's data type.
   # The single source of what counts as a mode (per-axis reuses it per fiber).
   # The distinct values with the maximum count, read from the frequency table
   # (value_counts, which covers numeric / object / fixlen), then sorted

data/lib/carray/methods/nunique.rb

@@ -30,7 +30,7 @@ class CArray
   #   @return [Integer, CArray] Integer for `axis: nil`, otherwise a
   #     reduced `CA_INT64` CArray.
   def nunique (axis: nil, keep_axis: false)
-    # Per-fiber single-pass seen-set hash (C __nunique__), one lane per dtype
+    # Per-fiber single-pass seen-set hash (C __nunique__), one lane per data type
     # family (numeric widen / NaN collapse, object rb_hash + rb_eql, fixlen
     # byte-hash + memcmp). Masked cells are skipped; the accumulator is a no-op
     # (the distinct count is the interned-key count).

data/lib/carray/methods/snap.rb

@@ -7,7 +7,7 @@ class CArray
   #   matching `CArray#round`; `:floor` snaps toward `-inf`, `:ceil`
   #   toward `+inf`).
   #
-  #   The output has the same dtype as `self` (integer input is coerced
+  #   The output has the same data type as `self` (integer input is coerced
   #   to float internally when `step` / `offset` are floats, following
   #   normal arithmetic promotion). NaN / Inf are preserved as a mask
   #   on the output; the rounding kernels map NaN to 0.0, which would
@@ -45,7 +45,12 @@ class CArray
     # Detect NaN / Inf before rounding (which maps NaN -> 0.0 silently).
     invalid_mask = scaled.float? ? scaled.is_invalid : nil
 
-    out = scaled.send(direction) * step + offset
+    snapped = case direction
+              when :round then scaled.round
+              when :floor then scaled.floor
+              when :ceil  then scaled.ceil
+              end
+    out = snapped * step + offset
 
     if invalid_mask && invalid_mask.count(true) > 0
       out.mask = out.has_mask? ? (out.mask | invalid_mask) : invalid_mask

data/lib/carray/methods/unique.rb

@@ -16,7 +16,7 @@ class CArray
   #   Masked cells do not participate and never appear in the result;
   #   an all-masked array yields an empty CArray.
   #
-  #   Distinctness follows `==` for numeric dtypes, with two float
+  #   Distinctness follows `==` for numeric data types, with two float
   #   special cases so the result matches value-based expectations:
   #   all NaN collapse to a single distinct value (rather than one per
   #   cell) and -0.0 / +0.0 are the same value. The value kept for
@@ -32,10 +32,10 @@ class CArray
   #   its own unit: the distinct values are values, so the array comes back
   #   as itself rather than as raw storage ticks.
   #
-  #   @return [CArray] 1-D CArray of the distinct values, same dtype
+  #   @return [CArray] 1-D CArray of the distinct values, same data type
   #     as `self`.
   def unique (sort: false)
-    # Single-pass seen-set hash (C __unique_flat__), one lane per dtype family:
+    # Single-pass seen-set hash (C __unique_flat__), one lane per data type family:
     # integer widens to a 64-bit key; float uses the bitwise key with all-NaN
     # collapsed and -0.0 / +0.0 normalized; object keys on rb_hash + rb_eql and
     # fixlen on a byte-hash + memcmp, both reproducing Ruby Hash distinctness.

data/lib/carray/methods/value_counts.rb

@@ -3,7 +3,7 @@ class CArray
   # @overload value_counts(sort: false)
   #   Returns `[values, counts]`, the distinct values of `self` paired
   #   with the number of times each occurs. `values` is a 1-D CArray of
-  #   `self`'s dtype; `counts` is a 1-D `CA_INT64` where `counts[i]` is
+  #   `self`'s data type; `counts` is a 1-D `CA_INT64` where `counts[i]` is
   #   the number of occurrences of `values[i]`. This is the frequency-
   #   table member of the value-hash discovery family ({#unique},
   #   {#mask_duplicates}, {#nunique}); like {#unique} it always
@@ -39,7 +39,7 @@ class CArray
       raise ArgumentError, "value_counts: sort must be false, :count, or :value"
     end
     # Single-pass frequency-table hash (C __value_counts_flat__), one lane per
-    # dtype family: integer widens to a 64-bit key; float uses the bitwise key
+    # data type family: integer widens to a 64-bit key; float uses the bitwise key
     # with all NaN collapsed and -0.0 / +0.0 normalized; object keys on rb_hash +
     # rb_eql and fixlen on a byte-hash + memcmp, both reproducing Ruby Hash
     # distinctness. Masked cells are skipped in the kernel.

data/lib/carray/runtime.rb

@@ -87,22 +87,3 @@ class CArray
 
 end
 
-class CAUnboundRepeat
-  # Overrides {CArray#template} for unbound-repeat views.
-  #
-  # The C-level `CArray#template` allocates an entity sized to `self.shape`,
-  # which for a CAUnboundRepeat would include the inflated unbound (`:*`)
-  # axes — semantically wrong (unbound axes are not yet bound to a size)
-  # and a memory bomb on broadcast patterns.  Required for correctness.
-  #
-  # This override allocates at the **parent's compact shape** instead, then
-  # rewraps the result with the same `spec` so the returned view preserves
-  # the unbound broadcast pattern.
-  #
-  # @param argv [Array] forwarded to {CArray#template} (data_type, bytes:, ...)
-  # @yield forwarded to {CArray#template}
-  # @return [CAUnboundRepeat] new entity wrapped with the original unbound spec
-  def template (*argv, &block)
-    return parent.template(*argv,&block)[*spec.map{|x| x != :* ? nil : x}]
-  end
-end

data/lib/carray/slab_iterator.rb

@@ -90,7 +90,7 @@ class CASlabIterator < CAIterator
   # A per-slab reduction that folds each slab to one value is exactly the core
   # per-axis reduction over the slab axes, so every reduction is a direct
   # delegation to `reference.<op>(axis: slab_axes)`. This inherits the core
-  # dtype, mask, empty/all-masked (identity vs UNDEF) and epsilon-close
+  # data type, mask, empty/all-masked (identity vs UNDEF) and epsilon-close
   # contracts unchanged -- there is no separate slab reduction kernel. (Unlike
   # the map / reduce block surface, these are mask-aware: they route through the
   # core reduction, which handles masked sources.)
@@ -98,14 +98,23 @@ class CASlabIterator < CAIterator
   # @overload sum
   #   Per-slab sum, delegating to `reference.sum(axis: slab_axes)`.
   #   @return [CArray] one value per slab (shape = self.dim minus the slab axes)
+  # @overload accumulate
+  #   Per-slab sum kept in the source's own data type, wrapping at its width,
+  #   as the core `accumulate` does -- `sum` answers in the type the core
+  #   promotes to (float64 for integers).
+  #   @return [CArray] one value per slab
   # The rest are analogous: prod / mean / min / max, sample and population
   # variance / stddev, all / any, fused minmax ([min, max] pair), the axis-local
   # position min_index / max_index (index within the slab axes), and the flat
   # source address min_addr / max_addr (which source cell holds the extremum).
-  [:sum, :prod, :mean, :min, :max, :variance, :stddev, :all, :any,
+  [:sum, :accumulate, :prod, :mean, :min, :max, :variance, :stddev, :all, :any,
    :variancep, :stddevp, :minmax, :min_index, :max_index,
    :min_addr, :max_addr].each do |op|
-    define_method(op) { @reference.send(op, axis: @slab_axes) }
+    class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def #{op}
+        @reference.#{op}(axis: @slab_axes)
+      end
+    RUBY
   end
 
   # @overload count(v = <none>)
@@ -243,7 +252,7 @@ class CASlabIterator < CAIterator
   #
   # A per-slab running accumulation along the slab axis is exactly the core
   # per-axis cumulative over that axis, so every scan delegates to
-  # `reference.<op>(axis: slab_axis)`, inheriting the core dtype / mask (masked
+  # `reference.<op>(axis: slab_axis)`, inheriting the core data type / mask (masked
   # cells hold the running total, output unmasked) contracts unchanged. Each
   # cell is in exactly one slab (a partition), so the running value is
   # well-defined; the surface is uniform with the family even though it
@@ -258,16 +267,20 @@ class CASlabIterator < CAIterator
   #   Per-slab inclusive running product (float64), reference-shaped.
   #   @return [CArray]
   # @overload cummax
-  #   Per-slab inclusive running maximum (reference dtype), reference-shaped.
+  #   Per-slab inclusive running maximum (reference data type), reference-shaped.
   #   @return [CArray]
   # @overload cummin
-  #   Per-slab inclusive running minimum (reference dtype), reference-shaped.
+  #   Per-slab inclusive running minimum (reference data type), reference-shaped.
   #   @return [CArray]
   # @overload cumcount
   #   Per-slab running count of present cells (int64), reference-shaped.
   #   @return [CArray]
   [:cumsum, :cumprod, :cummax, :cummin, :cumcount].each do |op|
-    define_method(op) { @reference.send(op, axis: single_scan_axis(op)) }
+    class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def #{op}
+        @reference.#{op}(axis: single_scan_axis(:#{op}))
+      end
+    RUBY
   end
 
   private