red_amber 0.4.0 → 0.4.1

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,52 @@ 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 :div, :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-other*(self/other).floor`.
+    # @param other [Vector, numeric]
+    #   other numeric Vector or numeric scalar.
+    # @return [Vector]
+    #   modulo of dividing self by other.
+    #
+    def modulo(other)
+      other = other.data if other.is_a?(Vector)
+      d = find(:divide).execute([data, other])
+      d = find(:floor).execute([d]) if d.value.is_a?(Arrow::DoubleArray)
+      m = find(:multiply).execute([d, other])
+      datum = find(:subtract).execute([data, m])
+      Vector.create(datum.value)
+    end
+    alias_method :mod, :modulo
+    alias_method :'%', :modulo
+
+    # Returns element-wise modulo.
+    #
+    # This function is a overflow-checking variant of #modulo.
+    # @return (see #modulo)
+    #
+    def modulo_checked(other)
+      other = other.data if other.is_a?(Vector)
+      d = find(:divide_checked).execute([data, other])
+      d = find(:floor).execute([d]) if d.value.is_a?(Arrow::DoubleArray)
+      m = find(:multiply_checked).execute([d, other])
+      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 +289,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 +311,42 @@ 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 other [Vector, numeric]
+    #   other numeric Vector or numeric scalar.
+    # @return [Vector]
+    #   quotient of dividing self by other.
+    #
+    def quotient(other)
+      other = other.data if other.is_a?(Vector)
+      datum = find(:divide).execute([Arrow::DoubleArray.new(data), other])
+      Vector.create(datum.value)
+    end
+    alias_method :quo, :quotient
+    alias_method :fdiv, :quotient
+
+    # Returns element-wise quotient by double Vector.
+    #
+    # This function is a overflow-checking variant of #quotient.
+    # @return (see #quotient)
+    #
+    def quotient_checked(other)
+      other = other.data if other.is_a?(Vector)
+      datum = find(:divide_checked).execute([Arrow::DoubleArray.new(data), other])
+      Vector.create(datum.value)
+    end
+
     # Subtract the arguments element-wise.
     #
     # Results will wrap around on integer overflow.
@@ -260,8 +357,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 +383,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 +404,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.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red_amber
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Hirokazu SUZUKI (heronshoes)
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-25 00:00:00.000000000 Z
+date: 2023-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: red-arrow
@@ -133,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: Simple dataframe library for Ruby