carray 3.0.3 → 3.0.5

data/lib/carray/basics.rb

@@ -13,9 +13,19 @@
 
 class CArray
 
+  # The order sort puts two object values in (ca_obj_order_cmp in C): a
+  # Float NaN after every other value, NaN ties NaN, other pairs by `<=>`.
+  # nil when `<=>` cannot order the pair; the caller says what refused.
+  private_class_method def self.object_order_cmp (a, b)
+    a_nan = a.is_a?(Float) && a.nan?
+    b_nan = b.is_a?(Float) && b.nan?
+    return (a_nan ? 1 : 0) - (b_nan ? 1 : 0) if a_nan || b_nan
+    a <=> b
+  end
+
   # reshape / flatten / transpose! are defined in C
   # (ext/ca_obj_refer.c and ext/ca_obj_transpose.c).  The bare size-1
-  # insertion primitive is `__insert_axis_size1__` (C); `insert_axis` below
+  # insertion primitive is `insert_size_one_axes` (C); `insert_axis` below
   # is the user-facing method that owns the name and adds `repeat:`.
 
   # @overload insert_axis(*positions, repeat: nil)
@@ -58,7 +68,7 @@ class CArray
 
     # No repeat: -> plain size-1 insertion.  The source-frame C primitive
     # handles normalization, range check and multiplicity directly.
-    return __insert_axis_size1__(*flat) if repeat.nil?
+    return insert_size_one_axes(*flat) if repeat.nil?
 
     # Source frame: each position names the source axis the new axis goes
     # before.  Gaps live in [0, ndim] (ndim = append at end); negatives count
@@ -98,7 +108,7 @@ class CArray
     final = {}
     order.each_with_index { |i, k| final[i] = gaps[i] + k }
 
-    inter = __insert_axis_size1__(*order.map { |i| gaps[i] })
+    inter = insert_size_one_axes(*order.map { |i| gaps[i] })
     return inter unless order.any? { |i| reps[i] > 1 }
 
     shp = inter.shape
@@ -107,13 +117,15 @@ class CArray
   end
 
   # @overload drop_axis
-  #   Returns a view of `self` with every size-1 axis dropped.
+  #   Returns a view of `self` with every size-1 axis dropped.  When every
+  #   axis has size 1, one axis of size 1 is kept.
   #   @return [CArray] view with reduced `ndim`.
   def drop_axis
     if ndim == 1
       return self[]
     else
       newdim = shape.reject{|x| x == 1 }
+      newdim = [1] if newdim.empty?     # every axis has size 1: keep one
       return ( ndim != newdim.size ) ? reshape(*newdim) : self[]
     end
   end
@@ -146,7 +158,7 @@ class CArray
   # out of range (a time array reads its bounds as times, a record array
   # orders by its declared members, a Face that cannot be ordered refuses),
   # and its store writes the bound or the fill value into them.
-  private def __face_clip__ (min, max, fill_value, lfill, ufill)
+  private def face_clip (min, max, fill_value, lfill, ufill)
     lfill = fill_value if lfill.nil?
     ufill = fill_value if ufill.nil?
     out = copy
@@ -158,8 +170,8 @@ class CArray
   # An array of +shape+ of the same kind as self: its data type and cell
   # width, or its Face over a zero storage.  Nothing is written into it, so
   # it can be built for a read-only Face too.
-  private def __blank_like__ (shape)
-    storage = __face_storage__
+  private def blank_like (shape)
+    storage = face_storage
     out = CArray.new(storage.data_type, shape, bytes: storage.bytes)
     face? ? out.face_lift(self) : out
   end
@@ -179,7 +191,13 @@ class CArray
   #   @param src [CArray] source array.
   #   @return [self]
   #   @raise [ArgumentError] when `offset.length != self.ndim`.
+  #   @raise [FrozenError] when `self` is frozen.
   def paste (offset, src)
