carray 3.0.6 → 3.0.7

data/lib/carray/frame/verbs.rb

@@ -111,7 +111,7 @@ class CAFrame
   #
   # What the block returns becomes the column as it is: a view stays a view
   # of what it was made from, so a write to a cell reaches it (+copy+ cuts
-  # that).
+  # that). A lazy expression is evaluated, as a column holds its values.
   #
   # @param names [Array<String, Range, Regexp>] the columns; default all.
   # @yieldparam col [CArray] a column.
@@ -190,6 +190,9 @@ class CAFrame
     pieces.each { |p| p[] = UNDEF }
     time_text_of(col).to_a.each_with_index do |cell, i|
       next if UNDEF.equal?(cell) || cell.nil?
+      unless cell.is_a?(String)
+        raise ArgumentError, "split_column: row #{i} of #{key.inspect} holds #{cell.inspect}, which is not text"
+      end
       cell.split(sep, n).each_with_index { |part, k| pieces[k][i] = part }
     end
     rebuilt = {}
@@ -327,7 +330,15 @@ class CAFrame
       raise ArgumentError,
             "stack_columns: shape: #{layer.inspect} does not hold the #{names.size} columns"
     end
-    col = CArray.stack(parts, axis: 1)
+    CAFrame.__send__(:refuse_rounded_pieces, parts, "stack_columns", "column #{names.first.inspect}")
+    begin
+      col = CArray.stack(parts, axis: 1)
+    rescue ArgumentError => e
+      raise unless e.message.start_with?("stack: ")
+      raise ArgumentError,
+            "stack_columns: the columns do not meet as one column " \
+            "(#{e.message.delete_prefix("stack: ")}); cast them to one type first"
+    end
     col = col.reshape(nrow, *layer, *trailing) if layer.size > 1
     rebuilt = {}
     @columns.each do |k, v|
@@ -548,7 +559,7 @@ class CAFrame
         end
         resolve_cast_map(name_or_map, label)
       else
-        { column_key(name_or_map, label) => type }
+        resolve_cast_map({ column_key(name_or_map, label) => type }, label)
       end
     # Read every column before rebinding any, so a raise leaves the frame as
     # it was.
@@ -579,13 +590,15 @@ class CAFrame
     named.each_key do |name|
       refuse_missing_column(name, label.chomp(":")) unless @columns.key?(name)
     end
-    rest = @columns.keys - named.keys
+    inferred, named = named.partition { |_, t| t == :infer }.map(&:to_h)
+    rest = @columns.keys - named.keys - inferred.keys
     types =
       case default
       when nil    then {}
       when :infer then rest.empty? ? {} : select(*rest).infer_types
       else             rest.to_h { |name| [name, default] }
       end
+    types.merge!(select(*inferred.keys).infer_types) unless inferred.empty?
     types.merge!(named.compact)
   end
   
@@ -610,11 +623,13 @@ class CAFrame
   # none present is not listed.
   #
   # A number with a leading zero ("007") is a code and keeps its column as
-  # text, and so does an integer too long for int64 (an identifier), which a
-  # float would round. A day-first or month-first date ("01/02/2024") is not
-  # read as time, since which one it is cannot be told. Only text columns
-  # are looked at -- an object column or a string Face (CAString,
-  # CAConstString); columns that already have a type are not listed.
+  # text, and so does an integer too long for int64 (an identifier), or one
+  # past 2**53 among decimals, which a float would round. A day-first or
+  # month-first date ("01/02/2024") is not read as time, since which one it
+  # is cannot be told. Only text columns are looked at -- an object column
+  # or a string Face (CAString, CAConstString); columns that already have a
+  # type are not listed. An object column's cells are read as their text,
+  # so Ruby numbers there are typed as that text would be.
   #
   #   df.cast(df.infer_types)                            # what cast(:infer) does
   #   df.cast(df.infer_types.merge("code" => :int32))    # as cast(default: :infer, "code" => :int32)
