carray 3.0.6 → 3.0.7

data/lib/carray/core_extensions.rb

@@ -9,7 +9,8 @@
 #  Provides:
 #    - Postfix math on Float/Integer/Rational (sqrt, exp, log, sin, ...)
 #      enabling scalar/CArray polymorphism: the same expression
-#      `(0.0415*(t-218.8)).tanh` works whether t is a Float or a CArray.
+#      `(0.0415*(t-218.8)).tanh` works whether t is a Float or a CArray,
+#      and answers as the array does (`(-1.0).sqrt` is NaN, not an exception).
 #    - The same postfix math on Complex, so an expression written for a
 #      complex CArray still reads for a single cell taken out of it.
 #    - Angle normalisation on Numeric (deg_360 / deg_180 / rad_2pi / rad_pi).
@@ -43,11 +44,18 @@ class CArray
   # lexically scoped: nothing changes for code that does not opt in.
   module CoreExtensions
 
+    # What a real scalar answers through the float64 kernel of the array form.
+    # The refinement exists so that one expression reads for a scalar and for
+    # an array, so it answers as the array does: NaN outside a function's
+    # domain where Ruby's Math raises, the sign of a zero, and the accuracy of
+    # expm1 and log1p near zero.  The cost is one CScalar per call.
+    #
     # @!visibility private
     MATH_METHODS = %i[
       sqrt exp log log10
       sin cos tan sinh cosh tanh
       asin acos atan asinh acosh atanh
+      expm1 log1p rsqrt signbit
     ].freeze
 
     [Float, Integer, Rational].each do |klass|
@@ -55,7 +63,7 @@ class CArray
         MATH_METHODS.each do |m|
           module_eval <<~RUBY, __FILE__, __LINE__ + 1
             def #{m}
-              Math.#{m}(self)
+              CA_FLOAT64(self).#{m}[0]
             end
           RUBY
         end
@@ -68,26 +76,12 @@ class CArray
         def distance(other)
           (self.to_f - other.to_f).abs
         end
-        # M.1 (PyTorch alignment) scalar polymorphism additions.
         # `trunc` is left to Ruby's built-in semantics (Float#truncate
         # returns Integer when arg=0) — its CArray counterpart preserves
         # data type, so scalar-side use should call .to_f.trunc explicitly.
-        # Math.expm1 / Math.log1p don't exist in stdlib; hand-roll.
-        def expm1
-          Math.exp(self) - 1.0
-        end
-        def log1p
-          Math.log(1.0 + self)
-        end
-        def rsqrt
-          1.0 / Math.sqrt(self)
-        end
         def square
           self * self
         end
-        def signbit
-          self.negative?
-        end
       end
     end
 
@@ -109,14 +103,9 @@ class CArray
       square rsqrt
     ].freeze
 
-    # Complex is not handled the way Float / Integer / Rational are.
-    # Math.tanh(Complex(1,2)) raises RangeError -- of the stdlib Math
-    # methods only Math.sqrt accepts a Complex -- so the complex forms
-    # need their own implementation.
-    #
-    # Each one runs the value through a one-element cmplx128 CScalar, so
-    # the answer comes from the very kernel the array form would have
-    # used.  That is the point: the branch cuts of csqrt / clog / casin /
+    # Complex goes the same way, through a one-element cmplx128 CScalar, so
+    # the answer comes from the very kernel the array form would have used.
+    # That is the point: the branch cuts of csqrt / clog / casin /
     # cacosh / catanh, and the sign of a zero on either side of them, are
     # whatever the platform's C99 complex.h says they are, and they are
     # not the same everywhere.  On this machine, for instance,
@@ -143,50 +132,12 @@ class CArray
     end
 
     refine Numeric do
