red_amber 0.1.5 → 0.1.6

data/doc/Vector.md

@@ -18,6 +18,13 @@ Class `RedAmber::Vector` represents a series of data in the DataFrame.
 
   ```ruby
   vector = RedAmber::Vector.new([1, 2, 3])
+  # or
+  vector = RedAmber::Vector.new(1, 2, 3)
+  # or
+  vector = RedAmber::Vector.new(1..3)
+  # or
+  vector = RedAmber::Vector.new(Arrow::Array([1, 2, 3])
+
   # =>
   #<RedAmber::Vector(:uint8, size=3):0x000000000000f514>
   [1, 2, 3]
@@ -29,8 +36,24 @@ Class `RedAmber::Vector` represents a series of data in the DataFrame.
 
 ### `values`, `to_a`, `entries`
 
+### `indices`, `indexes`, `indeces`
+
+  Return indices in an Array
+
+### `to_ary`
+  Vector has `#to_ary`. It implicitly converts a Vector to an Array when required.
+
+  ```ruby
+  [1, 2] + Vector.new([3, 4])
+
+  # =>
+  [1, 2, 3, 4]
+  ```
+
 ### `size`, `length`, `n_rows`, `nrow`
 
+### `empty?`
+
 ### `type`
 
 ### `boolean?`, `numeric?`, `string?`, `temporal?`
@@ -49,6 +72,10 @@ Class `RedAmber::Vector` represents a series of data in the DataFrame.
 
   - `n_nulls` is an alias of `n_nils`
 
+### `has_nil?`
+
+  Returns `true` if self has any `nil`. Otherwise returns `false`.
+
 ### `inspect(limit: 80)`
 
   - `limit` sets size limit to display long array.
@@ -60,6 +87,47 @@ Class `RedAmber::Vector` represents a series of data in the DataFrame.
     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, ... ]
     ```
 
+## Selecting Values
+
+### `take(indices)`, `[](indices)`
+
+- Acceptable class for indices:
+  - Integer, Float
+  - Vector of integer or float
+  - Arrow::Arry of integer or float
+- Negative index is also OK like the Ruby's primitive Array.
+
+```ruby
+array = RedAmber::Vector.new(%w[A B C D E])
+indices = RedAmber::Vector.new([0.1, -0.5, -5.1])
+array.take(indices)
+# or
+array[indices]
+
+# =>
+#<RedAmber::Vector(:string, size=3):0x000000000000f820>
+["A", "E", "A"]
+```
+
+### `filter(booleans)`, `[](booleans)`
+
+- Acceptable class for booleans:
+  - An array of true, false, or nil
+  - Boolean Vector
+  - Arrow::BooleanArray
+
+```ruby
+array = RedAmber::Vector.new(%w[A B C D E])
+booleans = [true, false, nil, false, true]
+array.filter(booleans)
+# or
+array[booleans]
+
+# =>
+#<RedAmber::Vector(:string, size=2):0x000000000000f21c>
+["A", "E"]
+```
+
 ## Functions
 
 ### Unary aggregations: `vector.func => scalar`
@@ -68,8 +136,8 @@ Class `RedAmber::Vector` represents a series of data in the DataFrame.
 
 | Method    |Boolean|Numeric|String|Options|Remarks|
 | ----------- | --- | --- | --- | --- | --- |
-| ✓ `all`     |  ✓  |     |     | ✓ ScalarAggregate|     |
-| ✓ `any`     |  ✓  |     |     | ✓ ScalarAggregate|     |
+| ✓ `all?`     |  ✓  |     |     | ✓ ScalarAggregate| alias `all` |
+| ✓ `any?`     |  ✓  |     |     | ✓ ScalarAggregate| alias `any` |
 | ✓ `approximate_median`|  |✓|  | ✓ ScalarAggregate| alias `median`|
 | ✓ `count`   |  ✓  |  ✓  |  ✓  | ✓  Count  |     |
 | ✓ `count_distinct`| ✓ | ✓ | ✓ | ✓  Count  |alias `count_uniq`|
@@ -203,6 +271,9 @@ boolean.all(opts: {skip_nulls: false}) #=> false
   vector.tally #=> {NaN=>2}
   vector.value_counts #=> {NaN=>2}
   ```
+### `index(element)`
+
+  Returns index of specified element.
 
 ### `sort_indexes`, `sort_indices`, `array_sort_indices`
 