+    # The write goes through a window view, which is not frozen itself:
+    # refuse a frozen self here, as a write into it directly is refused.
+    if frozen?
+      raise FrozenError.new("can't modify frozen #{self.class}: #{inspect}", receiver: self)
+    end
     raise ArgumentError, "offset length must equal ndim" if offset.length != ndim
     # A zero-length source covers no cell, so there is nothing to write --
     # and the empty range it would ask for is not a window CAWindow can
@@ -300,8 +318,7 @@ class CArray
   # @overload clip(min, max = nil, fill_value = nil, lfill: nil, ufill: nil)
   #   Returns `self` with every element clamped to `[min, max]`.
   #
-  #   Either bound may be `nil` for a one-sided clip; that side
-  #   dispatches to the `pmax` / `pmin` binop kernels. When
+  #   Either bound may be `nil` for a one-sided clip. When
   #   `fill_value` (or `lfill` / `ufill`) is given, out-of-range
   #   cells are replaced by the fill instead of clamped -- pass
   #   `UNDEF` to mask that end. `fill_value` is sugar for symmetric
@@ -310,7 +327,11 @@ class CArray
   #
   #   `min` may not exceed `max` (in any cell, when a bound is an
   #   array); equal bounds give every unmasked cell that value.
-  #   A NaN bound bounds nothing.
+  #   A NaN cell of `self` stays NaN, one-sided or two-sided (unlike
+  #   `pmax` / `pmin`, which answer the other operand for it).
+  #   A NaN in a bound array leaves that cell unbounded on that side,
+  #   as `nil` does for the whole side.  A bound is never UNDEF or
+  #   masked: a missing bound is not read as either, so fill it first.
   #
   #   Boundary is strict `[min, max]`: values equal to a bound
   #   remain unchanged in both the clamped and filled variants.
@@ -325,7 +346,8 @@ class CArray
   #   @param ufill [Object, nil] override above-range fill.
   #   @return [CArray] new CArray with clamped or filled values.
   #   @raise [ArgumentError] when both `min` and `max` are `nil`,
-  #     or when `min` exceeds `max`.
+  #     when either is `UNDEF` or has a masked cell, or when `min`
+  #     exceeds `max`.
   #   @example
   #     a.clip(0, 10)                          # strict clamp
   #     a.clip(0, 10, -1)                      # both ends -> -1
@@ -334,7 +356,16 @@ class CArray
     if min.nil? && max.nil?
       raise ArgumentError, "clip: at least one of (min, max) must be given"
     end
-    return __face_clip__(min, max, fill_value, lfill, ufill) if face?
+    [min, max].each do |bound|
+      undefined = UNDEF.equal?(bound) ||
+                  (bound.is_a?(CArray) && bound.any_masked?) ||
+                  (bound.is_a?(Array) && bound.flatten.any? { |v| UNDEF.equal?(v) })
+      next unless undefined
+      raise ArgumentError, "clip: a bound can not be UNDEF or masked " \
+                           "(fill the bound first; a NaN bound leaves its cell " \
+                           "unbounded, and UNDEF as the fill masks the cells out of range)"
+    end
+    return face_clip(min, max, fill_value, lfill, ufill) if face?
     if !min.nil? && !max.nil?
       reversed = if min.is_a?(CArray) then min.gt(max).any
                  elsif max.is_a?(CArray) then max.lt(min).any
@@ -350,20 +381,31 @@ class CArray
     ufill = fill_value if ufill.nil?
 
     if lfill.nil? && ufill.nil?
-      return __clip_ki__(min, max) if !min.nil? && !max.nil?
-      return pmax(min) if max.nil?
-      return pmin(max)
+      return clamp_between(min, max) if !min.nil? && !max.nil?
+      return clamp_below(min) if max.nil?
+      return clamp_above(max)
     end
 
     # A side without a fill still clamps.
     out = self.copy
