red_amber 0.2.2 → 0.3.0

data/lib/red_amber/refinements.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module RedAmber
+  # Add additional capabilities to Hash
+  module RefineHash
+    refine Hash do
+      # Convert self to an Arrow::Table
+      def to_arrow
+        Arrow::Table.new(self)
+      end
+    end
+  end
+
+  # Add additional capabilities to Array-like classes
+  module RefineArrayLike
+    refine Array do
+      def to_arrow_array
+        Arrow::Array.new(self)
+      end
+    end
+
+    refine Range do
+      def to_arrow_array
+        Arrow::Array.new(Array(self))
+      end
+    end
+
+    # common methods for Arrow::Array and Arrow::ChunkedArray
+    # Refinement#include is deprecated and will be removed in Ruby 3.2
+    refine Arrow::Array do
+      def to_arrow_array
+        self
+      end
+
+      def type_class
+        value_data_type.class
+      end
+
+      def boolean?
+        value_data_type.instance_of?(Arrow::BooleanDataType)
+      end
+
+      def numeric?
+        value_data_type.class < Arrow::NumericDataType
+      end
+
+      def float?
+        value_data_type.class < Arrow::FloatingPointDataType
+      end
+
+      def integer?
+        value_data_type.class < Arrow::IntegerDataType
+      end
+
+      def list?
+        is_a? Arrow::ListArray
+      end
+
+      def unsigned_integer?
+        value_data_type.instance_of?(Arrow::UInt8DataType) ||
+          value_data_type.instance_of?(Arrow::UInt16DataType) ||
+          value_data_type.instance_of?(Arrow::UInt32DataType) ||
+          value_data_type.instance_of?(Arrow::UInt64DataType)
+      end
+
+      def string?
+        value_data_type.instance_of?(Arrow::StringDataType)
+      end
+
+      def dictionary?
+        value_data_type.instance_of?(Arrow::DictionaryDataType)
+      end
+
+      def temporal?
+        value_data_type.class < Arrow::TemporalDataType
+      end
+
+      def primitive_invert
+        n = Arrow::Function.find(:is_null).execute([self])
+        i = Arrow::Function.find(:if_else).execute([n, false, self])
+        Arrow::Function.find(:invert).execute([i]).value
+      end
+    end
+
+    refine Arrow::ChunkedArray do
+      def to_arrow_array
+        self
+      end
+
+      def type_class
+        value_data_type.class
+      end
+
+      def boolean?
+        value_data_type.instance_of?(Arrow::BooleanDataType)
+      end
+
+      def numeric?
+        value_data_type.class < Arrow::NumericDataType
+      end
+
+      def float?
+        value_data_type.class < Arrow::FloatingPointDataType
+      end
+
+      def integer?
+        value_data_type.class < Arrow::IntegerDataType
+      end
+
+      def unsigned_integer?
+        value_data_type.instance_of?(Arrow::UInt8DataType) ||
+          value_data_type.instance_of?(Arrow::UInt16DataType) ||
+          value_data_type.instance_of?(Arrow::UInt32DataType) ||
+          value_data_type.instance_of?(Arrow::UInt64DataType)
+      end
+
+      def string?
+        value_data_type.instance_of?(Arrow::StringDataType)
+      end
+
+      def dictionary?
+        value_data_type.instance_of?(Arrow::DictionaryDataType)
+      end
+
+      def temporal?
+        value_data_type.class < Arrow::TemporalDataType
+      end
+
+      def list?
+        value_type.nick == 'list'
+      end
+
+      def primitive_invert
+        n = Arrow::Function.find(:is_null).execute([self])
+        i = Arrow::Function.find(:if_else).execute([n, false, self])
+        Arrow::Function.find(:invert).execute([i]).value
+      end
+    end
+  end
+
+  # Add additional capabilities to Arrow::Table
+  module RefineArrowTable
+    refine Arrow::Table do
+      def keys
+        columns.map(&:name)
+      end
+
+      def key?(key)
+        keys.include?(key)
+      end
+    end
+  end
+
+  # Add additional capabilities to Array
+  module RefineArray
+    refine Array do
+      def integers?
+        all? { |e| e.is_a?(Integer) } # rubocop:disable Performance/RedundantEqualityComparisonBlock
+      end
+
+      def booleans?
+        all? { |e| e.is_a?(TrueClass) || e.is_a?(FalseClass) || e.is_a?(NilClass) }
+      end
+
+      def symbols?
+        all? { |e| e.is_a?(Symbol) } # rubocop:disable Performance/RedundantEqualityComparisonBlock
+      end
+
+      def strings?
+        all? { |e| e.is_a?(String) } # rubocop:disable Performance/RedundantEqualityComparisonBlock
+      end
+
+      def symbols_or_strings?
+        all? { |e| e.is_a?(Symbol) || e.is_a?(String) }
+      end
+
+      # convert booleans to indices
+      def booleans_to_indices
+        (0...size).select.with_index { |_, i| self[i] }
+      end
+
+      # select elements by booleans
+      def select_by_booleans(booleans)
+        select.with_index { |_, i| booleans[i] }
+      end
+
+      # reject elements by booleans
+      def reject_by_booleans(booleans)
+        reject.with_index { |_, i| booleans[i] }
+      end
+
+      # reject elements by indices
+      # notice: order by indices is not considered.
+      def reject_by_indices(indices)
+        reject.with_index { |_, i| indices.include?(i) || indices.include?(i - size) }
+      end
+    end
+  end
+end

data/lib/red_amber/vector.rb

@@ -10,33 +10,38 @@ 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 [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
+    alias_method :to_arrow_array, :data
+
     attr_accessor :key
 
     def to_s
@@ -45,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
@@ -93,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
@@ -187,76 +195,9 @@ module RedAmber
     alias_method :ne, :not_equal
 
     def coerce(other)
-      case other
-      when Vector, Array, Arrow::Array
-        raise VectorArgumentError, "Size unmatch: #{size} != #{other.length}" unless size == other.length
-
-        [Vector.new(Array(other)), self]
-      end
       [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)
@@ -269,10 +210,9 @@ 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)
-      else
-        raise VectorArgumentError, "Operand is not supported: #{other.class}"
       end
     end