carray 3.0.2 → 3.0.4

data/lib/carray/block_iterator.rb

@@ -167,19 +167,44 @@ class CABlockIterator < CAIterator
   # below a full tile, so `min_count:` marks them UNDEF with no masking.  The
   # output data type is seeded from the first region (all regions share it).
   def assemble
-    outs = nil
+    grids = nil
+    faces = nil
+    single = true
     each_region do |strip_ranges, tiles, out_ranges|
       view = @source[*strip_ranges].block_view(*tiles)
       res  = yield(view, tiles)
-      if res.is_a?(Array)
-        outs ||= res.map { |r| CArray.new(r.data_type, @shape) }
-        res.each_index { |k| outs[k][*out_ranges] = res[k] }
-      else
-        outs ||= CArray.new(res.data_type, @shape)
-        outs[*out_ranges] = res
-      end
+      single = false if res.is_a?(Array)
+      res  = [res] unless res.is_a?(Array)
+      faces ||= res.map { |r| r.face? ? r : nil }
+      parts = res.map { |r| r.face? ? face_grid_part(r) : r }
+      grids ||= parts.map { |r| CArray.new(r.data_type, @shape, bytes: r.bytes) }
+      parts.each_index { |k| grids[k][*out_ranges] = parts[k] }
     end
-    outs
+    unless grids
+      # An empty source has no region.  A view with unit tiles has no cells
+      # either; reducing it gives each output's type for the empty grid.
+      res = yield(@source.block_view(*[1] * @sndim), [1] * @sndim)
+      single = !res.is_a?(Array)
+      res = [res] unless res.is_a?(Array)
+      faces = res.map { |r| r.face? ? r : nil }
+      grids = res.map { |r| r = face_grid_part(r) if r.face?; CArray.new(r.data_type, @shape, bytes: r.bytes) }
+    end
+    outs = grids.each_index.map { |k| faces[k] ? face_grid(grids[k], faces[k]) : grids[k] }
+    single ? outs[0] : outs
+  end
+
+  # A region result that is a Face (a CATime mean, a CATimedelta stddev) is
+  # assembled on its storage and the Face is put back on the whole grid;
+  # assembling the Face itself would copy its surface bytes into an array that
+  # no longer knows it is one.  A CAConstString's storage points into its own
+  # buffer, which the regions do not share, so it is assembled as strings.
+  def face_grid_part (r)
+    r.is_a?(CAConstString) ? r.to_string.parent : r.parent
+  end
+
+  def face_grid (grid, face)
+    return CArray.const_string(grid, encoding: face.encoding) if face.is_a?(CAConstString)
+    grid.face_lift(face)
   end
 
   # Fold every region with a single core reduction `op` (the tier-1 shape).
@@ -255,19 +280,13 @@ 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
-  # @!method all(min_count: nil, fill_value: nil)
+  # @!method all
   #   Whether every cell of each tile is true.
-  #   @param min_count [Integer, nil] fewest cells that must be present
-  #     for a result; a piece with fewer comes back masked.
-  #   @param fill_value [Object, nil] value to put in place of a masked
-  #     result instead of leaving it masked.
+  #   Takes no `min_count:` or `fill_value:`, as the core `all` does not.
   #   @return [CArray] tile-grid shaped
-  # @!method any(min_count: nil, fill_value: nil)
+  # @!method any
   #   Whether any cell of each tile is true.
-  #   @param min_count [Integer, nil] fewest cells that must be present
-  #     for a result; a piece with fewer comes back masked.
-  #   @param fill_value [Object, nil] value to put in place of a masked
-  #     result instead of leaving it masked.
+  #   Takes no `min_count:` or `fill_value:`, as the core `any` does not.
   #   @return [CArray] tile-grid shaped
   # @!method variancep(min_count: nil, fill_value: nil)
   #   Per-tile population variance (divisor `n`).
