carray 3.0.3 → 3.0.5

data/yard-stubs/carray_scatter.rb

@@ -16,13 +16,17 @@ class CArray
   # Shared contract:
   #
   # - `addrs` is a CArray of any integer type (coerced to
-  #   `CA_SIZE`) or a Ruby Array.
+  #   `CA_SIZE`) or a Ruby Array. A float or complex CArray is
+  #   refused with `IndexError`, as `self[addrs]` refuses it.
   # - `vals` is a CArray of length matching `addrs` (coerced to
-  #   `self.data_type`), or a Numeric scalar broadcast to all
-  #   addresses. A complex `self` also takes a Complex scalar.
-  # - Out-of-range `addrs[i]` (`< 0` or `>= self.elements`) raises
-  #   `IndexError`.  The pairs before it stay applied, through a view
-  #   as well.
+  #   `self.data_type`), or a scalar broadcast to all addresses: any
+  #   Numeric, `true` / `false`, or `UNDEF`. The scalar is converted as
+  #   `self[i] = v` converts it, so a value that does not fit the type
+  #   raises (`RangeError`, `FloatDomainError` for NaN into an integer
+  #   type). A scalar `UNDEF` is a masked value.
+  # - A negative `addrs[i]` counts from the end. One out of range
+  #   raises `IndexError`; the pairs before it stay applied, through a
+  #   view as well.
   # - `self.data_type` must be numeric. Complex is accepted by
   #   every variant except {#scatter_min!} and {#scatter_max!},
   #   since complex values have no order.
@@ -100,12 +104,15 @@ class CArray
   #   allocates view state); useful in hot loops where a scatter
   #   result is written back many times.
   #
-  #   Unlike the arithmetic `scatter_*!` family, `self` may be
-  #   **boolean** (assignment does not widen), and `true` / `false`
-  #   are accepted as scalar `vals` alongside numeric scalars.
+  #   Unlike the arithmetic `scatter_*!` family, `self` may be of any
+  #   type (assignment does not widen): **boolean**, with `true` /
+  #   `false` (or `1` / `0`) as its scalar values, and **object** or
+  #   **fixlen**, written as `self.flatten[addrs] = vals` writes them
+  #   (as `put_nd` and `put_along_axis` take them). A scalar `UNDEF`
+  #   masks every addressed cell.
   #
   #   @param addrs [CArray, Array<Integer>]
-  #   @param vals [CArray, Numeric, true, false]
+  #   @param vals [CArray, Object, UNDEF]
   #   @return [self]
   def scatter_replace!(addrs, vals); end
 

data/yard-stubs/carray_slab.rb

@@ -14,7 +14,8 @@ class CArray
   #   duration of the block — capturing it across iterations sees the last
   #   slab's data — and it is read-only: writing through it raises.  To
   #   produce values per slab use `map_slab` or `reduce_slab`; to write in
-  #   place, assign through the array itself.
+  #   place, assign through the array itself.  Over a Face (`CATime`, a
+  #   record type) the slab is that Face.
   # @overload each_slab(axis:)
   #   Returns an Enumerator when no block is given.
   #   @param axis [Integer, Array<Integer>, nil] the slab axis or axes
@@ -29,7 +30,9 @@ class CArray
   #   block's result.  The block receives the slab view and must return a
   #   value of the same shape as the slab (a CArray or scalar); the results
   #   are written into the output at the same positions, and a masked
-  #   cell of the block's result is masked in the output.
+  #   cell of the block's result is masked in the output.  Over a Face the
+  #   slab is that Face, and the output is too unless `data_type:` is
+  #   given; a read-only Face answers in `:object` cells.
   #   @param axis [Integer, Array<Integer>, nil] the slab axis or axes.
   #   @param data_type [Symbol, Integer, Class, nil] output data type
   #     (defaults to `self`'s data type).
@@ -48,6 +51,10 @@ class CArray
   #   Per-element form (`init:` given): the block receives `(acc, x)` for
   #   each element of the slab and returns the new accumulator; the final
   #   accumulator per slab fills the output.
