carray 3.0.3 → 3.0.4

data/lib/carray/methods/is_in.rb

@@ -5,10 +5,11 @@ class CArray
   #   each cell whose value appears in the set `values`.
   #
   #   `values` is treated as a set, not as an operand to broadcast: it
-  #   may be any shape (or an Array / Range) and is flattened to a
+  #   may be any shape (or an Array) and is flattened to a
   #   single seen-set, so its shape need not match `self`. Only one
   #   argument is accepted; to test a few immediate values pass an
-  #   Array (`a.is_in([0, -1])`).
+  #   Array (`a.is_in([0, -1])`). A single value is a set of one, as
+  #   `[value]` is (`a.is_in(2)` is `a.is_in([2])`).
   #
   #   When `self` and `values` have different numeric data types they are
   #   promoted to a common type first (the same promotion binops use,
@@ -46,8 +47,10 @@ class CArray
   #   For a per-fiber "does this fiber contain any of these values"
   #   reduction, compose with {#any}: `a.is_in(values).any(axis: k)`.
   #
-  #   @param values [CArray, Array, Range] the set to test membership
+  #   @param values [CArray, Array] the set to test membership
   #     against. Promoted with `self` to a common data type.
+  #   @raise [ArgumentError] for a Range, which reads as an interval rather
+  #     than the set of its steps.
   #   Between two time arrays the question is about instants, not ticks:
   #   `values` is reconciled into `self`'s unit first, so a `:D` array and an
   #   `:h` array match on the instants they share.  The same holds for the set
@@ -55,6 +58,7 @@ class CArray
   #
   #   @return [CArray] boolean CArray of the same shape as `self`.
   def is_in (values)
+    refuse_range_set(values, "is_in")
     a, b = promote_value_set(values)
     a.__send__(:__is_in__, b)
   end
@@ -69,11 +73,12 @@ class CArray
   #   always flat, like {#unique}, because the distinct values of a
   #   fiber vary in number.
   #
-  #   @param other [CArray, Array, Range] promoted with `self`.
+  #   @param other [CArray, Array] promoted with `self` (a Range is refused, as by {#is_in}).
   #   @param sort [Boolean] when true, return the values sorted
   #     ascending instead of in first-appearance order.
   #   @return [CArray] 1-D CArray of the common distinct values.
   def intersection (other, sort: false)
+    refuse_range_set(other, "intersection")
     a, b = promote_value_set(other)
     r = a.__send__(:__intersection__, b)
     r = r.to_unit(unit) if !a.equal?(self) && respond_to?(:in_common_unit_with)
@@ -85,10 +90,11 @@ class CArray
   #   absent from `other`, in `self`'s first-appearance order.
   #   See {#intersection} for the shared semantics and options.
   #
-  #   @param other [CArray, Array, Range] promoted with `self`.
+  #   @param other [CArray, Array] promoted with `self` (a Range is refused, as by {#is_in}).
   #   @param sort [Boolean] when true, return the values sorted ascending.
   #   @return [CArray] 1-D CArray of the self-only distinct values.
   def difference (other, sort: false)
+    refuse_range_set(other, "difference")
     a, b = promote_value_set(other)
     r = a.__send__(:__difference__, b)
     r = r.to_unit(unit) if !a.equal?(self) && respond_to?(:in_common_unit_with)
@@ -103,11 +109,12 @@ class CArray
   #   holds the values of both ({#intersection} and {#difference} answer in
   #   `self`'s unit, since their values are `self`'s).
   #
-  #   @param other [CArray, Array, Range] promoted with `self`.
+  #   @param other [CArray, Array] promoted with `self` (a Range is refused, as by {#is_in}).
   #   @param sort [Boolean] when true, return the values sorted ascending
   #     (a merged, ordered set — e.g. a common time axis).
   #   @return [CArray] 1-D CArray of the combined distinct values.
   def union (other, sort: false)