@@ -622,18 +637,30 @@ class CAFrame
     @columns.each_with_object({}) do |(key, col), types|
       next unless string_column?(col)
       type = text_for_decimal_reading(col).__infer_number_type_of_text__
+      next if type == :float64 && integer_text_past_float?(col)
       type ||= :boolean if boolean_word_column?(col)
       type ||= :time if first_present_cell_can_be_time_text?(col) && time_text_column?(time_text_of(col))
       types[key] = type if type
     end
   end
 
+  # Whether a cell is an integer a float64 would round. Fewer than 16 digits
+  # cannot be, which leaves a const string column's other cells unread.
+  private def integer_text_past_float?(col)
+    long = col.is_a?(CAConstString) ? col[col.byte_length.ge(16).strip_mask(false)].to_a : time_text_of(col).to_a
+    long.any? do |text|
+      next text.abs > 2**53 if text.is_a?(Integer)   # an object cell read as its text
+      text.is_a?(String) && text.match?(/\A\s*[-+]?\d{16,}\s*\z/) && Integer(text.strip, 10).abs > 2**53
+    end
+  end
+
   # Bring every column to one common data type and rebind them (memo §11.4).
   # The frame-level counterpart of +CArray.promote_list+: where +cast+ forces
   # named columns to a type, +promote+ widens the whole table until it has a
-  # single type. Returns a new frame; like +cast+ it allocates fresh columns,
-  # so this frame keeps its own. The index is not a column and is left
-  # alone.
+  # single type. Returns a new frame; a column that changes type is a fresh
+  # one, and one that has the type already is shared with this frame, as
+  # +promote+ with no argument leaves it. The index is not a column and is
+  # left alone.
   #
   #   df.promote             # the common type CArray.result_type would pick
   #   df.promote(:object)    # force the widest type: anything fits
@@ -829,6 +856,9 @@ class CAFrame
   # A constant fill, in place, naming the column when the value does not go
   # into it, as strip_mask names it.
   private def fill_constant (key, col, value)