-    out = out.pmax(min) if !min.nil? && lfill.nil?
-    out = out.pmin(max) if !max.nil? && ufill.nil?
+    out = out.clamp_below(min) if !min.nil? && lfill.nil?
+    out = out.clamp_above(max) if !max.nil? && ufill.nil?
     out[self.lt(min)] = lfill unless min.nil? || lfill.nil?
     out[self.gt(max)] = ufill unless max.nil? || ufill.nil?
     out
   end
 
+  # A one-sided clip of a float array passes a NaN cell through, as the
+  # two-sided one does: the open side is a NaN bound, which leaves it
+  # unbounded.  pmax / pmin would answer the bound for a NaN cell.
+  protected def clamp_below (min)
+    float? ? clamp_between(min, Float::NAN) : pmax(min)
+  end
+
+  protected def clamp_above (max)
+    float? ? clamp_between(Float::NAN, max) : pmin(max)
+  end
+
   # `contains` was retired in favour of {#is_in} (value-hash membership).
   # `a.contains(v1, v2)` -> `a.is_in([v1, v2])`;
   # `a.contains(v1, v2, axis: k)` -> `a.is_in([v1, v2]).any(axis: k)`.
@@ -549,3 +591,49 @@ class Enumerator::ArithmeticSequence
     return CA_OBJECT(to_a)
   end
 end
+
+class CArray
+  # map_slab / reduce_slab over a Face answer in that Face, as its other
+  # reductions do: each block value is written into a blank of the Face
+  # (which reads a CATime::Element, a string, a Face array ...) and handed
+  # to the slab engine as the storage it became; the result is lifted back
+  # at the end.  A read-only Face has no blank to write into, so its values
+  # are collected as the surface objects they are.  A `data_type:` from the
+  # caller is the caller's, and passes through.
+  module FaceSlabResult
+    def map_slab (**kw, &block)
+      return super unless face? && kw[:data_type].nil? && block
+      return super(**kw, data_type: :object, &block) if read_only?
+      out = super(**kw, data_type: face_storage.data_type) { |slab|
+        face_slab_storage(block.call(slab), slab.shape)
+      }
+      out.face_lift(self)
+    end
+
+    def reduce_slab (**kw, &block)
+      return super unless face? && kw[:data_type].nil? && block
+      return super(**kw, data_type: :object, &block) if read_only?
+      fiber = kw.key?(:init)
+      init  = kw.delete(:init)
+      out = super(**kw, data_type: face_storage.data_type) { |slab|
+        value = if fiber
+                  slab.to_a.flatten.inject(init) { |acc, e| block.call(acc, e) }
+                else
+                  block.call(slab)
+                end
+        face_slab_storage(value, [1])[0]
+      }
+      out.face_lift(self)
+    end
+
+    private
+
+    def face_slab_storage (value, shape)
+      cell = blank_like(shape)
+      cell[] = value
+      cell.__send__(:face_storage)
+    end
+  end
+
+  prepend FaceSlabResult
+end

data/lib/carray/bincount_nd.rb

@@ -78,8 +78,13 @@ class CArray
     #     accumulators; `nil` for pure counts (int64).
     #   @return [BincountND]
     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?
+      raise ArgumentError, "lengths must be a non-empty list" if lengths.empty?
+      lengths.each_with_index do |l, k|
+        unless l.is_a?(Integer)
+          raise TypeError, "lengths[#{k}] must be an Integer (got #{l.inspect})"
+        end
+      end
+      @lengths = lengths.dup
       @lengths.each_with_index do |l, k|
         raise ArgumentError, "lengths[#{k}] must be >= 1" if l < 1
       end
@@ -209,6 +214,7 @@ class CArray
 
       if weights
         raise ArgumentError, "weights given but accumulator is unweighted" unless @weighted
+        # coerce: the accumulator's type, declared by weights_data_type:
         weights = CArray.wrap_readonly(weights, @counts_data_type)
         expected_w_shape = chunk.shape.dup
         expected_w_shape.delete_at(channel_ax)