+    refuse_range_set(other, "union")
     a, b = promote_value_set(other)
     r = a.__send__(:__union__, b)
     sort ? r.sort : r
@@ -115,6 +122,16 @@ class CArray
 
   private
 
+  # A Range reads as an interval in Ruby, which a set of its steps is not
+  # (2.5 is not in [2, 3, 4]), so the set-valued verbs refuse one rather
+  # than answer for the steps.
+  def refuse_range_set (values, verb)
+    return unless values.is_a?(Range)
+    raise ArgumentError,
+          "#{verb}: a Range is not taken as a set; pass its values as an Array " \
+          "((#{values.inspect}).to_a), or test an interval with is_between(#{values.inspect})"
+  end
+
   # Reconcile a set-valued argument with self to a common data_type via
   # CArray.result_type (the single-source promotion rule the eager binop and
   # lazy CABinOp share), returning [self', set']. Only data types are reconciled,
@@ -141,36 +158,38 @@ class CArray
       return fixlen_widened_with(values)
     end
     # A Face that reconciles operands (CATime) reads a bare Array as values
-    # of its own kind -- instants written as Time / String / elements.
-    if values.is_a?(Array) && face? && respond_to?(:to_comparable)
-      return [self, to_comparable(values)]
+    # of its own kind -- instants written as Time / String / elements -- and
+    # meets them as a comparison does (comparable_pair).
+    if values.is_a?(Array) && face? && respond_to?(:comparable_pair)
+      return comparable_pair(values)
     end
     # A single value (a Time, an element, a bare number) is a set of one,
     # read the same way; a bare number is refused like any other operand
     # that is not of its kind.
     if !values.is_a?(CArray) && !values.is_a?(Range) && face? &&
-       respond_to?(:to_comparable)
-      return [self, to_comparable([values])]
+       respond_to?(:comparable_pair)
+      return comparable_pair([values])
     end
     # ...and so does an array of values that are not of its kind (an object
     # column of Time values, a string column).
-    if values.is_a?(CArray) && respond_to?(:to_comparable) &&
-       !values.respond_to?(:to_comparable)
-      return [self, values_in_face(self, values) || to_comparable([])]
+    if values.is_a?(CArray) && respond_to?(:comparable_pair) &&
+       !values.respond_to?(:comparable_pair)
+      return comparable_pair(values)
     end
     # The same from the other side: values of a time array looked for in an
     # array that is not one.
-    if values.is_a?(CArray) && values.respond_to?(:to_comparable) &&
-       !respond_to?(:to_comparable)
-      return [values_in_face(values, self) || values.to_comparable([]), values]
+    if values.is_a?(CArray) && values.respond_to?(:comparable_pair) &&
+       !respond_to?(:comparable_pair)
+      set, own = values.comparable_pair(self)
+      return [own, set]
     end
     # A Face whose storage is not of its surface type.  When its cells are
     # its values, the set meets it as it would meet an array of the storage
     # type, and the Face stays while that type does not change.  Any other
     # Face leaves the set to the lookup, which brings it into the Face's
     # space or refuses it.
-    if face? && (storage = __face_storage__).data_type != data_type
-      unless __comparable_storage__
+    if face? && (storage = face_storage).data_type != data_type
+      unless comparable_storage?
         set = values.is_a?(Range) ? values.to_a : values
         return [self, set.is_a?(CArray) ? set : CArray.wrap_readonly(set)]
       end
@@ -181,9 +200,16 @@ class CArray
     when Array then return promote_elements(values)
     when Range then return promote_elements(values.to_a)
     end
+    # A single value is a set of one, as [value] is.  wrap_readonly would make
+    # it an object array, which takes self into the object lane, where 2.0 is
+    # not eql? 2.
+    if !values.is_a?(CArray) && !values.respond_to?(:to_ca) &&
+       !CArray.memory_view_available?(values)
+      return promote_elements([values])
+    end
     set = values.is_a?(CArray) ? values : CArray.wrap_readonly(values)
     return [self, set] if set.data_type == data_type   # common fast path