+    if col.read_only?
+      raise "fill: column #{key.inspect} (#{CArray::Inspector.type_label(col)}) can not modify read-only array"
+    end
     col.unmask(value)
   rescue ArgumentError, TypeError, RangeError, FloatDomainError => e
     raise e.exception("fill: column #{key.inspect} (#{CArray::Inspector.type_label(col)}) " \
@@ -962,6 +992,7 @@ class CAFrame
               "fill: give a method or value after the column #{how.inspect}; " \
               "a String alone is a column name"
       end
+      refuse_unknown_fill_method(how, "fill")
       map = @columns.select { |key, col| !key_names.include?(key) && col.any_masked? }
                     .keys.to_h { |key| [key, how] }
       return map.empty? ? nil : map
@@ -970,16 +1001,18 @@ class CAFrame
     return names_selected(names, "fill").to_h { |key| [key, how] }
   end
 
+  private def refuse_unknown_fill_method (how, verb)
+    return unless how.is_a?(Symbol) && !%i[ffill bfill linear].include?(how)
+    raise ArgumentError,
+          "#{verb}: unknown method #{how.inspect} (:ffill | :bfill | :linear, or a constant fill value)"
+  end
+
   private def fill_by_map (map, verb)
     raise ArgumentError, "#{verb}: the Hash names no column" if map.empty?
     refuse_if_frozen
     keys = column_keys(map.keys, verb)
     keys.each { |key| refuse_missing_column(key) unless @columns.key?(key) }
-    map.each_value do |how|
-      next unless how.is_a?(Symbol) && !%i[ffill bfill linear].include?(how)
-      raise ArgumentError,
-            "#{verb}: unknown method #{how.inspect} (:ffill | :bfill | :linear, or a constant fill value)"
-    end
+    map.each_value { |how| refuse_unknown_fill_method(how, verb) }
     pairs = keys.zip(map.values)
     pairs.each { |key, how| yield self, key, how if @columns[key].read_only? }
     filled = pairs.map do |key, how|
@@ -988,10 +1021,18 @@ class CAFrame
       yield probe, key, how
       [key, probe[key]]
     end
-    filled.compact.each { |key, col| @columns[key][] = col }
+    filled.compact.each { |key, col| write_filled_cells(@columns[key], col) }
     return self
   end
 
+  # Only the cells a fill gave a value: a view may show one stored cell
+  # twice, and writing a copy that stayed masked would mask it again.
+  private def write_filled_cells(col, filled)
+    return unless col.has_mask?
+    target = col.is_masked & filled.is_not_masked
+    col[target] = filled[target] if target.any
+  end
+
   private def fill_linear_column(key, col, verb = "fill")
     # A Face column interpolates through its own linear_fetch (a time
     # column's keeps the Face and its unit), as the core gap fill does.
@@ -1021,7 +1062,7 @@ class CAFrame
       return
     end
     # The same fill as the core, with the index as x.
-    col[] = col.send(:linear_fill_along, @index)   # write-through
+    write_filled_cells(col, col.send(:linear_fill_along, @index))
   end
 
   # Text cells are data, not Ruby literals: an object column cast to a
@@ -1038,7 +1079,7 @@ class CAFrame
     if type == :string
       return col if col.is_a?(CArray::StringOperationMixin)
       begin
-        return CArray.string(col)
+        return CArray.string(col).copy
       rescue CArray::DataTypeError, TypeError => e
         raise e.class, "column #{key.inspect} cannot be cast to :string: #{e.message}"
       end
@@ -1154,9 +1195,11 @@ class CAFrame
       next unless present[addr]
       text = cells[addr]
       m = text.is_a?(String) && TIMEDELTA_TEXT.match(text)
-      if m
-        values[addr] = Integer(m[1], 10)
-        units[addr] = CATime::Resolution.new(m[2] ? Integer(m[2], 10) : 1, m[3].to_sym)
+      value = m && Integer(m[1], 10)
+      count = m && (m[2] ? Integer(m[2], 10) : 1)
+      if m && value.bit_length < 64 && count.positive? && count.bit_length < 64
+        values[addr] = value
+        units[addr] = CATime::Resolution.new(count, m[3].to_sym)
       elsif !text.nil? && !(text.is_a?(String) && text.strip.empty?)
         bad << addr
       end
@@ -1175,7 +1218,11 @@ class CAFrame
     ticks[nil] = UNDEF
     distinct.each do |u|
       addrs = units.each_index.select { |i| units[i] == u }
-      scaled = CATimeUnitAlgebra.convert_scale!(CA_INT64(addrs.map { |i| values[i] }), u, unit)
+      begin
+        scaled = CATimeUnitAlgebra.convert_scale!(CA_INT64(addrs.map { |i| values[i] }), u, unit)
+      rescue RangeError
+        raise RangeError, "cast: column #{key.inspect} holds durations too long for their finest unit, #{unit}"
+      end
       ticks[CA_INT64(addrs)] = scaled
     end
     ticks.reshape(*col.shape).timedelta(unit: unit)
@@ -1421,7 +1468,13 @@ class CAFrame
     # to say about a surface it cannot read, so the widening check -- which
     # is about primitive promotion -- applies to plain columns only.
     @columns.each { |key, col| refuse_narrowing(key, col, type) unless col.face? }
-    @columns.each_key { |key| @columns[key] = @columns[key].to_type(type) }
+    # A column that has the type already stays as it is, as promote leaves it
+    # with no target.
+    name = CArray.data_type_name(type)
+    @columns.each_key do |key|
+      col = @columns[key]
+      @columns[key] = col.to_type(type) unless !col.face? && col.data_type_name == name
+    end
   end
 
   private def refuse_narrowing(key, col, type)

data/lib/carray/frame/windows.rb

@@ -61,7 +61,7 @@ class WindowedFrame
   #   Returns the CAKeyWindowIterator of one column.
   #   @return [CAKeyWindowIterator]
   def [] (name)
-    @plan.for_value(@frame[@frame.__send__(:column_key, name, "windows")])
+    @plan.for_value(@frame.__send__(:named_column, @frame.__send__(:column_key, name, "windows"), "windows"))
   end
 
   # What each window covered, one value per row: see CAKeyWindowIterator.
@@ -113,13 +113,14 @@ class WindowedFrame
   # @param names [Array<String>] the columns; default every column that has
   #   a quantile.
   # @return [CAFrame]
-  def quantile (*names)
+  def quantile (*names, **keywords)
+    refuse_keywords(keywords)
     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
+    return CAFrame.new(cols, axis_name: @frame.axis_name, index: @frame.index&.copy) 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
@@ -130,17 +131,40 @@ class WindowedFrame
     window_reduce(reduction, names, min_count: min_count, fill_value: fill_value)
   end
 
-  def window_value (reduction, *names)
+  def window_value (reduction, *names, **keywords)
+    refuse_keywords(keywords)
     window_reduce(reduction, names)
   end
 
+  # These reductions take no keyword. Without the **keywords above, Ruby
+  # would hand a keyword in as a column name.
+  def refuse_keywords (keywords)
+    return if keywords.empty?
+    list = keywords.keys.map(&:inspect).join(", ")
+    raise ArgumentError, "unknown keyword#{keywords.size > 1 ? "s" : ""}: #{list}"
+  end
+
   # 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, args = [], **keywords)
     keywords = keywords.compact
+    if @at && names.include?(@key_names.first)
+      raise ArgumentError, "#{reduction}: #{@key_names.first.inspect} is the key, already the result's index"
+    end
+    fills = keywords.delete(:fill_value)
+    refuse_unknown_fill_columns(reduction, fills)
+    refuse_wrong_reduction_arguments(reduction, args, 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)
+      fill = fills.is_a?(Hash) ? fills[name] : fills
+      kw = fill.nil? ? keywords : keywords.merge(fill_value: fill)
+      named[name] =
+        if %i[first last].include?(reduction) && col.ndim == 1 && args.empty? && kw.empty? &&
+           col.face? && !col.__send__(:holds_new_values?)
+          col[@plan.for_value(present_rows(col)).public_send(reduction)].copy
+        else
+          @plan.for_value(col).public_send(reduction, *args, **kw)
+        end
     end
     out = named if @at && !names.empty?
     return out if out.is_a?(CArray) && !@at
@@ -149,7 +173,7 @@ class WindowedFrame
       key = @frame.__send__(:key_column, @key_names.first, "windows")
       CAFrame.new(out, axis_name: @key_names.first, index: CAFrame.__send__(:key_labels, key, @at.copy))
     else
-      CAFrame.new(out, axis_name: @frame.axis_name, index: @frame.index)
+      CAFrame.new(out, axis_name: @frame.axis_name, index: @frame.index&.copy)
     end
   end
 end

data/lib/carray/fuse_source.rb

@@ -185,7 +185,9 @@ class CArray
     # 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.
+    # Ractor may be running them, and that can crash the process.  Two Ractors
+    # dumping one sequence for the first time crash Ruby before 4.1, so the
+    # dump goes through a lock.
     def self.code_location (sequence, path)
       line = sequence.first_lineno
       found = []
@@ -206,7 +208,7 @@ class CArray
         start, whole = found.first
         [start.start_line, start.start_column, whole.end_line, whole.end_column]
       else
-        sequence.to_a[4][:code_location]
+        CArray.send(:instruction_sequence_to_a, sequence)[4][:code_location]
       end
     end
 

data/lib/carray/iterator.rb

@@ -256,6 +256,14 @@ class CAIterator
     end))
   end
 