-      def deg_360
-        a = self.to_f
-        fa = a / 360.0
-        if a >= 0
-          (fa - fa.floor) * 360.0
-        else
-          (fa - fa.ceil + 1) * 360.0
-        end
-      end
-
-      def deg_180
-        a = self.to_f
-        fa = (a + 180.0) / 360.0
-        b = if a >= 0
-              (fa - fa.floor) * 360.0 - 180.0
-            else
-              (fa - fa.ceil) * 360.0 - 180.0
-            end
-        b += 360.0 if b <= -180.0
-        b
-      end
-
-      def rad_2pi
-        a = self.to_f
-        two_pi = 2 * Math::PI
-        fa = a / two_pi
-        if a >= 0
-          (fa - fa.floor) * two_pi
-        else
-          (fa - fa.ceil + 1) * two_pi
-        end
-      end
-
-      def rad_pi
-        a = self.to_f
-        two_pi = 2 * Math::PI
-        fa = (a + Math::PI) / two_pi
-        b = if a >= 0
-              (fa - fa.floor) * two_pi - Math::PI
-            else
-              (fa - fa.ceil) * two_pi - Math::PI
-            end
-        b += two_pi if b <= -Math::PI
-        b
+      %i[deg_360 deg_180 rad_2pi rad_pi].each do |m|
+        module_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{m}
+            CA_FLOAT64(self.to_f).#{m}[0]
+          end
+        RUBY
       end
 
       def eq(other)

data/lib/carray/data_type_extension.rb

@@ -151,6 +151,7 @@ class CArray
     #   @param n [Integer] number of samples.
     #   @return [CArray]
     def linspace (x1, x2, n = 100)
+      raise TypeError, "linspace: n must be an Integer (got #{n.class})" unless n.is_a?(Integer)
       data_type = self::DataType
       unless data_type
         guess = guess_data_type_from_values(x1, x2)

data/lib/carray/fixlen_string.rb

@@ -87,7 +87,7 @@ class CArray
     values.each_with_index do |s, i|
       entity[i] = s.nil? ? UNDEF : s.to_s
     end
-    CAFixlenString.wrap(entity)
+    CAFixlenString.wrap(entity, encoding: CAFixlenString.__send__(:encoding_of_strings, values))
   end
 
 end
@@ -95,6 +95,88 @@ end
 # Mutable fixed-width String Face: L1 ops + in-place variants.  In-place
 # transforms re-store through the native fixlen path (silent truncate).
 class CAFixlenString