-    t = value_match_type(CArray.result_type(self, set), set.data_type)
+    t = query_match_type(set)
     [coerce_self(t), set.to_type(t)]
   end
 
@@ -200,12 +226,17 @@ 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.
+      # coerce: a fixlen or object set holds values of self's kind (see above)
       [self, elems.to_ca.to_type(data_type, bytes: bytes)]
     elsif data_type == CA_OBJECT
+      # coerce: an object set holds values of self's kind
       [self, elems.to_ca.to_type(data_type)]
+    elsif elems.any? { |v| v.is_a?(String) || v.is_a?(Symbol) }
+      # A String is a value, which result_type would read as the name of a
+      # data type; a numeric self meets it in the object lane.
+      [to_type(CA_OBJECT), elems.to_ca.to_type(CA_OBJECT)]
     else
       t = CArray.result_type(self, *elems)
-      t = value_match_type(t, CA_INT64) if elems.any? { |v| v.is_a?(Integer) && v < 0 }
       [coerce_self(t), elems.to_ca.to_type(t)]
     end
   end
@@ -216,7 +247,7 @@ class CArray
   # their values; anything else, or the same kind of array as self, is
   # taken as it is.  A record is left to be refused.
   def values_for_lookup (other)
-    return other if other.send(:__orderable_storage__)
+    return other if other.send(:orderable_storage?)
     return other if face? && other.class == self.class
     if other.respond_to?(:to_string)
       other.to_string
@@ -244,20 +275,6 @@ class CArray
     x.bytes == w ? x : x.to_fixlen_string(bytes: w)
   end
 
-  # The values of +other+, which has no to_comparable, read as values of +face+'s
-  # kind (instants written as Time / Date / String for a time key), in an
-  # array of +other+'s shape; a masked cell stays masked.  nil when every
-  # cell is masked: there is nothing to read.
-  private def values_in_face(face, other)
-    return face.to_comparable(other) if other.is_a?(Array)
-    vals = other.flatten.to_a
-    filler = vals.find { |v| !UNDEF.equal?(v) }
-    return nil if filler.equal?(nil) && vals.all? { |v| UNDEF.equal?(v) }
-    out = face.to_comparable(vals.map { |v| UNDEF.equal?(v) ? filler : v })
-    out[other.is_masked.flatten] = UNDEF if other.has_mask?
-    out.reshape(*other.shape)
-  end
-
   def coerce_self (t)
     CArray.result_type(self) == t ? self : to_type(t)
   end

data/lib/carray/methods/join.rb

@@ -46,12 +46,7 @@ class CArray
       return sep.nil? ? to_a.join : to_a.join(sep)
     end
 
-    ax = Integer(axis)
-    ax += ndim if ax < 0
-    if ax < 0 || ax >= ndim
-      raise ArgumentError,
-            "axis #{axis.inspect} out of range for ndim=#{ndim}"
-    end
+    ax = normalize_axis(axis, "join")
 
     sep_str = sep || ""
 

data/lib/carray/methods/lag.rb

