red_amber 0.4.0 → 0.4.2

data/lib/red_amber/vector.rb

@@ -27,28 +27,6 @@ module RedAmber
       instance
     end
 
-    # Return true if it is an aggregation function.
-    #
-    # @param function [Symbol]
-    #   function name to test.
-    # @return [Booleans]
-    #   true if function is a aggregation function, otherwise false.
-    #
-    # @example
-    #   Vector.aggregate?(:mean) # => true
-    #
-    #   Vector.aggregate?(:round) # => false
-    #
-    # @since 0.4.0
-    #
-    def self.aggregate?(function)
-      %i[
-        all all? any any? approximate_median count count_distinct count_uniq
-        max mean median min min_max product quantile sd std stddev sum
-        unbiased_variance var variance
-      ].include?(function.to_sym)
-    end
-
     # Create a Vector.
     #
     # @param array [Array, Vector, Range, Arrow::Array, #to_arrow_array]
@@ -532,13 +510,10 @@ module RedAmber
 
           yield self
         else
-          function = function&.to_sym
-          unless function && respond_to?(function) && Vector.aggregate?(function)
-            raise VectorArgumentError, "illegal function: #{function.inspect}"
-          end
-
-          send(function)
+          send(function&.to_sym)
         end
+      raise VectorArgumentError, 'not an aggregation function' if value.is_a?(Vector)
+
       Vector.new([value] * size)
     end
     alias_method :expand, :propagate
@@ -555,8 +530,10 @@ 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 NilClass
+        nils = data.class.new([nil] * size)
+        find(function).execute([data, nils], options)
+      else
         find(function).execute([data, other], options)
       end
     end

data/lib/red_amber/vector_binary_element_wise.rb

@@ -174,6 +174,13 @@ module RedAmber
     #
     define_binary_element_wise :logb
 
+    # Compute base `b` logarithm of self.
+    #
+    # This function is a overflow-checking variant of #logb.
+    # @return (see #logb)
+    #
+    define_binary_element_wise :logb_checked
+
     # Logical 'or' boolean values with Kleene logic.
     #
     # @macro kleene_logic_or
@@ -211,6 +218,13 @@ module RedAmber
     define_binary_element_wise :add
     alias_method :'+', :add
 
+    # Add the arguments element-wise.
+    #
+    # This function is a overflow-checking variant of #add.
+    # @return (see #add)
+    #
+    define_binary_element_wise :add_checked
+
     # Divide the arguments element-wise.
     #
     # Integer division by zero returns an error. However, integer overflow
@@ -219,11 +233,51 @@ module RedAmber
     # @param divisor [Vector, Numeric]
     #   numeric vector or numeric scalar as divisor.
     # @return [Vector]
-    #   division of self and other.
+    #   division of self by other.
     #
     define_binary_element_wise :divide
     alias_method :'/', :divide
 
