red_amber 0.4.2 → 0.5.1

data/lib/red_amber/vector_string_function.rb

@@ -0,0 +1,279 @@
+# 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
+    alias_method :match_substring?, :match_substring
+
+    # 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
+    alias_method :end_with?, :end_with
+
+    # 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('arr')
+    #   # =>
+    #   #<RedAmber::Vector(:boolean, size=5):0x00000000000193fc>
+    #   [true, false, false, 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
+    alias_method :start_with?, :start_with
+
+    # 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
+    alias_method :match_like?, :match_like
+
+    # 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
+
+    # Find first occurrence of substring in string Vector.
+    #
+    # @overload find_substring(string, ignore_case: nil)
+    #   Emit the index in bytes of the first occurrence of the given
+    #     literal pattern, or -1 if not found.
+    #
+    #   @param string [String]
+    #     string pattern to match.
+    #   @param ignore_case [boolean]
+    #     switch whether to ignore case. Ignore case if true.
+    #   @return [Vector]
+    #     index Vector of occurences.
+    #     nil inputs emit nil.
+    #   @example Match with string.
+    #     vector = Vector['array', 'Arrow', 'carrot', nil, 'window']
+    #     vector.find_substring('arr')
+    #     # =>
+    #     #<RedAmber::Vector(:boolean, size=5):0x00000000000161e8>
+    #     [0, -1, 1, nil, -1]
+    #
+    # @overload find_substring(regexp, ignore_case: nil)
+    #   Emit the index in bytes of the first occurrence of the given
+    #     regexp pattern, or -1 if not found.
+    #   It calls `find_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]
+    #     index Vector of occurences.
+    #     nil inputs emit nil.
+    #   @example Match with regexp.
+    #     vector.find_substring(/arr/i)
+    #     # or vector.find_substring(/arr/, ignore_case: true)
+    #     # =>
+    #     #<RedAmber::Vector(:boolean, size=5):0x000000000001b74c>
+    #     [0, 0, 1, nil, -1]
+    #
+    # @since 0.5.1
+    #
+    def find_substring(pattern, ignore_case: nil)
+      options = Arrow::MatchSubstringOptions.new
+      datum =
+        case pattern
+        when String
+          options.ignore_case = (ignore_case || false)
+          options.pattern = pattern
+          find(:find_substring).execute([data], options)
+        when Regexp
+          options.ignore_case = (pattern.casefold? || ignore_case || false)
+          options.pattern = pattern.source
+          find(:find_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.1'
 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

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors = ['Hirokazu SUZUKI (heronshoes)']
   spec.email = ['heronshoes877@gmail.com']
 
-  spec.summary = 'Simple dataframe library for Ruby'
-  spec.description = 'RedAmber is a simple dataframe library ' \
+  spec.summary = 'A data frame library for Rubyists'
+  spec.description = 'RedAmber is a data frame library ' \
                      'inspired by Rover-df and powered by Red Arrow.'
   spec.homepage = 'https://github.com/red-data-tools/red_amber'
   spec.license = 'MIT'
@@ -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.1
 platform: ruby
 authors:
 - Hirokazu SUZUKI (heronshoes)
-autorequire:
+autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-04-02 00:00:00.000000000 Z
+date: 2023-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: red-arrow
@@ -16,28 +16,32 @@ 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
-description: RedAmber is a simple dataframe library inspired by Rover-df and powered
-  by Red Arrow.
+        version: 12.0.0
+description: RedAmber is a data frame library inspired by Rover-df and powered by
+  Red Arrow.
 email:
 - heronshoes877@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".devcontainer/Dockerfile"
+- ".devcontainer/devcontainer.json"
+- ".devcontainer/onCreateCommand.sh"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
 - ".yardopts"
 - CHANGELOG.md
 - Gemfile
 - LICENSE
+- README.ja.md
 - README.md
 - Rakefile
 - benchmark/basic.yml
@@ -55,6 +59,8 @@ files:
 - doc/CODE_OF_CONDUCT.md
 - doc/DataFrame.md
 - doc/DataFrame_Comparison.md
+- doc/Dev_Containers.ja.md
+- doc/Dev_Containers.md
 - doc/SubFrames.md
 - doc/Vector.md
 - doc/image/arrow_table_new.png
@@ -84,17 +90,15 @@ files:
 - doc/image/vector/unary_aggregation.png
 - doc/image/vector/unary_aggregation_w_option.png
 - doc/image/vector/unary_element_wise.png
+- doc/qmd/examples_of_red_amber.qmd
+- doc/qmd/red-amber.qmd
 - 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
@@ -114,6 +118,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
@@ -127,7 +132,7 @@ metadata:
   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:
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -143,7 +148,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.4.10
-signing_key:
+signing_key: 
 specification_version: 4
-summary: Simple dataframe library for Ruby
+summary: A data frame library for Rubyists
 test_files: []

data/docker/Gemfile.lock

@@ -1,80 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    benchmark-ips (2.12.0)
-    benchmark_driver (0.16.3)
-    bigdecimal (3.1.4)
-    concurrent-ruby (1.2.2)
-    csv (3.2.6)
-    extpp (0.1.1)
-    faker (3.1.1)
-      i18n (>= 1.8.11, < 2)
-    fiddle (1.1.1)
-    gio2 (4.1.2)
-      fiddle
-      gobject-introspection (= 4.1.2)
-    glib2 (4.1.2)
-      native-package-installer (>= 1.0.3)
-      pkg-config (>= 1.3.5)
-    gobject-introspection (4.1.2)
-      glib2 (= 4.1.2)
-    i18n (1.12.0)
-      concurrent-ruby (~> 1.0)
-    io-console (0.6.0)
-    irb (1.6.3)
-      reline (>= 0.3.0)
-    libui (0.0.15)
-    native-package-installer (1.1.5)
-    numo-narray (0.9.2.1)
-    pkg-config (1.5.1)
-    red-amber-view (0.0.1)
-      libui
-      red-arrow
-      red_amber
-    red-arrow (11.0.0)
-      bigdecimal (>= 3.1.0)
-      extpp (>= 0.1.1)
-      gio2 (>= 3.5.0)
-      native-package-installer
-      pkg-config
-    red-arrow-numo-narray (0.0.6)
-      numo-narray
-      red-arrow
-    red-datasets (0.1.5)
-      csv (>= 3.2.4)
-      rexml
-      rubyzip
-    red-datasets-arrow (0.0.3)
-      red-arrow
-      red-datasets (>= 0.0.3)
-    red-parquet (11.0.0)
-      red-arrow (= 11.0.0)
-    red_amber (0.4.1)
-      red-arrow (~> 11.0.0)
-    reline (0.3.2)
-      io-console (~> 0.5)
-    rexml (3.2.5)
-    rover-df (0.3.4)
-      numo-narray (>= 0.9.1.9)
-    rubyzip (2.3.2)
-
-PLATFORMS
-  x86_64-linux
-
-DEPENDENCIES
-  benchmark-ips
-  benchmark_driver
-  faker
-  irb
-  numo-narray
-  red-amber-view
-  red-arrow (~> 11.0.0)
-  red-arrow-numo-narray
-  red-datasets
-  red-datasets-arrow
-  red-parquet (~> 11.0.0)
-  red_amber (>= 0.4.1)
-  rover-df
-
-BUNDLED WITH
-   2.4.8

data/docker/example

@@ -1,74 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-$stderr.print "starting.\r"
-
-require 'bundler/setup'
-
-$stderr.print "starting..\r"
-require 'red_amber'
-include RedAmber
-
-$stderr.print "starting...\r"
-require 'datasets-arrow'
-
-$stderr.print "reading penguins...\r"
-penguins = DataFrame.new(Datasets::Penguins.new)
-
-$stderr.print "reading diamonds...\r"
-diamonds = DataFrame.new(Datasets::Diamonds.new)
-
-$stderr.print "reading starwars...\r"
-starwars = DataFrame.new(Datasets::Rdataset.new('dplyr', 'starwars'))
-
-$stderr.print "reading openintro/simpsons_paradox_covid...\r"
-ds = Datasets::Rdataset.new('openintro', 'simpsons_paradox_covid')
-simpsons_paradox_covid = DataFrame.new(ds.to_arrow)
-
-$stderr.print "reading mtcars...                          \r"
-mtcars = DataFrame.new(Datasets::Rdatasets.new('datasets', 'mtcars'))
-
-$stderr.print "reading iris...  \r"
-iris = DataFrame.new(Datasets::Iris.new)
-
-$stderr.print "reading band_members...\r"
-band_members = DataFrame.new(Datasets::Rdatasets.new('dplyr', 'band_members'))
-
-$stderr.print "reading band_instruments...\r"
-band_instruments = DataFrame.new(Datasets::Rdatasets.new('dplyr', 'band_instruments'))
-
-$stderr.print "reading band_instruments2...\r"
-band_instruments2 = DataFrame.new(Datasets::Rdatasets.new('dplyr', 'band_instruments2'))
-
-$stderr.print "reading import_cars...      \r"
-import_cars = DataFrame.load(Arrow::Buffer.new(<<~TSV), format: :tsv)
-  Year	Audi	BMW	BMW_MINI	Mercedes-Benz	VW
-  2017	28336	52527	25427	68221	49040
-  2018	26473	50982	25984	67554	51961
-  2019	24222	46814	23813	66553	46794
-  2020	22304	35712	20196	57041	36576
-  2021	22535	35905	18211	51722	35215
-TSV
-
-$stderr.print "reading comecome...   \r"
-comecome = DataFrame.load(Arrow::Buffer.new(<<~CSV), format: :csv)
-  name,age
-  Yasuko,68
-  Rui,49
-  Hinata,28
-CSV
-
-$stderr.print "reading general dataframe and subframes...\r"
-dataframe = DataFrame.new(
-  x: [*1..6],
-  y: %w[A A B B B C],
-  z: [false, true, false, nil, true, false]
-)
-subframes = SubFrames.new(dataframe, [[0, 1], [2, 3, 4], [5]])
-
-# Welcome to RedAmber example!
-# This environment will offer these pre-loaded datasets:
-#   penguins, diamonds, iris, starwars, simpsons_paradox_covid,
-#   mtcars, band_members, band_instruments, band_instruments2
-#   (original) import_cars, comecome, dataframe, subframes
-binding.irb