@@ -344,6 +350,10 @@ class CArray
   #   @return [BincountND]
   def bincount_nd (lengths:, axis: [-2, -1], weights: nil)
     raise ArgumentError, "lengths must be an Array of per-dim extents" unless lengths.is_a?(Array)
+    axis = [-2, -1] if axis.nil?
+    unless axis.is_a?(Array) && axis.size == 2
+      raise ArgumentError, "bincount_nd: axis: is a [sample, channel] pair (got #{axis.inspect})"
+    end
     sample_ax  = normalize_axis(axis[0], "bincount_nd sample axis")
     channel_ax = normalize_axis(axis[1], "bincount_nd channel axis")
     fiber_shape = shape.dup

data/lib/carray/block_iterator.rb

@@ -302,28 +302,47 @@ class CABlockIterator < CAIterator
   #   @param fill_value [Object, nil] value to put in place of a masked
   #     result instead of leaving it masked.
   #   @return [CArray] tile-grid shaped
-  [:sum, :accumulate, :prod, :mean, :min, :max, :variance, :stddev,
-   :variancep, :stddevp].each do |op|
-    define_method(op) do |min_count: nil, fill_value: nil|
-      if FACE_WINNER_INDEX.key?(op) && @source.face?
-        return face_winner(FACE_WINNER_INDEX[op], min_count, fill_value)
-      end
-      kw = {}
-      kw[:min_count]  = min_count  unless min_count.nil?
-      kw[:fill_value] = fill_value unless fill_value.nil?
-      fold(op, **kw)
+  CArray.send(:define_named_methods, self,
+              [:sum, :accumulate, :prod, :mean, :min, :max, :variance, :stddev,
+               :variancep, :stddevp], :fold_reduction)
+
+  private def fold_reduction (op, min_count: nil, fill_value: nil)
+    if FACE_WINNER_INDEX.key?(op) && @source.face?
+      return face_winner(FACE_WINNER_INDEX[op], min_count, fill_value)
     end
+    kw = {}
+    kw[:min_count]  = min_count  unless min_count.nil?
+    kw[:fill_value] = fill_value unless fill_value.nil?
+    fold(op, **kw)
   end
 
-  [:all, :any].each do |op|
-    define_method(op) { |**kw| fold(op, **CAIterator.reduce_keywords(op, kw)) }
+  CArray.send(:define_named_methods, self, [:all, :any], :fold_with_keywords)
+
+  private def fold_with_keywords (op, **kw)
+    fold(op, **CAIterator.reduce_keywords(op, kw))
   end
 
+  # @!method first
+  #   Per-tile first present value, in row-major order within the tile;
+  #   UNDEF for a tile with none.
+  #   @return [CArray] tile-grid shaped
+  # @!method last
+  #   Per-tile last present value; UNDEF for a tile with none.
+  #   @return [CArray] tile-grid shaped
+  # @!method nunique
+  #   Per-tile number of distinct present values (int64); 0 for a tile with
+  #   none.
+  #   @return [CArray] tile-grid shaped
+  #
+  # These take no `min_count:` or `fill_value:`, as the core ones do not.
+  CArray.send(:define_named_methods, self, [:first, :last, :nunique], :fold_with_keywords)
+
   # A Face's minimum and maximum are cells of the Face, so they are gathered
   # from the source by the winner's address.  Assembling the per-region results
   # instead copies the Face's storage into an array that no longer knows it is
   # one: a CATime came back as 8-byte strings.
   FACE_WINNER_INDEX = { min: :min_index, max: :max_index }.freeze
+  Ractor.make_shareable(FACE_WINNER_INDEX)
   private_constant :FACE_WINNER_INDEX
 
   # ---- count family and elements ----------------------------------------