@@ -0,0 +1,49 @@
+class CArray
+
+  # @overload lag(n = 1, axis: nil)
+  #   Returns the value `n` steps earlier along `axis`, cell by cell: cell
+  #   `i` of the result is cell `i - n` of `self`. A cell with no value `n`
+  #   steps back is UNDEF, so a difference against it is UNDEF rather than
+  #   a difference against a stand-in value:
+  #
+  #   ```
+  #   x = CA_FLOAT64([1.0, 4.0, 9.0])
+  #   x.lag           # => [UNDEF, 1.0, 4.0]
+  #   x - x.lag       # => [UNDEF, 3.0, 5.0]
+  #   x.lag(-1)       # => [4.0, 9.0, UNDEF]   (the value one step later)
+  #   ```
+  #
+  #   The cell `n` steps back is taken by position: when it is masked, the
+  #   result is UNDEF there too. It is `shift` with `UNDEF` as the fill
+  #   value, and returns the same kind of view: it shares storage with
+  #   `self`. Use `copy` for an independent array.
+  #
+  #   The steps run along one axis. A 1-D array has only one, so `axis:`
+  #   may be left out; an array of more dimensions must name it, since
+  #   stepping back through the cells in flatten order would carry a value
+  #   across from the end of one row to the start of the next.
+  #
+  #   @param n [Integer] steps back; a negative `n` looks ahead.
+  #   @param axis [Integer, nil] the axis the steps run along.
+  #   @return [CArray] a view, shaped like `self`.
+  #   @raise [TypeError] when `n` or `axis` is not an Integer.
+  #   @raise [ArgumentError] when `axis` is out of range, or left out for an
+  #     array of more than one dimension.
+  def lag (n = 1, axis: nil)
+    unless n.is_a?(Integer)
+      raise TypeError, "lag: n must be an Integer (got #{n.class})"
+    end
+    if axis.nil?
+      unless ndim == 1
+        raise ArgumentError,
+              "lag: name the axis to step along (axis:) for an array of " \
+              "#{ndim} dimensions"
+      end
+      axis = 0
+    end
+    steps = Array.new(ndim, 0)
+    steps[normalize_axis(axis, "lag")] = n
+    shift(*steps, fill_value: UNDEF)
+  end
+
+end

data/lib/carray/methods/locate_addr.rb

@@ -1,4 +1,5 @@
-require "carray/methods/is_in"   # fixlen_widened_with, values_in_face, values_for_lookup
+require "carray/methods/is_in"   # fixlen_widened_with, values_for_lookup
+require "carray/distance_limit"
 
 class CArray
 
@@ -42,10 +43,9 @@ class CArray
   #   variables without repeating the lookup.
   #
   #   @param ref [CArray, Array, Range] reference values to match against;
-  #     any shape (used as flat). An Array or Range is coerced with `to_ca`
-  #     and so lands in `:object`, where numeric matching follows Ruby
-  #     `eql?` (`2.0` does not match `2`); pass a CArray to match in a
-  #     numeric lane.
+  #     any shape (used as flat). An Array or Range is the list of its
+  #     values, met at a common type with `self` as {#is_in} meets one, so
+  #     `2` finds `2.0`.
   #   @return [CArray] `:int64` flat addresses into `ref`, same shape as
   #     `self`; unmatched cells are masked.
   #   @raise [CArray::DataTypeError] when `self` and `ref` have no common data type.
@@ -58,30 +58,35 @@ class CArray
       a, b = in_common_unit_with(ref)
       return a.locate_addr(b)
     end
-    if respond_to?(:to_comparable) && !ref.respond_to?(:to_comparable)
-      ref = values_in_face(self, ref)
-      return CArray.int64(*shape).fill(UNDEF) unless ref
-    elsif ref.respond_to?(:to_comparable) && !respond_to?(:to_comparable)
-      q = values_in_face(ref, self)
-      return CArray.int64(*shape).fill(UNDEF) unless q
-      return q.locate_addr(ref)
+    # They meet as a comparison does (comparable_pair).
+    if respond_to?(:comparable_pair) && !ref.respond_to?(:comparable_pair)
+      key, r = comparable_pair(ref)
+      return key.locate_addr(r)
+    elsif ref.respond_to?(:comparable_pair) && !respond_to?(:comparable_pair)
+      r, key = ref.comparable_pair(self)
+      return key.locate_addr(r)
     end
     unless ref.is_a?(CArray) || ref.respond_to?(:to_ca)
       raise TypeError, "locate_addr: the reference is an array of values (got #{ref.class})"
     end