+  # CArray#count over a view: CABlock / CAWindow shadow #count with a geometry
+  # accessor, so it is dispatched explicitly, while a Face keeps a #count of
+  # its own (CAConstString reads its cells as Strings).
+  private def count_cells (view, *args, **kw)
+    return view.count(*args, **kw) if view.face?
+    CArray.instance_method(:count).bind_call(view, *args, **kw)
+  end
+
   # Recommended (should) surface -- template methods.  These are well-defined
   # for some members and structurally impossible for others, so they are not
   # required: `map` is a per-piece element-wise transform scattered back to the

data/lib/carray/key_windows.rb

@@ -76,7 +76,9 @@ class CAKeyWindowIterator < CAIterator
         raise ArgumentError, "windows: at: is a one-dimensional CArray of points"
       end
     end
-    @key      = on
+    # Taken as it is now, as the windows are: first_key, last_key and bounds
+    # read it later.
+    @key      = on.copy
     @n        = value.dim0
     # Taken as they are now, as the windows are: bounds reads them later.
     @points   = at&.copy
@@ -412,9 +414,13 @@ class CAKeyWindowIterator < CAIterator
     if sample.is_a?(Array)
       return sample.each_index.map { |k| lay_out(results.map { |r| r[k] }, sample[k], trail) }
     end