@@ -362,11 +381,11 @@ class CABlockIterator < CAIterator
   #   @return [CArray]
   def count_masked (**kw)
     kw   = CAIterator.reduce_keywords(:count_masked, kw)
-    need = CArray.__min_count_need__(:count_masked, kw[:min_count], 0)
+    need = CArray.__present_cells_needed_per_result_cell__(:count_masked, kw[:min_count], 0)
     out  = elements - count_not_masked
     # A count of the mask reads every cell of the tile.
     out[elements.lt(need)] = UNDEF if need > 0
-    CArray.__reduce_fill__(out, kw[:fill_value])
+    CArray.__fill_undefined_result_cells__(out, kw[:fill_value])
   end
 
   # @overload elements
@@ -434,13 +453,14 @@ class CABlockIterator < CAIterator
   # and with `min_count` a tile with too few present cells, is a masked cell.
   def face_winner (idx_op, min_count, fill_value)
     addr = winner_addr(idx_op)
-    need = CArray.__min_count_need__(idx_op == :min_index ? :min : :max, min_count, 0)
+    need = CArray.__present_cells_needed_per_result_cell__(idx_op == :min_index ? :min : :max, min_count, 0)
     addr[count_not_masked.lt(need)] = UNDEF if need > 0
     src   = @source.reshape(@source.elements)
     empty = addr.is_masked
     return src[addr].copy unless empty.any
-    # A masked index drops the cell rather than masking it, so an empty tile
-    # needs a placeholder address.  Pointing it at a masked cell of the source
+    # A masked index would read as masked, but gathering by one gives the
+    # source a mask, so an empty tile takes a placeholder address instead.
+    # Pointing it at a masked cell of the source
     # carries the mask through the gather, which a read-only Face (whose copy
     # cannot be written) needs.  Otherwise mask the placeholder afterwards.
     if fill_value.nil? && src.has_mask? && (hole = src.is_masked.where).elements > 0
@@ -474,7 +494,7 @@ class CABlockIterator < CAIterator
       out ||= CArray.int64(*@shape)
       out[*out_ranges] = picked
     end
-    CArray.__reduce_fill__(out || CArray.int64(*@shape), kw[:fill_value])
+    CArray.__fill_undefined_result_cells__(out || CArray.int64(*@shape), kw[:fill_value])
   end
 
   public
@@ -691,24 +711,81 @@ class CABlockIterator < CAIterator
   # @!method cumcount
   #   Per-tile running count of present cells (int64), source-shaped.
   #   @return [CArray]
-  [:cumsum, :cumprod, :cummax, :cummin, :cumcount].each do |op|
-    define_method(op) { block_scan(op) }
+  CArray.send(:define_named_methods, self,
+              [:cumsum, :cumprod, :cummax, :cummin, :cumcount], :scan_tiles)
+
+  # A scan takes no arguments here.
+  private def scan_tiles (op, *args)
+    unless args.empty?
+      raise ArgumentError, "wrong number of arguments (given #{args.size}, expected 0)"
+    end
+    block_scan(op)
+  end
+
+  # @overload lag(n = 1)
+  #   Per-tile value `n` steps earlier, counting the tile's cells row-major;
+  #   UNDEF where the tile has none, so a lag never reaches into another
+  #   tile. A partial edge tile counts only the cells it has.
+  #   @return [CArray] source-shaped
+  def lag (n = 1)
+    unless n.is_a?(Integer)
+      raise TypeError, "lag: n must be an Integer (got #{n.class})"
+    end
+    tile_wise { |rows, axis| rows.lag(n, axis: axis) }
+  end
+
+  # @overload strip_mask(method:)
+  #   Per-tile fill of the masked cells, counting the tile's cells row-major:
+  #   `:forward` / `:ffill` or `:backward` / `:bfill`. A fill never reaches
+  #   into another tile, so a masked cell with nothing to carry in its tile
+  #   stays masked.
+  #   @return [CArray] source-shaped
+  def strip_mask (method:)
+    CAIterator.hold_backward?(method)
+    tile_wise { |rows, axis| rows.strip_mask(method: method, axis: axis) }
+  end
+
+  # @overload order(descending: false, method: :ordinal, kind: :quick)
+  #   Per-tile rank of each cell among the tile's cells (int64, `0` the
+  #   smallest), as `CArray#order` ranks them; a partial edge tile ranks only
+  #   the cells it has. The keywords are those of `CArray#order`.
+  #   @return [CArray] source-shaped
+  def order (**kw)
+    tile_wise { |rows, axis| rows.order(axis: axis, **kw) }
   end
 
   private
 