+    # Divide the arguments element-wise.
+    #
+    # This function is a overflow-checking variant of #divide.
+    # @return (see #divide)
+    #
+    define_binary_element_wise :divide_checked
+
+    # Returns element-wise modulo.
+    #
+    # This is equivalent to `self-divisor*(self/divisor).floor`.
+    # @note Same behavior as Ruby.
+    # @param divisor [Vector, numeric]
+    #   divisor numeric Vector or numeric scalar.
+    # @return [Vector]
+    #   modulo of dividing self by divisor.
+    #
+    def modulo(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      d = find(:divide).execute([data, divisor])
+      d = find(:floor).execute([d]) if d.value.is_a?(Arrow::DoubleArray)
+      m = find(:multiply).execute([d, divisor])
+      datum = find(:subtract).execute([data, m])
+      Vector.create(datum.value)
+    end
+    alias_method :'%', :modulo
+
+    # Returns element-wise modulo.
+    #
+    # This function is a overflow-checking variant of #modulo.
+    # @return (see #modulo)
+    #
+    def modulo_checked(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      d = find(:divide_checked).execute([data, divisor])
+      d = find(:floor).execute([d]) if d.value.is_a?(Arrow::DoubleArray)
+      m = find(:multiply_checked).execute([d, divisor])
+      datum = find(:subtract_checked).execute([data, m])
+      Vector.create(datum.value)
+    end
+
     # Multiply the arguments element-wise.
     #
     # Results will wrap around on integer overflow.
@@ -234,8 +288,16 @@ module RedAmber
     #   multiplication of self and other.
     #
     define_binary_element_wise :multiply
+    alias_method :mul, :multiply
     alias_method :'*', :multiply
 
+    # Multiply the arguments element-wise.
+    #
+    # This function is a overflow-checking variant of #multiply.
+    # @return (see #multiply)
+    #
+    define_binary_element_wise :multiply_checked
+
     # Raise arguments to power element-wise.
     #
     # Integer to negative integer power returns an error.
@@ -248,8 +310,72 @@ module RedAmber
     #   power operation of self and other.
     #
     define_binary_element_wise :power
+    alias_method :pow, :power
     alias_method :'**', :power
 
+    # Raise arguments to power element-wise.
+    #
+    # This function is a overflow-checking variant of #power.
+    # @return (see #power)
+    #
+    define_binary_element_wise :power_checked
+
+    # Returns element-wise quotient by double Vector.
+    #
+    # @param divisor [Vector, numeric]
+    #   divisor numeric Vector or numeric scalar.
+    # @return [Vector]
+    #   quotient of dividing self by divisor.
+    #
+    def fdiv(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      datum = find(:divide).execute([Arrow::DoubleArray.new(data), divisor])
+      Vector.create(datum.value)
+    end
+
+    # Returns element-wise quotient by double Vector.
+    #
+    # This function is a overflow-checking variant of #quotient.
+    # @return (see #quotient)
+    #
+    def fdiv_checked(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      datum = find(:divide_checked).execute([Arrow::DoubleArray.new(data), divisor])
+      Vector.create(datum.value)
+    end
+
+    # Returns element-wise remainder.
+    #
+    # This is equivalent to `self-divisor*(self/divisor).trunc`.
+    # @note Same behavior as Ruby's remainder.
+    # @param divisor [Vector, numeric]
+    #   divisor numeric Vector or numeric scalar.
+    # @return [Vector]
+    #   modulo of dividing self by divisor.
+    #
+    def remainder(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      d = find(:divide).execute([data, divisor])
+      d = find(:trunc).execute([d]) if d.value.is_a?(Arrow::DoubleArray)
+      m = find(:multiply).execute([d, divisor])
+      datum = find(:subtract).execute([data, m])
+      Vector.create(datum.value)
+    end
+
+    # Returns element-wise modulo.
+    #
+    # This function is a overflow-checking variant of #modulo.
+    # @return (see #modulo)
+    #
+    def remainder_checked(divisor)
+      divisor = divisor.data if divisor.is_a?(Vector)
+      d = find(:divide_checked).execute([data, divisor])
+      d = find(:trunc).execute([d]) if d.value.is_a?(Arrow::DoubleArray)
+      m = find(:multiply_checked).execute([d, divisor])
+      datum = find(:subtract_checked).execute([data, m])
+      Vector.create(datum.value)
+    end
+
     # Subtract the arguments element-wise.
     #
     # Results will wrap around on integer overflow.
@@ -260,8 +386,16 @@ module RedAmber
     #   subtraction of self and other.
     #
     define_binary_element_wise :subtract
+    alias_method :sub, :subtract
     alias_method :'-', :subtract
 
+    # Subtract the arguments element-wise.
+    #
+    # This function is a overflow-checking variant of #subtract.
+    # @return (see #subtract)
+    #
+    define_binary_element_wise :subtract_checked
+
     # Left shift of self by other.
     #
     # The shift operates as if on the two's complement representation of the number.
@@ -278,6 +412,13 @@ module RedAmber
     define_binary_element_wise :shift_left
     alias_method :'<<', :shift_left
 
+    # Left shift of self by other.
+    #
+    # This function is a overflow-checking variant of #shift_left.
+    # @return (see #shift_left)
+    #
+    define_binary_element_wise :shift_left_checked
+
     # Right shift of self by other.
     #
     # This is equivalent to dividing `x` by 2 to the power `y`.
@@ -292,6 +433,13 @@ module RedAmber
     define_binary_element_wise :shift_right
     alias_method :'>>', :shift_right
 
+    # Right shift of self by other.
+    #
+    # This function is a overflow-checking variant of #shift_right.
+    # @return (see #shift_right)
+    #
+    define_binary_element_wise :shift_right_checked
+
     # Logical 'xor' boolean values
     #
     # When a nil is encountered in either input, a nil is output.

data/lib/red_amber/vector_selectable.rb

@@ -128,24 +128,55 @@ module RedAmber
       raise VectorArgumentError, "Invalid argument: #{args}"
     end
 
-    # @param values [Array, Arrow::Array, Vector]
+    # Check if elements of self are in the other values.
+    #
+    # @param values [Vector, Array, Arrow::Array, Arrow::ChunkedArray]
+    #   values to test existence.
+    # @return [Vector]
+    #   boolean Vector.
+    #
     def is_in(*values)
-      self_data = chunked? ? data.pack : data
-
-      array =
+      enum =
         case values
-        in [Vector] | [Arrow::Array] | [Arrow::ChunkedArray]
-          values[0].to_a
+        in [] | [[]] | [nil] |[[nil]]
+          return Vector.new([false] * size)
+        in [Vector | Arrow::Array | Arrow::ChunkedArray]
+          values[0].each
         else
-          Array(values).flatten
+          parse_args(values, size, symbolize: false)
         end
-
-      Vector.create(self_data.is_in(array))
+      enum.filter_map { self == _1 unless _1.nil? }.reduce(&:|)
     end
 
-    # Arrow's support required
+    # Returns index of first matched position of element in self.
+    #
+    # @param element
+    #   an element of self.
+    # @return [integer, nil]
+    #   founded position of element. If it is not found, returns nil.
+    #
     def index(element)
-      to_a.index(element)
+      (0...size).find { |i| self[i] == element }
+    end
+
+    # Returns first element of self.
+    #
+    # @return
+    #   the first element.
+    # @since 0.4.1
+    #
+    def first
+      data[0]
+    end
+
+    # Returns last element of self.
+    #
+    # @return
+    #   the last element.
+    # @since 0.4.1
+    #
+    def last
+      data[-1]
     end
 
     # Drop nil in self and returns a new Vector as a result.
@@ -236,7 +267,13 @@ module RedAmber
     # @since 0.4.0
     #
     def rank
-      datum = Arrow::Function.find(:rank).execute([data])
+      datum =
+        case data
+        when Arrow::ChunkedArray
+          Arrow::Function.find(:rank).execute([data.pack])
+        else
+          Arrow::Function.find(:rank).execute([data])
+        end
       Vector.create(datum.value) - 1
     end
 

data/lib/red_amber/vector_unary_element_wise.rb

@@ -56,6 +56,13 @@ module RedAmber
     #
     define_unary_element_wise :abs
 
+    # Calculate the absolute value of self element-wise.
+    #
+    # This function is a overflow-checking variant of #abs.
+    # @return (see #abs)
+    #
+    define_unary_element_wise :abs_checked
+
     # Compute the inverse cosine of self element-wise.
     #
     # NaN is returned for invalid input values.
@@ -64,6 +71,13 @@ module RedAmber
     #
     define_unary_element_wise :acos
 
+    # Compute the inverse cosine of self element-wise.
+    #
+    # This function is a overflow-checking variant of #acos.
+    # @return (see #acos)
+    #
+    define_unary_element_wise :acos_checked
+
     # Compute the inverse sine of self element-wise.
     #
     # NaN is returned for invalid input values.
@@ -72,6 +86,13 @@ module RedAmber
     #
     define_unary_element_wise :asin
 
+    # Compute the inverse sine of self element-wise.
+    #
+    # This function is a overflow-checking variant of #asin.
+    # @return (see #asin)
+    #
+    define_unary_element_wise :asin_checked
+
     # Return the indices that would sort self.
     #
     # Computes indices Vector that define a stable sort of self.
@@ -129,8 +150,16 @@ module RedAmber
     #
     define_unary_element_wise :cos
 
+    # Compute the cosine of self element-wise.
+    #
+    # This function is a overflow-checking variant of #cos.
+    # @return (see #cos)
+    #
+    define_unary_element_wise :cos_checked
+
     # Compute cumulative sum over the numeric Vector.
     #
+    # This function is a overflow-checking variant of #cumsum.
     # @note Self must be numeric.
     # @note Return error for integer overflow.
     # @return [Vector]
@@ -261,6 +290,13 @@ module RedAmber
     #
     define_unary_element_wise :ln
 
+    # Compute natural logarithm.
+    #
+    # This function is a overflow-checking variant of #ln.
+    # @return (see #ln)
+    #
+    define_unary_element_wise :ln_checked
+
     # Compute base 10 logarithm.
     #
     # Non-positive values return -inf or NaN. Nil values return nil.
@@ -269,6 +305,13 @@ module RedAmber
     #
     define_unary_element_wise :log10
 
+    # Compute base 10 logarithm.
+    #
+    # This function is a overflow-checking variant of #log10.
+    # @return (see #log10)
+    #
+    define_unary_element_wise :log10_checked
+
     # Compute natural log of (1+x).
     #
     # Non-positive values return -inf or NaN. Nil values return nil.
@@ -278,6 +321,13 @@ module RedAmber
     #
     define_unary_element_wise :log1p
 
+    # Compute natural log of (1+x).
+    #
+    # This function is a overflow-checking variant of #log1p.
+    # @return (see #log1p)
+    #
+    define_unary_element_wise :log1p_checked
+
     # Compute base 2 logarithm.
     #
     # Non-positive values return -inf or NaN. Nil values return nil.
@@ -286,6 +336,13 @@ module RedAmber
     #
     define_unary_element_wise :log2
 
+    # Compute base 2 logarithm.
+    #
+    # This function is a overflow-checking variant of #log2.
+    # @return (see #log2)
+    #
+    define_unary_element_wise :log2_checked
+
     # Round to a given precision.
     #
     # Options are used to control the number of digits and rounding mode.
@@ -390,6 +447,28 @@ module RedAmber
     #
     define_unary_element_wise :sin
 
+    # Compute the sine of self element-wise.
+    #
+    # This function is a overflow-checking variant of #sin.
+    # @return (see #sin)
+    #
+    define_unary_element_wise :sin_checked
+
+    # Compute square root of self.
+    #
+    # NaN is returned for invalid input values.
+    # @return [Vector]
+    #   sqrt of each element of self.
+    #
+    define_unary_element_wise :sqrt
+
+    # Compute square root of self.
+    #
+    # This function is a overflow-checking variant of #sqrt.
+    # @return (see #sqrt)
+    #
+    define_unary_element_wise :sqrt_checked
+
     # Compute the tangent of self element-wise.
     #
     # NaN is returned for invalid input values.
@@ -398,6 +477,13 @@ module RedAmber
     #
     define_unary_element_wise :tan
 
+    # Compute the tangent of self element-wise.
+    #
+    # This function is a overflow-checking variant of #tan.
+    # @return (see #tan)
+    #
+    define_unary_element_wise :tan_checked
+
     # Compute the integral part
     #
     # Compute the nearest integer not greater in magnitude than each element.
@@ -432,5 +518,12 @@ module RedAmber
     #
     define_unary_element_wise :negate
     alias_method :'-@', :negate # rubocop:disable Lint/SymbolConversion
+
+    # Negate the argument element-wise
+    #
+    # This function is a overflow-checking variant of #negate.
+    # @return (see #negate)
+    #
+    define_unary_element_wise :negate_checked
   end
 end

data/lib/red_amber/version.rb

@@ -2,5 +2,5 @@
 
 module RedAmber
   # Library version
-  VERSION = '0.4.0'
+  VERSION = '0.4.2'
 end

data/red_amber.gemspec

@@ -11,13 +11,13 @@ Gem::Specification.new do |spec|
   spec.summary = 'Simple dataframe library for Ruby'
   spec.description = 'RedAmber is a simple dataframe library ' \
                      'inspired by Rover-df and powered by Red Arrow.'
-  spec.homepage = 'https://github.com/heronshoes/red_amber'
+  spec.homepage = 'https://github.com/red-data-tools/red_amber'
   spec.license = 'MIT'
   spec.required_ruby_version = '>= 3.0'
 
   spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = 'https://github.com/heronshoes/red_amber'
-  spec.metadata['changelog_uri'] = 'https://github.com/heronshoes/red_amber/blob/main/CHANGELOG.md'
+  spec.metadata['source_code_uri'] = 'https://github.com/red-data-tools/red_amber'
+  spec.metadata['changelog_uri'] = 'https://github.com/red-data-tools/red_amber/blob/main/CHANGELOG.md'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red_amber
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.2
 platform: ruby
 authors:
 - Hirokazu SUZUKI (heronshoes)
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-25 00:00:00.000000000 Z
+date: 2023-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: red-arrow
@@ -87,6 +87,15 @@ files:
 - doc/tdr.md
 - doc/tdr_ja.md
 - doc/yard-templates/default/fulldoc/html/css/common.css
+- docker/.env
+- docker/Dockerfile
+- docker/Gemfile
+- docker/Gemfile.lock
+- docker/docker-compose.yml
+- docker/example
+- docker/notebook/examples_of_red_amber.ipynb
+- docker/notebook/red-amber.ipynb
+- docker/readme.md
 - lib/red-amber.rb
 - lib/red_amber.rb
 - lib/red_amber/data_frame.rb
@@ -110,13 +119,13 @@ files:
 - lib/red_amber/version.rb
 - red_amber.gemspec
 - sig/red_amber.rbs
-homepage: https://github.com/heronshoes/red_amber
+homepage: https://github.com/red-data-tools/red_amber
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/heronshoes/red_amber
-  source_code_uri: https://github.com/heronshoes/red_amber
-  changelog_uri: https://github.com/heronshoes/red_amber/blob/main/CHANGELOG.md
+  homepage_uri: https://github.com/red-data-tools/red_amber
+  source_code_uri: https://github.com/red-data-tools/red_amber
+  changelog_uri: https://github.com/red-data-tools/red_amber/blob/main/CHANGELOG.md
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -133,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Simple dataframe library for Ruby