-    out = CArray.new(sample.data_type, [@nout, *trail], bytes: sample.bytes)
+    # A Face that holds no new value cannot be written cell by cell, so its
+    # values are held as the surface objects they are.
+    surface = sample.face? && !sample.__send__(:holds_new_values?)
+    shape = [@nout, *trail]
+    out = surface ? CArray.new(CA_OBJECT, shape) : sample.__send__(:blank_like, shape)
     flat = out.reshape(@nout, results.size)
-    results.each_with_index { |r, j| flat[nil, j] = r }
+    results.each_with_index { |r, j| flat[nil, j] = surface ? r.to_a : r }
     out
   end
 
@@ -548,7 +554,7 @@ class CAKeyWindowIterator < CAIterator
 
   def window_bound (width, op)
     key = @points || @key
-    return key if width.nil?
+    return key.copy if width.nil?
     if key.is_a?(CATime) || key.is_a?(CATimedelta)
       key = key.to_unit(CATimeUnitAlgebra.finer(key.unit, width.unit))
     end

data/lib/carray/lazy.rb

@@ -430,26 +430,20 @@ class CArray
   private :clamp_between
   LazyDispatch.send(:private, :clamp_between)
 
-  # `**` integer-exponent lazy fast path.
+  # `**` with an Integer exponent.
   #
-  # The default OP_POW path above goes through the `power` binop kernel,
-  # which uses `pow(x, p)` / `cpow(x, p)` (transcendental, ~20-50 ns/cell)
-  # for float / complex parents.  When `other` is an Integer, the eager
-  # `rb_ca_pow` dispatches to `rb_ca_ipower` (= binary exponentiation via
-  # `op_powi_<type>`, ~1-3 mul/cell, 3-5x faster than the transcendental
-  # form).  Mirror that dispatch here so `a.lazy ** 2` rides the same
-  # fast path.
-  #
-  # Routing rule (matches eager `rb_ca_pow`):
+  # The eager `rb_ca_pow` sends a Float / Complex array to an Integer power
+  # through `rb_ca_ipower` (ext/ca_op_ipower.c), which keeps the exponent
+  # an int64 and computes each cell with pow / powf / cpow, the answer the
+  # `power` kernel gives for the same exponent held in an array.  The lazy
+  # form builds the matching CABinOp(OP_IPOWER) node:
   #   - lazy parent + Integer exponent + Float/Complex parent data_type
   #     -> wrap exponent as CScalar.int64 + CABinOp(OP_IPOWER)
