carray 3.0.4 → 3.0.6

data/lib/carray/frame/windows.rb

@@ -79,8 +79,12 @@ class WindowedFrame
 
   # The windowed reductions.  Without names, a frame of every column whose
   # type has the reduction (the on: and by: columns left out), on the
-  # frame's rows and index; given names, the CArray (one) or the Array of
-  # them (several), as +df[...]+ returns columns.
+  # frame's rows and index; given names, the CArray (one), as +df[name]+
+  # returns a column, or a frame of those columns (several) on the frame's
+  # rows and index.  With +at:+ the answers
+  # are one per point, not per row, so names or none, the result is a frame
+  # with the points as its index, as a group reduction's result is labelled
+  # by the groups.
   CArray.send(:define_named_methods, self,
               [:sum, :mean, :min, :max, :prod, :accumulate, :median,
                :variance, :stddev, :variancep, :stddevp], :window_reduction)
@@ -88,6 +92,38 @@ class WindowedFrame
   CArray.send(:define_named_methods, self,
               [:first, :last, :nunique, :count, :all, :any], :window_value)
 
+  # Each window's +p+-th percentile (0 to 100), as +median+ gives the 50th.
+  # The percentage comes first, then the names.
+  #
+  #   w.percentile(90, "rain")
+  #
+  # @param p [Numeric] the percentage.
+  # @param names [Array<String>] the columns; default every column that has
+  #   a percentile.
+  # @return [CAFrame, CArray] as the other windowed reductions return.
+  def percentile (p, *names, min_count: nil, fill_value: nil)
+    CAFrame.__send__(:check_percentage, p)
+    window_reduce(:percentile, names, [p], min_count: min_count, fill_value: fill_value)
+  end
+
+  # Each window's five quartile percentiles, as +CAFrame#quantile+ gives
+  # them: a column "x" gives "x_p0", "x_p25", "x_p50", "x_p75" and "x_p100",
+  # a frame on the frame's rows and index, or with +at:+ on the points.
+  #
+  # @param names [Array<String>] the columns; default every column that has
+  #   a quantile.
+  # @return [CAFrame]
+  def quantile (*names)
+    named = {}
+    over_named_columns(:quantile, names, @key_names) do |col, name|
+      named[name] = @plan.for_value(col).quantile
+    end
+    cols = CAFrame.__send__(:quantile_columns, named)
+    return CAFrame.new(cols, axis_name: @frame.axis_name, index: @frame.index) unless @at
+    key = @frame.__send__(:key_column, @key_names.first, "windows")
+    CAFrame.new(cols, axis_name: @key_names.first, index: CAFrame.__send__(:key_labels, key, @at.copy))
+  end
+
   private
 
   def window_reduction (reduction, *names, min_count: nil, fill_value: nil)
@@ -100,12 +136,14 @@ class WindowedFrame
 
   # An N-D column (each row a profile) is reduced along the rows, each
   # window keeping the trailing shape, as a group reduces it.
-  def window_reduce (reduction, names, **keywords)
+  def window_reduce (reduction, names, args = [], **keywords)
     keywords = keywords.compact
-    out = over_named_columns(reduction, names, @key_names) do |col|
-      @plan.for_value(col).public_send(reduction, **keywords)
+    named = {}
+    out = over_named_columns(reduction, names, @key_names, args) do |col, name|
+      named[name] = @plan.for_value(col).public_send(reduction, *args, **keywords)
     end
-    return out unless names.empty?
+    out = named if @at && !names.empty?
+    return out if out.is_a?(CArray) && !@at
     if @at
       # Each result has an index of its own, as a group's result has.
       key = @frame.__send__(:key_column, @key_names.first, "windows")

data/lib/carray/fuse_source.rb

@@ -160,9 +160,9 @@ class CArray
 
     def self.extract (block)
       sequence = RubyVM::InstructionSequence.of(block) rescue nil
