carray 3.0.5 → 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/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

@@ -384,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.
@@ -474,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;
@@ -495,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).
@@ -518,7 +523,9 @@ 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
@@ -540,7 +547,9 @@ 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

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/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

@@ -337,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
@@ -476,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)
@@ -749,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
@@ -906,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!
@@ -955,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
@@ -991,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)

data/lib/carray/serialize.rb

@@ -685,11 +685,11 @@ class CArray
 
 end
 
-# Marshal of a view and a scalar: the {CArray#marshal_dump} payload, loaded
-# back by the class method rather than into an empty instance.  A view comes
-# back as a plain array (a copy owns its memory, as #copy gives); a scalar
-# comes back a scalar.  A wrap is refused below.
-[CAView, CAWrap, CScalar].each do |klass|
+# Marshal of a view, a mask and a scalar: the {CArray#marshal_dump} payload,
+# loaded back by the class method rather than into an empty instance.  A
+# view, a wrap and a mask come back as a plain array (a copy owns its
+# memory, as #copy gives); a scalar comes back a scalar.
+[CAView, CAWrap, CScalar, CArrayMask, CAObjectMask].each do |klass|
   klass.class_eval do
     # A Face other than a record is refused: the payload would carry its
     # storage without what makes it the Face (a unit, labels), and load
@@ -703,28 +703,45 @@ end
               "dump its values with to_type(:object)" +
               (storage ? ", or its storage, which ##{storage} gives" : "")
       end
+      return dump_payload unless data_type == CA_OBJECT
+      # An object view dumps its cells by a nested Marshal.dump, which does
+      # not know the objects the outer dump has written.  A cell holding the
+      # view again (directly or through other views) would dump it without
+      # end, so dumping the same view from inside its own dump is refused,
+      # as reading such a cell is.
+      refuse_reentry("Marshal.dump") { dump_payload }
+    end
+
+    private
+
+    # Marshal writes the instance variables of an object that has _dump
+    # after the String it returns, unless the String has instance
+    # variables of its own.  A view keeps its parent in one, so a view of
+    # a large array would carry the whole parent, and a parent holding the
+    # view in a cell would be an object cycle.  The String is given one of
+    # its own, which _load ignores.
+    def dump_payload
       Marshal.dump(CArray.instance_method(:marshal_dump).bind_call(self))
+             .tap { |s| s.instance_variable_set(:@carray_payload, true) }
     end
   end
 end
 
-class CAView
+[CAView, CArrayMask, CAObjectMask].each do |klass|
   # @return [CArray] the plain array a {#_dump} string describes.
-  def self._load (str)
-    CArray.send(:array_from_marshal_payload, Marshal.load(str))
+  # Defined with def, not define_singleton_method: a block's method keeps
+  # the block's self and cannot be called from another Ractor.
+  klass.singleton_class.class_eval do
+    def _load (str)
+      CArray.send(:array_from_marshal_payload, Marshal.load(str))
+    end
   end
 end
 
 class CAWrap
-  # A wrap borrows memory, which Marshal cannot carry to another process;
-  # Ruby would also try to write the objects that keep the borrowed memory
-  # alive.  Its copy owns its memory and marshals.
-  def _dump (_level)
-    raise TypeError,
-          "Marshal cannot carry a #{self.class}: it borrows its memory; " \
-          "dump .copy instead"
-  end
-
+  # A wrap borrows its memory, which Marshal cannot carry to another
+  # process: {#_dump} above writes its values, and the load gives a plain
+  # array that owns a copy of them, as it does for a view of the wrap.
   def self._load (str)
     CArray.send(:array_from_marshal_payload, Marshal.load(str))
   end

data/lib/carray/stack.rb

@@ -106,11 +106,14 @@ class CArray
     # describe a segment sequence, so absorbing their parents keeps chain
     # depth at 1 (avoids 2-level xfer_all / reduce chains through the
     # intermediate CAMeld).  A CAMeld with a different meld_axis is left
-    # intact — its segment structure is orthogonal.
-    if arrays.any? { |a| a.is_a?(CAMeld) && a.meld_axis == axis_norm }
-      arrays = arrays.flat_map { |a|
-        a.is_a?(CAMeld) && a.meld_axis == axis_norm ? a.parents : [a]
-      }
+    # intact — its segment structure is orthogonal.  So is a read-only one
+    # (frozen or flagged): writes through it are refused, and absorbing it
+    # would drop that.  The mask of a meld is a CAMeld with no parents of
+    # its own; it is passed on, to be refused as a part.
+    absorbed = ->(a) { a.is_a?(CAMeld) && a.meld_axis == axis_norm &&
+                       !a.read_only? && !a.mask_array? }
+    if arrays.any?(&absorbed)
+      arrays = arrays.flat_map { |a| absorbed.(a) ? a.parents : [a] }
     end
     CAMeld.new(arrays, axis: axis_norm)
   end
@@ -291,10 +294,19 @@ class CAStack
   #   preserving `self.k_axis`. Distinct from `CArray#stack`, which
   #   always treats `self` as a single parent of a new K-stack.
   #   @param others [Array<CArray>] extra parents to append.
+  #   A read-only stack hands on read-only views of its parents, so
+  #   writes into its cells stay refused.
   #   @return [CAStack]
   #   @raise [ArgumentError] when no `others` are given.
   def append (*others)
     raise ArgumentError, "append: at least one parent required" if others.empty?
-    CArray.stack(self.parents + others, axis: self.k_axis)
+    if mask_array?
+      raise ArgumentError, "append: a mask array can have no mask and can not be a part"
+    end
+    mine = self.parents
+    if read_only?
+      mine = mine.map { |p| p[].tap(&:set_read_only_flag) }
+    end
+    CArray.stack(mine + others, axis: self.k_axis)
   end
 end

data/lib/carray/time.rb

@@ -1122,6 +1122,9 @@ class CATime
   #   @raise [RangeError] when the widened ticks overflow int64.
   def to_unit(unit)
     to = CATime::Resolution.parse(unit)
+    # The conversion hands back the storage itself when the unit does not
+    # change; the result is a new array whichever unit is asked for.
+    return face_storage.copy.time(unit: to) if to == self.unit
     CATimeUnitAlgebra.convert_instant_floor(face_storage, self.unit, to).time(unit: to)
   end
 
@@ -1830,6 +1833,8 @@ class CATimedelta
   #   @raise [RangeError] when the widened ticks overflow int64.
   def to_unit(unit)
     to = CATime::Resolution.parse(unit)
+    # As CATime#to_unit: a new array even when the unit does not change.
+    return face_storage.copy.timedelta(unit: to) if to == self.unit
     CATimeUnitAlgebra.convert_scale_trunc(face_storage, self.unit, to).timedelta(unit: to)
   end