carray 3.0.0 → 3.0.1

data/ext/ruby_carray.c

@@ -2,7 +2,7 @@
 
   Single entry point Init_carray_ext: declares the CArray class
   hierarchy + exception class + CA module, populates top-level
-  constants (CA_RANK_MAX / CA_NIL / CA_* data_type Symbols / alignment
+  constants (CA_RANK_MAX / CA_* data_type Symbols / alignment
   values), then drives the per-module Init_* sequence in load order.
 
   CAREFUL: the Init_* call order below carries real ordering
@@ -14,6 +14,7 @@
 ---------------------------------------------------------------------------- */
 
 #include "carray.h"
+#include "carray_build_flags.h"
 #include "version.h"
 
 #ifdef HAVE_RB_ARITHMETIC_SEQUENCE_EXTRACT
@@ -26,7 +27,7 @@ VALUE rb_cCAIterator;
 VALUE rb_eCADataTypeError;
 VALUE rb_mCA;
 
-VALUE CA_NIL;
+VALUE CA_UNSPECIFIED;
 
 void Init_carray_core ();
 void Init_carray_undef ();
@@ -81,7 +82,6 @@ void Init_ca_obj_stack ();   /* multi-parent outer-axis stack */
 void Init_ca_obj_meld ();    /* multi-parent ragged concat along existing axis */
 void Init_ca_obj_transpose ();
 void Init_ca_obj_repeat ();
-void Init_ca_obj_unbound_repeat ();
 void Init_ca_obj_reduce ();
 void Init_ca_obj_field ();
 void Init_ca_obj_fake ();
@@ -107,7 +107,7 @@ void Init_ca_obj_moncmp ();  /* CAMonCmp + lazy elementwise predicate dispatch *
 
 /* Init_carray_iterator retired; CAIterator is a form-only base defined inline
    in Init_carray_ext (accessors in lib/carray/iterator.rb).  The 2.0 C engines
-   (dimension / window / block iterators) live at samples/caiterator/. */
+   (dimension / window / block iterators) were retired in 3.0. */
 
 void Init_carray_mathfunc ();
 
@@ -142,7 +142,7 @@ Init_carray_ext (void)
   rb_cCScalar    = rb_define_class("CScalar",   rb_cCArray);
   rb_cCAView  = rb_define_class("CAView", rb_cCArray);
   /* CAREFUL: CAStride must exist before its subclasses (CARefer /
-     CABlock / CAField / CARepeat / CAUnboundRepeat / CATranspose /
+     CABlock / CAField / CARepeat / CATranspose /
      CAFarray) are defined or registered.  See devel/CAStride.md. */
   rb_cCAStride   = rb_define_class("CAStride",  rb_cCAView);
   rb_cCARefer    = rb_define_class("CARefer",   rb_cCAStride);
@@ -151,10 +151,6 @@ Init_carray_ext (void)
   rb_cCASelect   = rb_define_class("CASelect",  rb_cCAView);
   rb_cCAObject   = rb_define_class("CAObject",  rb_cCAView);
   rb_cCARepeat   = rb_define_class("CARepeat",  rb_cCAStride);
-  /* CAUnboundRepeat: a CAStride with stride-0 axes on each `*` position
-     and sized (matching parent) on each nil position. */
-  rb_cCAUnboundRepeat  = rb_define_class("CAUnboundRepeat",  rb_cCAStride);
-
   rb_cCArrayMask     = rb_define_class("CArrayMask",    rb_cCArray);
   rb_cCAStrideMask   = rb_define_class("CAStrideMask",  rb_cCAStride);
   rb_cCAReferMask    = rb_define_class("CAReferMask",   rb_cCARefer);
@@ -162,7 +158,6 @@ Init_carray_ext (void)
   rb_cCAFieldMask    = rb_define_class("CAFieldMask",   rb_cCAField);
   rb_cCASelectMask   = rb_define_class("CASelectMask",  rb_cCASelect);
   rb_cCARepeatMask   = rb_define_class("CARepeatMask",  rb_cCARepeat);
-  rb_cCAUnboundRepeatMask  = rb_define_class("CAUnboundRepeatMask",  rb_cCAUnboundRepeat);
 
   /* -- Exception class -- */
 
@@ -175,6 +170,10 @@ Init_carray_ext (void)
 
   /* -- version -- */
 
+  /* The flags this build's arithmetic was compiled with.  Anything that
+     computes what these kernels compute, somewhere other than in them, has
+     to be built the same way to arrive at the same answer. */
+  rb_define_const(rb_cCArray, "BUILD_FLAGS",  rb_str_new2(CA_BUILD_FLAGS));
   rb_define_const(rb_cCArray, "VERSION",       rb_str_new2(CA_VERSION));
   rb_define_const(rb_cCArray, "VERSION_CODE",  INT2NUM(CA_VERSION_CODE));
   rb_define_const(rb_cCArray, "VERSION_MAJOR", INT2NUM(CA_VERSION_MAJOR));
@@ -184,8 +183,14 @@ Init_carray_ext (void)
 
   /* -- system -- */
   rb_define_const(rb_cObject, "CA_RANK_MAX", INT2NUM(CA_RANK_MAX));
-  CA_NIL = rb_funcall(rb_cObject, rb_intern("new"), 0);
-  rb_define_const(rb_cObject, "CA_NIL", CA_NIL);
+  /* Sentinel meaning "the caller did not give this argument".  It is
+     distinct from nil because nil is itself a legal fill value (a
+     CA_OBJECT array can be filled with nil), so nil cannot mark
+     absence.  C code only ever compares against it; the value is never
+     read and must never be passed in from Ruby.  The constant exists to
+     anchor the object against the GC. */
+  CA_UNSPECIFIED = rb_funcall(rb_cObject, rb_intern("new"), 0);
+  rb_define_const(rb_cCArray, "UNSPECIFIED", CA_UNSPECIFIED);
 
 #ifdef HAVE_COMPLEX_H
   /* @private */
@@ -320,7 +325,6 @@ Init_carray_ext (void)
   Init_ca_obj_meld();
   Init_ca_obj_transpose();
   Init_ca_obj_repeat();
-  Init_ca_obj_unbound_repeat();
   Init_ca_obj_reduce();
   Init_ca_obj_field();
   Init_ca_obj_fake();
@@ -351,9 +355,7 @@ Init_carray_ext (void)
   /* CAIterator is the form-only base of the 3.0 iterator family; its shared
      accessors are plain Ruby attr_readers (lib/carray/iterator.rb).  The C
      reduction iterators subclass it and carray_access.c constructs
-     CASlabIterator by name, so the class object must exist here.  The retired
-     2.0 dispatch engines (dimension / window / block C iterators + the
-     kernel_at_addr base) are preserved at samples/caiterator/. */
+     CASlabIterator by name, so the class object must exist here. */
   rb_cCAIterator = rb_define_class("CAIterator", rb_cObject);
 
   Init_ca_group_iter();    /* devel/MEMO_AXIS_GROUP.md — axis-group [] surface

data/ext/version.h

@@ -1,6 +1,6 @@
-#define CA_VERSION "3.0.0"
-#define CA_VERSION_CODE 300
+#define CA_VERSION "3.0.1"
+#define CA_VERSION_CODE 301
 #define CA_VERSION_MAJOR 3
 #define CA_VERSION_MINOR 0
-#define CA_VERSION_TEENY 0
-#define CA_VERSION_DATE "2026/08/25"
+#define CA_VERSION_TEENY 1
+#define CA_VERSION_DATE "2026/09/07"

data/lib/carray/autoload_carray.rb

@@ -62,6 +62,24 @@ class CArray
   autoload :TableMethods, "carray/table"
 end
 
+# ---- Fusion (reading a lazy expression as a plan) --------------------------
+#
+# Nothing in the core asks for a plan -- CArray can always walk the view --
+# so this loads only when something that compiles one asks.
+
+class CArray
+  autoload :Fusion, "carray/fusion"
+end
+
+# ---- Reading a block as an expression (CArray.fuse) -------------------------
+#
+# Only `fuse` needs this, and only when it is called, so the parser it uses
+# is not loaded by `require "carray"`.
+
+class CArray
+  autoload :FuseSource, "carray/fuse_source"
+end
+
 # ---- Iterators (class / slab) ----------------------------------------------
 
 autoload :CASlabIterator,   "carray/slab_iterator"
@@ -172,6 +190,7 @@ end
 # (2) Single-feature method files under carray/methods/
 # ============================================================================
 
+
 class CArray
   # composition family (eager ragged list -> one array)
   autoload_method "self.concatenate", "carray/methods/composition"

data/lib/carray/autoload_method_extension.rb

@@ -15,6 +15,7 @@
 # monkey patching is avoided -- only classes that explicitly `extend
 # AutoloadMethodExtension` gain the method.
 
+# @private
 module AutoloadMethodExtension
   # @!visibility private
   def autoload_method (method, library)
@@ -31,7 +32,7 @@ module AutoloadMethodExtension
   private
 
   def autoload_define (target, name, library, original_spec)
-    target.send(:define_method, name) do |*args, **kwargs, &block|
+    target.define_method(name) do |*args, **kwargs, &block|
       begin
         require library
       rescue LoadError

data/lib/carray/axis_group.rb

@@ -401,8 +401,8 @@ class CAGroupIterator
   end
 
   # @overload cummax(axis: :group)
-  #   Per-group inclusive running maximum, source-shaped, in the source dtype
-  #   (extrema do not grow magnitude, so the dtype is preserved). The first
+  #   Per-group inclusive running maximum, source-shaped, in the source data type
+  #   (extrema do not grow magnitude, so the data type is preserved). The first
   #   member of a group emits its own value. Without :group delegates to value
   #   cummax.
   #   @return [CArray]
@@ -411,7 +411,7 @@ class CAGroupIterator
   end
 
   # @overload cummin(axis: :group)
-  #   Per-group inclusive running minimum, source-shaped, in the source dtype.
+  #   Per-group inclusive running minimum, source-shaped, in the source data type.
   #   Without :group delegates to value cummin.
   #   @return [CArray]
   def cummin (**kw)
@@ -612,7 +612,7 @@ class CAGroupIterator
       unless value.respond_to?(op)
         raise NotImplementedError, "axis_group scan: value has no ##{op}"
       end
-      return value.send(op)
+      return value.public_send(op)
     end
     unless fused.empty?
       raise ArgumentError,
@@ -630,7 +630,7 @@ class CAGroupIterator
   # operation, and remains a follow-up.
   def order_stat (op, args, kw)
     has_group, fused = AxisGroup.parse_axis(kw[:axis])
-    return value.send(op, *args) unless has_group
+    return value.public_send(op, *args) unless has_group
     unless fused.empty?
       raise NotImplementedError,
             "axis_group: folding a band into an order statistic (axis: [:group, k]) " \
@@ -651,13 +651,13 @@ class CAGroupIterator
     ccat, kdims, gslots, bslots, gaxes = composite_layout
     nout = (op == :quantile) ? 5 : 1
     if bslots.empty?
-      res = value.group_by_category(ccat).send(op, *args)
+      res = value.group_by_category(ccat).public_send(op, *args)
       return nout == 1 ? res.reshape(*kdims) : res.map { |r| r.reshape(*kdims) }
     end
     out_shape = spec.slot_meta.map { |m| m[:kind] == :group ? m[:k] : m[:len] }
     outs = Array.new(nout) { CArray.float64(*out_shape) }
     each_band_block(ccat, gslots, bslots, gaxes) do |_vi, out_idx, _co, gi|
-      result = gi.send(op, *args)
+      result = gi.public_send(op, *args)
       if nout == 1
         outs[0][*out_idx] = result.reshape(*kdims)
       else

data/lib/carray/basics.rb

@@ -30,27 +30,26 @@ class CArray
   #   shift as other axes are inserted (e.g. `insert_axis(0, 1, 2)`
   #   puts one axis before each of the first three source axes).
   #
-  #   Each inserted axis takes one of three forms, chosen by its
-  #   `repeat` value: `1` (or `nil`) for a plain size-1 axis, an
-  #   Integer `N > 1` for a read-only bound repeat view, or `:*` for
-  #   an unbound repeat that binds on assignment. `repeat` is either
-  #   a single value applied to every inserted axis, or an Array
-  #   giving one value per position.
+  #   Each inserted axis takes one of two forms, chosen by its
+  #   `repeat` value: `1` (or `nil`) for a plain size-1 axis, or an
+  #   Integer `N > 1` for a read-only bound repeat view. `repeat` is
+  #   either a single value applied to every inserted axis, or an
+  #   Array giving one value per position.
   #
-  #   The everyday way to add an axis is the `:_` / `:*` indexer
-  #   when the shape is known at the call site; `insert_axis` is for
-  #   library code that builds the axis list programmatically.
+  #   The everyday way to add an axis is the `:_` indexer when the
+  #   shape is known at the call site; `insert_axis` is for library
+  #   code that builds the axis list programmatically.
   #
   #   @param positions [Array<Integer>] source-frame positions of the
   #     new axes.
-  #   @param repeat [Integer, Symbol, Array, nil] repeat spec applied
-  #     to each inserted axis.
+  #   @param repeat [Integer, Array, nil] repeat spec applied to each
+  #     inserted axis.
   #   @return [CArray] view with the new axes inserted.
   #   @example
   #     a = CArray.int32(3, 4).seq
   #     a.insert_axis(0)                       # shape (1, 3, 4)
   #     a.insert_axis(1, repeat: 5)            # shape (3, 5, 4)
-  #     a.insert_axis(0, 1, repeat: [:*, 3])   # mixed unbound + bound
+  #     a.insert_axis(0, 1, repeat: [1, 3])    # size-1 then bound
   def insert_axis (*positions, repeat: nil)
     flat = positions.flatten
     if flat.empty?
@@ -81,57 +80,31 @@ class CArray
         Array.new(flat.length, repeat)
       end
 
-    # Validate each value.  A positive Integer or :* only; nil is not a
-    # valid per-axis repeat.
-    reps.each do |r|
-      case r
-      when Integer
-        raise ArgumentError, "insert_axis: repeat count must be >= 1" if r < 1
-      when :*
-        # ok
-      else
-        raise ArgumentError,
-          "insert_axis: repeat must be a positive Integer or :*, got #{r.inspect}"
-      end
+  # Validate each value.  A positive Integer only; nil is not a valid
+  # per-axis repeat.
+  reps.each do |r|
+    unless r.is_a?(Integer)
+      raise ArgumentError,
+        "insert_axis: repeat must be a positive Integer, got #{r.inspect}"
     end
+    raise ArgumentError, "insert_axis: repeat count must be >= 1" if r < 1
+  end
 
-    # Final output layout: stable order by (gap, argument index) keeps
-    # same-gap axes in argument order; the k-th inserted axis lands at output
-    # position gap + k.  This output position is only used to drive the
-    # output-shaped view constructors (broadcast_to / unbound_repeat); the
-    # actual insertion always goes through the source-frame primitive below.
-    order = (0...flat.length).sort_by { |i| [gaps[i], i] }
-    final = {}
-    order.each_with_index { |i, k| final[i] = gaps[i] + k }
-
-    unbound_args  = order.select { |i| reps[i] == :* }
-    concrete_args = order.reject { |i| reps[i] == :* }   # in output order
-
-    # Stage 1: insert the concrete (size-1 / bound) axes by their source
-    # gaps, then grow the bound ones with broadcast_to.
-    inter = self
-    unless concrete_args.empty?
-      inter = __insert_axis_size1__(*concrete_args.map { |i| gaps[i] })
-      if concrete_args.any? { |i| reps[i].is_a?(Integer) && reps[i] > 1 }
-        shp = inter.shape
-        concrete_args.each do |i|
-          r = reps[i]
-          next unless r.is_a?(Integer) && r > 1
-          # intermediate position = final position minus unbound axes before it
-          shp[final[i] - unbound_args.count { |u| final[u] < final[i] }] = r
-        end
-        inter = inter.broadcast_to(*shp)
-      end
-    end
+  # Final output layout: stable order by (gap, argument index) keeps
+  # same-gap axes in argument order; the k-th inserted axis lands at output
+  # position gap + k.  This output position only drives broadcast_to; the
+  # insertion itself always goes through the source-frame primitive.
+  order = (0...flat.length).sort_by { |i| [gaps[i], i] }
+  final = {}
+  order.each_with_index { |i, k| final[i] = gaps[i] + k }
 
-    return inter if unbound_args.empty?
+  inter = __insert_axis_size1__(*order.map { |i| gaps[i] })
+  return inter unless order.any? { |i| reps[i] > 1 }
 
-    # Stage 2: add the unbound axes over the final ndim (`:*` at unbound
-    # positions, nil consumes one stage-1 axis in order).
-    pattern = Array.new(ndim + flat.length, nil)
-    unbound_args.each { |i| pattern[final[i]] = :* }
-    inter.unbound_repeat(*pattern)
-  end
+  shp = inter.shape
+  order.each { |i| shp[final[i]] = reps[i] if reps[i] > 1 }
+  inter.broadcast_to(*shp)
+end
 
   # @overload drop_axis
   #   Returns a view of `self` with every size-1 axis dropped.
@@ -246,6 +219,33 @@ class CArray
 
   alias cmp <=>
 
+  # @!group Elementwise math
+
+  # Returns `[quotient, remainder]` element-wise.
+  #
+  # The quotient is floored toward -inf, so `q * other + r == self` holds
+  # for every sign combination -- the pair Ruby's `Integer#divmod` and
+  # `Float#divmod` return.  For integers that is `self / other` unchanged;
+  # for floats `/` is true division, so the quotient is floored here.
+  #
+  # @param other [CArray, Numeric] divisor.
+  # @return [Array<CArray>] the floored quotient and the remainder.
+  # @raise [ArgumentError] for complex arrays, which have no ordering to
+  #   floor toward.
+  # @example
+  #   CA_INT32([-7]).divmod(3)     # => [-3, 2]
+  #   CA_DOUBLE([-7.0]).divmod(3.0) # => [-3.0, 2.0]
+  def divmod(other)
+    if complex?
+      raise ArgumentError, "divmod is not defined for complex arrays"
+    end
+    q = self / other
+    q = q.floor unless q.integer?
+    [q, self % other]
+  end
+
+  # @!endgroup
+
   # @overload clip(min, max = nil, fill_value = nil, lfill: nil, ufill: nil)
   #   Returns `self` with every element clamped to `[min, max]`.
   #

data/lib/carray/bincount_nd.rb

@@ -68,16 +68,16 @@ class CArray
   # use `CArray#histogram`.
   class BincountND
 
-    # @overload initialize(lengths:, fiber_shape: [], weights_dtype: nil)
+    # @overload initialize(lengths:, fiber_shape: [], weights_data_type: nil)
     #   Allocates a new N-D discrete bincount accumulator.
     #   @param lengths [Array<Integer>] per-dimension label ranges;
     #     each must be `>= 1`.
     #   @param fiber_shape [Array<Integer>] shape of the leading
     #     axes.
-    #   @param weights_dtype [Symbol, nil] `data_type` for weighted
+    #   @param weights_data_type [Symbol, nil] `data_type` for weighted
     #     accumulators; `nil` for pure counts (int64).
     #   @return [BincountND]
-    def initialize (lengths:, fiber_shape: [], weights_dtype: nil)
+    def initialize (lengths:, fiber_shape: [], weights_data_type: nil)
       @lengths = lengths.map(&:to_i)
       raise ArgumentError, "lengths must be a non-empty list" if @lengths.empty?
       @lengths.each_with_index do |l, k|
@@ -85,11 +85,11 @@ class CArray
       end
       @m = @lengths.size
       @fiber_shape = fiber_shape.map(&:to_i).freeze
-      @weighted = !weights_dtype.nil?
-      @counts_dtype = @weighted ? weights_dtype : :int64
+      @weighted = !weights_data_type.nil?
+      @counts_data_type = @weighted ? weights_data_type : :int64
       ext_dims = @lengths.map { |l| l + 1 }       # +1: upper overflow cell
       ext_shape = @fiber_shape + ext_dims
-      @full_counts = CArray.public_send(@counts_dtype, *ext_shape).fill(0)
+      @full_counts = CArray.public_send(@counts_data_type, *ext_shape).fill(0)
       @sample_axis  = nil
       @channel_axis = nil
     end
@@ -209,7 +209,7 @@ class CArray
 
       if weights
         raise ArgumentError, "weights given but accumulator is unweighted" unless @weighted
-        weights = CArray.wrap_readonly(weights, @counts_dtype)
+        weights = CArray.wrap_readonly(weights, @counts_data_type)
         expected_w_shape = chunk.shape.dup
         expected_w_shape.delete_at(channel_ax)
         unless weights.shape == expected_w_shape
@@ -297,7 +297,7 @@ class CArray
       result = self.class.send(:new,
                                lengths: @lengths,
                                fiber_shape: @fiber_shape,
-                               weights_dtype: @weighted ? @counts_dtype : nil)
+                               weights_data_type: @weighted ? @counts_data_type : nil)
       rf = result.instance_variable_get(:@full_counts)
       rf[] = @full_counts + other.full_counts
       result.instance_variable_set(:@sample_axis, @sample_axis)
@@ -344,14 +344,14 @@ class CArray
     [sample_ax, channel_ax].sort.reverse.each { |p| fiber_shape.delete_at(p) }
 
     # Weighted counts are float64-only (the FLAT bincount coerces weights to the
-    # counts dtype and the FIBER kernel requires float64 weights/counts), so the
-    # dtype is fixed here rather than derived from the weights' own dtype.
-    weights_dtype = (:float64 if weights)
+    # counts data type and the FIBER kernel requires float64 weights/counts), so
+    # the type is fixed here rather than derived from the weights' own type.
+    weights_data_type = (:float64 if weights)
 
     h = BincountND.send(:new,
                         lengths: lengths,
                         fiber_shape: fiber_shape,
-                        weights_dtype: weights_dtype)
+                        weights_data_type: weights_data_type)
     h.add(self, axis: axis, weights: weights)
     h
   end

data/lib/carray/block_iterator.rb

@@ -19,7 +19,7 @@
 #  is a `block_view` (a CAStride: zero-copy over the source via compose-fold),
 #  reduced over the trailing tile axes by a core reduction and scattered into the
 #  ceil-shaped tile grid.  One core reduction per region; the named reductions
-#  delegate straight to the core, so their dtype / mask / empty (ERI) / epsilon
+#  delegate straight to the core, so their data type / mask / empty (ERI) / epsilon
 #  contracts are the core's, unchanged.  Because tiles do not overlap, no
 #  padded entity is built (unlike CAWindowIterator) and the interior stays on
 #  the source buffer.
@@ -165,7 +165,7 @@ class CABlockIterator < CAIterator
   # quantile) which are assembled into that many grids.  Boundary regions use a
   # smaller (unmasked, ragged) block_view whose present cell count is naturally
   # below a full tile, so `min_count:` marks them UNDEF with no masking.  The
-  # output dtype is seeded from the first region (all regions share it).
+  # output data type is seeded from the first region (all regions share it).
   def assemble
     outs = nil
     each_region do |strip_ranges, tiles, out_ranges|
@@ -184,7 +184,7 @@ class CABlockIterator < CAIterator
 
   # Fold every region with a single core reduction `op` (the tier-1 shape).
   def fold (op, **kw)
-    assemble { |view, _tiles| view.send(op, axis: @tile_axes, **kw) }
+    assemble { |view, _tiles| view.public_send(op, axis: @tile_axes, **kw) }
   end
 
   public
@@ -194,14 +194,20 @@ class CABlockIterator < CAIterator
   # A per-tile fold to one value over the trailing tile axes is exactly a core
   # per-axis reduction over those axes, so every reduction delegates to
   # `block_view.<op>(axis: tile_axes, ...)` per region.  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.  `min_count:` / `fill_value:` pass straight to the core.
 
   # @overload sum(min_count: nil, fill_value: nil)
   #   Per-tile sum.  @return [CArray] tile-grid shaped
+  # @overload accumulate(min_count: nil, fill_value: nil)
+  #   Per-tile 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), so a tile count over `uint8` cells
+  #   stays one byte wide instead of eight.
+  #   @return [CArray] tile-grid shaped
   # The rest are analogous: prod / mean / min / max, sample and population
   # variance / stddev, all / any.
-  [:sum, :prod, :mean, :min, :max, :variance, :stddev, :all, :any,
+  [:sum, :accumulate, :prod, :mean, :min, :max, :variance, :stddev, :all, :any,
    :variancep, :stddevp].each do |op|
     define_method(op) do |min_count: nil, fill_value: nil|
       kw = {}
@@ -281,7 +287,11 @@ class CABlockIterator < CAIterator
   #   Per-tile position of the maximum (tile-local flat index).
   #   @return [CArray]
   [:min_index, :max_index].each do |op|
-    define_method(op) { assemble { |view, _| view.send(op, axis: @tile_axes) } }
+    class_eval <<~RUBY, __FILE__, __LINE__ + 1
+      def #{op}
+        assemble { |view, _| view.#{op}(axis: @tile_axes) }
+      end
+    RUBY
   end
 
   # @overload min_addr
@@ -309,7 +319,7 @@ class CABlockIterator < CAIterator
     each_region do |strip_ranges, tiles, out_ranges|
       vview = @source[*strip_ranges].block_view(*tiles)
       sview = saddr[*strip_ranges].block_view(*tiles)
-      mi    = vview.send(idx_op, axis: @tile_axes)         # tile-local flat index
+      mi    = vview.public_send(idx_op, axis: @tile_axes)  # tile-local flat index
       grid  = (0...@sndim).map { |i| vview.shape[i] }
       cells = tiles.inject(1) { |p, t| p * t }
       safe  = mi.copy
@@ -380,7 +390,7 @@ class CABlockIterator < CAIterator
       wt     = tiles == @sizes ? weights : weights[*tiles.map { |t| 0...t }]
       wshape = ([1] * @sndim) + tiles
       # Pass the weights through unchanged, like the window iterator: core wsum /
-      # wmean own weight/dtype coercion, so do not pre-coerce the weights here.
+      # wmean own weight / type coercion, so do not pre-coerce the weights here.
       wfull  = wt.reshape(*wshape).broadcast_to(*view.shape)
       yield view, wfull
     end
@@ -516,8 +526,8 @@ class CABlockIterator < CAIterator
   # reusing the same padded (masked-margin) entity as the iterate escape
   # hatches, so this is the slow path (a per-tile materialize), and the
   # out-of-bounds cells of a partial edge tile are dropped from the result.
-  # cumsum / cumprod -> float64, cummax / cummin preserve the value dtype,
-  # cumcount -> int64 running count of present cells; the output dtype is seeded
+  # cumsum / cumprod -> float64, cummax / cummin preserve the value data type,
+  # cumcount -> int64 running count of present cells; the output data type is seeded
   # from the first tile's scan.
 
   # @overload cumsum
@@ -527,10 +537,10 @@ class CABlockIterator < CAIterator
   #   Per-tile inclusive running product (float64), source-shaped.
   #   @return [CArray]
   # @overload cummax
-  #   Per-tile inclusive running maximum (value dtype), source-shaped.
+  #   Per-tile inclusive running maximum (value data type), source-shaped.
   #   @return [CArray]
   # @overload cummin
-  #   Per-tile inclusive running minimum (value dtype), source-shaped.
+  #   Per-tile inclusive running minimum (value data type), source-shaped.
   #   @return [CArray]
   # @overload cumcount
   #   Per-tile running count of present cells (int64), source-shaped.
@@ -542,7 +552,7 @@ class CABlockIterator < CAIterator
   private
 
   # Drive a within-tile segment scan: scan each tile flattened row-major and
-  # scatter back to a source-shaped result.  The output dtype is taken from the
+  # scatter back to a source-shaped result.  The output data type is taken from the
   # first tile's scan (all tiles share it); the padded margin is UNDEF and the
   # OOB cells of a partial edge tile are cropped from the result.
   def block_scan (op)
@@ -552,7 +562,7 @@ class CABlockIterator < CAIterator
     pgv  = nil
     CArray.each_index(*@shape) do |*g|
       tile    = tgv[*g, *nils]
-      scanned = tile.copy.reshape(tile.elements).send(op).reshape(*@sizes)
+      scanned = tile.copy.reshape(tile.elements).public_send(op).reshape(*@sizes)
       unless pout
         pout = CArray.new(scanned.data_type, padded_source.shape)
         pout[] = UNDEF

data/lib/carray/categorical.rb

@@ -2,7 +2,7 @@
 #
 #  carray/categorical.rb
 #
-#  CACategorical — a categorical dtype: dense integer codes (the storage) plus
+#  CACategorical — a categorical data type: dense integer codes (the storage) plus
 #  a label vocabulary. Structurally the same as a pandas Categorical or an
 #  Arrow dictionary: each element is an index into a small set of categories.
 #
@@ -66,7 +66,7 @@ class CACategorical < CAObject
   }.freeze
 
   # The exclusion sentinel per codes data_type: the all-ones bit pattern, read
-  # as type-max for an unsigned dtype and as -1 for a signed one. Either way it
+  # as type-max for an unsigned data type and as -1 for a signed one. Either way it
   # is out of every valid [0, k) range and byte-identical to a pandas / Arrow
   # missing code.
   SENTINEL = {
@@ -521,7 +521,7 @@ class CArray
     # Integer / Float keys stay distinct (eql?, so 1 and 1.0 are separate
     # categories). The discovery path below is reserved for sort_labels (which
     # reorders the vocabulary, desyncing the appearance-order codes), an explicit
-    # labels list, and the dtypes the factorize kernel does not take (complex).
+    # labels list, and the data types the factorize kernel does not take (complex).
     if labels.nil? && !sort_labels && (integer? || float? || object? || fixlen? || boolean?)
       codes, levels = __factorize_appearance__
       return CACategorical.from_codes(codes, levels.to_a)
@@ -541,7 +541,7 @@ class CArray
       end
     end
 
-    # Choose a narrow unsigned code dtype, reserving its top value as the
+    # Choose a narrow unsigned code type, reserving its top value as the
     # exclusion sentinel so it never collides with a real code 0..k-1.
     k = labels_arr.size
     code_type, sentinel =