@@ -218,39 +289,40 @@ boolean.all(opts: {skip_nulls: false}) #=> false
 ## Coerce (not impremented)
 
 ## Update vector's value
-### `replace_with(booleans, replacements)` => vector
+### `replace(specifier, replacer)` => vector
 
-- Accepts Vector, Array, Arrow::Array for booleans and replacements.
-  - Replacements can accept scalar
-- Booleans specifies the position of replacement in true.
-- Replacements specifies the vaues to be replaced.
-  - The number of true in booleans must be equal to the length of replacement
+- Accepts Scalar, Range  of Integer, Vector, Array, Arrow::Array as a specifier
+- Accepts Scalar, Vector, Array and Arrow::Array as a replacer.
+- Boolean specifiers specify the position of replacer in true.
+- Index specifiers specify the position of replacer in indices.
+- replacer specifies the values to be replaced.
+  - The number of true in booleans must be equal to the length of replacer
 
 ```ruby
 vector = RedAmber::Vector.new([1, 2, 3])
 booleans = [true, false, true]
-replacemants = [4, 5]
-vector.replace_with(booleans, replacemants)
+replacer = [4, 5]
+vector.replace(booleans, replacer)
 # => 
 #<RedAmber::Vector(:uint8, size=3):0x000000000001ee10>
 [4, 2, 5] 
 ```
 
-- Scalar value in replacements can be broadcasted.
+- Scalar value in replacer can be broadcasted.
 
 ```ruby
-replacemant = 0
-vector.replace_with(booleans, replacement)
+replacer = 0
+vector.replace(booleans, replacer)
 # => 
 #<RedAmber::Vector(:uint8, size=3):0x000000000001ee10>
 [0, 2, 0] 
 ```
 
-- Returned data type is automatically up-casted by replacement.
+- Returned data type is automatically up-casted by replacer.
 
 ```ruby
-replacement = 1.0
-vector.replace_with(booleans, replacement)
+replacer = 1.0
+vector.replace(booleans, replacer)
 # => 
 #<RedAmber::Vector(:double, size=3):0x0000000000025d78>
 [1.0, 2.0, 1.0]
@@ -260,29 +332,29 @@ vector.replace_with(booleans, replacement)
 
 ```ruby
 booleans = [true, false, nil]
-replacemant = -1
-vec.replace_with(booleans, replacement)
+replacer = -1
+vec.replace(booleans, replacer)
 => 
 #<RedAmber::Vector(:int8, size=3):0x00000000000304d0>
 [-1, 2, nil]
 ```
 
-- Replacemants can have nil in it.
+- replacer can have nil in it.
 
 ```ruby
 booleans = [true, false, true]
-replacemants = [nil]
-vec.replace_with(booleans, replacemants)
+replacer = [nil]
+vec.replace(booleans, replacer)
 => 
 #<RedAmber::Vector(:int8, size=3):0x00000000000304d0>
 [nil, 2, nil]
 ```
 
-- If no replacemants specified, it is same as to specify nil.
+- If no replacer specified, it is same as to specify nil.
 
 ```ruby
 booleans = [true, false, true]
-vec.replace_with(booleans)
+vec.replace(booleans)
 => 
 #<RedAmber::Vector(:int8, size=3):0x00000000000304d0>
 [nil, 2, nil]
@@ -292,12 +364,27 @@ vec.replace_with(booleans)
 
 ```ruby
 vector = RedAmber::Vector.new(['A', 'B', 'NA'])
-vector.replace_with(vector == 'NA', nil)
+vector.replace(vector == 'NA', nil)
 # =>
 #<RedAmber::Vector(:string, size=3):0x000000000000f8ac>
 ["A", "B", nil]
 ```
 
+- Specifier in indices.
+
+Specified indices are used 'as sorted'. Position in indices and replacer may not have correspondence.
+
+```ruby
+vector = RedAmber::Vector.new([1, 2, 3])
+indices = [2, 1]
+replacer = [4, 5]
+vector.replace(indices, replacer)
+# =>
+#<RedAmber::Vector(:uint8, size=3):0x000000000000f244>
+[1, 4, 5] # not [1, 5, 4]
+```
+
+
 ### `fill_nil_forward`, `fill_nil_backward` => vector
 
 Propagate the last valid observation forward (or backward).