-  #   - lazy parent (other cases) -> CABinOp(OP_POW)  [existing]
-  #   - else -> eager (which itself dispatches to ipower internally)
+  #   - lazy parent (other cases) -> CABinOp(OP_POW)
+  #   - else -> eager
   #
-  # Integer parents intentionally stay on OP_POW: the mkkernel-generated
-  # `power` binop kernel already uses `op_powi_<type>` for integer data_types
-  # via the `int:` expr in MkKernel.binop :power, so OP_POW + int parent
-  # is already fast.  The lazy-substrate gap was Float/Complex only.
+  # Integer parents stay on OP_POW: the `power` kernel's `int:` expr is
+  # `op_powi_<type>`, binary exponentiation in the integer type.
   module LazyDispatch
     def **(other)
       if ( lazy_view? || (other.is_a?(CArray) && other.lazy_view?) ) &&
@@ -498,7 +492,8 @@ class CArray
   # `eq` / `feq`.
   #
   # A comparison with UNDEF goes to the eager method, which answers `eq` /
-  # `ne` from the mask and refuses the others.
+  # `ne` from the mask and refuses the others, and so does one with nil on
+  # an array that can not hold it.
   #
   # `feq` is arity 1 in eager (compile-time FLT_EPSILON / DBL_EPSILON);
   # we mirror that here.  Runtime eps is a future extension (struct field

data/lib/carray/methods/bin.rb

@@ -105,6 +105,9 @@ class CArray
   #   @raise [ArgumentError] when `edges` is not 1-D, has fewer than 2
   #     values, has a masked value or NaN, or decreases anywhere.  Equal
   #     edges (a bin of zero width) and infinite ones are accepted.
+  #   Values and edges are compared as float64, so int64 values beyond
+  #   2**53 are compared at that precision.
+  #
   #   @example
   #     e = CA_FLOAT64([0, 1, 10, 100])
   #     v = CA_FLOAT64([0.5, 5.0, 50.0, -1.0, 200.0])

data/lib/carray/methods/composition.rb

@@ -140,7 +140,7 @@ class CArray
   # consistency required across rows / columns).
   def self.__ragged_paste (list, tdim, axis, data_type, name)
     shared_attrs = attrs_shared_by(list)
-    list = CArray.promote_list(list, data_type: data_type)
+    list = promote_list_for(name, list, data_type: data_type)
     # promote_list has already enforced homogeneity (= common data_type, and
     # for Face elements: same Face class + portable + state-compatible).  So,
     # mirroring CArray.stack, paste at the storage level and re-wrap the

data/lib/carray/methods/factorize.rb

@@ -44,6 +44,8 @@ class CArray
     if excluded.count(true) > 0
       codes.mask = codes.has_mask? ? (codes.mask | excluded) : excluded
     end
+    # A const string's discovery reads its bytes and gives Ruby Strings.
+    levels = CArray.const_string(levels, encoding: encoding) if is_a?(CAConstString)
     [codes, levels]
   end
 

data/lib/carray/methods/gather_nd.rb

@@ -94,7 +94,10 @@ class CArray
     # The write goes through a flattened view, which carries a frozen
     # array's read-only flag but not its frozenness; say what the array is.
     raise FrozenError.new("can't modify frozen #{self.class}", receiver: self) if frozen?
-    flat_addr, _outer, _rest = gather_nd_flat_addr(indices, "put_nd")
+    flat_addr, outer, rest = gather_nd_flat_addr(indices, "put_nd")
+    # The values lie as gather_nd gives them back.
+    out_shape = outer + rest
+    flat_addr = flat_addr.reshape(*out_shape) unless out_shape.empty?
     if flat_addr.has_mask?
       # A masked coordinate writes nothing.  The values are laid out over
       # the coordinates by the store itself, so they mean what they mean

data/lib/carray/methods/is_in.rb

@@ -40,8 +40,9 @@ class CArray
   #   `Array#include?` does, so they are equal there. To match by value
   #   across Integer and Float, convert the array to a numeric type first.
   #