-      location = sequence && sequence.to_a[4][:code_location]
       path     = sequence && (sequence.absolute_path || sequence.path)
-      unless location && path && File.readable?(path)
+      location = path && File.readable?(path) && code_location(sequence, path)
+      unless location
         raise ArgumentError,
               "CArray.fuse cannot read this block's source (defined in irb, " \
               "eval, or a file that is no longer there).  Write `.lazy` on " \
@@ -181,6 +181,35 @@ class CArray
       end
     end
 
+    # [first_line, first_column, last_line, last_column] of the block.  The
+    # block that starts on the sequence's first line is found in the file's
+    # syntax tree.  Only when two start on that line is the sequence itself
+    # dumped: InstructionSequence#to_a reads the instructions while another
+    # Ractor may be running them, and that can crash the process.
+    def self.code_location (sequence, path)
+      line = sequence.first_lineno
+      found = []
+      pending = [Prism.parse_file(path).value]
+      until pending.empty?
+        node = pending.pop
+        next unless node
+        # A lambda's code starts after the arrow, at its parameters or brace.
+        start = case node
+                when Prism::BlockNode  then node.location
+                when Prism::LambdaNode then (node.parameters || node).location
+                end
+        start = node.opening_loc if start && node.is_a?(Prism::LambdaNode) && !node.parameters
+        found << [start, node.location] if start && start.start_line == line
+        pending.concat(node.compact_child_nodes)
+      end
+      if found.size == 1
+        start, whole = found.first
+        [start.start_line, start.start_column, whole.end_line, whole.end_column]
+      else
+        sequence.to_a[4][:code_location]
+      end
+    end
+
     # -- the rewrite -------------------------------------------------------
 
     # The leaves are the names being read.  Everything else keeps its shape:

data/lib/carray/inspect.rb

@@ -262,7 +262,11 @@ class CArray
   #   count, and a truncated data preview.
   #   @return [String]
   def inspect
-    return CArray::Inspector.new(self).inspect_string
+    # A cell of an object array can hold an expression over the array, whose
+    # inspect shows the array again: that is refused as cyclic, as reading a
+    # cell that holds the array is.
+    return CArray::Inspector.new(self).inspect_string unless object?
+    refuse_reentry("inspect") { CArray::Inspector.new(self).inspect_string }
   end
 
   # @overload inspect_full
@@ -290,7 +294,8 @@ class CArray
   #
   #   @return [String]
   def inspect_full
-    return CArray::Inspector.new(self).inspect_string(abbrev: false)
+    return CArray::Inspector.new(self).inspect_string(abbrev: false) unless object?
+    refuse_reentry("inspect_full") { CArray::Inspector.new(self).inspect_string(abbrev: false) }
   end
 
   private

data/lib/carray/iterator.rb

@@ -71,6 +71,38 @@ class CAIterator
     end
   end
 
+  # A member that keeps what it built from its source's values or mask (a
+  # padded copy, the views over it, counts of the cells present) names those
+  # instance variables here.  They are dropped when a public method of the
+  # member is entered from outside, so every call reads the source as it is
+  # then; within one call the helpers it runs share them.  What follows from
+  # the source's shape alone is kept for good.
+  def self.read_source_per_call (*state)
+    names = public_instance_methods(false)
+    prepend(Module.new do
+      module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+        private def forget_source_state
+          #{state.inspect}.each { |v| remove_instance_variable(v) if instance_variable_defined?(v) }
+        end
+      RUBY
+      names.each do |name|
+        module_eval(<<~RUBY, __FILE__, __LINE__ + 1)
+          def #{name} (...)
+            return super if @reading_source
+            forget_source_state
+            @reading_source = true
+            begin
+              super
+            ensure
+              @reading_source = false
+            end
+          end
+        RUBY
+      end
+    end)
+  end
+  private_class_method :read_source_per_call
+
   def self.reduce_keywords (op, kw) # :nodoc:
     if kw.key?(:axis)
       raise ArgumentError, "#{op}: unknown keyword: :axis (the iterator sets the axes)"