+  # A source-shaped result built tile by tile: the block gets a region's
+  # tiles as rows (one tile's cells, row-major, along +axis+) and gives back
+  # rows of the same shape. Each region has whole tiles of one size, so a
+  # partial edge tile is its own cells rather than cells and padding.
+  def tile_wise
+    out = nil
+    each_region do |strip_ranges, tiles, _out_ranges|
+      view  = @source[*strip_ranges].block_view(*tiles)
+      grid  = view.shape[0, @sndim]
+      found = yield(view.copy.reshape(*grid, tiles.inject(1, :*)), @sndim)
+                .reshape(*grid, *tiles)
+      out ||= tile_output(found)
+      out[*strip_ranges].block_view(*tiles)[] = tile_values(out, found)
+    end
+    # a source with no cells has no region; its one-cell rows give the type
+    out || yield(@source.copy.reshape(*@source.shape, 1), @sndim).reshape(*@source.shape)
+  end
+
   # Drive a within-tile segment scan: scan each tile flattened row-major and
   # 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)
+  def block_scan (op, *args)
     tgv  = tile_grid_view
     nils = Array.new(@sndim, nil)
     pout = nil
     pgv  = nil
     CArray.each_index(*@shape) do |*g|
       tile    = tgv[*g, *nils]
-      scanned = tile.copy.reshape(tile.elements).public_send(op).reshape(*@sizes)
+      scanned = tile.copy.reshape(tile.elements).public_send(op, *args).reshape(*@sizes)
       unless pout
         pout = CArray.new(scanned.data_type, padded_source.shape, bytes: scanned.bytes)
         pout[] = UNDEF
@@ -719,6 +796,24 @@ class CABlockIterator < CAIterator
     pout[*@sndim.times.map { |i| 0...@source.shape[i] }].copy
   end
 
+  # A source-shaped array that can hold what #tile_wise gives: of its kind,
+  # or an object array for a read-only Face, which cannot be written cell by
+  # cell.
+  def tile_output (lagged)
+    if lagged.face? && lagged.read_only?
+      CArray.object(*@source.shape)
+    else
+      lagged.__send__(:blank_like, @source.shape)
+    end
+  end
+
+  # The values as +out+ can hold them: a Face going into an object array
+  # goes as its surface values, not its storage.
+  def tile_values (out, lagged)
+    return lagged unless out.data_type == CA_OBJECT && lagged.face?
+    CArray.object(*lagged.shape) { lagged.to_a }
+  end
+
   # A padded entity whose interior holds the source and whose partial-edge
   # margin is masked (UNDEF), sized to exactly cover the ceil tile grid.  When
   # the source already divides evenly this is the source itself (no copy), so
@@ -729,7 +824,7 @@ class CABlockIterator < CAIterator
       if pshape == @source.shape.to_a
         @source
       else
-        pad = CArray.new(@source.data_type, pshape, bytes: @source.bytes)
+        pad = @source.__send__(:blank_like, pshape)   # a Face stays one
         pad[] = UNDEF
         pad[*@sndim.times.map { |i| 0...@source.shape[i] }] = @source
         pad
@@ -742,6 +837,14 @@ class CABlockIterator < CAIterator
   def tile_grid_view
     @tile_grid_view ||= padded_source.block_view(*@sizes)
   end