+    # An Array or Range of values meets self as is_in's does: the common type
+    # comes from self and the elements, so 2 finds 2.0 in a float array.  The
+    # conversion keeps the order, so the addresses stay positions in ref.
+    if ref.is_a?(Array) || ref.is_a?(Range)
+      q, r = promote_elements(ref.is_a?(Range) ? ref.to_a : ref)
+      return q.send(:__locate_addr__, r)
+    end
     ref = ref.to_ca unless ref.is_a?(CArray)
     ref = values_for_lookup(ref)
     if data_type == CA_FIXLEN && ref.data_type == CA_FIXLEN && bytes != ref.bytes
       a, b = fixlen_widened_with(ref)
       return a.locate_addr(b) unless a.equal?(self) && b.equal?(ref)
     end
-    # Put self and ref in a common lane via the single-source promotion rule
-    # (CArray.result_type), so a fractional query against an int ref is compared
-    # at the promoted type instead of truncating (1.5 no longer matches 1).
-    # to_type is elementwise and order-preserving, so the addresses stay valid
-    # indices into ref. result_type raises for cross-family input; an integer
-    # pair of mixed sign is matched by value (see value_match_type).
-    t = value_match_type(CArray.result_type(self, ref), ref.data_type)
+    # Put self and ref in the type they match in (query_match_type), so a
+    # fractional query against an int ref is compared as a float (1.5 does
+    # not match 1) and a pair of mixed sign by value.  to_type is elementwise
+    # and order-preserving, so the addresses stay valid indices into ref.
+    t = ref.send(:query_match_type, self)
     q = (data_type     == t) ? self : to_type(t)
     r = (ref.data_type == t) ? ref  : ref.to_type(t)
     q.send(:__locate_addr__, r)
@@ -137,6 +142,8 @@ class CArray
             "locate_nearest_addr: direction must be :round / :floor / " \
             ":ceil (got #{direction.inspect})"
     end
+    [self, ref].each { |key| nearest_refuse_bytes(key) }
+    limit = tolerance && DistanceLimit.read(tolerance, self, "tolerance:")
     return CArray.int64(*shape) if elements == 0
     # A masked reference value matches nothing, as in locate_addr: sorting
     # puts the masked ones last, and only the others are searched.  A NaN
@@ -169,13 +176,29 @@ class CArray
     si = si.reshape(*shape)
     si[is_masked] = UNDEF if has_mask?
     idx = ri.project(si)
-    if tolerance
+    if limit
       dist = (ref.project(idx) - self).abs
-      idx[dist > nearest_tolerance(tolerance, dist)] = UNDEF
+      idx[dist > limit] = UNDEF
     end
     idx
   end
 
+  # A key held as fixed-length bytes (raw fixlen, or a fixlen string) has
+  # no nearest: the search counts keys as numbers.  A Face whose storage is
+  # a number (a time) is searched by that number.
+  # +subject+ and +remedy+ let a caller (CAFrame#join_asof) say it in its
+  # own words.
+  private def nearest_refuse_bytes(key, subject = nil, remedy = "match exact values with locate_addr")
+    # A Face whose cells encode the value (a const string, a categorical)
+    # is refused later by its own reconcile, which says why.
+    return unless key.is_a?(CArray) && key.__send__(:orderable_storage?)
+    storage = key.face? ? key.__send__(:face_storage) : key
+    return unless storage.data_type == CA_FIXLEN
+    subject ||= "locate_nearest_addr: a #{CArray::Inspector.type_label(key)} key"
+    raise CArray::DataTypeError,
+          "#{subject} is held as fixed-length bytes, which have no nearest; #{remedy}"
+  end
+
   # The keys locate_nearest_addr orders by: the storage of the sorted
   # reference and of the query, in one numeric type.  A Face key is first
   # brought into the reference's space (two time keys of different units
@@ -189,10 +212,10 @@ class CArray
         rs = rs.to_unit(u)
         q  = q.to_unit(u)
       end
-      q  = rs.__send__(:__reconcile_operand__, q, "locate_nearest_addr")
-      rs = rs.__send__(:__face_storage__)
+      q  = rs.__send__(:reconcile_operand, q, "locate_nearest_addr")
+      rs = rs.__send__(:face_storage)
     end