-  #   Masked cells of `values` do not enter the set. Masked cells of
-  #   `self` stay masked in the result (membership is unknown), so
+  #   Masked cells of `values` do not enter the set, and neither does `nil`
+  #   unless `self` is an `:object` array, which can hold it. Masked cells
+  #   of `self` stay masked in the result (membership is unknown), so
   #   `is_in` propagates `self`'s mask like an element-wise comparison.
   #
   #   For a per-fiber "does this fiber contain any of these values"
@@ -59,7 +60,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, b = promote_value_set(values_of_set(values))
     a.__send__(:__is_in__, b)
   end
 
@@ -132,6 +133,25 @@ class CArray
           "((#{values.inspect}).to_a), or test an interval with is_between(#{values.inspect})"
   end
 
+  # The set as the array reads it.  nil is no value of an array that can not
+  # hold it, so it enters no set, and true and false are the numbers 1 and 0
+  # to an integer, float or complex array, as they are to eq.
+  def values_of_set (values)
+    return values if data_type == CA_OBJECT
+    numeric = !face? && (integer? || float? || complex?)
+    case values
+    when Array
+      values = values.compact
+      numeric ? values.map { |v| (v == true) ? 1 : (v == false) ? 0 : v } : values
+    when CArray
+      ( values.data_type == CA_OBJECT ) ? values.mask_eq(nil) : values
+    when true, false
+      numeric ? (values ? 1 : 0) : values
+    else
+      values
+    end
+  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,

data/lib/carray/methods/locate_addr.rb

@@ -135,7 +135,9 @@ class CArray
   #     `self`; cells with no match in the direction and beyond-tolerance
   #     cells are masked.
   #   @raise [ArgumentError] when `direction` is not one of the accepted
-  #     symbols, or `tolerance` is not a duration for a time key.
+  #     symbols, `tolerance` is not a duration for a time key, or `:round` /
+  #     `tolerance` is asked of an object key whose values have no `-` (a
+  #     String is ordered but has no distance).
   def locate_nearest_addr (ref, direction: :round, tolerance: nil)
     unless [:round, :floor, :ceil].include?(direction)
       raise ArgumentError,
@@ -150,8 +152,8 @@ class CArray
     # one has no place among the others either; it sorts after them.
     ri = ref.sort_addr
     ri = ri[0...ref.count_not_masked] if ref.has_mask?
-    if ref.float? && ri.elements > 0
-      ri = ri[0...(ri.elements - ref[ri].is_nan.count(true))]
+    if ri.elements > 0 && (nan = nearest_nan_cells(ref[ri]))
+      ri = ri[0...(ri.elements - nan.count(true))]
     end
     if ri.elements == 0
       out = CArray.int64(*shape)
@@ -160,6 +162,7 @@ class CArray
     end
     rs = ref[ri]
     n = rs.elements
+    nearest_refuse_distanceless(rs, direction, limit)
     rk, qk = nearest_keys(rs, self)
     # The position of each cell among the sorted references is counted, not
     # interpolated: :floor takes the last reference at or below it, :ceil the
@@ -172,17 +175,69 @@ class CArray
          when :round then nearest_round(rk, qk, nearest_count_below(rk, qk, false))
          end
     si[si.lt(0) | si.ge(n)] = UNDEF
-    si[qk.is_nan.strip_mask(false)] = UNDEF if qk.float?
+    nan = nearest_nan_cells(qk)
+    si[nan.strip_mask(false)] = UNDEF if nan
     si = si.reshape(*shape)
     si[is_masked] = UNDEF if has_mask?
     idx = ri.project(si)
     if limit
-      dist = (ref.project(idx) - self).abs
-      idx[dist > limit] = UNDEF
+      idx[nearest_beyond(ref.project(idx), self, limit)] = UNDEF
     end
     idx
   end
 
