red_amber 0.1.6 → 0.1.7

data/doc/Vector.md

@@ -38,10 +38,11 @@ Class `RedAmber::Vector` represents a series of data in the DataFrame.
 
 ### `indices`, `indexes`, `indeces`
 
-  Return indices in an Array
+  Return indices in an Array.
 
 ### `to_ary`
-  Vector has `#to_ary`. It implicitly converts a Vector to an Array when required.
+
+  It implicitly converts a Vector to an Array when required.
 
   ```ruby
   [1, 2] + Vector.new([3, 4])
@@ -60,13 +61,9 @@ Class `RedAmber::Vector` represents a series of data in the DataFrame.
 
 ### `type_class`
 
-### [ ] `each` (not impremented yet)
-
-### [ ] `chunked?` (not impremented yet)
-
-### [ ] `n_chunks` (not impremented yet)
+### `each`
 
-### [ ] `each_chunk` (not impremented yet)
+  If block is not given, returns Enumerator.
 
 ### `n_nils`, `n_nans`
 
@@ -78,7 +75,7 @@ Class `RedAmber::Vector` represents a series of data in the DataFrame.
 
 ### `inspect(limit: 80)`
 
-  - `limit` sets size limit to display long array.
+  - `limit` sets size limit to display a long array.
 
     ```ruby
     vector = RedAmber::Vector.new((1..50).to_a)
@@ -167,9 +164,9 @@ double = RedAmber::Vector.new([1, 0/0.0, -1/0.0, 1/0.0, nil, ""])
 [1.0, NaN, -Infinity, Infinity, nil, 0.0]
 
 double.count #=> 5
-double.count(opts: {mode: :only_valid}) #=> 5, default
-double.count(opts: {mode: :only_null}) #=> 1
-double.count(opts: {mode: :all}) #=> 6
+double.count(mode: :only_valid) #=> 5, default
+double.count(mode: :only_null) #=> 1
+double.count(mode: :all) #=> 6
 
 boolean = RedAmber::Vector.new([true, true, nil])
 #=>
@@ -177,8 +174,8 @@ boolean = RedAmber::Vector.new([true, true, nil])
 [true, true, nil]
 
 boolean.all #=> true
-boolean.all(opts: {skip_nulls: true}) #=> true
-boolean.all(opts: {skip_nulls: false}) #=> false
+boolean.all(skip_nulls: true) #=> true
+boolean.all(skip_nulls: false) #=> false
 ```
 
 ### Unary element-wise: `vector.func => vector`
@@ -212,6 +209,37 @@ boolean.all(opts: {skip_nulls: false}) #=> false
 | ✓ `tan`      |     |  ✓  |     |     |       |
 | ✓ `trunc`    |     |  ✓  |     |     |       |
 
+Examples of options for `#round`;
+
+- `:n-digits` The number of digits to show.
+- `round_mode` Specify rounding mode.
+
+```ruby
+double = RedAmber::Vector.new([15.15, 2.5, 3.5, -4.5, -5.5])
+# => [15.15, 2.5, 3.5, -4.5, -5.5]
+double.round
+# => [15.0, 2.0, 4.0, -4.0, -6.0]
+double.round(mode: :half_to_even)
+# => Default. Same as double.round
+double.round(mode: :towards_infinity)
+# => [16.0, 3.0, 4.0, -5.0, -6.0]
+double.round(mode: :half_up)
+# => [15.0, 3.0, 4.0, -4.0, -5.0]
+double.round(mode: :half_towards_zero)
+# => [15.0, 2.0, 3.0, -4.0, -5.0]
+double.round(mode: :half_towards_infinity)
+# => [15.0, 3.0, 4.0, -5.0, -6.0]
+double.round(mode: :half_to_odd)
+# => [15.0, 3.0, 3.0, -5.0, -5.0]
+
+double.round(n_digits: 0)
+# => Default. Same as double.round
+double.round(n_digits: 1)
+# => [15.2, 2.5, 3.5, -4.5, -5.5]
+double.round(n_digits: -1)
+# => [20.0, 0.0, 0.0, -0.0, -10.0]
+```
+
 ### Binary element-wise: `vector.func(vector) => vector`
 
   ![binary element-wise](doc/image/../../image/vector/binary_element_wise.png)