+  #
+  #   `UNDEF` from the block masks that output cell.  Over a Face the slab
+  #   (and each element) is that Face's, and the output is that Face unless
+  #   `data_type:` is given; a read-only Face answers in `:object` cells.
   #   @param axis [Integer, Array<Integer>, nil] the slab axis or axes.
   #   @param init [Object] the initial accumulator (selects the
   #     per-element form).

data/yard-stubs/carray_sort.rb

@@ -179,8 +179,8 @@ class CArray
   #   is a one-liner on top of `flatten[axis2addr(...)]`.
   #
   #   Shape rule: `indices.ndim == self.ndim`, and
-  #   `indices.dim[j] == self.dim[j]` for all `j != axis`;
-  #   `indices.dim[axis]` is free.
+  #   `indices.shape[j] == self.shape[j]` for all `j != axis`;
+  #   `indices.shape[axis]` is free.
   #
   #   `indices` data_type: any integer kind (zero-copy when
   #   already `:int64`). Negative indices: Python-style
@@ -196,9 +196,10 @@ class CArray
   #   @return [CArray] `:int64` view-flat addresses, same shape as
   #     `indices`.
   #   @raise [IndexError] when an index is out of range after
-  #     negative normalization.
-  #   @raise [ArgumentError] for shape / ndim / data_type
-  #     violations.
+  #     negative normalization, or `indices` is a float or complex
+  #     array.
+  #   @raise [ArgumentError] for shape / ndim violations, or a
+  #     boolean / object `indices`.
   def axis2addr(indices, axis: 0); end
 
   # @!endgroup

data/yard-stubs/carray_test.rb

@@ -6,8 +6,9 @@ class CArray
   # @!group Index and address conversion
 
   # @overload valid_index?(*idx)
-  #   Returns `true` if the given index tuple is in range for `self`.
-  #   The number of indices must equal `ndim`.
+  #   Returns `true` if the given index tuple names a cell of `self`,
+  #   that is, if `self[*idx]` would not raise. A negative index counts
+  #   from the end of its axis. The number of indices must equal `ndim`.
   #   @param idx [Array<Integer>] one index per axis.
   #   @return [Boolean]
   #   @raise [ArgumentError] if the number of indices does not match
@@ -15,7 +16,8 @@ class CArray
   def valid_index?(*idx); end
 
   # @overload valid_addr?(addr)
-  #   Returns `true` if `addr` is in range `0...elements` for `self`.
+  #   Returns `true` if `addr` names a cell of `self`: `0...elements`, or
+  #   a negative address counting from the end (`-elements..-1`).
   #   @param addr [Integer] flat address into the contiguous element
   #     sequence.
   #   @return [Boolean]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: carray
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 3.0.5
 platform: ruby
 authors:
 - himotoyoshi
@@ -111,11 +111,13 @@ files:
 - ext/carray_attribute.c
 - ext/carray_bincount.c
 - ext/carray_broadcast.c
+- ext/carray_build_flags.h
 - ext/carray_call_cfunc.c
 - ext/carray_call_cfunc.h
 - ext/carray_cast.c
 - ext/carray_cast_func.rb
 - ext/carray_class.c
+- ext/carray_config.h
 - ext/carray_conversion.c
 - ext/carray_copy.c
 - ext/carray_core.c
@@ -129,6 +131,21 @@ files:
 - ext/carray_index_classifier.c
 - ext/carray_index_classifier.h
 - ext/carray_internal.h
+- ext/carray_kernels_bincmp.c
+- ext/carray_kernels_binop.c
+- ext/carray_kernels_init.c
+- ext/carray_kernels_moncmp.c
+- ext/carray_kernels_monop.c
+- ext/carray_kernels_reduce_aggregate.c
+- ext/carray_kernels_reduce_boolean.c
+- ext/carray_kernels_reduce_cumulative.c
+- ext/carray_kernels_reduce_extreme.c
+- ext/carray_kernels_reduce_variance.c
+- ext/carray_kernels_scan.c
+- ext/carray_kernels_search.c
+- ext/carray_kernels_sort.c
+- ext/carray_kernels_triop.c
+- ext/carray_key_windows.c
 - ext/carray_lazy.c
 - ext/carray_loop.c
 - ext/carray_mask.c