+
+  # The greater String of each cell and `other`, cell by cell: `other` is a
+  # CAFixlenString of the same shape or one String.  The result is as wide as
+  # the wider of the two.
+  # @return [CAFixlenString]
+  def pmax (other)
+    refuse_unordered_operands(__callee__, other)
+    pick_by_order(other) { |a, b| a.lt(b) }
+  end
+
+  # The lesser String of each cell and `other`; see {#pmax}.
+  # @return [CAFixlenString]
+  def pmin (other)
+    refuse_unordered_operands(__callee__, other)
+    pick_by_order(other) { |a, b| a.gt(b) }
+  end
+
+  # A String has no NaN to let win, so these are other names of pmax / pmin.
+  alias_method :maximum, :pmax
+  alias_method :minimum, :pmin
+  alias_method :fmax, :pmax
+  alias_method :fmin, :pmin
+
+  # @overload min_addr(axis: nil)
+  #   @return [Integer, CArray] the flat address of the smallest String.
+  def min_addr (*args, **kw)
+    to_string.min_addr(*args, **kw)
+  end
+
+  # @overload max_addr(axis: nil)
+  #   @return [Integer, CArray] the flat address of the largest String.
+  def max_addr (*args, **kw)
+    to_string.max_addr(*args, **kw)
+  end
+
+  # A value that is no String is in no cell, and the kernels below take only
+  # bytes: these ask the Strings, which answer it as any other value.
+  CArray.send(:define_named_methods, self,
+              [:eq, :ne, :count, :search, :search_addr, :is_in, :union, :difference, :intersection],
+              :through_strings_unless_text, super_block: true)
+
+  private def through_strings_unless_text (op, args, kw)
+    v = args[0]
+    return yield(*args, **kw) if args.empty? || v.is_a?(String) || v.is_a?(CArray) ||
+                                 v.is_a?(Array) || UNDEF.equal?(v)
+    to_string.public_send(op, *args, **kw)
+  end
+
+  # `other` where the block says self's cell loses to it, else self's cell.
+  # Another array of Strings (a CAString, a CAConstString, an object array)
+  # is taken as fixed-length strings, so the result is one.
+  private def pick_by_order (other)
+    return copy.tap { |out| out[] = UNDEF } if UNDEF.equal?(other)
+    if other.is_a?(CArray) && !other.is_a?(CAFixlenString)
+      other = CArray.string(other) if other.data_type == CA_OBJECT && !other.face?
+      other = other.to_fixlen_string if other.respond_to?(:to_fixlen_string)
+    end
+    yield(self, other).then_else(other, self)
+  end
+
+  # Both branches of a selection at the width of the wider one.
+  private def branches_in_common (x, y)
+    width = [x, y].map { |v|
+      case v
+      when CArray then v.bytes
+      when String then v.bytesize
+      else 1
+      end
+    }.max
+    [x, y].map { |v|
+      v.is_a?(CAFixlenString) && !v.scalar? ? v.to_fixlen_string(bytes: width) : v
+    }
+  end
+
+  # The encoding a column of these strings holds its text in: that of the
+  # strings beyond ASCII, UTF-8 if none is, and BINARY if they disagree,
+  # since the column cannot read them all back.
+  private_class_method def self.encoding_of_strings (values)
+    text = values.compact.map(&:to_s).reject(&:ascii_only?).map(&:encoding).uniq
+    text.size > 1 ? Encoding::BINARY : (text.first || Encoding::UTF_8)
+  end
+
   # inspect's name for the array: the class and the cell width, which is the
   # longest string a cell holds.
   private def inspect_label

data/lib/carray/frame/column_verbs.rb

@@ -26,13 +26,36 @@ class CAFrame
   # rows), so the answer is about the type and not the data: a refusal
   # there means the operation does not apply, while an error in the verb
   # itself is left to raise. An object column is the exception: its type
-  # says nothing of what it holds, so one with no present value is left out
-  # of a verb run over every column. An N-D column (each row a profile) is
+  # says nothing of what it holds, so one with no present value, or whose
+  # cells do not answer, is left out of a verb run over every column. An N-D column (each row a profile) is
   # asked, and computed, along the rows.
   module ColumnVerbs
 
     private
 
+    # The row of each cell, UNDEF where the cell is masked: a first or last
+    # taken of it picks the row, and the row picks the value of a Face that
+    # cannot hold new values, as lag picks it.
+    def present_rows (col)
+      rows = CArray.int64(col.elements).seq
+      rows[col.is_masked] = UNDEF if col.has_mask?
+      rows
+    end
+
+    # A verb whose answers lie on the frame's rows, with no column to compute:
+    # a frame of no column would also have no row.
+    def refuse_no_column_on_rows (verb, out, nrow)
+      return unless out.is_a?(Hash) && out.empty? && nrow > 0
+      raise ArgumentError, "#{verb}: no column to compute (every column is a key or has no #{verb})"
+    end
+
+    def refuse_unknown_fill_columns (verb, fills)
+      return unless fills.is_a?(Hash)
+      unknown = fills.keys - @frame.column_names
+      return if unknown.empty?
+      raise ArgumentError, "#{verb}: fill_value names no column #{unknown.map(&:inspect).join(', ')}"
+    end
+
     def over_named_columns (verb, names, key_names, args = [], keywords = {})
       if names.empty?
         cols = {}
@@ -41,7 +64,8 @@ class CAFrame
           col = @frame[name]
           next if valueless_object_column?(col, verb, args)
           next unless column_has?(col, verb, args, keywords)
