red_amber 0.2.3 → 0.3.0

data/lib/red_amber/vector.rb

@@ -10,39 +10,37 @@ module RedAmber
     include VectorSelectable
     include Helper
 
+    using RefineArrayLike
+
+    # Quicker constructor of Vector.
+    #
+    def self.create(arrow_array)
+      instance = allocate
+      instance.instance_variable_set(:@data, arrow_array)
+      instance
+    end
+
+    # Create a Vector.
+    #
+    # @note default is headless Vector and '@key == nil'
     def initialize(*array)
-      @key = nil # default is 'headless' Vector
-      if array.empty? || array.first.nil?
-        Vector.new([])
-      else
-        array.flatten!
-        @data =
-          case array
-          in [Vector => v]
-            v.data
-          in [Arrow::Array => a]
-            a
-          in [Arrow::ChunkedArray => ca]
-            ca
-          in [arrow_array_like] if arrow_array_like.respond_to?(:to_arrow_array)
-            arrow_array_like.to_arrow_array
-          in [Range => r]
-            Arrow::Array.new(Array(r))
-          else
-            begin
-              Arrow::Array.new(Array(array))
-            rescue Error
-              raise VectorArgumentError, "Invalid argument: #{array}"
-            end
-          end
-      end
+      @data =
+        case array
+        in [Vector => v]
+          v.data
+        in [Range => r]
+          Arrow::Array.new(Array(r))
+        in [Arrow::Array | Arrow::ChunkedArray]
+          array[0]
+        in [arrow_array_like] if arrow_array_like.respond_to?(:to_arrow_array)
+          arrow_array_like.to_arrow_array
+        else
+          Arrow::Array.new(array.flatten)
+        end
     end
 
     attr_reader :data
-
-    def to_arrow_array
-      @data
-    end
+    alias_method :to_arrow_array, :data
 
     attr_accessor :key
 
@@ -52,45 +50,46 @@ module RedAmber
 
     def inspect(limit: 80)
       if ENV.fetch('RED_AMBER_OUTPUT_MODE', 'Table').casecmp('MINIMUM').zero?
-        # Better performance than `.upcase == 'MINIMUM'``
+        # Better performance than `.upcase == 'MINIMUM'`
         "#{self.class}(:#{type}, size=#{size})"
       else
         sio = StringIO.new << '['
-        to_a.each_with_object(sio).with_index do |(e, s), i|
-          next_str = "#{s.size > 1 ? ', ' : ''}#{e.inspect}"
-          if (s.size + next_str.size) < limit
-            s << next_str
+        each.with_index do |e, i|
+          next_str = "#{sio.size > 1 ? ', ' : ''}#{e.inspect}"
+          if (sio.size + next_str.size) < limit
+            sio << next_str
           else
-            s << ', ... ' if i < size
+            sio << ', ... ' if i < size
             break
           end
         end
         sio << ']'
 
-        format "#<#{self.class}(:#{type}, size=#{size}):0x%016x>\n%s\n", object_id, sio.string
+        format "#<#{self.class}(:#{type}, size=#{size}):0x%016x>\n%s\n",
+               object_id, sio.string
       end
     end
 
-    def values
+    def to_ary
       @data.values
     end
-    alias_method :to_a, :values
-    alias_method :entries, :values
+
+    alias_method :to_a, :to_ary
+    alias_method :values, :to_ary
+    alias_method :entries, :to_ary
 
     def indices
       (0...size).to_a
     end
+
     alias_method :indexes, :indices
     alias_method :indeces, :indices
 
-    def to_ary
-      values
-    end
-
     def size
       # only defined :length in Arrow?
       @data.length
     end
+
     alias_method :length, :size
     alias_method :n_rows, :size
     alias_method :nrow, :size
@@ -100,39 +99,43 @@ module RedAmber
     end
 
     def type
-      @data.value_type.nick.to_sym
+      list? ? :list : @data.value_type.nick.to_sym
     end
 
     def boolean?
-      type_class == Arrow::BooleanDataType
+      @data.boolean?
     end
 
     def numeric?
-      type_class < Arrow::NumericDataType
+      @data.numeric?
     end
 
     def float?
-      type_class < Arrow::FloatingPointDataType
+      @data.float?
     end
 
     def integer?
-      type_class < Arrow::IntegerDataType
+      @data.integer?
     end
 
     def string?