data/lib/carray/lazy.rb

@@ -330,9 +330,28 @@ class CArray
     # branch uses C99 `remainder`, round-half-to-even).
   }.freeze
 
+  # A Face answers an operator by its own values (a label, an instant, a
+  # String) and refuses what it can't answer; the lazy kernels read the
+  # storage and see neither.  With a Face among the operands the operator is
+  # the eager one, on the lazy operands computed.
+  module LazyDispatch
+    private
+
+    def face_among_operands? (*operands)
+      operands.any? { |o| o.is_a?(CArray) && o.face? }
+    end
+
+    def computed_operand (operand)
+      ( operand.is_a?(CArray) && operand.lazy_view? ) ? operand.copy : operand
+    end
+  end
+
   CArray.send(:define_named_methods, LazyDispatch, LAZY_BINOP_OP_IDS, template: <<~'RUBY')
     def __NAME__(other)
       if lazy_view? || (other.is_a?(CArray) && other.lazy_view?)
+        if face_among_operands?(self, other)
+          return computed_operand(self).__send__(__method__, computed_operand(other))
+        end
         CABinOp.__build__(self, other, __VALUE__)
       else
         super(other)
@@ -365,12 +384,6 @@ class CArray
     alias_method word, op
   end
 
-  # `pow` is the canonical C method (defined by rb_define_method in
-  # ext/ca_op_ipower.c) that `**` is rb_define_alias'd to.  The `**`
-  # dispatch in this file does not reach `pow` through the C alias, so
-  # `a.lazy.pow(2)` would fall to eager; `pow` is aliased again here.
-  alias_method :pow, :**
-
   # `fmax` / `fmin` are rb_define_alias'd to `pmax` / `pmin` at Init
   # time (the same C alias); they are aliased again beside them, in
   # LazyDispatch.
@@ -403,6 +416,10 @@ class CArray
                       (op2.is_a?(CArray) && op2.lazy_view?) ||
                       (op3.is_a?(CArray) && op3.lazy_view?)
       if lazy_receiver
+        if face_among_operands?(self, op2, op3)
+          return computed_operand(self).__send__(__method__, computed_operand(op2),
+                                                 computed_operand(op3))
+        end
         CATriOp.__build__(self, op2, op3, __VALUE__)
       else
         super(op2, op3)
@@ -435,6 +452,10 @@ class CArray
   # is already fast.  The lazy-substrate gap was Float/Complex only.
   module LazyDispatch
     def **(other)
