red_amber 0.4.2 → 0.5.0

data/lib/red_amber/vector_selectable.rb

@@ -153,10 +153,23 @@ module RedAmber
     # @param element
     #   an element of self.
     # @return [integer, nil]
-    #   founded position of element. If it is not found, returns nil.
+    #   position of element. If it is not found, returns nil.
     #
     def index(element)
-      (0...size).find { |i| self[i] == element }
+      if element.nil?
+        datum = find(:is_null).execute([data])
+        value = Arrow::Scalar.resolve(true, :boolean)
+      else
+        datum = data
+        value = Arrow::Scalar.resolve(element, type)
+      end
+      datum = find(:index).execute([datum], value: value)
+      index = get_scalar(datum)
+      if index.negative?
+        nil
+      else
+        index
+      end
     end
 
     # Returns first element of self.
@@ -229,15 +242,23 @@ module RedAmber
       take(sort_indices(order: order))
     end
 
-    # Returns numerical rank of self.
+    # Returns 0-based numerical rank of self.
     # - Nil values are considered greater than any value.
     # - NaN values are considered greater than any value but smaller than nil values.
-    # - Tiebreakers are ranked in order of appearance.
+    # - Tiebreakers are ranked in order of appearance by default or
+    #   with `tie: :first` option.
     # - `RankOptions` in C++ function is not implemented in C GLib yet.
     #   This method is currently fixed to the default behavior.
     #
+    # @param tie [:first, :min, :max, :dense]
+    #   configure how ties between equal values are handled.
+    #   - first: Ranks are assigned in order of when ties appear in the input.
+    #   - min: Ties get the smallest possible rank in the sorted order.
+    #   - max: Ties get the largest possible rank in the sorted order.
+    #   - dense: The ranks span a dense [1, M] interval where M is the number
+    #     of distinct values in the input.
     # @return [Vector]
-    #   0-based rank of self (0...size in range).
+    #   0-based rank in uint64 of self (0...size in range).
     # @example Rank of float Vector
     #   fv = Vector.new(0.1, nil, Float::NAN, 0.2, 0.1); fv
     #
@@ -245,7 +266,7 @@ module RedAmber
     #   #<RedAmber::Vector(:double, size=5):0x000000000000c65c>
     #   [0.1, nil, NaN, 0.2, 0.1]
     #
-    #   fv.rank
+    #   fv.rank # or fv.rank(tie: :first)
     #
     #   # =>
     #   #<RedAmber::Vector(:uint64, size=5):0x0000000000003868>
@@ -264,20 +285,42 @@ module RedAmber
     #   #<RedAmber::Vector(:uint64, size=5):0x0000000000003868>
     #   [0, 2, 4, 1, 3]
     #
+    # @example Rank of Float Vector with tie: :min
+    #   fv.rank(tie: :min)
+    #
+    #   # =>
+    #   #<RedAmber::Vector(:uint64, size=5):0x00000000001593ac>
+    #   [0, 3, 3, 2, 0]
+    #
+    # @example Rank of Float Vector with tie: :max
+    #   fv.rank(tie: :max)
+    #
+    #   # =>
+    #   #<RedAmber::Vector(:uint64, size=5):0x0000000000160d50>
+    #   [1, 4, 4, 2, 1]
+    #
+    # @example Rank of Float Vector with tie: :dense
+    #   fv.rank(tie: :dense)
+    #
+    #   # =>
+    #   #<RedAmber::Vector(:uint64, size=5):0x000000000016993c>
+    #   [0, 2, 2, 1, 0]
+    #
     # @since 0.4.0
     #
-    def rank
+    def rank(tie: :first)
       datum =
         case data
         when Arrow::ChunkedArray
-          Arrow::Function.find(:rank).execute([data.pack])
+          find(:rank).execute([data.pack], tiebreaker: tie)
         else
-          Arrow::Function.find(:rank).execute([data])
+          find(:rank).execute([data], tiebreaker: tie)
         end