@@ -283,16 +302,49 @@ 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, :all, :any,
-   :variancep, :stddevp].each do |op|
-    define_method(op) do |min_count: nil, fill_value: nil|
-      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
+
+  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 ----------------------------------------
 
   # @overload count(v = <none>)
@@ -300,15 +352,16 @@ class CABlockIterator < CAIterator
   #   partial edge tile); `count(UNDEF)` counts masked cells; `count(v)` counts
   #   cells equal to `v`.
   #   @return [CArray] tile-grid shaped
-  def count (*args)
-    return count_not_masked if args.empty?
+  def count (*args, **kw)
+    return count_not_masked(**kw) if args.empty?
+    kw = CAIterator.reduce_keywords(:count, kw)
     out = nil
     each_region do |strip_ranges, tiles, out_ranges|
       view = @source[*strip_ranges].block_view(*tiles)
       # block_view is a CAStride, so #count is not shadowed; dispatch
       # CArray#count explicitly anyway, matching the family regularity.
-      red = CArray.instance_method(:count).bind_call(view, *args, axis: @tile_axes)
-      out ||= CArray.new(red.data_type, @shape)
+      red = CArray.instance_method(:count).bind_call(view, *args, axis: @tile_axes, **kw)
+      out ||= CArray.new(red.data_type, @shape, bytes: red.bytes)
       out[*out_ranges] = red
     end
     out
@@ -318,16 +371,21 @@ class CABlockIterator < CAIterator
   #   Per-tile count of present (non-masked) cells.  For a partial edge tile
   #   this is the real cell count (the OOB cells are not present).
   #   @return [CArray]
-  def count_not_masked
-    fold(:count_not_masked)
+  def count_not_masked (**kw)
+    fold(:count_not_masked, **CAIterator.reduce_keywords(:count_not_masked, kw))
   end
 
   # @overload count_masked
   #   Per-tile count of masked cells.  Equals `elements - count_not_masked`;
   #   the OOB cells of a partial edge tile count here.
   #   @return [CArray]
-  def count_masked
-    elements - count_not_masked
+  def count_masked (**kw)
+    kw   = CAIterator.reduce_keywords(:count_masked, kw)
+    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.__fill_undefined_result_cells__(out, kw[:fill_value])
   end
 
   # @overload elements
@@ -349,6 +407,10 @@ class CABlockIterator < CAIterator
   #   Per-tile `[min, max]` (two tile-grid-shaped CArrays, a single fused pass).
   #   @return [Array<CArray>]
   def minmax (min_count: nil, fill_value: nil)
+    if @source.face?
+      return [min(min_count: min_count, fill_value: fill_value),
+              max(min_count: min_count, fill_value: fill_value)]
+    end
     kw = {}
     kw[:min_count]  = min_count  unless min_count.nil?
     kw[:fill_value] = fill_value unless fill_value.nil?
@@ -364,8 +426,9 @@ class CABlockIterator < CAIterator
   #   @return [CArray]
   [:min_index, :max_index].each do |op|
     class_eval <<~RUBY, __FILE__, __LINE__ + 1