-    t = value_match_type(CArray.result_type(q, rs), rs.data_type)
+    t = rs.send(:query_match_type, q)
     rk = (rs.data_type == t) ? rs : rs.to_type(t)
     qk = (q.data_type  == t) ? q  : q.to_type(t)
     [rk, qk.flatten]
@@ -234,33 +257,6 @@ class CArray
     si
   end
 
-  # The tolerance in the units of the distance. A time key measures its
-  # distance as a CATimedelta, so its tolerance is a duration: a String in
-  # the spelling CArray.time takes for a unit ("10 minutes"), or a
-  # CATimedelta value. A bare number would mean a different length in each
-  # unit, so it is refused there; any other key takes a number.
-  private def nearest_tolerance(tolerance, dist)
-    unless dist.is_a?(CATimedelta)
-      if tolerance.is_a?(String)
-        raise ArgumentError,
-              "tolerance: #{tolerance.inspect} is a duration, but the key is " \
-              "#{data_type_name}; give a number"
-      end
-      return tolerance
-    end
-    case tolerance
-    when String
-      res = CATime::Resolution.parse(tolerance)
-      CATimedelta::Element.new(res.count, res.base)
-    when CATimedelta::Element
-      tolerance
-    else
-      raise ArgumentError,
-            "tolerance: a time key needs a duration such as \"10 minutes\" " \
-            "or a CATimedelta value (got #{tolerance.inspect})"
-    end
-  end
-
   # @!endgroup
 
 end

data/lib/carray/methods/mode.rb

@@ -74,7 +74,7 @@ class CArray
   #     reduced CArrays, one per mode rank (per-axis).
   def mode (axis: nil)
     # An error from the methods mode is made of (sort, ...) names mode.
-    CArray.__answer_as__(:mode) { mode_answered(axis) }
+    CArray.__name_errors_after_method__(:mode) { mode_answered(axis) }
   end
 
   private def mode_answered (axis)

data/lib/carray/methods/nunique.rb

@@ -12,7 +12,9 @@ class CArray
   #   whole array and returns an Integer. With `axis: k` it counts per
   #   fiber along axis `k`, returning a reduced `CA_INT64` CArray
   #   (shape = self.shape with axis `k` removed; `keep_axis: true` keeps
-  #   it as a length-1 axis). The shape rule matches other per-axis
+  #   it as a length-1 axis). An Array of axes counts over all of them
+  #   together, one count per remaining position; naming every axis
+  #   returns an Integer. The shape rule matches other per-axis
   #   reductions such as `sum(axis:)`.
   #
   #   The distinct count has identity 0: an empty array, an all-masked
@@ -25,12 +27,12 @@ class CArray
   #   distinctness follows Ruby `eql?` / `hash` (which, unlike numeric,
   #   does not collapse distinct NaN objects).
   #
-  #   @param axis [Integer, nil] axis to count along; `nil` counts over
-  #     the whole array.
+  #   @param axis [Integer, Array<Integer>, nil] axis or axes to count
+  #     over; `nil` counts over the whole array.
   #   @param keep_axis [Boolean] when `axis` is given, keep the reduced
   #     axis as a length-1 axis instead of dropping it.
-  #   @return [Integer, CArray] Integer for `axis: nil`, otherwise a
-  #     reduced `CA_INT64` CArray.
+  #   @return [Integer, CArray] Integer for `axis: nil` or every axis,
+  #     otherwise a reduced `CA_INT64` CArray.
   # @overload nunique(along: k)
   #   Returns how many distinct **sub-arrays** `self` holds, comparing
   #   whole sub-arrays rather than cells: `along: k` names the axis
@@ -60,7 +62,10 @@ class CArray
       # then read the single reduced cell as an Integer.
       flatten.send(:__nunique__, 0, false)[0]
     else