-          cols[name] = yield(col, name)
+          cols[name] = answer_of_every_column(col, name) { |c, n| yield(c, n) }
+          cols.delete(name) if cols[name].equal?(NO_ANSWER)
         end
         return cols
       end
@@ -50,7 +74,7 @@ class CAFrame
                               names.map { |name| @frame.__send__(:column_key, name, verb) }, verb)
       results = keys.map do |key|
         name = key
-        col = @frame[key]
+        col = @frame.__send__(:named_column, key, verb)
         unless column_has?(col, verb, args, keywords)
           raise CArray::DataTypeError,
                 "#{verb}: column #{name.inspect} " \
@@ -61,11 +85,42 @@ class CAFrame
       results.size == 1 ? results.first : keys.zip(results).to_h
     end
 
+    NO_ANSWER = Object.new.freeze
+    private_constant :NO_ANSWER
+
+    # What an object column holds shows only in the verb itself: one whose
+    # cells do not answer is left out of a verb run over every column, as a
+    # column of a type without the operation is, wherever those cells sit.
+    # refuse_wrong_reduction_arguments has refused what no column would take.
+    def answer_of_every_column (col, name)
+      return yield(col, name) if col.face? || col.data_type != CA_OBJECT
+      begin
+        yield(col, name)
+      rescue TypeError, ArgumentError, NoMethodError, RangeError
+        NO_ANSWER
+      end
+    end
+
+    # The arguments of a reduction, asked of the core on a number before any
+    # column, so a wrong one is not taken for a column that does not answer.
+    # fill_value: is of each column's type, and stays out of this.
+    def refuse_wrong_reduction_arguments (verb, args, keywords)
+      return if verb == :count
+      CArray.float64(1).public_send(verb, *args, **keywords.reject { |k, _| k == :fill_value })
+    rescue CArray::DataTypeError, NoMethodError
+      nil
+    end
+
     # An object column with no present cell says nothing of what it holds,
     # so a verb run over every column leaves it out, as select leaves it out
-    # of every kind; counting the present cells applies to any column.
+    # of every kind; counting the present cells applies to any column. A
+    # Face kept in object cells (a CAString) with rows, every one masked, is
+    # the same: the type would be asked of masked cells only, which answer
+    # with the identity whatever the type. With no rows the type is asked of
+    # blank cells of its kind.
     def valueless_object_column? (col, verb, args)
-      return false if col.face? || col.data_type != CA_OBJECT
+      return false if col.data_type != CA_OBJECT
+      return false if col.face? && col.elements == 0
       return false if %i[count_not_masked count_masked].include?(verb)
       return false if verb == :count && args.empty?
       col.count_not_masked == 0

data/lib/carray/frame/concat.rb

@@ -52,10 +52,13 @@ class CAFrame
     index_pieces(frames, verb: "meld")
     check_trailing_shapes(frames, names, verb: "meld")
     frames = frames_with_rows(frames)
+    if first.index
+      check_same_column_type(frames.map(&:index), first.axis_name, verb: "meld")
+    end
     cols = {}
     names.each do |name|
       check_same_column_type(frames.map { |f| f[name] }, name, verb: "meld")
-      cols[name] = CArray.meld(frames.map { |f| f[name] }, axis: 0)
+      cols[name] = welding_column(name, "meld") { CArray.meld(frames.map { |f| f[name] }, axis: 0) }
     end
     new(cols, axis_name: first.axis_name, index: meld_index(frames))
   end
@@ -85,7 +88,9 @@ class CAFrame
     frames = frames_with_rows(frames)
     cols = {}
     names.each do |name|
-      cols[name] = CArray.concatenate(frames.map { |f| f[name] })
+      pieces = face_pieces_in_one_state(frames.map { |f| f[name] })
+      refuse_rounded_pieces(pieces, "concatenate", "column #{name.inspect}")
+      cols[name] = welding_column(name, "concatenate") { CArray.concatenate(pieces) }
     end
     new(cols, axis_name: first.axis_name, index: concatenate_index(frames))
   end