-      def #{op}
-        assemble { |view, _| view.#{op}(axis: @tile_axes) }
+      def #{op} (**kw)
+        kw = CAIterator.reduce_keywords(:#{op}, kw)
+        assemble { |view, _| view.#{op}(axis: @tile_axes, **kw) }
       end
     RUBY
   end
@@ -376,26 +439,50 @@ class CABlockIterator < CAIterator
   #   minima. Unlike `min_index` (the tile-local position) this indexes back
   #   into the original array. An all-masked tile is a masked cell.
   #   @return [CArray] tile-grid shaped int64
-  def min_addr; winner_addr(:min_index); end
+  def min_addr (**kw); winner_addr(:min_index, kw); end
 
   # @overload max_addr
   #   Per-tile flat source address of the maximum. See {#min_addr}.
   #   @return [CArray] tile-grid shaped int64
-  def max_addr; winner_addr(:max_index); end
+  def max_addr (**kw); winner_addr(:max_index, kw); end
 
   private
 
+  # Per-tile minimum or maximum of a Face source, gathered from the source by
+  # the winner's address so the result is the Face itself.  An all-masked tile,
+  # 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.__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 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
+      return src[addr.strip_mask(hole[0])].copy
+    end
+    out = src[addr.strip_mask(0)].copy
+    out[empty] = fill_value.nil? ? UNDEF : fill_value
+    out
+  end
+
   # Per-tile source address of the winner. The tile-local flat index (min_index /
   # max_index) is looked up in a source-address companion tiled the same way, so
   # the tile geometry is reused rather than recomputed. An all-masked tile yields
   # a masked index; it is gathered at 0 and re-masked in the result.
-  def winner_addr (idx_op)
+  def winner_addr (idx_op, kw = {})
+    kw    = CAIterator.reduce_keywords(idx_op, kw)
     saddr = CArray.int64(*@source.shape).seq!
     out = nil
     each_region do |strip_ranges, tiles, out_ranges|
       vview = @source[*strip_ranges].block_view(*tiles)
       sview = saddr[*strip_ranges].block_view(*tiles)
-      mi    = vview.public_send(idx_op, axis: @tile_axes)  # tile-local flat index
+      mi    = vview.public_send(idx_op, axis: @tile_axes, **kw.slice(:min_count))  # tile-local flat index
       grid  = (0...@sndim).map { |i| vview.shape[i] }
       cells = tiles.inject(1) { |p, t| p * t }
       safe  = mi.copy
@@ -407,7 +494,7 @@ class CABlockIterator < CAIterator
       out ||= CArray.int64(*@shape)
       out[*out_ranges] = picked
     end
-    out
+    CArray.__fill_undefined_result_cells__(out || CArray.int64(*@shape), kw[:fill_value])
   end
 
   public
@@ -441,15 +528,17 @@ class CABlockIterator < CAIterator
   #   Per-tile weighted sum; `weights` is shaped like one full tile (`Π b_i`).
   #   At a partial edge tile the weight kernel is sliced to the present cells.
   #   @return [CArray]
-  def wsum (weights)
-    weighted(weights) { |view, w| view.wsum(w, axis: @tile_axes) }
+  def wsum (weights, **kw)
+    kw = CAIterator.reduce_keywords(:wsum, kw)
+    weighted(weights) { |view, w| view.wsum(w, axis: @tile_axes, **kw) }
   end
 
   # @overload wmean(weights)
   #   Per-tile weighted mean; `weights` shaped like one full tile.
   #   @return [CArray]
-  def wmean (weights)
-    weighted(weights) { |view, w| view.wmean(w, axis: @tile_axes) }
+  def wmean (weights, **kw)
+    kw = CAIterator.reduce_keywords(:wmean, kw)
+    weighted(weights) { |view, w| view.wmean(w, axis: @tile_axes, **kw) }
   end
 
   private
@@ -479,21 +568,22 @@ class CABlockIterator < CAIterator
   # Core per-axis order statistics take a single integer axis, so a 1-D tile
   # delegates straight to the C path; a multi-axis tile is materialized per
   # region and its tile axes flattened into one before the single-axis core
-  # order-stat.  A masked source raises (the known per-axis masked limitation);
-  # strip the mask with `ca.value` first if needed.
+  # order-stat.  Masked cells are left out, as in `CArray#median(axis:)`.
 
   # @overload median
   #   Per-tile median.  @return [CArray]
-  def median
-    order_stat { |v, axis| v.median(axis: axis) }
+  def median (**kw)
+    kw = CAIterator.reduce_keywords(:median, kw)
+    order_stat { |v, axis| v.median(axis: axis, **kw) }
   end
 
   # @overload percentile(*pers)
   #   Per-tile percentile(s).  One argument returns one CArray, several an array
   #   of CArrays (as `CArray#percentile`).
   #   @return [CArray, Array<CArray>]
-  def percentile (*pers)
-    order_stat { |v, axis| v.percentile(*pers, axis: axis) }
+  def percentile (*pers, **kw)
+    kw = CAIterator.reduce_keywords(:percentile, kw)
+    order_stat { |v, axis| v.percentile(*pers, axis: axis, **kw) }
   end
 
   # @overload quantile
@@ -585,7 +675,7 @@ class CABlockIterator < CAIterator
   #   @return [CArray, Enumerator] source-shaped
   def map
     return to_enum(:map) unless block_given?
-    pout = CArray.new(padded_source.data_type, padded_source.shape)
+    pout = CArray.new(padded_source.data_type, padded_source.shape, bytes: padded_source.bytes)
     pgv  = pout.block_view(*@sizes)
     tgv  = tile_grid_view
     nils = Array.new(@sndim, nil)
@@ -621,26 +711,83 @@ 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)
+        pout = CArray.new(scanned.data_type, padded_source.shape, bytes: scanned.bytes)
         pout[] = UNDEF
         pgv  = pout.block_view(*@sizes)
       end
@@ -649,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
@@ -659,7 +824,7 @@ class CABlockIterator < CAIterator
       if pshape == @source.shape.to_a
         @source
       else
-        pad = CArray.new(@source.data_type, pshape)
+        pad = @source.__send__(:blank_like, pshape)   # a Face stays one
         pad[] = UNDEF
         pad[*@sndim.times.map { |i| 0...@source.shape[i] }] = @source
         pad
@@ -672,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,42 +68,34 @@ 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
-    # none = not any (Kleene): not(true)=false, not(false)=true, not(UNDEF)=UNDEF
-    r = __kleene_fold(:any, opts)
-    r.is_a?(CArray) ? r.not : (r.equal?(UNDEF) ? UNDEF : !r)
+    return none_skipping_masked(**opts) if skip_masked
+    kleene_fold(:none, opts)
   end
 
   private
 
-  # Three-valued fold via counts.  `kind` is :any (OR) or :all (AND).
-  # `opts` carries axis: / keep_axis: (same surface as the skipna reduction).
-  def __kleene_fold (kind, opts)
-    axis = opts[:axis]
-    if axis.nil?
-      if kind == :any
-        return true  if count(true)  > 0     # a known TRUE settles OR
-      else
-        return false if count(false) > 0     # a known FALSE settles AND
-      end
-      return UNDEF if count_masked > 0        # undetermined
-      return( kind == :any ? false : true )
+  # Three-valued fold.  `kind` is :any, :all or :none.  The available-case
+  # reduction answers wherever an unmasked cell settles the fold (a true for
+  # 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)
+    r = case kind
+        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)
+      settled = ( kind == :any ) ? r : r.not
+      out = r.copy
+      out[settled.not & (cm > 0)] = UNDEF
+      out
+    else
+      settled = ( kind == :any ) ? r : !r
+      return r if settled
+      ( cm > 0 ) ? UNDEF : r
     end
-
-    keep = opts[:keep_axis]
-    cnt_kw = keep ? { axis: axis, keep_axis: keep } : { axis: axis }
-    ck = ( kind == :any ) ? count(true, **cnt_kw) : count(false, **cnt_kw)
-    cm = count_masked(axis: axis)               # count_masked has no keep_axis
-    cm = cm.reshape(*ck.shape) unless cm.shape == ck.shape
-
-    # A cell is undetermined only where it is masked AND the known side does
-    # not settle it (ck counts the settling value: true for OR, false for AND).
-    # Masking only those cells avoids leaving an all-zero mask behind.
-    out = CArray.boolean(*ck.shape)
-    out[] = ( kind == :any ) ? 0 : 1            # OR default false / AND default true
-    out[ck.eq(0) & (cm > 0)] = UNDEF             # genuinely undetermined
-    out[ck > 0] = ( kind == :any ) ? 1 : 0       # known side dominates
-    out
   end
 
 end