-      type_class == Arrow::StringDataType
+      @data.string?
     end
 
     def dictionary?
-      type_class == Arrow::DictionaryDataType
+      @data.dictionary?
     end
 
     def temporal?
-      type_class < Arrow::TemporalDataType
+      @data.temporal?
+    end
+
+    def list?
+      @data.list?
     end
 
     def type_class
-      @data.value_data_type.class
+      @data.type_class
     end
 
     def each

data/lib/red_amber/vector_functions.rb

@@ -12,7 +12,8 @@ module RedAmber
   module VectorFunctions
     # [Unary aggregations]: vector.func => scalar
     unary_aggregations =
-      %i[all any approximate_median count count_distinct max mean min min_max product stddev sum variance]
+      %i[all any approximate_median count count_distinct max mean min min_max
+         product stddev sum variance]
     unary_aggregations.each do |function|
       define_method(function) do |**options|
         datum = exec_func_unary(function, options)
@@ -54,7 +55,10 @@ module RedAmber
     # @param min_count [Integer] min count.
     # @return [Float] quantile.
     def quantile(prob = 0.5, interpolation: :linear, skip_nils: true, min_count: 0)
-      raise VectorArgumentError, "Invalid: probability #{prob} must be between 0 and 1" unless (0..1).cover? prob
+      unless (0..1).cover? prob
+        raise VectorArgumentError,
+              "Invalid: probability #{prob} must be between 0 and 1"
+      end
 
       datum = find(:quantile).execute([data],
                                       q: prob,
@@ -66,7 +70,8 @@ module RedAmber
 
     # Return quantiles in a DataFrame
     #
-    def quantiles(probs = [1.0, 0.75, 0.5, 0.25, 0.0], interpolation: :linear, skip_nils: true, min_count: 0)
+    def quantiles(probs = [1.0, 0.75, 0.5, 0.25, 0.0],
+                  interpolation: :linear, skip_nils: true, min_count: 0)
       if probs.empty? || !probs.all? { |q| (0..1).cover?(q) }
         raise VectorArgumentError, "Invarid probavilities #{probs}"
       end
@@ -74,20 +79,23 @@ module RedAmber
       DataFrame.new(
         probs: probs,
         quantiles: probs.map do |q|
-          quantile(q, interpolation: interpolation, skip_nils: skip_nils, min_count: min_count)
+          quantile(q,
+                   interpolation: interpolation, skip_nils: skip_nils,
+                   min_count: min_count)
         end
       )
     end
 
     # [Unary element-wise]: vector.func => vector
     unary_element_wise =
-      %i[abs acos asin array_sort_indices atan bit_wise_not ceil cos fill_null_backward \
-         fill_null_forward floor is_finite is_inf is_nan is_null is_valid ln log10 log1p log2 \
+      %i[abs acos asin array_sort_indices atan bit_wise_not ceil cos
+         fill_null_backward fill_null_forward floor
+         is_finite is_inf is_nan is_null is_valid ln log10 log1p log2
          round round_to_multiple sign sin tan trunc unique]
     unary_element_wise.each do |function|
       define_method(function) do |**options|
         datum = exec_func_unary(function, options)
-        Vector.new(datum.value)
+        Vector.create(datum.value)
       end
     end
     alias_method :is_nil, :is_null
@@ -113,12 +121,12 @@ module RedAmber
     unary_element_wise_op.each do |function, operator|
       define_method(function) do |**options|
         datum = exec_func_unary(function, options)
-        Vector.new(datum.value)
+        Vector.create(datum.value)
       end
 
       define_method(operator) do |**options|
         datum = exec_func_unary(function, options)
-        Vector.new(datum.value)
+        Vector.create(datum.value)
       end
     end
     alias_method :not, :invert
@@ -129,7 +137,7 @@ module RedAmber
     binary_element_wise.each do |function|
       define_method(function) do |other, **options|
         datum = exec_func_binary(function, other, options)
-        Vector.new(datum.value)
+        Vector.create(datum.value)
       end
     end
 
@@ -145,7 +153,7 @@ module RedAmber
     logical_binary_element_wise.each do |method, function|
       define_method(method) do |other, **options|
         datum = exec_func_binary(function, other, options)
-        Vector.new(datum.value)
+        Vector.create(datum.value)
       end
     end
 
@@ -171,12 +179,12 @@ module RedAmber
     binary_element_wise_op.each do |function, operator|
       define_method(function) do |other, **options|
         datum = exec_func_binary(function, other, options)
-        Vector.new(datum.value)
+        Vector.create(datum.value)
       end
 
       define_method(operator) do |other, **options|
         datum = exec_func_binary(function, other, options)
-        Vector.new(datum.value)
+        Vector.create(datum.value)
       end
     end
     alias_method :eq, :equal
@@ -190,67 +198,6 @@ module RedAmber
       [Vector.new(Array(other) * size), self]
     end
 
-    # < Not implimented yet > ---
-
-    # option(s) required
-    # - index
-
-    # Returns other than value
-    # - mode
-    # - tdigest
-
-    # Functions with numerical range check (unary)
-    # - abs_checked acos_checked asin_checked cos_checked ln_checked
-    #   log10_checked log1p_checked log2_checked sin_checked tan_checked
-
-    # Functions with numerical range check (binary)
-    # - add_checked divide_checked logb_checked multiply_checked power_checked subtract_checked
-    #   shift_left_checked shift_right_checked
-
-    # (array functions)
-    # dictionary_encode,
-    # partition_nth_indices,
-    # quarter, quarters_between,
-
-    # (strings)
-    # ascii_capitalize, ascii_center, ascii_is_alnum, ascii_is_alpha, ascii_is_decimal,
-    # ascii_is_lower, ascii_is_printable, ascii_is_space, ascii_is_title, ascii_is_upper,
-    # ascii_lower, ascii_lpad, ascii_ltrim, ascii_ltrim_whitespace, ascii_reverse,
-    # ascii_rpad, ascii_rtrim, ascii_rtrim_whitespace, ascii_split_whitespace,
-    # ascii_swapcase, ascii_title, ascii_trim, ascii_trim_whitespace, ascii_upper,
-    # binary_join, binary_join_element_wise, binary_length, binary_repeat,
-    # binary_replace_slice, binary_reverse, count_substring, count_substring_regex,
-    # ends_with, extract_regex, find_substring, find_substring_regex,
-    # match_like, match_substring, match_substring_regex, replace_substring,
-    # replace_substring_regex, split_pattern, split_pattern_regex, starts_with,
-    # string_is_ascii, utf8_capitalize, utf8_center, utf8_is_alnum, utf8_is_alpha,
-    # utf8_is_decimal, utf8_is_digit, utf8_is_lower, utf8_is_numeric, utf8_is_printable,
-    # utf8_is_space, utf8_is_title, utf8_is_upper, utf8_length, utf8_lower, utf8_lpad,
-    # utf8_ltrim, utf8_ltrim_whitespace, utf8_normalize, utf8_replace_slice, utf8_reverse,
-    # utf8_rpad, utf8_rtrim, utf8_rtrim_whitespace, utf8_slice_codeunits, utf8_split_whitespace,
-    # utf8_swapcase, utf8_title, utf8_trim, utf8_trim_whitespace, utf8_upper
-
-    # (temporal)
-    # assume_timezone, ceil_temporal, day, day_of_week, day_of_year, day_time_interval_between,
-    # days_between, floor_temporal, hour, hours_between, iso_calendar, iso_week, iso_year,
-    # microsecond, microseconds_between, millisecond, milliseconds_between, minute,
-    # minutes_between, month, month_day_nano_interval_between, month_interval_between,
-    # nanosecond, nanoseconds_between, round_temporal, second, seconds_between, strftime,
-    # strptime, subsecond, us_week, week, weeks_between, year, year_month_day, years_between
-
-    # (onditional)
-    # case_when, cast,
-
-    # (indices)
-    # choose, index_in, index_in_meta_binary, indices_nonzero
-
-    # (others)
-    # coalesce,
-    # is_in_meta_binary,
-    # list_element, list_flatten, list_parent_indices, list_value_length, make_struct,
-    # max_element_wise, min_element_wise, random, select_k_unstable,
-    # struct_field,
-
     private # =======
 
     def exec_func_unary(function, options)
@@ -263,7 +210,8 @@ module RedAmber
       case other
       when Vector
         find(function).execute([data, other.data], options)
-      when Arrow::Array, Arrow::ChunkedArray, Arrow::Scalar, Array, Numeric, String, TrueClass, FalseClass
+      when Arrow::Array, Arrow::ChunkedArray, Arrow::Scalar,
+           Array, Numeric, String, TrueClass, FalseClass
         find(function).execute([data, other], options)
       end
     end

data/lib/red_amber/vector_selectable.rb

@@ -4,91 +4,122 @@
 # reference: https://arrow.apache.org/docs/cpp/compute.html
 
 module RedAmber
-  # mix-ins for class Vector
-  # Functions to select some data.
+  # mix-in for class Vector
+  #   Functions to select some data.
   module VectorSelectable
-    def drop_nil
-      datum = find(:drop_null).execute([data])
-      Vector.new(datum.value)
-    end
+    using RefineArray
+    using RefineArrayLike
+
+    # Select elements in the self by indices.
+    #
+    # @param indices [Array<Numeric>, Vector] indices.
+    # @yield [Array<Numeric>, Vector] indices.
+    # @return [Vector] Vector by selected elements.
+    #
+    #   TODO: support for the option `boundscheck: true`
+    def take(*indices, &block)
+      if block
+        unless indices.empty?
+          raise VectorArgumentError, 'Must not specify both arguments and block.'
+        end
 
-    # vector calculation version of selection by indices
-    # TODO: support for option {boundscheck: true}
-    def take(*indices)
-      indices.flatten!
-      return Vector.new([]) if indices.empty?
+        indices = [yield]
+      end
 
-      indices = indices[0] if indices.one? && !indices[0].is_a?(Numeric)
-      indices = Vector.new(indices) unless indices.is_a?(Vector)
+      vector =
+        case indices
+        in [Vector => v] if v.numeric?
+          return Vector.create(take_by_vector(v))
+        in []
+          return Vector.new
+        in [(Arrow::Array | Arrow::ChunkedArray) => aa]
+          Vector.create(aa)
+        else
+          Vector.new(indices.flatten)
+        end
 
-      take_by_vector(indices) # returns sub Vector
+      unless vector.numeric?
+        raise VectorArgumentError, "argument must be a integers: #{indices}"
+      end
+
+      Vector.create(take_by_vector(vector))
     end
 
-    # TODO: support for option {null_selection_behavior: :drop}
+    # Select elements in the self by booleans.
+    #
+    # @param booleans [Array<true, false, nil>, Vector] booleans.
+    # @yield [Array<true, false, nil>, Vector] booleans.
+    # @return [Vector] Vector by selected elements.
+    #
+    #   TODO: support for the option `null_selection_behavior: :drop`
     def filter(*booleans, &block)
       if block
-        raise VectorArgumentError, 'Must not specify both arguments and block.' unless booleans.empty?
+        unless booleans.empty?
+          raise VectorArgumentError, 'Must not specify both arguments and block.'
+        end
 
         booleans = [yield]
       end
 
-      booleans.flatten!
-      return Vector.new([]) if booleans.empty?
-
-      b = booleans[0]
-      boolean_array =
-        case b
-        when Vector
-          raise VectorTypeError, 'Argument is not a boolean.' unless b.boolean?
+      case booleans
+      in [Vector => v]
+        raise VectorTypeError, 'Argument is not a boolean.' unless v.boolean?
 
-          b.data
-        when Arrow::BooleanArray
-          b
+        Vector.create(filter_by_array(v.data))
+      in [Arrow::BooleanArray => ba]
+        Vector.create(filter_by_array(ba))
+      in []
+        Vector.new
+      else
+        booleans.flatten!
+        a = Arrow::Array.new(booleans)
+        if a.boolean?
+          Vector.create(filter_by_array(a))
+        elsif booleans.compact.empty? # [nil, nil] becomes string array
+          Vector.new
         else
-          raise VectorTypeError, 'Argument is not a boolean.' unless booleans?(booleans)
-
-          Arrow::BooleanArray.new(booleans)
+          raise VectorTypeError, "Argument is not a boolean: #{booleans}"
         end
-
-      filter_by_array(boolean_array) # returns sub Vector
+      end
     end
     alias_method :select, :filter
     alias_method :find_all, :filter
 
-    #   @param indices
-    #   @param booleans
+    # Select elements in the self by indices or booleans.
+    #
+    # @param args [Array<Numeric, true, false, nil>, Vector] specifier.
+    # @yield [Array<Numeric, true, false, nil>, Vector] specifier.
+    # @return [scalar, Array] returns scalar or array.
+    #
     def [](*args)
-      args.flatten!
-      return Vector.new([]) if args.empty?
-
-      arg = args[0]
-      case arg
-      when Vector
-        return take_by_vector(arg) if arg.numeric?
-        return filter_by_array(arg.data) if arg.boolean?
-
-        raise VectorTypeError, "Argument must be numeric or boolean: #{arg}"
-      when Arrow::BooleanArray
-        return filter_by_array(arg)
-      when Arrow::Array
-        array = arg
-      when Range
-        array = normalize_element(arg)
-      else
-        unless arg.is_a?(Numeric) || booleans?([arg])
-          raise VectorArgumentError, "Argument must be numeric or boolean: #{args}"
+      array =
+        case args
+        in [Vector => v]
+          return scalar_or_array(take_by_vector(v)) if v.numeric?
+          return scalar_or_array(filter_by_array(v.data)) if v.boolean?
+
+          raise VectorTypeError, "Argument must be numeric or boolean: #{args}"
+        in [Arrow::BooleanArray => ba]
+          return scalar_or_array(filter_by_array(ba))
+        in []
+          return nil
+        in [Arrow::Array => arrow_array]
+          arrow_array
+        in [Range => r]
+          Arrow::Array.new(parse_range(r, size))
+        else
+          Arrow::Array.new(args.flatten)
         end
-      end
-      array ||= Arrow::Array.new(args)
-      return filter_by_array(array) if array.is_a?(Arrow::BooleanArray)
+
+      return scalar_or_array(filter_by_array(array)) if array.boolean?
 
       vector = Vector.new(array)
-      return take_by_vector(vector) if vector.numeric?
+      return scalar_or_array(take_by_vector(vector)) if vector.numeric?
 
       raise VectorArgumentError, "Invalid argument: #{args}"
     end
 
-    #   @param values [Array, Arrow::Array, Vector]
+    # @param values [Array, Arrow::Array, Vector]
     def is_in(*values)
       self_data = chunked? ? data.pack : data
 
@@ -100,7 +131,7 @@ module RedAmber
           Array(values).flatten
         end
 
-      Vector.new(self_data.is_in(array))
+      Vector.create(self_data.is_in(array))
     end
 
     # Arrow's support required
@@ -108,28 +139,44 @@ module RedAmber
       to_a.index(element)
     end
 
+    def drop_nil
+      datum = find(:drop_null).execute([data])
+      Vector.create(datum.value)
+    end
+
     private
 
     # Accepts indices by numeric Vector
     def take_by_vector(indices)
-      raise VectorTypeError, "Indices must be numeric Vector: #{indices}" unless indices.numeric?
-      raise VectorArgumentError, "Index out of range: #{indices.min}" if indices.min <= -size - 1
+      indices = (indices < 0).if_else(indices + size, indices) if (indices < 0).any?
 
-      normalized_indices = (indices < 0).if_else(indices + size, indices) # normalize index from tail
-      raise VectorArgumentError, "Index out of range: #{normalized_indices.max}" if normalized_indices.max >= size
+      min, max = indices.min_max
+      raise VectorArgumentError, "Index out of range: #{min}" if min < 0
+      raise VectorArgumentError, "Index out of range: #{max}" if max >= size
 
-      index_array = Arrow::UInt64ArrayBuilder.build(normalized_indices.data) # round to integer array
+      index_array =
+        if indices.float?
+          Arrow::UInt64ArrayBuilder.build(indices.data)
+        else
+          indices.data
+        end
 
-      datum = find(:take).execute([data, index_array]) # :array_take will fail with ChunkedArray
-      Vector.new(datum.value)
+      # :array_take will fail with ChunkedArray
+      find(:take).execute([data, index_array]).value
     end
 
     # Accepts booleans by Arrow::BooleanArray
     def filter_by_array(boolean_array)
-      raise VectorArgumentError, 'Booleans must be same size as self.' unless boolean_array.length == size
+      unless boolean_array.length == size
+        raise VectorArgumentError, 'Booleans must be same size as self.'
+      end
+
+      find(:array_filter).execute([data, boolean_array]).value
+    end
 
-      datum = find(:array_filter).execute([data, boolean_array])
-      Vector.new(datum.value)
+    def scalar_or_array(arrow_array)
+      a = arrow_array.to_a
+      a.size > 1 ? a : a[0]
     end
   end
 end