@@ -315,3 +402,48 @@ integer.fill_nil_backward
 #<RedAmber::Vector(:uint8, size=5):0x000000000000f974>
 [0, 1, 3, 3, nil]
 ```
+
+### `boolean_vector.if_else(true_choice, false_choice)` => vector
+
+Choose values based on self. Self must be a boolean Vector.
+
+`true_choice`, `false_choice` must be of the same type scalar / array / Vector.
+`nil` values in `cond` will be promoted to the output.
+
+This example will normalize negative indices to positive ones.
+
+```ruby
+indices = RedAmber::Vector.new([1, -1, 3, -4])
+array_size = 10
+normalized_indices = (indices < 0).if_else(indices + array_size, indices)
+
+# =>
+#<RedAmber::Vector(:int16, size=4):0x000000000000f85c>
+[1, 9, 3, 6]
+```
+
+### `is_in(values)` => boolean vector
+
+For each element in self, return true if it is found in given `values`, false otherwise.
+By default, nulls are matched against the value set. (This will be changed in SetLookupOptions: not impremented.)
+
+```ruby
+vector = RedAmber::Vector.new %W[A B C D]
+values = ['A', 'C', 'X']
+vector.is_in(values)
+
+# =>
+#<RedAmber::Vector(:boolean, size=4):0x000000000000f2a8>
+[true, false, true, false]
+```
+
+`values` are casted to the same Class of Vector.
+
+```ruby
+vector = RedAmber::Vector.new([1, 2, 255])
+vector.is_in(1, -1)
+
+# =>
+#<RedAmber::Vector(:boolean, size=3):0x000000000000f320>
+[true, false, true]
+```

data/lib/red-amber.rb

@@ -0,0 +1,27 @@
+# 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

data/lib/red_amber/data_frame.rb

@@ -6,11 +6,11 @@ module RedAmber
   class DataFrame
     # mix-in
     include DataFrameDisplayable
-    include DataFrameHelper
     include DataFrameIndexable
     include DataFrameSelectable
     include DataFrameObservationOperation
     include DataFrameVariableOperation
+    include Helper
 
     def initialize(*args)
       @variables = @keys = @vectors = @types = @data_types = nil
@@ -44,7 +44,7 @@ module RedAmber
     attr_reader :table
 
     def to_arrow
-      table
+      @table
     end
 
     def save(output, options = {})
@@ -79,12 +79,12 @@ module RedAmber
     alias_method :var_names, :keys
 
     def key?(key)
-      keys.include?(key.to_sym)
+      @keys.include?(key.to_sym)
     end
     alias_method :has_key?, :key?
 
     def key_index(key)
-      keys.find_index(key.to_sym)
+      @keys.find_index(key.to_sym)
     end
     alias_method :find_index, :key_index
     alias_method :index, :key_index
@@ -101,10 +101,10 @@ module RedAmber
       @vectors || @vectors = init_instance_vars(:vectors)
     end
 
-    def indexes
-      0...size
+    def indices
+      (0...size).to_a
     end
-    alias_method :indices, :indexes
+    alias_method :indexes, :indices
 
     def to_h
       variables.transform_values(&:to_a)
@@ -133,6 +133,19 @@ module RedAmber
       Rover::DataFrame.new(to_h)
     end
 
+    def to_iruby
+      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)]
+      else
+        ['text/plain', tdr_str]
+      end
+    end
+
     private
 
     # initialize @variable, @keys, @vectors and return one of them
@@ -148,5 +161,24 @@ module RedAmber
       @variables, @keys, @vectors = ary
       ary[%i[variables keys vectors].index(var)]
     end
+
+    def html_table
+      reduced = size > 8 ? self[0..4, -4..-1] : self
+
+      converted = reduced.assign do
+        vectors.select.with_object({}) do |vector, assigner|
+          if vector.has_nil?
+            assigner[vector.key] = vector.to_a.map do |e|
+              e = e.nil? ? '<i>(nil)</i>' : e.to_s # nil
+              e = '""' if e.empty? # empty string
+              e.sub(/(\s+)/, '"\1"') # blank spaces
+            end
+          end
+        end
+      end
+
+      html = IRuby::HTML.table(converted.to_h, maxrows: 8, maxcols: 15)
+      "#{size} x #{n_keys} vector#{pl(n_keys)} ; #{html}"
+    end
   end
 end

data/lib/red_amber/data_frame_displayable.rb

@@ -14,7 +14,11 @@ module RedAmber
     # def summary() end
 
     def inspect
-      "#<#{shape_str(with_id: true)}>\n#{dataframe_info(3)}"
+      if ENV.fetch('RED_AMBER_OUTPUT_MODE', 'tdr') == 'table'
+        "#<#{shape_str(with_id: true)}>\n#{self}"
+      else
+        "#<#{shape_str(with_id: true)}>\n#{dataframe_info(3)}"
+      end
     end
 
     # - limit: max num of Vectors to show
@@ -30,10 +34,6 @@ module RedAmber
 
     private # =====
 
-    def pl(num)
-      num > 1 ? 's' : ''
-    end
-
     def shape_str(with_id: false)
       shape_info = empty? ? '(empty)' : "#{size} x #{n_keys} Vector#{pl(n_keys)}"
       id = with_id ? format(', 0x%016x', object_id) : ''
@@ -81,12 +81,12 @@ module RedAmber
     end
 
     def make_header_format(levels, headers, quoted_keys)
-      # find longest word to adjust column width
+      # find longest word to adjust width
       w_idx = n_keys.to_s.size
       w_key = [quoted_keys.map(&:size).max, headers[:key].size].max
       w_type = [types.map(&:size).max, headers[:type].size].max
-      w_row = [levels.map { |l| l.to_s.size }.max, headers[:levels].size].max
-      "%-#{w_idx}s %-#{w_key}s %-#{w_type}s %#{w_row}s %s\n"
+      w_level = [levels.map { |l| l.to_s.size }.max, headers[:levels].size].max
+      "%-#{w_idx}s %-#{w_key}s %-#{w_type}s %#{w_level}s %s\n"
     end
 
     def type_group(data_type)

data/lib/red_amber/data_frame_observation_operation.rb

@@ -3,81 +3,9 @@
 module RedAmber
   # mix-ins for the class DataFrame
   module DataFrameObservationOperation
-    # slice and select some observations to create sub DataFrame
-    def slice(*args, &block)
-      slicer = args
-      if block
-        raise DataFrameArgumentError, 'Must not specify both arguments and block.' unless args.empty?
-
-        slicer = instance_eval(&block)
-      end
-      slicer = [slicer].flatten
-      return remove_all_values if slicer.empty? || slicer[0].nil?
-
-      # filter with same length
-      booleans = nil
-      if slicer[0].is_a?(Vector) || slicer[0].is_a?(Arrow::BooleanArray)
-        booleans = slicer[0].to_a
-      elsif slicer.size == size && booleans?(slicer)
-        booleans = slicer
-      end
-      return select_obs_by_boolean(booleans) if booleans
-
-      # filter with indexes
-      slicer = expand_range(slicer)
-      return map_indices(*slicer) if integers?(slicer)
-
-      raise DataFrameArgumentError, "Invalid argument #{args}"
-    end
-
-    # remove selected observations to create sub DataFrame
-    def remove(*args, &block)
-      remover = args
-      if block
-        raise DataFrameArgumentError, 'Must not specify both arguments and block.' unless args.empty?
-
-        remover = instance_eval(&block)
-      end
-      remover = [remover].flatten
-
-      return self if remover.empty?
-
-      # filter with same length
-      booleans = nil
-      if remover[0].is_a?(Vector) || remover[0].is_a?(Arrow::BooleanArray)
-        booleans = remover[0].to_a
-      elsif remover.size == size && booleans?(remover)
-        booleans = remover
-      end
-      if booleans
-        inverted = booleans.map(&:!)
-        return select_obs_by_boolean(inverted)
-      end
-
-      # filter with indexes
-      slicer = indexes.to_a - expand_range(remover)
-      return remove_all_values if slicer.empty?
-      return map_indices(*slicer) if integers?(slicer)
-
-      raise DataFrameArgumentError, "Invalid argument #{args}"
-    end
-
-    def remove_nil
-      func = Arrow::Function.find(:drop_null)
-      DataFrame.new(func.execute([table]).value)
-    end
-    alias_method :drop_nil, :remove_nil
-
     def group(aggregating_keys, func, target_keys)
       t = table.group(*aggregating_keys)
       RedAmber::DataFrame.new(t.send(func, *target_keys))
     end
-
-    private
-
-    # return a DataFrame with same keys as self without values
-    def remove_all_values
-      DataFrame.new(keys.each_with_object({}) { |key, h| h[key] = [] })
-    end
   end
 end