@@ -140,6 +157,7 @@ files:
 - ext/carray_order.c
 - ext/carray_partition.c
 - ext/carray_random.c
+- ext/carray_round.c
 - ext/carray_scatter.c
 - ext/carray_segment.c
 - ext/carray_slab.c
@@ -159,7 +177,6 @@ files:
 - ext/version.h
 - ext/version.rb
 - lib/carray.rb
-- lib/carray/arrow_tensor.rb
 - lib/carray/attribute.rb
 - lib/carray/autoload_carray.rb
 - lib/carray/autoload_method_extension.rb
@@ -177,8 +194,10 @@ files:
 - lib/carray/core_extensions.rb
 - lib/carray/data_type_extension.rb
 - lib/carray/data_type_limits.rb
+- lib/carray/distance_limit.rb
 - lib/carray/fixlen_string.rb
 - lib/carray/frame.rb
+- lib/carray/frame/column_verbs.rb
 - lib/carray/frame/concat.rb
 - lib/carray/frame/convert.rb
 - lib/carray/frame/csv_parser.rb
@@ -191,11 +210,13 @@ files:
 - lib/carray/frame/reshape.rb
 - lib/carray/frame/sort.rb
 - lib/carray/frame/verbs.rb
+- lib/carray/frame/windows.rb
 - lib/carray/fuse_source.rb
 - lib/carray/fusion.rb
 - lib/carray/histogram.rb
 - lib/carray/inspect.rb
 - lib/carray/iterator.rb
+- lib/carray/key_windows.rb
 - lib/carray/lazy.rb
 - lib/carray/mask_gap_fill.rb
 - lib/carray/math.rb
@@ -212,8 +233,10 @@ files:
 - lib/carray/methods/gather_nd.rb
 - lib/carray/methods/index.rb
 - lib/carray/methods/insert_block.rb
+- lib/carray/methods/is_between.rb
 - lib/carray/methods/is_in.rb
 - lib/carray/methods/join.rb
+- lib/carray/methods/lag.rb
 - lib/carray/methods/locate_addr.rb
 - lib/carray/methods/mask_duplicates.rb
 - lib/carray/methods/meshgrid.rb
@@ -237,7 +260,6 @@ files:
 - lib/carray/string_operation_extension.rb
 - lib/carray/struct.rb
 - lib/carray/struct_builder.rb
-- lib/carray/table.rb
 - lib/carray/time.rb
 - lib/carray/window_iterator.rb
 - yard-stubs/ca_obj_array.rb

data/lib/carray/arrow_tensor.rb