+  # The NaN cells of a key, nil for a key that has none. A NaN in an object
+  # key is the cell that differs from itself.
+  private def nearest_nan_cells(key)
+    return key.is_nan if key.float?
+    return key.ne(key) if key.data_type == CA_OBJECT && !key.face?
+    nil
+  end
+
+  # :round and tolerance: measure how far a key is from its neighbours. An
+  # object key whose values have no subtraction (a String) is ordered but
+  # has no distance: only :floor and :ceil apply to it.
+  private def nearest_refuse_distanceless(key, direction, limit, subject = "locate_nearest_addr")
+    return unless key.data_type == CA_OBJECT && !key.face?
+    return unless direction == :round || limit
+    value = key.to_a.find { |v| !v.equal?(UNDEF) && v == v }
+    return if value.nil? || value.respond_to?(:-)
+    asked = (direction == :round) ? "direction: :round" : "tolerance:"
+    raise ArgumentError,
+          "#{subject}: #{asked} measures a distance, and a key of #{value.class} values " \
+          "has none (#{value.class} has no -); use direction: :floor or :ceil without tolerance:"
+  end
+
+  # Whether each pair of keys lies farther apart than +limit+. A time key is
+  # measured in ticks of the unit both keys meet in, as an integer key is:
+  # two instants an int64 holds can lie farther apart than an int64 holds (a
+  # nanosecond key spanning more than 292 years).
+  private def nearest_beyond(a, b, limit)
+    time_key = (a.is_a?(CATime) || a.is_a?(CATimedelta)) && a.class == b.class
+    r = time_key && CATimeUnitAlgebra.ratio(limit.unit, CATimeUnitAlgebra.diff_unit(a.unit, b.unit))
+    return nearest_distance(a, b) > limit unless r
+    a, b = a.in_common_unit_with(b)
+    threshold = (limit.value * r).floor
+    out = nearest_distance(a.ticks, b.ticks) > [threshold, 2**64 - 1].min
+    out[] = false if threshold >= 2**64 - 1
+    out
+  end
+
+  # How far apart two keys are. Integer keys are measured from the smaller to
+  # the larger, which fits an unsigned integer however far apart they are:
+  # the difference in their own type would wrap.
+  private def nearest_distance(a, b)
+    return (a - b).abs if a.face? || b.face?
+    t = a.send(:query_match_type, b)
+    return (a - b).abs if t == CA_OBJECT
+    a, b = a.to_type(t), b.to_type(t)
+    return (a - b).abs unless a.integer?
+    unless t == CA_UINT64
+      a, b = a.to_type(CA_INT64), b.to_type(CA_INT64)
+    end
+    (a.pmax(b) - a.pmin(b)).to_type(CA_UINT64)
+  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.
@@ -207,11 +262,7 @@ class CArray
   # that holds both.
   private def nearest_keys(rs, q)
     if rs.face? || q.face?
-      if rs.respond_to?(:to_unit) && q.class == rs.class && q.unit != rs.unit
-        u  = CATimeUnitAlgebra.finer(rs.unit, q.unit)
-        rs = rs.to_unit(u)
-        q  = q.to_unit(u)
-      end
+      rs, q = rs.in_common_unit_with(q) if rs.respond_to?(:to_unit) && q.class == rs.class && q.unit != rs.unit
       q  = rs.__send__(:reconcile_operand, q, "locate_nearest_addr")
       rs = rs.__send__(:face_storage)
     end
@@ -248,7 +299,7 @@ class CArray
   private def nearest_round(rk, qk, lt)
     lo = rk.project(lt - 1)
     hi = rk.project(lt)
-    upper = (hi - qk).le(qk - lo).strip_mask(false)
+    upper = nearest_distance(hi, qk).le(nearest_distance(qk, lo)).strip_mask(false)
     upper[lo.is_masked] = true if lo.has_mask?
     upper[hi.is_masked] = false if hi.has_mask?
     upper[hi.eq(qk).strip_mask(false)] = true