-      __nunique__(normalize_axis(axis, "nunique"), keep_axis)
+      axes = Array(axis).map { |a| normalize_axis(a, "nunique") }
+      counts = __nunique__(axes, keep_axis)
+      # naming every axis reduces to one count, an Integer as sum(axis:) gives
+      (axes.size == ndim && ! keep_axis) ? counts[0] : counts
     end
   end
 

data/lib/carray/methods/resize.rb

@@ -43,11 +43,11 @@ class CArray
     # const string, a categorical) resizes too.  The new area starts as zero
     # storage; a given fill_value is written as a value of the array, which a
     # read-only Face refuses.
-    out = __blank_like__(newdim)
-    out_storage = out.__send__(:__face_storage__)
+    out = blank_like(newdim)
+    out_storage = out.__send__(:face_storage)
     out[] = fill_value unless fill_value.equal?(NO_FILL_VALUE)
     out_storage.mask.paste(offset, self.false) if out_storage.has_mask?
-    out_storage.paste(offset, __face_storage__)
+    out_storage.paste(offset, face_storage)
     out
   end
 

data/lib/carray/methods/value_counts.rb

@@ -52,17 +52,10 @@ class CArray
       [ values[CArray.int64(order.size) { |i| order[i] }],
         counts[CArray.int64(order.size) { |i| order[i] }] ]
     when :value
-      # Ascending value; NaN (numeric) or non-comparable last. Build the
-      # permutation with an explicit NaN-last key so float NaN doesn't blow up
-      # the Ruby sort, then gather both arrays through it.
-      v = values.to_a
-      order = (0...v.size).sort_by do |i|
-        x = v[i]
-        nan = x.is_a?(Float) && x.nan?
-        [nan ? 1 : 0, nan ? 0 : x, i]
-      end
-      [ values[CArray.int64(order.size) { |i| order[i] }],
-        counts[CArray.int64(order.size) { |i| order[i] }] ]
+      # Ascending value in the order sort uses (NaN after every number),
+      # then gather both arrays through it.
+      order = values.sort_index
+      [values[order], counts[order]]
     else
       [values, counts]
     end

data/lib/carray/record_order.rb

@@ -49,7 +49,7 @@ class CARecord
   #   @return [CArray] the indices that partition about the `kth` record.
   [:sort_addr, :sort_index, :rank_index, :order,
    :min_index, :max_index, :partition_index].each do |op|
-    define_method(op) { |*args, **kw| record_rank.public_send(op, *args, **kw) }
+    define_method(op, &Ractor.make_shareable(proc { |*args, **kw| record_rank.public_send(op, *args, **kw) }))
   end
 
   # @overload min(axis: nil, keep_axis: false)
@@ -93,10 +93,10 @@ class CARecord
   # @!method gt(other)
   # @!method ge(other)
   [:lt, :le, :gt, :ge].each do |op|
-    define_method(op) do |other|
+    define_method(op, &Ractor.make_shareable(proc do |other|
       mine, theirs = record_rank_with(other)
       mine.public_send(op, theirs)
-    end
+    end))
   end
 
   alias <  lt

data/lib/carray/rng.rb

@@ -29,6 +29,7 @@ class CArray
       :xoshiro256pp => File.expand_path("../../ext/ca_rng_xoshiro256pp.h",
                                         __dir__),
     }.freeze
+    Ractor.make_shareable(SOURCE_FILES)
 
     # The C each generator is, as text.
     #
@@ -50,6 +51,7 @@ class CArray
     SOURCE = SOURCE_FILES.transform_values { |path|
       File.read(path, :encoding => "UTF-8")
     }.freeze
+    Ractor.make_shareable(SOURCE)
 
     # What every generator's text needs beside it, and what none of them
     # owns: turning uniforms into a normal is the same arithmetic whichever
@@ -80,6 +82,7 @@ class CArray
         :bits    => "ca_xoshiro256pp_next",
       }.freeze,
     }.freeze
+    Ractor.make_shareable(DRAW_FUNCTIONS)
 
   end