@@ -1,401 +0,0 @@
-# Apache Arrow "tensor IPC" reader / writer for CArray.  [experimental]
-#
-# This surface is experimental: the method names, the module namespace, and
-# the packaging (it may later be extracted into a standalone, array-library-
-# neutral gem) are not yet frozen and may change in a future release.
-#
-# This is an interoperability layer, not an archival format: it exchanges
-# a dense numeric array with the Arrow ecosystem (pyarrow.ipc.write_tensor /
-# read_tensor and equivalents) using Arrow's encapsulated tensor message.
-# For faithful, reproducible persistence of a CArray -- mask, attributes,
-# data_class and all -- use CArray.save / CArray.load (the _CARRAY3 format).
-#
-# The on-disk shape is: a 0xFFFFFFFF continuation marker, an int32 metadata
-# length, a FlatBuffers Message whose header is a Tensor (element type, shape,
-# byte strides, and a Buffer descriptor), padding to an 8-byte boundary, then
-# the raw contiguous element bytes.  Only the numeric types Arrow tensors
-# admit are supported (int8..int64, uint8..uint64, float32, float64); boolean,
-# complex, fixlen and object arrays have no Arrow tensor representation and are
-# rejected.  A masked CArray is rejected too, mirroring the MemoryView policy:
-# Arrow tensors carry no validity concept, so the caller must be explicit
-# (ca.value to drop the mask, ca.unmask_copy(fill) to bake it in, or persist
-# the mask separately through CArray.save).
-
-require "stringio"
-
-class CArray
-  # Reader / writer for Arrow's encapsulated tensor IPC message, for
-  # exchanging a dense numeric array with the Arrow ecosystem
-  # (`pyarrow.ipc.write_tensor` / `read_tensor` and equivalents).
-  #
-  # Experimental: the method names, this namespace and the packaging are not
-  # frozen, and the layer may later move to a standalone, array-library-neutral
-  # gem.  It is an interoperability format, not an archival one — an Arrow
-  # tensor carries no mask, attributes or data_class, so `CArray.save` /
-  # `CArray.load` remain the way to persist a CArray faithfully.
-  #
-  # Only the numeric types an Arrow tensor admits are supported (int8..int64,
-  # uint8..uint64, float32, float64).  Boolean, complex, fixlen and object
-  # arrays are rejected, as is a masked array — Arrow tensors have no validity
-  # concept, so the caller must be explicit (`ca.value` to drop the mask,
-  # `ca.unmask_copy(fill)` to bake it in, or save the mask separately).
-  module ArrowTensor
-
-    # CArray data_type symbol -> Arrow element-type descriptor.
-    #   [:float, precision]  precision: 1 = single, 2 = double
-    #   [:int, bit_width, signed?]
-    DTYPE_TO_ARROW = {
-      float32: [:float, 1], float64: [:float, 2],
-      int8:  [:int, 8,  true],  int16: [:int, 16, true],
-      int32: [:int, 32, true],  int64: [:int, 64, true],
-      uint8: [:int, 8,  false], uint16:[:int, 16, false],
-      uint32:[:int, 32, false], uint64:[:int, 64, false],
-    }.freeze
-
-    module_function
-
-    # Write +ca+ to +io+ as an Arrow tensor IPC message.
-    def write (ca, io)
-      if ca.has_mask?
-        raise ArgumentError,
-              "cannot write a masked CArray as an Arrow tensor " \
-              "(Arrow tensors have no validity concept); pass ca.value to " \
-              "drop the mask, ca.unmask_copy(fill) to fill it, or use " \
-              "CArray.save for a mask-preserving round-trip"
-      end
-      arrow = DTYPE_TO_ARROW[ca.data_type]
-      unless arrow
-        raise ArgumentError,
-              "cannot write a #{ca.data_type} CArray as an Arrow tensor " \
-              "(Arrow tensors are numeric only: int8..int64, uint8..uint64, " \
-              "float32, float64)"
-      end
-      raise ArgumentError, "cannot write a 0-dimensional array" if ca.ndim < 1
-
-      shape   = ca.shape
-      elt     = ca.bytes
-      strides = row_major_strides(shape, elt)
-
-      body = StringIO.new("".b)
-      ca.dump_binary(body)          # raw contiguous element bytes, row-major
-      body = body.string
-
-      meta = build_metadata(arrow, shape, strides, body.bytesize)
-      pad  = (8 - ((8 + meta.bytesize) % 8)) % 8
-      meta += "\0".b * pad
-
-      io.write([0xFFFFFFFF].pack("V"))
-      io.write([meta.bytesize].pack("l<"))
-      io.write(meta)
-      io.write(body)
-      ca
-    end
-
-    # Read an Arrow tensor IPC message from +io+ and return a new CArray.
-    def read (io)
-      b = io.respond_to?(:read) ? io.read : io.to_s
-      b = b.b
-      meta = parse_metadata(b)
-      type = meta[:data_type]
-      unless CArray.respond_to?(:data_type_code) && DTYPE_TO_ARROW.key?(type)
-        raise ArgumentError,
-              "Arrow tensor element type #{type.inspect} has no CArray " \
-              "counterpart"
-      end
-      build_carray(type, meta[:shape], meta[:strides], meta[:body])
-    end
-
-    # ---- helpers ----------------------------------------------------------
-
-    def row_major_strides (shape, elt)
-      s = Array.new(shape.length)
-      acc = elt
-      (shape.length - 1).downto(0) do |i|
-        s[i] = acc
-        acc *= shape[i]
-      end
-      s
-    end
-    private_class_method :row_major_strides
-
-    def build_carray (type, shape, strides, body)
-      elt   = CArray.new(type, [1]).bytes
-      rmaj  = row_major_strides(shape, elt)
-      if strides == rmaj
-        ca = CArray.new(type, shape)
-        ca.load_binary(StringIO.new(body))
-        return ca
-      end
-      cmaj = row_major_strides(shape.reverse, elt).reverse
-      if strides == cmaj
-        t = CArray.new(type, shape.reverse)
-        t.load_binary(StringIO.new(body))
-        return t.transpose(*(0...shape.length).to_a.reverse).to_ca
-      end
-      # General strided layout (rare): gather element by element.
-      gather_strided(type, shape, strides, body)
-    end
-    private_class_method :build_carray
-
-    def gather_strided (type, shape, strides, body)
-      elt  = CArray.new(type, [1]).bytes
-      code = UNPACK[type]
-      ca   = CArray.new(type, shape)
-      elements = shape.inject(1, :*)
-      idx = Array.new(shape.length, 0)
-      elements.times do
-        off = 0
-        idx.each_with_index { |v, k| off += v * strides[k] }
-        ca[*idx] = body[off, elt].unpack1(code)
-        k = shape.length - 1
-        while k >= 0
-          idx[k] += 1
-          break if idx[k] < shape[k]
-          idx[k] = 0
-          k -= 1
-        end
-      end
-      ca
-    end
-    private_class_method :gather_strided
-
-    # @!visibility private
-    UNPACK = {
-      float32:"e", float64:"E",
-      int8:"c", int16:"s<", int32:"l<", int64:"q<",
-      uint8:"C", uint16:"v", uint32:"V", uint64:"Q<",
-    }.freeze
-
-    # ---- FlatBuffers Message encoder (header = Tensor) --------------------
-
-    # Minimal back-to-front FlatBuffers builder, specialised to the fields the
-    # Tensor message uses (scalars, tables, vectors, one inline struct).
-    #
-    # @!visibility private
-    class Builder
-      def initialize
-        @buf = "".b
-        @minalign = 1
-        @vt = nil
-        @obj_start = nil
-      end
-
-      # @!visibility private
-      def offset; @buf.bytesize; end
-
-      # @!visibility private
-      def prep (size, additional)
-        @minalign = size if size > @minalign
-        align = ((~(@buf.bytesize + additional)) + 1) & (size - 1)
-        @buf.prepend("\0".b * align) if align > 0
-      end
-
-      # @!visibility private
-      def u8 (x);  @buf.prepend([x].pack("C"));  end
-      # @!visibility private
-      def i16 (x); @buf.prepend([x].pack("s<")); end
-      # @!visibility private
-      def u16 (x); @buf.prepend([x].pack("v"));  end
-      # @!visibility private
-      def u32 (x); @buf.prepend([x].pack("V"));  end
-      # @!visibility private
-      def i32 (x); @buf.prepend([x].pack("l<")); end
-      # @!visibility private
-      def i64 (x); @buf.prepend([x].pack("q<")); end
-
-      # @!visibility private
-      def uoffset (off)
-        prep(4, 0)
-        u32(offset() - off + 4)
-      end
-
-      # @!visibility private
-      def slot (v); @vt[v] = offset(); end
-
-      # @!visibility private
-      def slot_i16 (v, x); prep(2,0); i16(x); slot(v); end
-      # @!visibility private
-      def slot_u8  (v, x); prep(1,0); u8(x);  slot(v); end
-      # @!visibility private
-      def slot_i32 (v, x); prep(4,0); i32(x); slot(v); end
-      # @!visibility private
-      def slot_i64 (v, x); prep(8,0); i64(x); slot(v); end
-      # @!visibility private
-      def slot_bool(v, x); prep(1,0); u8(x ? 1 : 0); slot(v); end
-      # @!visibility private
-      def slot_uoffset (v, off); uoffset(off); slot(v); end
-
-      # @!visibility private
-      def start_object (n); @vt = Array.new(n, 0); @obj_start = offset(); end
-
-      # @!visibility private
-      def end_object
-        prep(4, 0)
-        i32(0)                       # soffset placeholder
-        obj = offset()
-        n = @vt.length
-        n -= 1 while n > 0 && @vt[n-1] == 0
-        (n-1).downto(0) do |i|
-          u16(@vt[i] == 0 ? 0 : (obj - @vt[i]))
-        end
-        u16(obj - @obj_start)        # referenced table size
-        u16((n + 2) * 2)             # vtable size
-        soff = offset() - obj
-        @buf[@buf.bytesize - obj, 4] = [soff].pack("l<")
-        obj
-      end
-
-      # @!visibility private
-      def start_vector (elem, count, align); prep(4, elem*count); prep(align, elem*count); end
-      # @!visibility private
-      def end_vector (count); u32(count); offset(); end
-
-      # @!visibility private
-      def finish (root)
-        prep(@minalign, 4)
-        uoffset(root)
-        @buf
-      end
-    end
-
-    def build_metadata (arrow, shape, strides, body_len)
-      fb = Builder.new
-      tag = arrow[0] == :float ? 3 : 2
-
-      type_off =
-        if arrow[0] == :float
-          fb.start_object(1)
-          fb.slot_i16(0, arrow[1])            # precision
-          fb.end_object
-        else
-          fb.start_object(2)
-          fb.slot_i32(0, arrow[1])            # bitWidth
-          fb.slot_bool(1, arrow[2])           # is_signed
-          fb.end_object
-        end
-
-      dim_offs = shape.map do |sz|
-        fb.start_object(2)
-        fb.slot_i64(0, sz)                     # TensorDim.size (name omitted)
-        fb.end_object
-      end
-      fb.start_vector(4, dim_offs.length, 4)
-      dim_offs.reverse_each { |o| fb.uoffset(o) }
-      shape_vec = fb.end_vector(dim_offs.length)
-
-      fb.start_vector(8, strides.length, 8)
-      strides.reverse_each { |s| fb.i64(s) }
-      strides_vec = fb.end_vector(strides.length)
-
-      fb.start_object(5)                       # Tensor: type_type,type,shape,strides,data
-      fb.prep(8, 16)                           # data: inline Buffer struct
-      fb.i64(body_len)                         #   length
-      fb.i64(0)                                #   offset
-      fb.slot(4)
-      fb.slot_uoffset(3, strides_vec)
-      fb.slot_uoffset(2, shape_vec)
-      fb.slot_uoffset(1, type_off)
-      fb.slot_u8(0, tag)                       # type_type
-      tensor_off = fb.end_object
-
-      fb.start_object(5)                       # Message: version,header_type,header,bodyLength,custom
-      fb.slot_i64(3, body_len)
-      fb.slot_uoffset(2, tensor_off)
-      fb.slot_u8(1, 4)                         # header_type = Tensor
-      fb.slot_i16(0, 4)                        # metadata version V5
-      msg_off = fb.end_object
-
-      fb.finish(msg_off)
-    end
-    private_class_method :build_metadata
-
-    # ---- FlatBuffers Message decoder --------------------------------------
-
-    def parse_metadata (b)
-      u16 = ->(o){ b[o,2].unpack1("v") }
-      i32 = ->(o){ b[o,4].unpack1("l<") }
-      u32 = ->(o){ b[o,4].unpack1("V") }
-      i64 = ->(o){ b[o,8].unpack1("q<") }
-      field = ->(t,f){ vt = t - i32.(t); vts = u16.(vt); slot = 4 + f*2
-                       next 0 if slot >= vts; vo = u16.(vt+slot); vo==0 ? 0 : t+vo }
-      deref = ->(pos){ pos + u32.(pos) }
-
-      raise ArgumentError, "not an Arrow IPC message" unless u32.(0) == 0xffffffff
-      meta_len = i32.(4)
-      fb = 8
-      body_off = 8 + meta_len
-
-      msg = fb + i32.(fb)
-      htag = (p = field.(msg,1); p == 0 ? 0 : b.getbyte(p))
-      raise ArgumentError, "not a tensor message" unless htag == 4
-      hpos = deref.(field.(msg,2))
-
-      type_tag = b.getbyte(field.(hpos,0))
-      type_tbl = deref.(field.(hpos,1))
-      shp_vec  = deref.(field.(hpos,2)); n = u32.(shp_vec)
-      shape = (0...n).map { |i| dp = deref.(shp_vec + 4 + i*4); i64.(field.(dp,0)) }
-      sv_slot = field.(hpos,3)
-      strides =
-        if sv_slot == 0
-          row_major_strides(shape, CArray.new(arrow_symbol(type_tag, type_tbl, u16, i32, b), [1]).bytes)
-        else
-          sv = deref.(sv_slot); m = u32.(sv); (0...m).map { |i| i64.(sv + 4 + i*8) }
-        end
-      dpos = field.(hpos,4)
-      data_off = i64.(dpos); data_len = i64.(dpos+8)
-
-      { data_type: arrow_symbol(type_tag, type_tbl, u16, i32, b),
-        shape: shape, strides: strides,
-        body: b[body_off + data_off, data_len] }
-    end
-    private_class_method :parse_metadata
-
-    def arrow_symbol (tag, tbl, u16, i32, b)
-      case tag
-      when 3
-        { 0=>:float16, 1=>:float32, 2=>:float64 }[u16.(tbl_field(tbl, 0, i32, u16))] ||
-          (raise ArgumentError, "unsupported Arrow float precision")
-      when 2
-        bw = i32.(tbl_field(tbl, 0, i32, u16))
-        sf = tbl_field(tbl, 1, i32, u16)
-        signed = sf == 0 ? false : (b.getbyte(sf) != 0)  # is_signed FlatBuffers default = false
-        (signed ? "int#{bw}" : "uint#{bw}").to_sym
-      else
-        raise ArgumentError, "unsupported Arrow tensor element type (tag=#{tag})"
-      end
-    end
-    private_class_method :arrow_symbol
-
-    def tbl_field (t, f, i32, u16)
-      vt = t - i32.(t); vts = u16.(vt); slot = 4 + f*2
-      return 0 if slot >= vts
-      vo = u16.(vt + slot); vo == 0 ? 0 : t + vo
-    end
-    private_class_method :tbl_field
-
-  end
-
-  # Reads an Arrow tensor IPC file and returns it as a new CArray.
-  #
-  # Experimental, and the name is provisional.
-  #
-  # @param filename [String] path to the message.
-  # @return [CArray]
-  # @see ArrowTensor
-  def self.load_arrow_tensor (filename)
-    File.open(filename, "rb") { |io| ArrowTensor.read(io) }
-  end
-
-  # Writes `self` to `filename` as an Arrow tensor IPC message.
-  #
-  # Experimental, and the name is provisional.  Rejects a masked or
-  # non-numeric array; see {ArrowTensor} for the type policy.
-  #
-  # @param filename [String] path to write.
-  # @return [self]
-  # @see ArrowTensor
-  def save_arrow_tensor (filename)
-    File.open(filename, "wb") { |io| ArrowTensor.write(self, io) }
-    self
-  end
-end