@@ -286,7 +314,32 @@ boolean.all(opts: {skip_nulls: false}) #=> false
 ### [ ] (index functions)
 ### [ ] (other functions)
 
-## Coerce (not impremented)
+## Coerce
+
+```ruby
+vector = RedAmber::Vector.new(1,2,3)
+# => 
+#<RedAmber::Vector(:uint8, size=3):0x00000000000decc4>            
+[1, 2, 3]                                                         
+
+# Vector's `#*` method
+vector * -1
+# =>
+#<RedAmber::Vector(:int16, size=3):0x00000000000e3698>            
+[-1, -2, -3]                                                      
+
+# coerced calculation
+-1 * vector
+# => 
+#<RedAmber::Vector(:int16, size=3):0x00000000000ea4ac>            
+[-1, -2, -3]
+
+# `@-` operator
+-vector
+# =>
+#<RedAmber::Vector(:uint8, size=3):0x00000000000ee7b4>
+[255, 254, 253]
+```
 
 ## Update vector's value
 ### `replace(specifier, replacer)` => vector

data/lib/red-amber.rb

@@ -1,27 +1,3 @@
 # frozen_string_literal: true
 
-require 'arrow'
-require 'rover-df'
-
-require_relative 'red_amber/helper'
-require_relative 'red_amber/data_frame_displayable'
-require_relative 'red_amber/data_frame_indexable'
-require_relative 'red_amber/data_frame_selectable'
-require_relative 'red_amber/data_frame_observation_operation'
-require_relative 'red_amber/data_frame_variable_operation'
-require_relative 'red_amber/data_frame'
-require_relative 'red_amber/vector_functions'
-require_relative 'red_amber/vector_updatable'
-require_relative 'red_amber/vector_selectable'
-require_relative 'red_amber/vector'
-require_relative 'red_amber/version'
-
-module RedAmber
-  class Error < StandardError; end
-
-  class DataFrameArgumentError < ArgumentError; end
-  class DataFrameTypeError < TypeError; end
-
-  class VectorArgumentError < ArgumentError; end
-  class VectorTypeError < TypeError; end
-end
+require_relative 'red_amber'

data/lib/red_amber/data_frame.rb

@@ -8,7 +8,6 @@ module RedAmber
     include DataFrameDisplayable
     include DataFrameIndexable
     include DataFrameSelectable
-    include DataFrameObservationOperation
     include DataFrameVariableOperation
     include Helper
 
@@ -130,6 +129,7 @@ module RedAmber
     end
 
     def to_rover
+      require 'rover'
       Rover::DataFrame.new(to_h)
     end
 
@@ -137,15 +137,17 @@ module RedAmber
       require 'iruby'
       return ['text/plain', '(empty DataFrame)'] if empty?
 
-      if ENV.fetch('RED_AMBER_OUTPUT_MODE', 'tdr') == 'table'
-        ['text/html', html_table]
-      elsif size <= 5
-        ['text/plain', tdr_str(tally: 0)]
+      if ENV.fetch('RED_AMBER_OUTPUT_MODE', 'Table') == 'TDR'
+        size <= 5 ? ['text/plain', tdr_str(tally: 0)] : ['text/plain', tdr_str]
       else
-        ['text/plain', tdr_str]
+        ['text/html', html_table]
       end
     end
 
+    def group(*group_keys)
+      Group.new(self, group_keys)
+    end
+
     private
 
     # initialize @variable, @keys, @vectors and return one of them
@@ -178,7 +180,7 @@ module RedAmber
       end
 
       html = IRuby::HTML.table(converted.to_h, maxrows: 8, maxcols: 15)
-      "#{size} x #{n_keys} vector#{pl(n_keys)} ; #{html}"
+      "#{self.class} <#{size} x #{n_keys} vector#{pl(n_keys)}> #{html}"
     end
   end
 end

data/lib/red_amber/data_frame_displayable.rb

@@ -6,7 +6,9 @@ module RedAmber
   # mix-ins for the class DataFrame
   module DataFrameDisplayable
     def to_s
-      @table.to_s
+      return '' if empty?
+
+      format_table(width: 80)
     end
 
     # def describe() end
@@ -14,10 +16,10 @@ module RedAmber
     # def summary() end
 
     def inspect
-      if ENV.fetch('RED_AMBER_OUTPUT_MODE', 'tdr') == 'table'
-        "#<#{shape_str(with_id: true)}>\n#{self}"
-      else
+      if ENV.fetch('RED_AMBER_OUTPUT_MODE', 'Table') == 'TDR'
         "#<#{shape_str(with_id: true)}>\n#{dataframe_info(3)}"
+      else
+        "#<#{shape_str(with_id: true)}>\n#{self}"
       end
     end
 
@@ -128,5 +130,78 @@ module RedAmber
       a << "#{n_nil} nil#{pl(n_nil)}" unless n_nil.zero?
       a
     end
+
+    def format_table(width: 80)
+      head = 5
+      tail = 3
+      n_digit = 1
+
+      original = self
+      indices = size > head + tail ? [*0...head, *(size - tail)...size] : [*0...size]
+      df = slice(indices).assign do
+        assigner = { '': indices.map { |i| (i + 1).to_s } }
+        vectors.each_with_object(assigner) do |v, a|
+          a[v.key] = v.to_a.map do |e|
+            if e.nil?
+              '(nil)'
+            elsif v.float?
+              e.round(n_digit).to_s
+            elsif v.string?
+              e
+            else
+              e.to_s
+            end
+          end
+        end
+      end
+
+      df = df.pick { [keys[-1], keys[0..-2]] }
+      df = size > head + tail ? df[0, 0, 0...head, 0, -tail..-1] : df[0, 0, 0..-1]
+      df = df.assign do
+        vectors.each_with_object({}) do |v, assigner|
+          vec = v.replace(0, v.key.to_s)
+                 .replace(1, v.key == :'' ? '' : "<#{original[v.key].type}>")
+          assigner[v.key] = size > head + tail ? vec.replace(head + 2, ':') : vec
+        end
+      end
+
+      width_list = df.vectors.map { |v| v.to_a.map(&:length).max }
+      total_length = width_list[-1] # reserved for last column
+
+      formats = []
+      row_ellipsis = nil
+      df.vectors.each_with_index do |v, i|
+        w = width_list[i]
+        if total_length + w > width && i < df.n_keys - 1
+          row_ellipsis = i
+          formats << '%3s'
+          formats << format_for_column(df.vectors[-1], original, width_list[-1])
+          break
+        end
+        formats << format_for_column(v, original, w)
+        total_length += w
+      end
+      format_str = formats.join(' ')
+
+      str = StringIO.new
+      if row_ellipsis
+        df = df[df.keys[0..row_ellipsis], df.keys[-1]]
+        df = df.assign(df.keys[row_ellipsis] => ['...'] * df.size)
+      end
+
+      df.to_a.each do |row|
+        str.puts format(format_str, *row).rstrip
+      end
+
+      str.string
+    end
+
+    def format_for_column(vector, original, width)
+      if vector.key != :'' && !original[vector.key].numeric?
+        "%-#{width}s"
+      else
+        "%#{width}s"
+      end
+    end
   end
 end

data/lib/red_amber/group.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RedAmber
+  # group class
+  class Group
+    def initialize(dataframe, *group_keys)
+      @dataframe = dataframe
+      @table = @dataframe.table
+      @group_keys = group_keys.flatten
+
+      raise GroupArgumentError, 'group_keys is empty.' if @group_keys.empty?
+
+      d = @group_keys - @dataframe.keys
+      raise GroupArgumentError, "#{d} is not a key of\n #{@dataframe}." unless d.empty?
+
+      @group = @table.group(*@group_keys)
+    end
+
+    def count(*summary_keys)
+      by(:count, summary_keys)
+    end
+
+    def sum(*summary_keys)
+      by(:sum, summary_keys)
+    end
+
+    def product(*summary_keys)
+      by(:product, summary_keys)
+    end
+
+    def mean(*summary_keys)
+      by(:mean, summary_keys)
+    end
+
+    def min(*summary_keys)
+      by(:min, summary_keys)
+    end
+
+    def max(*summary_keys)
+      by(:max, summary_keys)
+    end
+
+    def stddev(*summary_keys)
+      by(:stddev, summary_keys)
+    end
+
+    def variance(*summary_keys)
+      by(:variance, summary_keys)
+    end
+
+    private
+
+    def by(func, summary_keys)
+      summary_keys = Array(summary_keys).flatten
+      d = summary_keys - @dataframe.keys
+      raise GroupArgumentError, "#{d} is not a key of\n #{@dataframe}." unless summary_keys.empty? || d.empty?
+
+      RedAmber::DataFrame.new(@group.send(func, *summary_keys))
+    end
+  end
+end

data/lib/red_amber/vector.rb

@@ -91,15 +91,23 @@ module RedAmber
     end
 
     def boolean?
-      type == :boolean
+      type_class == Arrow::BooleanDataType
     end
 
     def numeric?
       type_class < Arrow::NumericDataType
     end
 
+    def float?
+      type_class < Arrow::FloatingPointDataType
+    end
+
+    def integer?
+      type_class < Arrow::IntegerDataType
+    end
+
     def string?
-      type == :string
+      type_class == Arrow::StringDataType
     end
 
     def temporal?
@@ -110,7 +118,13 @@ module RedAmber
       @data.value_data_type.class
     end
 
-    # def each() end
+    def each
+      return enum_for(:each) unless block_given?
+
+      size.times do |i|
+        yield self[i]
+      end
+    end
 
     def chunked?
       @data.is_a? Arrow::ChunkedArray

data/lib/red_amber/vector_functions.rb

@@ -14,8 +14,8 @@ module RedAmber
     unary_aggregations =
       %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 |opts: nil|
-        datum = exec_func_unary(function, options: opts)
+      define_method(function) do |**options|
+        datum = exec_func_unary(function, options)
         get_scalar(datum)
       end
     end
@@ -25,12 +25,12 @@ module RedAmber
     alias_method :any?, :any
 
     def unbiased_variance
-      variance(opts: { ddof: 1 })
+      variance(ddof: 1)
     end
     alias_method :var, :unbiased_variance
 
     def sd
-      stddev(opts: { ddof: 1 })
+      stddev(ddof: 1)
     end
     alias_method :std, :sd
 
@@ -47,8 +47,8 @@ module RedAmber
       %i[abs 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 round round_to_multiple sign sin tan trunc unique]
     unary_element_wise.each do |function|
-      define_method(function) do |opts: nil|
-        datum = exec_func_unary(function, options: opts)
+      define_method(function) do |**options|
+        datum = exec_func_unary(function, options)
         Vector.new(datum.value)
       end
     end
@@ -72,13 +72,13 @@ module RedAmber
       negate: '-@',
     }
     unary_element_wise_op.each do |function, operator|
-      define_method(function) do |opts: nil|
-        datum = exec_func_unary(function, options: opts)
+      define_method(function) do |**options|
+        datum = exec_func_unary(function, options)
         Vector.new(datum.value)
       end
 
-      define_method(operator) do |opts: nil|
-        datum = exec_func_unary(function, options: opts)
+      define_method(operator) do |**options|
+        datum = exec_func_unary(function, options)
         Vector.new(datum.value)
       end
     end
@@ -95,8 +95,8 @@ module RedAmber
     binary_element_wise =
       %i[atan2 and_not and_not_kleene bit_wise_and bit_wise_or bit_wise_xor]
     binary_element_wise.each do |function|
-      define_method(function) do |other, opts: nil|
-        datum = exec_func_binary(function, other, options: opts)
+      define_method(function) do |other, **options|
+        datum = exec_func_binary(function, other, options)
         Vector.new(datum.value)
       end
     end
@@ -111,8 +111,8 @@ module RedAmber
       or_org: :or,
     }
     logical_binary_element_wise.each do |method, function|
-      define_method(method) do |other, opts: nil|
-        datum = exec_func_binary(function, other, options: opts)
+      define_method(method) do |other, **options|
+        datum = exec_func_binary(function, other, options)
         Vector.new(datum.value)
       end
     end
@@ -144,13 +144,13 @@ module RedAmber
       not_equal: '!=',
     }
     binary_element_wise_op.each do |function, operator|
-      define_method(function) do |other, opts: nil|
-        datum = exec_func_binary(function, other, options: opts)
+      define_method(function) do |other, **options|
+        datum = exec_func_binary(function, other, options)
         Vector.new(datum.value)
       end
 
-      define_method(operator) do |other, opts: nil|
-        datum = exec_func_binary(function, other, options: opts)
+      define_method(operator) do |other, **options|
+        datum = exec_func_binary(function, other, options)
         Vector.new(datum.value)
       end
     end
@@ -217,11 +217,13 @@ module RedAmber
 
     private # =======
 
-    def exec_func_unary(function, options: nil)
+    def exec_func_unary(function, options)
+      options = nil if options.empty?
       find(function).execute([data], options)
     end
 
-    def exec_func_binary(function, other, options: nil)
+    def exec_func_binary(function, other, options)
+      options = nil if options.empty?
       case other
       when Vector
         find(function).execute([data, other.data], options)

data/lib/red_amber/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RedAmber
-  VERSION = '0.1.6'
+  VERSION = '0.1.7'
 end

data/lib/red_amber.rb

@@ -1,3 +1,29 @@
 # frozen_string_literal: true
 
-require_relative 'red-amber'
+require 'arrow'
+require 'rover-df'
+
+require_relative 'red_amber/helper'
+require_relative 'red_amber/data_frame_displayable'
+require_relative 'red_amber/data_frame_indexable'
+require_relative 'red_amber/data_frame_selectable'
+require_relative 'red_amber/data_frame_variable_operation'
+require_relative 'red_amber/data_frame'
+require_relative 'red_amber/group'
+require_relative 'red_amber/vector_functions'
+require_relative 'red_amber/vector_updatable'
+require_relative 'red_amber/vector_selectable'
+require_relative 'red_amber/vector'
+require_relative 'red_amber/version'
+
+module RedAmber
+  class Error < StandardError; end
+
+  class DataFrameArgumentError < ArgumentError; end
+  class DataFrameTypeError < TypeError; end
+
+  class VectorArgumentError < ArgumentError; end
+  class VectorTypeError < TypeError; end
+
+  class GroupArgumentError < ArgumentError; end
+end

data/red_amber.gemspec

@@ -31,8 +31,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'red-arrow', '>= 8.0.0'
-  spec.add_dependency 'red-parquet', '>= 8.0.0'
-  spec.add_dependency 'rover-df', '~> 0.3.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.1.6
+  version: 0.1.7
 platform: ruby
 authors:
 - Hirokazu SUZUKI (heronshoes)
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-26 00:00:00.000000000 Z
+date: 2022-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: red-arrow
@@ -24,34 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 8.0.0
-- !ruby/object:Gem::Dependency
-  name: red-parquet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 8.0.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 8.0.0
-- !ruby/object:Gem::Dependency
-  name: rover-df
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.3.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.3.0
 description: RedAmber is a simple dataframe library inspired by Rover-df and powered
   by Red Arrow.
 email:
@@ -69,6 +41,7 @@ files:
 - Rakefile
 - benchmark/csv_load_penguins.yml
 - benchmark/drop_nil.yml
+- doc/47_examples_of_red_amber.ipynb
 - doc/CODE_OF_CONDUCT.md
 - doc/DataFrame.md
 - doc/Vector.md
@@ -95,9 +68,9 @@ files:
 - lib/red_amber/data_frame.rb
 - lib/red_amber/data_frame_displayable.rb
 - lib/red_amber/data_frame_indexable.rb
-- lib/red_amber/data_frame_observation_operation.rb
 - lib/red_amber/data_frame_selectable.rb
 - lib/red_amber/data_frame_variable_operation.rb
+- lib/red_amber/group.rb
 - lib/red_amber/helper.rb
 - lib/red_amber/vector.rb
 - lib/red_amber/vector_functions.rb

data/lib/red_amber/data_frame_observation_operation.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module RedAmber
-  # mix-ins for the class DataFrame
-  module DataFrameObservationOperation
-    def group(aggregating_keys, func, target_keys)
-      t = table.group(*aggregating_keys)
-      RedAmber::DataFrame.new(t.send(func, *target_keys))
-    end
-  end
-end