@@ -135,7 +140,8 @@ class CAFrame
               "stack: axis #{axis} out of range for column #{name.inspect} " \
               "(a #{parts.first.ndim}-D column takes 1 to #{parts.first.ndim})"
       end
-      cols[name] = CArray.stack(parts, axis: axis)
+      refuse_rounded_pieces(parts, "stack", "column #{name.inspect}")
+      cols[name] = welding_column(name, "stack") { CArray.stack(parts, axis: axis) }
     end
     new(cols, axis_name: first.axis_name, index: first.index)
   end
@@ -194,6 +200,43 @@ class CAFrame
 
   # ---- shared validators -------------------------------------------------
 
+  # Pieces of one Face in different states brought to one, as an outer join
+  # brings its two keys: times and durations to a common unit, categoricals
+  # to the labels of all, the first piece's first.
+  def self.face_pieces_in_one_state(pieces)
+    first = pieces.first
+    return pieces unless first.face? && pieces.all? { |p| p.class == first.class }
+    # names-check: units, not names
+    if first.respond_to?(:in_common_unit_with) && pieces.map(&:unit).uniq.size > 1
+      common = pieces.drop(1).reduce(first) { |acc, p| acc.in_common_unit_with(p).first }
+      return pieces.map { |p| p.unit == common.unit ? p : p.to_unit(common.unit) }
+    end
+    # names-check: label lists, not names
+    if first.is_a?(CACategorical) && pieces.map(&:labels).uniq.size > 1
+      labels = pieces.map(&:labels).reduce(:|)
+      return pieces.map { |p| CArray.object(*p.shape) { p.to_a }.categorize(labels: labels) }
+    end
+    pieces
+  end
+  private_class_method :face_pieces_in_one_state
+
+  # Pieces brought to a float: a value it rounds would be another value.
+  def self.refuse_rounded_pieces(pieces, verb, what)
+    return if pieces.size < 2 || pieces.any?(&:face?) || pieces.any? { |c| c.data_type == CA_FIXLEN }
+    refuse_rounded_integers(pieces, CArray.result_type(*pieces), verb, what)
+  end
+  private_class_method :refuse_rounded_pieces
+
+  # A refusal of the pieces reads as the verb the frames were given to, with
+  # the column it came from.
+  def self.welding_column(name, verb)
+    yield
+  rescue ArgumentError, CArray::DataTypeError => e
+    raise unless e.message.start_with?("#{verb}: ", "can't promote", "CAStack parents")
+    raise e.class, "#{verb}: column #{name.inspect}: #{e.message.delete_prefix("#{verb}: ")}"
+  end
+  private_class_method :welding_column
+
   def self.check_concat_inputs(frames, verb:)
     raise ArgumentError, "#{verb} requires at least one frame" if frames.empty?
     unless frames.all? { |f| f.is_a?(CAFrame) }
@@ -267,8 +310,7 @@ class CAFrame
   def self.meld_index(frames)
     indexes, axis = index_pieces(frames, verb: "meld")
     return nil unless indexes
-    axis   # unused; kept for symmetry
-    CArray.meld(indexes, axis: 0)
+    welding_column(axis, "meld") { CArray.meld(indexes, axis: 0) }
   end
   private_class_method :meld_index
 
@@ -276,7 +318,9 @@ class CAFrame
   def self.concatenate_index(frames)
     indexes, _axis = index_pieces(frames, verb: "concatenate")
     return nil unless indexes
-    CArray.concatenate(indexes)
+    indexes = face_pieces_in_one_state(indexes)
+    refuse_rounded_pieces(indexes, "concatenate", "the index")
+    welding_column(frames.first.axis_name, "concatenate") { CArray.concatenate(indexes) }
   end
   private_class_method :concatenate_index
 

data/lib/carray/frame/csv_parser.rb