-      Vector.create(datum.value) - 1
+      Vector.create(find(:subtract).execute([datum, 1]).value)
     end
 
     # Pick up elements at random.
+    # @note This method requires 'arrow-numo-narray' gem.
     #
     # @overload sample()
     #   Return a randomly selected element.
@@ -298,12 +341,12 @@ module RedAmber
     #     "C"
     #
     # @overload sample(n)
-    #   Pick up n elements at random.
+    #   Select n elements at random.
     #
     #   @param n [Integer]
-    #     positive number of elements to pick.
-    #     If n is smaller or equal to size, elements are picked by non-repeating.
-    #     If n is greater than `size`, elements are picked repeatedly.
+    #     positive number of elements to select.
+    #     If n is smaller or equal to size, elements are selected by non-repeating.
+    #     If n is greater than `size`, elements are selected repeatedly.
     #   @return [Vector]
     #     sampled elements.
     #     If n == 1 (in case of `sample(1)`), it returns a Vector of size == 1
@@ -315,7 +358,7 @@ module RedAmber
     #     #<RedAmber::Vector(:string, size=1):0x000000000001a3b0>
     #     ["H"]
     #
-    #   @example Sample same size of self: every element is picked in random order
+    #   @example Sample same size of self: every element is selected in random order
     #     v.sample(8)
     #
     #     # =>
@@ -330,18 +373,18 @@ module RedAmber
     #     ["E", "E", "A", "D", "H", "C", "A", "F", "H"]
     #
     # @overload sample(prop)
-    #   Pick up elements by proportion `prop` at random.
+    #   Select elements by proportion `prop` at random.
     #
     #   @param prop [Float]
-    #     positive proportion of elements to pick.
-    #     Absolute number of elements to pick:`prop*size` is rounded (by `half: :up``).
-    #     If prop is smaller or equal to 1.0, elements are picked by non-repeating.
-    #     If prop is greater than 1.0, some elements are picked repeatedly.
+    #     positive proportion of elements to select.
+    #     Absolute number of elements to select:`prop*size` is rounded (by `half: :up`).
+    #     If prop is smaller or equal to 1.0, elements are selected by non-repeating.
+    #     If prop is greater than 1.0, some elements are selected repeatedly.
     #   @return [Vector]
     #     sampled elements.
-    #     If picked element is only one, it returns a Vector of size == 1
+    #     If selected element is only one, it returns a Vector of size == 1
     #     not a scalar.
-    #   @example Sample same size of self: every element is picked in random order
+    #   @example Sample same size of self: every element is selected in random order
     #     v.sample(1.0)
     #
     #     # =>
@@ -355,6 +398,14 @@ module RedAmber
     #     #<RedAmber::Vector(:string, size=16):0x00000000000233e8>
     #     ["H", "B", "C", "B", "C", "A", "F", "A", "E", "C", "H", "F", "F", "A", ... ]
     #
+    #   @example prop less than 1.0
+    #     v.sample(0.7)
+    #
+    #     # =>
+    #     # Take (8 * 0.7).truncate => 5 samples
+    #     #<RedAmber::Vector(:string, size=5):0x000000000001afe0>
+    #     ["C", "A", "E", "H", "D"]
+    #
     # @since 0.4.0
     #
     def sample(n_or_prop = nil)
@@ -367,7 +418,7 @@ module RedAmber
         in Integer
           n_or_prop
         in Float
-          (n_or_prop * size).round
+          (n_or_prop * size).truncate
         in nil
           return to_a.sample
         else