+      if ( lazy_view? || (other.is_a?(CArray) && other.lazy_view?) ) &&
+         face_among_operands?(self, other)
+        return computed_operand(self) ** computed_operand(other)
+      end
       if other.is_a?(Integer) && (float? || complex?) &&
          (lazy_view? || (other.is_a?(CArray) && other.lazy_view?))
         CABinOp.__build__(self, CScalar.int64.tap { |s| s[0] = other },
@@ -447,6 +468,14 @@ class CArray
     end
   end
 
+  # `pow` is the canonical C method (defined by rb_define_method in
+  # ext/ca_op_ipower.c) that `**` is rb_define_alias'd to.  The `**`
+  # dispatch in this file does not reach `pow` through the C alias, so
+  # `a.lazy.pow(2)` would fall to eager; `pow` is aliased again here.
+  # An alias copies the method as it is at that moment, so this follows
+  # the integer-exponent `**` above, not the template one.
+  alias_method :pow, :**
+
   # coerce: when self is a lazy view and the scalar appears on the LEFT
   # (e.g. `2 * a.lazy`), Ruby's Numeric#* calls a.lazy.coerce(2).  The
   # default coerce would unwrap the lazy-ness via eager scalar promotion;
@@ -468,6 +497,9 @@ class CArray
   # equality returning bool, not element-wise.  Element-wise equality is
   # `eq` / `feq`.
   #
+  # A comparison with UNDEF goes to the eager method, which answers `eq` /
+  # `ne` from the mask and refuses the others.
+  #
   # `feq` is arity 1 in eager (compile-time FLT_EPSILON / DBL_EPSILON);
   # we mirror that here.  Runtime eps is a future extension (struct field
   # already reserved).
@@ -491,7 +523,12 @@ class CArray
 
   CArray.send(:define_named_methods, LazyDispatch, LAZY_BINCMP_OP_IDS, template: <<~'RUBY')
     def __NAME__(other)
-      if lazy_view? || (other.is_a?(CArray) && other.lazy_view?)
+      if UNDEF.equal?(other)
+        super(other)
+      elsif lazy_view? || (other.is_a?(CArray) && other.lazy_view?)
+        if face_among_operands?(self, other)
+          return computed_operand(self).__send__(__method__, computed_operand(other))
+        end
         CABinCmp.__build__(self, other, __VALUE__)
       else
         super(other)
@@ -510,7 +547,12 @@ class CArray
 
   CArray.send(:define_named_methods, LazyDispatch, LAZY_BINCMP_TOL_OP_IDS, template: <<~'RUBY')
     def __NAME__(other, tol)
-      if lazy_view? || (other.is_a?(CArray) && other.lazy_view?)
+      if UNDEF.equal?(other)
+        super(other, tol)
+      elsif lazy_view? || (other.is_a?(CArray) && other.lazy_view?)
+        if face_among_operands?(self, other)
+          return computed_operand(self).__send__(__method__, computed_operand(other), tol)
+        end
         CABinCmp.__build__(self, other, __VALUE__, tol.to_f.abs)
       else
         super(other, tol)
@@ -598,6 +640,8 @@ class CAMonOp
     op_id = __op_id__
     if op_id >= CAMonOp::CAST_BASE
       "cast_#{CArray.data_type_name(op_id - CAMonOp::CAST_BASE)}"
+    elsif op_id == CAMonOp::OP_BYTE_SWAP
+      "swap_bytes"       # a view of its own, not a lazy operation by name
     else
       (OP_NAMES[op_id] || "op_#{op_id}").to_s
     end

data/lib/carray/mask_gap_fill.rb

@@ -45,14 +45,14 @@ class CArray
                 "unmask: pass either a constant fill value or method:, not both"
         end
         held = gap_fill(method, axis, "unmask")
-        # Copy the filled values in place (a Face takes a Face of its own kind
-        # as it is).
-        value[] = held.value
-        if held.has_mask?
-          self.mask = held.mask              # residual leading/trailing mask
-        else
-          super()                   # fully filled: drop the mask
-        end
+        # Write only the cells the fill gave a value (a Face takes a Face of
+        # its own kind as it is). Writing every cell would let a view that
+        # reaches one cell twice send that cell's unfilled copy back last,
+        # masking it again.
+        return self unless has_mask?
+        filled = is_masked
+        filled = filled.and(held.is_not_masked) if held.has_mask?
+        self[filled] = held[filled] if filled.any
         return self
       end
       fill.equal?(MASK_FILL_UNSET) ? super() : super(fill)
@@ -161,7 +161,12 @@ class CArray
   end
 
   # Fill the masked cells of this 1-D array by linear interpolation against
-  # the coordinate `x` (same length, ascending over the present cells).
+  # the coordinate `x` (same length).  `x` need not be in order: the present
+  # cells are read as one series in the order of their `x`, so a frame whose
+  # index restarts for each station interpolates across the stations by
+  # time (interpolate one station at a time to keep them apart).  Present
+  # cells sharing an `x` keep their row order.  A cell whose `x` is masked,
+  # NaN or infinite has no place on the line: it is not used and not filled.
   # The one rule both the core (x = cell position) and CAFrame (x = index)
   # use: present cells come back exactly as they are, in this array's own
   # type; a masked cell inside the span of the present ones takes the
@@ -170,17 +175,34 @@ class CArray
   # NaN or Inf stored in a present cell is left alone.  A Face goes through
   # its own linear_fetch, which keeps its unit and rounds to its grid.
   def linear_fill_along (x)
-    present = is_not_masked
+    # A cell whose coordinate is masked, NaN or infinite has no place on the
+    # line: it is no point to interpolate between, and is not filled.
+    placed = x.is_not_masked
+    placed &= x.is_finite if !x.face? && x.float?
+    placed = placed.strip_mask(false)
+    present = is_not_masked & placed
     # Fewer than two valid points -> nothing to interpolate between; leave
     # every masked cell masked.
     return copy if present.count(true) < 2
-    addr = x[present].linear_section(x)       # valid positions -> monotonic grid
+    grid  = x[present]
+    order = nil
+    if ( grid[1..-1] < grid[0..-2] ).any
+      order = grid.sort_addr                  # stable: ties keep their row order
+      grid  = grid[order]
+    end
+    addr = grid.linear_section(x)             # valid positions -> monotonic grid
+    fill = (is_masked & placed & addr.is_finite).strip_mask(false)
     if face?
-      # The Face's linear_fetch already masks the exterior (out of range) and
-      # lands on its own grid.
-      return self[present].linear_fetch(addr)
+      # The Face's linear_fetch lands on its own grid; only the cells to fill
+      # take it, so a present cell comes back as it is.
+      known = self[present]
+      known = known[order] if order
+      out = copy
+      out[fill] = known.linear_fetch(addr)[fill] if fill.any
+      return out
     end
     v = value[present]
+    v = v[order] if order
     # A complex value interpolates its real and imaginary parts.
     interp = v.complex? ? v.linear_fetch(addr) : v.float64.linear_fetch(addr)
     # An integer array takes the nearest integer, half away from zero (as a
@@ -189,9 +211,7 @@ class CArray
     interp = interp.round if integer?
     # Built from the values alone, so a fully filled result carries no mask.
     out      = value.copy
-    masked   = is_masked
-    fill     = masked & addr.is_finite
-    exterior = masked & fill.not
+    exterior = is_masked & fill.not
     out[fill] = interp[fill] if fill.any
     out[exterior] = UNDEF if exterior.any
     out

data/lib/carray/meld_reduce.rb

@@ -171,7 +171,7 @@ class CAMeld
   # more elaborate (min_count / fill_value / keep_axis / multi-axis /
   # mask propagation) punts to super.
   def meld_reduce_fast_path_ok?(kw)
-    return false unless CArray.__fast_paths_enabled__
+    return false unless CArray.__fast_paths_enabled__(:meld_reduce)
     # The mask of a meld is a meld built in C, with no parents list.
     return false unless parents
     return false unless (kw.keys - [:axis]).empty?

data/lib/carray/methods/choose.rb

@@ -41,11 +41,12 @@ class CArray
       data_type = ca.empty? ? CA_OBJECT : CArray.result_type(*ca)
     end
     out = template(data_type)
+    dst = out.scalar? ? out.flatten : out   # a CScalar takes no index
     choices.each_with_index do |v, i|
       s = self.eq(i)
-      out[s] = v.is_a?(CArray) ? v[s] : v
+      dst[s] = !v.is_a?(CArray) ? v : v.scalar? ? v.flatten[s] : v[s]
     end
-    out[self.is_masked] = UNDEF if has_mask?
+    dst[self.is_masked] = UNDEF if has_mask?
     text ? CAString.wrap(out) : out
   end
 

data/lib/carray/methods/is_in.rb

@@ -226,8 +226,15 @@ class CArray
       # set for not matching self.  Same rule the scalar operand of a
       # comparison follows: a String standing in for a cell is padded to the
       # cell's width.
+      # A String longer than the cell keeps its length: self is read at its
+      # width instead (NUL-padded), so "abX" is in no two-byte cell.
+      w = elems.map { |v| v.is_a?(String) ? v.bytesize : 0 }.max.to_i
+      me = self
+      if w > bytes
+        me = is_a?(CAFixlenString) ? to_fixlen_string(bytes: w) : to_type(CA_FIXLEN, bytes: w)
+      end
       # coerce: a fixlen or object set holds values of self's kind (see above)
-      [self, elems.to_ca.to_type(data_type, bytes: bytes)]
+      [me, elems.to_ca.to_type(data_type, bytes: me.bytes)]
     elsif data_type == CA_OBJECT
       # coerce: an object set holds values of self's kind
       [self, elems.to_ca.to_type(data_type)]

data/lib/carray/methods/meshgrid.rb

@@ -58,7 +58,9 @@ class CArray
         raise ArgumentError,
               "coordinate vector #{k} should be 1-D (got #{a.ndim}-D)"
       end
-      a
+      # A CScalar takes no index, so a scalar axis is read as the
+      # one-cell array it stands for.
+      a.is_a?(CScalar) ? a.reshape(1) : a
     end
 
     ndim = axes.size

data/lib/carray/runtime.rb

@@ -7,10 +7,11 @@ class CArray
 
   # A fast path answers by a different algorithm what a general path also
   # answers.  A development build defines this in C, false when run with
-  # CARRAY_GENERAL_PATH=1 so the test suite takes the general paths (see
+  # CARRAY_GENERAL_PATH=1 so the test suite takes the general paths, and
+  # false for a name listed in CARRAY_SHORTCUTS_OFF (see
   # ext/carray_internal.h); a release build has no switch.
   unless respond_to?(:__fast_paths_enabled__)
-    def self.__fast_paths_enabled__ # :nodoc:
+    def self.__fast_paths_enabled__ (name = nil) # :nodoc:
       true
     end
   end
@@ -57,13 +58,14 @@ class CArray
   # is more naturally (and exactly, for Rational / BigDecimal weights) a
   # +(self * weights).sum+ composition than a dedicated :object kernel branch.
   #
-  # +weights+ is a Ruby Numeric scalar (W-A1) or a same-shape CArray; the 1-D
-  # axis-broadcast form (W-A2) is not supported for object weights (pass a
-  # scalar or a full-shape weight), matching CArray's explicit-broadcast rule.
-  # +opts+ is the trailing options Hash (axis:/keep_axis:/min_count:/
-  # fill_value:) forwarded verbatim by the C escape; it goes straight to +sum+.
+  # +weights+ takes the forms the numeric kernel takes: a scalar (or a
+  # one-element CArray), an array of the shape of the reduced axes (taken in
+  # ascending axis order), or an array of self.shape.  +opts+ is the trailing
+  # options Hash (axis:/keep_axis:/min_count:/fill_value:) forwarded verbatim
+  # by the C escape; it goes straight to +sum+.
   def wsum_object (weights, opts = {}) # :nodoc:
-    (self * weights).sum(**opts)
+    weights = weights_over_self_shape(weights, opts[:axis], "wsum")
+    return (self * weights).sum(**opts)
   end
   private :wsum_object
 
@@ -76,6 +78,7 @@ class CArray
   def wmean_object (weights, opts = {}) # :nodoc:
     axis      = opts[:axis]
     keep_axis = opts[:keep_axis]
+    weights = weights_over_self_shape(weights, axis, "wmean")
     prod = self * weights
     wv   = (weights.is_a?(CArray) ? weights : self * 0 + weights).copy
     wv[prod.is_masked] = UNDEF if prod.has_mask?
@@ -97,6 +100,42 @@ class CArray
   end
   private :wmean_object
 
+  # The weights of wsum / wmean as a scalar or an array of self.shape.  A
+  # CScalar is a scalar; any other array, one with a single element included,
+  # is held to the shapes.  An array of the shape of the reduced axes (in ascending axis order) is
+  # repeated along the kept axes; any other shape is refused, with the same
+  # message as the numeric kernel.
+  def weights_over_self_shape (weights, axis, name) # :nodoc:
+    unless weights.is_a?(CArray)
+      return weights
+    end
+    if weights.scalar?
+      w = weights[0]
+      # A boolean cell reads as true / false; as a weight it is 1 / 0.
+      w = (w ? 1 : 0) if weights.data_type == CA_BOOLEAN && !UNDEF.equal?(w)
+      return w
+    end
+    if weights.shape == self.shape
+      return weights
+    end
+    axes = case axis
+           when nil     then (0...self.ndim).to_a
+           when Integer then [axis]
+           else              axis
+           end
+    axes = axes.map { |a| ( a < 0 ) ? a + self.ndim : a }.sort
+    reduced_shape = axes.map { |a| self.shape[a] }
+    unless weights.shape == reduced_shape
+      raise ArgumentError,
+            "#{name}: weights of shape #{weights.shape.inspect} not accepted " \
+            "(expected a scalar, the shape of the reduced axes " \
+            "#{reduced_shape.inspect}, or self.shape #{self.shape.inspect})"
+    end
+    spread = self.shape.each_index.map { |i| axes.include?(i) ? self.shape[i] : 1 }
+    return weights.reshape(*spread).broadcast_to(*self.shape)
+  end
+  private :weights_over_self_shape
+
   # Define on +mod+ one method per name in +names+, each a `def` that passes
   # its own name and its arguments to the private method +to+:
   #

data/lib/carray/segment_iterator.rb

@@ -252,12 +252,20 @@ class CASegmentIterator < CAIterator
     return axis_by_masked_copy(axis, :variance) if axis
     m = moments
     return per_segment(core_reduce_kind(:variance)) { |s| s.variance } unless m
+    centred_variance(m, 1)
+  end
+
+  # The kernel divides the centred sum of squares by count - ddof once, as
+  # the core reduction does; scaling the sample variance by (n-1)/n instead
+  # rounds twice and lands an ulp away.
+  def centred_variance (m, ddof)
     cnt   = m[:count]
-    means = m[:sum] / cnt.float64    # per-segment mean (garbage where count 0/1,
-    out   = CArray.float64(@k)       #   ignored by the kernel's n<2 guards)
-    grouped.send(:__reduceat_variance__, @offsets, means, cnt, out)
+    means = m[:sum] / cnt.float64    # per-segment mean (garbage where the count
+    out   = CArray.float64(@k)       #   is too small; the kernel masks those)
+    grouped.send(:__reduceat_variance__, @offsets, means, cnt, out, ddof)
     out
   end
+  private :centred_variance
 
   # @overload stddev
   #   Returns per-segment SAMPLE standard deviation (ddof=1) as float64.
@@ -329,9 +337,17 @@ class CASegmentIterator < CAIterator
   #   with the distinctness of `CArray#nunique` (every NaN is one value,
   #   -0.0 is 0.0).  A segment with no present value counts 0.
   #   @return [CArray]
+  # Coding every cell costs the same for every cell, and the segment-by-
+  # segment way the same for every segment, so long segments are faster one
+  # by one: from an average of about 100 cells (1M cells on an M2 Max).
+  NUNIQUE_KERNEL_MAX_LENGTH = 100
+
   def nunique (axis: nil)
     return axis_by_core(axis, :nunique) if axis
-    return per_segment(CA_INT64) { |s| s.nunique } unless CArray.__fast_paths_enabled__
+    if ! CArray.__fast_paths_enabled__(:segment_nunique) ||
+       grouped.elements >= NUNIQUE_KERNEL_MAX_LENGTH * @k
+      return per_segment(CA_INT64) { |s| s.nunique }
+    end
     out = CArray.int64(@k)
     return out if grouped.elements.zero?
     # Each cell's value becomes a code, so a distinct (segment, value) pair is
@@ -375,11 +391,7 @@ class CASegmentIterator < CAIterator
     return axis_by_masked_copy(axis, :variancep) if axis
     m = moments
     return per_segment(core_reduce_kind(:variancep)) { |s| s.variancep } unless m
-    cnt = m[:count]
-    vp  = variance * (cnt - 1).float64 / cnt.float64
-    one = cnt.eq(1)                       # one value: defined, unlike variance --
-    vp[one] = (m[:sum] - m[:sum])[one]    # 0.0, or NaN for a NaN or an infinity
-    vp
+    centred_variance(m, 0)               # one value: 0.0, or NaN for a NaN or an infinity
   end
 
   # @overload stddevp
@@ -472,9 +484,8 @@ class CASegmentIterator < CAIterator
   end
 
   # @overload wmean(weights)
-  #   Per-segment weighted mean as float64, matching `CArray#wmean`. Empty
-  #   segment -> MASKED; a present segment whose weights sum to zero -> NaN
-  #   (core's 0/0 contract).
+  #   Per-segment weighted mean as float64, matching `CArray#wmean`. An empty
+  #   segment, and one whose weights sum to zero, is masked.
   #   @param weights [CArray]
   #   @return [CArray]
   def wmean (weights, axis: nil)
@@ -745,7 +756,7 @@ class CASegmentIterator < CAIterator
   # cumcount in int64 -- which is not the core's answer for every data type
   # (the core counts a boolean's running sum in uint64).
   def kernel_scans? (op, answer)
-    return false unless CArray.__fast_paths_enabled__
+    return false unless CArray.__fast_paths_enabled__(:segment_scan_kernel)
     return false if @value.face? || answer.face? || @value.complex?
     kernel_type =
       case op
@@ -902,9 +913,17 @@ class CASegmentIterator < CAIterator
   # segment's first or last slot and kept when it falls inside the segment.
   # A read-only Face cannot take UNDEF cell by cell, so its answers are
   # collected segment by segment, as its other reductions are.
+  #
+  # The running minimum or maximum costs the same for every cell, and the
+  # segment-by-segment way the same for every segment, so long segments
+  # are faster one by one: from an average of about 300 cells for :first
+  # and 2000 for :last (1M cells on an M2 Max).
+  EDGE_KERNEL_MAX_LENGTH = { first: 300, last: 2000 }.freeze
+
   def edge_values (op)
     n = grouped.elements
-    if n.zero? || (@value.face? && ! face_output?) || ! CArray.__fast_paths_enabled__
+    if n.zero? || (@value.face? && ! face_output?) || ! CArray.__fast_paths_enabled__(:segment_edge_kernel) ||
+       n >= EDGE_KERNEL_MAX_LENGTH.fetch(op) * @k
       return per_segment(core_reduce_kind(op)) { |s| s.public_send(op) }
     end
     slot = CArray.int64(n).seq!
@@ -951,7 +970,7 @@ class CASegmentIterator < CAIterator
   # CARRAY_GENERAL_PATH set reduces every group by the core instead, which
   # is how the two are compared.
   def kernel_reads? (data_type = grouped.data_type)
-    MONOID_TYPES.include?(data_type) && CArray.__fast_paths_enabled__
+    MONOID_TYPES.include?(data_type) && CArray.__fast_paths_enabled__(:segment_reduce_kernel)
   end
 
   def moments
@@ -987,7 +1006,7 @@ class CASegmentIterator < CAIterator
   def all_any
     return @all_any if defined?(@all_any)
     @all_any =
-      if grouped.data_type == CA_BOOLEAN && CArray.__fast_paths_enabled__
+      if grouped.data_type == CA_BOOLEAN && CArray.__fast_paths_enabled__(:segment_all_any_kernel)
         a = CArray.boolean(@k)
         o = CArray.boolean(@k)
         grouped.send(:__reduceat_all_any__, @offsets, a, o)