@@ -99,16 +99,24 @@ class CAFrame
     class Tokenizer
       attr_reader :sep, :quote, :strip
 
-      def initialize(sep, quote, strip)
+      # What a separator and a quote have to be, for reading and for writing.
+      def self.check_delimiters(sep, quote)
         unless sep.is_a?(String) && !sep.empty?
           raise ArgumentError, "sep: must be a non-empty String (got #{sep.inspect})"
         end
+        if sep.match?(/[\r\n]/)
+          raise ArgumentError, "sep: cannot hold a line end (got #{sep.inspect})"
+        end
         unless quote.is_a?(String) && quote.size == 1
           raise ArgumentError, "quote: must be one character (got #{quote.inspect})"
         end
         if sep.include?(quote)
           raise ArgumentError, "sep: #{sep.inspect} cannot contain the quote character"
         end
+      end
+
+      def initialize(sep, quote, strip)
+        Tokenizer.check_delimiters(sep, quote)
         @sep      = sep
         @quote    = quote
         @strip    = strip
@@ -239,7 +247,7 @@ class CAFrame
               part = part + @sep + parts[i]
             end
             inner = part[1...-1]
-            fields << (inner.include?(@quote) ? inner.gsub(@qq, @quote) : inner)
+            fields << (inner.include?(@quote) ? inner.gsub(@qq) { @quote } : inner)
           elsif part.include?(@quote)
             return nil
           else
@@ -438,7 +446,7 @@ class CAFrame
         CAFrame.__send__(:column_key, c, "read_csv", "columns: a column name") if c.is_a?(Symbol)
         next if c.is_a?(Integer) && c >= 0
         next if c.is_a?(Range) && (c.begin.nil? || (c.begin.is_a?(Integer) && c.begin >= 0)) &&
-                (c.end.nil? || c.end.is_a?(Integer))
+                (c.end.nil? || (c.end.is_a?(Integer) && c.end >= 0))
         raise ArgumentError, "read_csv: columns: takes column names, or indexes from 0 " \
                              "and Ranges of them (got #{c.inspect})"
       end
@@ -485,6 +493,7 @@ class CAFrame
           return nil if last.nil? && ncol.nil?
           last = ncol - 1 if last.nil?
           last -= 1 if c.end && c.exclude_end?
+          raise ArgumentError, "read_csv: columns: #{c.inspect} selects no column" if last < first
           (first..last).to_a
         end
       end
@@ -653,7 +662,7 @@ class CAFrame
 
     private def body_in_c(last = nil, chunk_bytes = CHUNK_BYTES)
       return read_body_into_const_string_columns if last.nil? && @read_text_as_const_string
-      chunked = last.nil? && @names && @io.respond_to?(:external_encoding) &&
+      chunked = last.nil? && @names && @io.respond_to?(:internal_encoding) &&
                 @io.internal_encoding.nil?
       # Names that have to agree with the first record leave its column
       # count to C, to be checked against them.

data/lib/carray/frame/frame.rb

@@ -489,7 +489,7 @@ class CAFrame
     return false if col.face? || col.data_type != :object
     found = false
     col.each do |v|
-      next if UNDEF.equal?(v)
+      next if UNDEF.equal?(v) || v.nil?
       return false unless v.is_a?(String)
       found = true
     end
@@ -650,8 +650,8 @@ class CAFrame
       verdicts[key] = verdict
     end
     # The verdicts are a table about the rows, not a part of this one, so the
-    # frame's attributes are not carried.
-    CAFrame.new(verdicts, axis_name: @axis_name, index: @index)
+    # frame's attributes are not carried and the index is its own.
+    CAFrame.new(verdicts, axis_name: @axis_name, index: @index&.copy)
   end
 
   # A new frame with a column moved to the index and the row axis named
@@ -707,6 +707,7 @@ class CAFrame
   # The first +n+ rows as a positional view-frame (memo §11.3). +n+ larger
   # than +nrow+ yields the whole frame; +n+ of 0 yields an empty frame.
   def head(n = 5)