data/lib/red_amber/vector_string_function.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module RedAmber
+  # Mix-in for class Vector
+  #   Methods for string-like related function
+  module VectorStringFunction
+    using RefineArray
+    using RefineArrayLike
+
+    # For each string in self, emit true if it contains a given pattern.
+    #
+    # @overload match_substring?(string, ignore_case: nil)
+    #   Emit true if it contains `string`.
+    #
+    #   @param string [String]
+    #     string pattern to match.
+    #   @param ignore_case [boolean]
+    #     switch whether to ignore case. Ignore case if true.
+    #   @return [Vector]
+    #     boolean Vector to show if elements contain a given pattern.
+    #     nil inputs emit nil.
+    #   @example Match with string.
+    #     vector = Vector.new('array', 'Arrow', 'carrot', nil, 'window')
+    #     vector.match_substring?('arr')
+    #     # =>
+    #     #<RedAmber::Vector(:boolean, size=5):0x000000000005a208>
+    #     [true, false, true, nil, false]
+    #
+    # @overload match_substring?(regexp, ignore_case: nil)
+    #   Emit true if it contains substring matching with `regexp`.
+    #   It calls `match_substring_regex` in Arrow compute function and
+    #   uses re2 library.
+    #
+    #   @param regexp [Regexp]
+    #     regular expression pattern to match. Ruby's Regexp is given and
+    #     it will passed to Arrow's kernel by its source.
+    #   @param ignore_case [boolean]
+    #     switch whether to ignore case. Ignore case if true.
+    #     When `ignore_case` is false, casefolding option in regexp is priortized.
+    #   @return [Vector]
+    #     boolean Vector to show if elements contain a given pattern.
+    #     nil inputs emit nil.
+    #   @example Match with regexp.
+    #     vector.match_substring?(/arr/)
+    #     # =>
+    #     #<RedAmber::Vector(:boolean, size=5):0x0000000000014b68>
+    #     [true, false, true, nil, false]
+    #
+    # @since 0.5.0
+    #
+    def match_substring?(pattern, ignore_case: nil)
+      options = Arrow::MatchSubstringOptions.new
+      datum =
+        case pattern
+        when String
+          options.ignore_case = (ignore_case || false)
+          options.pattern = pattern
+          find(:match_substring).execute([data], options)
+        when Regexp
+          options.ignore_case = (pattern.casefold? || ignore_case || false)
+          options.pattern = pattern.source
+          find(:match_substring_regex).execute([data], options)
+        else
+          message =
+            "pattern must be either String or Regexp: #{pattern.inspect}"
+          raise VectorArgumentError, message
+        end
+      Vector.create(datum.value)
+    end
+
+    # Check if elements in self end with a literal pattern.
+    #
+    # @param string [String]
+    #   string pattern to match.
+    # @param ignore_case [boolean]
+    #   switch whether to ignore case. Ignore case if true.
+    # @return [Vector]
+    #   boolean Vector to show if elements end with a given pattern.
+    #   nil inputs emit nil.
+    # @example Check if end with?.
+    #   vector = Vector.new('array', 'Arrow', 'carrot', nil, 'window')
+    #   vector.end_with?('ow')
+    #   # =>
+    #   #<RedAmber::Vector(:boolean, size=5):0x00000000000108ec>
+    #   [false, true, false, nil, true]
+    # @since 0.5.0
+    #
+    def end_with?(string, ignore_case: nil)
+      options = Arrow::MatchSubstringOptions.new
+      options.ignore_case = (ignore_case || false)
+      options.pattern = string
+      datum = find(:ends_with).execute([data], options)
+      Vector.create(datum.value)
+    end
+
+    # Check if elements in self start with a literal pattern.
+    #
+    # @param string [String]
+    #   string pattern to match.
+    # @param ignore_case [boolean]
+    #   switch whether to ignore case. Ignore case if true.
+    # @return [Vector]
+    #   boolean Vector to show if elements start with a given pattern.
+    #   nil inputs emit nil.
+    # @example Check if start with?.
+    #   vector = Vector.new('array', 'Arrow', 'carrot', nil, 'window')
+    #   vector.start_with?('ow')
+    #   # =>
+    #   #<RedAmber::Vector(:boolean, size=5):0x00000000000193fc>
+    #   [false, false, true, nil, false]
+    # @since 0.5.0
+    #
+    def start_with?(string, ignore_case: nil)
+      options = Arrow::MatchSubstringOptions.new
+      options.ignore_case = (ignore_case || false)
+      options.pattern = string
+      datum = find(:starts_with).execute([data], options)
+      Vector.create(datum.value)
+    end
+
+    # Match elements of self against SQL-style LIKE pattern.
+    #   the pattern matches a given pattern at any position.
+    #   '%' will match any number of characters,
+    #   '_' will match exactly one character,
+    #   and any other character matches itself.
+    #   To match a literal '%', '_', or '\', precede the character with a backslash.
+    #
+    # @param string [String]
+    #   string pattern to match.
+    # @param ignore_case [boolean]
+    #   switch whether to ignore case. Ignore case if true.
+    # @return [Vector]
+    #   boolean Vector to show if elements start with a given pattern.
+    #   nil inputs emit nil.
+    # @example Check with match_like?.
+    #   vector = Vector.new('array', 'Arrow', 'carrot', nil, 'window')
+    #   vector.match_like?('_rr%')
+    #   # =>
+    # @since 0.5.0
+    #
+    def match_like?(string, ignore_case: nil)
+      options = Arrow::MatchSubstringOptions.new
+      options.ignore_case = (ignore_case || false)
+      options.pattern = string
+      datum = find(:match_like).execute([data], options)
+      Vector.create(datum.value)
+    end
+
+    # For each string in self, count occuerences of substring in given pattern.
+    #
+    # @overload count_substring(string, ignore_case: nil)
+    #   Count if it contains `string`.
+    #
+    #   @param string [String]
+    #     string pattern to count.
+    #   @param ignore_case [boolean]
+    #     switch whether to ignore case. Ignore case if true.
+    #   @return [Vector]
+    #     int32 or int64 Vector to show if elements contain a given pattern.
+    #     nil inputs emit nil.
+    #   @example Count with string.
+    #     vector2 = Vector.new('amber', 'Amazon', 'banana', nil)
+    #     vector2.count_substring('an')
+    #     # =>
+    #     #<RedAmber::Vector(:int32, size=4):0x000000000003db30>
+    #     [0, 0, 2, nil]
+    #
+    # @overload count_substring(regexp, ignore_case: nil)
+    #   Count if it contains substring matching with `regexp`.
+    #   It calls `count_substring_regex` in Arrow compute function and
+    #   uses re2 library.
+    #
+    #   @param regexp [Regexp]
+    #     regular expression pattern to count. Ruby's Regexp is given and
+    #     it will passed to Arrow's kernel by its source.
+    #   @param ignore_case [boolean]
+    #     switch whether to ignore case. Ignore case if true.
+    #     When `ignore_case` is false, casefolding option in regexp is priortized.
+    #   @return [Vector]
+    #     int32 or int64 Vector to show the counts in given pattern.
+    #     nil inputs emit nil.
+    #   @example Count with regexp with case ignored.
+    #     vector2.count_substring(/a[mn]/i)
+    #     # =>
+    #     #<RedAmber::Vector(:int32, size=4):0x0000000000051298>
+    #     [1, 1, 2, nil]
+    #     # it is same result as `vector2.count_substring(/a[mn]/, ignore_case: true)`
+    #
+    # @since 0.5.0
+    #
+    def count_substring(pattern, ignore_case: nil)
+      options = Arrow::MatchSubstringOptions.new
+      datum =
+        case pattern
+        when String
+          options.ignore_case = (ignore_case || false)
+          options.pattern = pattern
+          find(:count_substring).execute([data], options)
+        when Regexp
+          options.ignore_case = (pattern.casefold? || ignore_case || false)
+          options.pattern = pattern.source
+          find(:count_substring_regex).execute([data], options)
+        else
+          message =
+            "pattern must be either String or Regexp: #{pattern.inspect}"
+          raise VectorArgumentError, message
+        end
+      Vector.create(datum.value)
+    end
+  end
+end