+
+  # lag and strip_mask(method:) give the source's values moved or held in
+  # place, so the result shows the source's attributes, as CArray#lag and
+  # CArray#strip_mask(method:) do.
+  prepend(Module.new do
+    def lag (*args, **keywords) = @source.__send__(:carry_attrs, super)
+    def strip_mask (**keywords) = @source.__send__(:carry_attrs, super)
+  end)
 end
 
 

data/lib/carray/boolean_reduce.rb

@@ -1,6 +1,6 @@
 # Boolean folds all / any / none gain a `skip_masked:` keyword.
 #
-#   skip_masked: true  (default) -- available-case (skipna): masked cells are
+#   skip_masked: true  (default) -- available-case: masked cells are
 #                                    ignored, the result is always true/false.
 #                                    This is the existing behavior; every other
 #                                    keyword (axis:, keep_axis:, ...) forwards
@@ -14,15 +14,15 @@
 #                                    false < unknown < true).
 #
 # The Kleene fold composes from count(true) / count(false) / count_masked, so
-# there is no dedicated kernel; the C reductions keep the skipna semantics
-# under the `__*_skipna__` aliases.
+# there is no dedicated kernel; the C reductions that skip masked cells stay
+# reachable as the private `*_skipping_masked` aliases.
 
 class CArray
 
-  alias_method :__any_skipna__,  :any
-  alias_method :__all_skipna__,  :all
-  alias_method :__none_skipna__, :none
-  private :__any_skipna__, :__all_skipna__, :__none_skipna__
+  alias_method :any_skipping_masked,  :any
+  alias_method :all_skipping_masked,  :all
+  alias_method :none_skipping_masked, :none
+  private :any_skipping_masked, :all_skipping_masked, :none_skipping_masked
 
   # Whether any cell is true.
   #
@@ -36,8 +36,8 @@ class CArray
   #   `keep_axis:`, ...).
   # @return [Boolean, CArray] a scalar, or an array when an axis is given.
   def any (skip_masked: true, **opts)
-    return __any_skipna__(**opts) if skip_masked
-    __kleene_fold(:any, opts)
+    return any_skipping_masked(**opts) if skip_masked
+    kleene_fold(:any, opts)
   end
 
   # Whether every cell is true.
@@ -52,8 +52,8 @@ class CArray
   #   `keep_axis:`, ...).
   # @return [Boolean, CArray] a scalar, or an array when an axis is given.
   def all (skip_masked: true, **opts)
-    return __all_skipna__(**opts) if skip_masked
-    __kleene_fold(:all, opts)
+    return all_skipping_masked(**opts) if skip_masked
+    kleene_fold(:all, opts)
   end
 
   # Whether no cell is true.
@@ -68,8 +68,8 @@ class CArray
   #   `keep_axis:`, ...).
   # @return [Boolean, CArray] a scalar, or an array when an axis is given.
   def none (skip_masked: true, **opts)
-    return __none_skipna__(**opts) if skip_masked
-    __kleene_fold(:none, opts)
+    return none_skipping_masked(**opts) if skip_masked
+    kleene_fold(:none, opts)
   end
 
   private
@@ -79,11 +79,11 @@ class CArray
   # any, a false for all, a true for none); elsewhere a masked cell leaves the
   # answer undetermined.  Going through that reduction checks the data type,
   # the axes and the keywords exactly as `skip_masked: true` does.
-  def __kleene_fold (kind, opts)
+  def kleene_fold (kind, opts)
     r = case kind
-        when :any then __any_skipna__(**opts)
-        when :all then __all_skipna__(**opts)
-        else           __none_skipna__(**opts)
+        when :any then any_skipping_masked(**opts)
+        when :all then all_skipping_masked(**opts)
+        else           none_skipping_masked(**opts)
         end
     cm = count_masked(**opts)
     if r.is_a?(CArray)