+    raise TypeError, "head: the count is an Integer (got #{n.inspect})" unless n.is_a?(Integer)
     raise ArgumentError, "head count must be non-negative (got #{n})" if n < 0
     row_span(0, [n, @nrow].min)
   end
@@ -714,6 +715,7 @@ class CAFrame
   # The last +n+ rows as a positional view-frame (memo §11.3). +n+ larger
   # than +nrow+ yields the whole frame; +n+ of 0 yields an empty frame.
   def tail(n = 5)
+    raise TypeError, "tail: the count is an Integer (got #{n.inspect})" unless n.is_a?(Integer)
     raise ArgumentError, "tail count must be non-negative (got #{n})" if n < 0
     row_span(@nrow - [n, @nrow].min, @nrow)
   end
@@ -728,6 +730,28 @@ class CAFrame
   # a row Hash and stays that way: zero matches raise KeyError, and duplicate
   # labels raise (go through +filter { |f| f.index.eq(label) }+ for the
   # multi-row, frame-returning path). Positional access is +df[i]+.
+  # A number as the index compares it without rounding: a whole float beside
+  # integers is an integer, and an integer beside floats that no float holds
+  # is no label there (a float32 index holds fewer integers than a float64
+  # one).
+  private def exact_label(label)
+    return label if @index.face?
+    if @index.integer? && label.is_a?(Float) && label.finite? && label == label.floor
+      label.to_i
+    elsif @index.float? && label.is_a?(Integer) && !index_float_holds?(label)
+      Float::NAN
+    else
+      label
+    end
+  end
+
+  # Whether the index's float type holds +n+ exactly.
+  private def index_float_holds?(n)
+    f = n.to_f
+    f = [f].pack("f").unpack1("f") if @index.data_type == CA_FLOAT32
+    f.finite? && f.to_i == n
+  end
+
   def at(label)
     raise ArgumentError, "at requires an index (set one with set_index)" unless @index
     # An index may hold a masked cell -- an outer join and align both build one
@@ -751,8 +775,8 @@ class CAFrame
             "at: the index is #{@index.data_type}, so the label must be a number " \
             "(got #{label.inspect}); convert it first, e.g. at(Float(s)) or at(Integer(s))"
     end
-    nan = label.is_a?(Float) && label.nan?
-    hit = nan ? @index.is_in([label]) : @index.eq(label)
+    nan = label.is_a?(Numeric) && label != label
+    hit = nan ? @index.is_in([label]) : @index.eq(exact_label(label))
     pos = hit.where
     case pos.elements
     when 0
@@ -1182,7 +1206,7 @@ class CAFrame
   # an index, the spliced-in frame must have one too (its rows need labels).
   private def splice_index(other, lo, hi)
     return nil unless @index
-    if other.nrow > 0 && other.index.nil?
+    if other.index.nil?
       raise ArgumentError,
             "splice frame needs an index because the target frame has one"
     end
@@ -1243,6 +1267,8 @@ class CAFrame
   end
 
   private def select_rows(selector)
+    # With no column and no index, nothing else bound-checks the selector.
+    selected_row_mask(selector) if @columns.empty? && @index.nil?
     cols = {}
     @columns.each do |name, col|
       cols[name] = col[selector, *([nil] * (col.ndim - 1))]
@@ -1264,6 +1290,12 @@ class CAFrame
     raise KeyError, "#{lead}no column #{key.inspect}"
   end
 
+  # The column a verb is given by name, the verb leading the refusal of a
+  # name that is no column.
+  private def named_column(key, verb)
+    @columns.fetch(key) { refuse_missing_column(key, verb) }
+  end
+
   # filter takes no keyword. keep_masked:, which it once took, is named
   # with where its work went: the selector settles an undetermined row.
   def self.refuse_filter_keywords(options, verb)