data/lib/red_amber/vector_unary_element_wise.rb

@@ -184,6 +184,8 @@ module RedAmber
     #
     # Propagate next valid value backward to previous nil values.
     # Or nothing if all next values are nil.
+    # @note Use `fill_nil(value)` to replace nil by a value.
+    # @see #fill_nil
     # @return [Vector]
     #   a Vector which filled nil backward.
     # @example
@@ -201,6 +203,8 @@ module RedAmber
     #
     # Propagate last valid value backward to next nil values.
     # Or nothing if all previous values are nil.
+    # @note Use `fill_nil(value)` to replace nil by a value.
+    # @see #fill_nil
     # @return [Vector]
     #   a Vector which filled nil forward.
     # @example

data/lib/red_amber/vector_updatable.rb

@@ -149,6 +149,22 @@ module RedAmber
       replace_with(booleans.data, replacer_array)
     end
 
+    # Replace nil to value.
+    #
+    # @note Use `fill_nil_backawrd` or `fill_nil_forward` to replace nil
+    #   by adjacent values.
+    # @see #fill_nil_backward
+    # @see #fill_nil_forward
+    # @param value [scalar]
+    #   the value to replace with.
+    # @return [Vector]
+    #   replaced Vector
+    # @since 0.5.0
+    #
+    def fill_nil(value)
+      is_nil.if_else(value, self)
+    end
+
     # Choose values based on self.
     #
     # [Ternary element-wise function] Returns a Vector.
@@ -449,6 +465,18 @@ module RedAmber
     end
     alias_method :concat, :concatenate
 
+    # Cast self to `type`.
+    #
+    # @param type [symbol]
+    #   type to cast.
+    # @return [Vector]
+    #   casted Vector.
+    # @since 0.5.0
+    #
+    def cast(type)
+      Vector.create(data.cast(type))
+    end
+
     private
 
     # Replace elements selected with a boolean mask

data/lib/red_amber/version.rb

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

data/lib/red_amber.rb

@@ -17,9 +17,10 @@ require_relative 'red_amber/group'
 require_relative 'red_amber/subframes'
 require_relative 'red_amber/vector_aggregation'
 require_relative 'red_amber/vector_binary_element_wise'
+require_relative 'red_amber/vector_selectable'
+require_relative 'red_amber/vector_string_function'
 require_relative 'red_amber/vector_unary_element_wise'
 require_relative 'red_amber/vector_updatable'
-require_relative 'red_amber/vector_selectable'
 require_relative 'red_amber/vector'
 require_relative 'red_amber/version'
 

data/red_amber.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'red-arrow', '~> 11.0.0'
+  spec.add_dependency 'red-arrow', '~> 12.0.0'
 
   # Development dependency has gone to the Gemfile (rubygems/bundler#7237)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: red_amber
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Hirokazu SUZUKI (heronshoes)
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-04-02 00:00:00.000000000 Z
+date: 2023-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: red-arrow
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 11.0.0
+        version: 12.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 11.0.0
+        version: 12.0.0
 description: RedAmber is a simple dataframe library inspired by Rover-df and powered
   by Red Arrow.
 email:
@@ -38,6 +38,7 @@ files:
 - CHANGELOG.md
 - Gemfile
 - LICENSE
+- README.ja.md
 - README.md
 - Rakefile
 - benchmark/basic.yml
@@ -114,6 +115,7 @@ files:
 - lib/red_amber/vector_aggregation.rb
 - lib/red_amber/vector_binary_element_wise.rb
 - lib/red_amber/vector_selectable.rb
+- lib/red_amber/vector_string_function.rb
 - lib/red_amber/vector_unary_element_wise.rb
 - lib/red_amber/vector_updatable.rb
 - lib/red_amber/version.rb
@@ -142,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.4.12
 signing_key:
 specification_version: 4
 summary: Simple dataframe library for Ruby