red_amber 0.1.7 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88bdd603d8daec1a95c0277ef68857f84346ad7cf95d0ba23a306e6b70567c29
-  data.tar.gz: 40add80cbaa5183ca0e93eadcdcd1fead37015cac1cb2360660002c0b1878255
+  metadata.gz: 3853e70f378cac65013a3bcfc51a2d55cb70cc494f3f3b70675bed944cc15b49
+  data.tar.gz: 3c65999cf978f1edf8c2c7fcce9a0ccb192d4da051f34fa0bf3f66ddc178eb1c
 SHA512:
-  metadata.gz: d043eea51117ecc48bdc52fa951e24d2618f273eb289a30f5bbb182e1a891763cdd35f6a7c6764f6e0061bddeaaa86b2374de1dc2b48f25a5b6b05c9af83a0e3
-  data.tar.gz: cdbba19750bf71fe99e55bf6c46cb4522018f43563d7a93fdc375987f9388234e4f7e833297fdb6b8dd5a41b5a1bfdbf287ea47663f5f8a90facb56a4c63daef
+  metadata.gz: fac66ba0bf5955cfe0d21a51b90ec16407182b9053e9b586dfe9f8e2526de4e90efecdd8eba1e8b3c99b12fc44544c82fb2f6af4b666b97876a64a6ee4deedf1
+  data.tar.gz: 1a4cc526ce9f097438f2b7d018552a4cd6aaa2d900012297cd1777c4b9e39063cc2988af91c138e93f291a56175aefb6a6b00c211f9b9c5bd38d75d6bc40acb9

data/.rubocop.yml

@@ -43,6 +43,11 @@ Lint/BinaryOperatorWithIdenticalOperands:
   Exclude:
     - 'test/test_vector_function.rb'
 
+# Need for test with empty block
+Lint/EmptyBlock:
+  Exclude:
+    - 'test/test_group.rb'
+
 # Max: 120
 Layout/LineLength:
   Max: 118
@@ -78,9 +83,10 @@ Metrics/ClassLength:
 Metrics/CyclomaticComplexity:
   Max: 12
   Exclude:
+    - 'lib/red_amber/data_frame_displayable.rb' # Max: 18
     - 'lib/red_amber/data_frame_selectable.rb' # Max: 14
+    - 'lib/red_amber/vector_selectable.rb' # Max: 13
     - 'lib/red_amber/vector_updatable.rb' # Max: 14
-    - 'lib/red_amber/data_frame_displayable.rb' # Max: 18
 
 # Max: 10
 Metrics/MethodLength:

data/.rubocop_todo.yml

@@ -1,15 +1,2 @@
-# This configuration was generated by
-# `rubocop --auto-gen-config`
-# on 2022-05-08 02:37:36 UTC using RuboCop version 1.27.0.
-# The point is for the user to remove these configuration records
-# one by one as the offenses are removed from the code base.
-# Note that changes in the inspected code, or installation of new
-# versions of RuboCop, may require this file to be generated again.
-
-# Offense count: 1
-# This cop supports unsafe auto-correction (--auto-correct-all).
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: forbid_for_all_comparison_operators, forbid_for_equality_operators_only, require_for_all_comparison_operators, require_for_equality_operators_only
-Style/YodaCondition:
-  Exclude:
-    - 'lib/red_amber/data_frame.rb'
+# We will use cops to detect bugs in an early stage
+# Feel free to use .rubocop_todo.yml by --auto-gen-config

data/.yardopts

@@ -0,0 +1 @@
+--output-dir doc/yard

data/CHANGELOG.md

@@ -2,6 +2,41 @@
 
 - Supports Arrow 9.0.0
 
+## [0.1.8] - 2022-08-04 (experimental)
+
+- Bug fixes
+
+  - Fix unnamed column in table formatter (#52)
+  - Fix DataFrame#key?, DataFrame#key_index when @keys.nil? (#52)
+  - Align order of replacer in Vector#replace (#53, resolved #38)
+
+- New features and improvements
+
+  - Refine DataFrame.new for empty arguments (#50)
+    - Delete .rubocop_todo.yml for not to use yoda condition (#50)
+
+  - Refine Group (#52, resolved #28)
+    - Refine Group methods creation
+    - Make group key at first(left)
+    - Show only one group count when same counts
+    - Add block acceptability for group
+    - Rename empty key to :unnamed in DataFrame.new
+    - Rename Group#aggregated_by to #summarize (#54)
+
+  - Add Vector#shift (#51)
+
+  - Vector#[] accepts Range as an argument (#51)
+
+- Update documents
+
+  - Add support for yard (#54)
+
+  - Renew jupyter notebook '53 examples' (#54)
+
+  - Add more examples and images in README (#52)
+  - Add document of group manipulations in README (#52)
+  - Renew DF#group document in DataFrame.md (#52)
+
 ## [0.1.7] - 2022-07-15 (experimental)
 
 - Bug fixes

data/Gemfile

@@ -18,6 +18,7 @@ group :test do
   gem 'iruby'
   gem 'test-unit'
   gem 'webrick'
+  gem 'yard'
 
   gem 'benchmark_driver'
   gem 'red-datasets'

data/README.md

@@ -56,7 +56,7 @@ require 'red_amber' # require 'red-amber' is also OK.
 require 'datasets-arrow'
 
 arrow = Datasets::Penguins.new.to_arrow
-RedAmber::DataFrame.new(arrow)
+penguins = RedAmber::DataFrame.new(arrow)
 
 # =>
 #<RedAmber::DataFrame : 344 x 8 Vectors, 0x0000000000013790>
@@ -78,28 +78,71 @@ RedAmber::DataFrame.new(arrow)
 
 For example, `DataFrame#pick` accepts keys as an argument and returns a sub DataFrame.
 
+![pick method image](doc/image/dataframe/pick.png)
+
 ```ruby
-df = penguins.pick(:body_mass_g)
+penguins.keys
+# =>
+[:species,                                       
+ :island,                                        
+ :bill_length_mm,
+ :bill_depth_mm,
+ :flipper_length_mm,
+ :body_mass_g,
+ :sex,
+ :year]
+
+df = penguins.pick(:species, :island, :body_mass_g)
 df
 
 # =>
-#<RedAmber::DataFrame : 344 x 1 Vector, 0x0000000000015cc0>
-    body_mass_g
-       <uint16>
-  1        3750
-  2        3800
-  3        3250
-  4       (nil)
-  5        3450
-  :           :
-342        5750
-343        5200
+#<RedAmber::DataFrame : 344 x 3 Vectors, 0x000000000003cc1c>                 
+    species  island    body_mass_g                                           
+    <string> <string>     <uint16>                                           
+  1 Adelie   Torgersen        3750                                           
+  2 Adelie   Torgersen        3800                                           
+  3 Adelie   Torgersen        3250                                           
+  4 Adelie   Torgersen       (nil)                                           
+  5 Adelie   Torgersen        3450                                           
+  : :        :                   :                                           
+342 Gentoo   Biscoe           5750                                           
+343 Gentoo   Biscoe           5200                                           
+344 Gentoo   Biscoe           5400
+```
+
+`DataFrame#drop` drops some columns to create a remainer DataFrame.
+
+![drop method image](doc/image/dataframe/drop.png)
+
+You can specify by keys or a boolean array (same size as n_keys).
+
+```ruby
+# Same as df.drop(:species, :island)
+df = df.drop(true, true, false)
+
+# =>
+#<RedAmber::DataFrame : 344 x 1 Vector, 0x0000000000048760>
+    body_mass_g                                     
+       <uint16>                                     
+  1        3750                                     
+  2        3800                                     
+  3        3250                                     
+  4       (nil)                                     
+  5        3450                                     
+  :           :                                     
+342        5750                                     
+343        5200                                     
 344        5400
 ```
 
+Arrow data is immutable, so these methods always return an new object.
+
 `DataFrame#assign` creates new variables (column in the table).
 
+![assign method image](doc/image/dataframe/assign.png)
+
 ```ruby
+# New column is created because ':body_mass_kg' is a new key.
 df.assign(:body_mass_kg => df[:body_mass_g] / 1000.0)
 
 # =>
@@ -117,12 +160,97 @@ df.assign(:body_mass_kg => df[:body_mass_g] / 1000.0)
 344        5400          5.4
 ```
 
+`DataFrame#slice` selects rows (observations) to create a sub DataFrame.
+
+![slice method image](doc/image/dataframe/slice.png)
+
+```ruby
+# returns 5 rows at the start and 5 rows from the end
+penguins.slice(0...5, -5..-1)
+
+# =>
+#<RedAmber::DataFrame : 10 x 8 Vectors, 0x0000000000042be4>
+   species  island    bill_length_mm bill_depth_mm flipper_length_mm ...     year
+   <string> <string>        <double>      <double>           <uint8> ... <uint16>
+ 1 Adelie   Torgersen           39.1          18.7               181 ...     2007
+ 2 Adelie   Torgersen           39.5          17.4               186 ...     2007
+ 3 Adelie   Torgersen           40.3          18.0               195 ...     2007
+ 4 Adelie   Torgersen          (nil)         (nil)             (nil) ...     2007
+ 5 Adelie   Torgersen           36.7          19.3               193 ...     2007
+ : :        :                      :             :                 : ...        :
+ 8 Gentoo   Biscoe              50.4          15.7               222 ...     2009
+ 9 Gentoo   Biscoe              45.2          14.8               212 ...     2009
+10 Gentoo   Biscoe              49.9          16.1               213 ...     2009
+```
+
+`DataFrame#remove` rejects rows (observations) to create a remainer DataFrame.
+
+![remove method image](doc/image/dataframe/remove.png)
+
+```ruby
+# penguins[:bill_length_mm] < 40 returns a boolean Vector
+penguins.remove(penguins[:bill_length_mm] < 40)
+
+# =>
+#<RedAmber::DataFrame : 244 x 8 Vectors, 0x000000000007d6f4>
+    species  island    bill_length_mm bill_depth_mm flipper_length_mm ...     year
+    <string> <string>        <double>      <double>           <uint8> ... <uint16>
+  1 Adelie   Torgersen           40.3          18.0               195 ...     2007
+  2 Adelie   Torgersen          (nil)         (nil)             (nil) ...     2007
+  3 Adelie   Torgersen           42.0          20.2               190 ...     2007
+  4 Adelie   Torgersen           41.1          17.6               182 ...     2007
+  5 Adelie   Torgersen           42.5          20.7               197 ...     2007
+  : :        :                      :             :                 : ...        :
+242 Gentoo   Biscoe              50.4          15.7               222 ...     2009
+243 Gentoo   Biscoe              45.2          14.8               212 ...     2009
+244 Gentoo   Biscoe              49.9          16.1               213 ...     2009
+```
+
 DataFrame manipulating methods like `pick`, `drop`, `slice`, `remove`, `rename` and `assign` accept a block.
 
-This is an exaple to eliminate observations (row in the table) containing nil.
+This example is usage of block to update numeric columns.
 
 ```ruby
-# remove all observation contains nil
+df = RedAmber::DataFrame.new(
+  integer: [0, 1, 2, 3, nil],
+  float:   [0.0, 1.1,  2.2, Float::NAN, nil],
+  string:  ['A', 'B', 'C', 'D', nil],
+  boolean: [true, false, true, false, nil])
+df
+
+# =>
+#<RedAmber::DataFrame : 5 x 4 Vectors, 0x000000000003131c>
+  integer    float string   boolean
+  <uint8> <double> <string> <boolean>
+1       0      0.0 A        true
+2       1      1.1 B        false
+3       2      2.2 C        true
+4       3      NaN D        false
+5   (nil)    (nil) (nil)    (nil)
+
+df.assign do
+  vectors.each_with_object({}) do |v, h|
+    h[v.key] = -v if v.numeric?
+  end
+end
+
+# =>
+#<RedAmber::DataFrame : 5 x 4 Vectors, 0x000000000009a1b4>
+  integer    float string   boolean
+  <uint8> <double> <string> <boolean>
+1       0     -0.0 A        true
+2     255     -1.1 B        false
+3     254     -2.2 C        true
+4     253      NaN D        false
+5   (nil)    (nil) (nil)    (nil)
+```
+
+Negate (-@) method of unsigned integer Vector returns complement. 
+
+Next example is to eliminate observations (row in the table) containing nil.
+
+```ruby
+# remove all observations containing nil
 nil_removed = penguins.remove { vectors.map(&:is_nil).reduce(&:|) }
 nil_removed.tdr
 # =>
@@ -145,12 +273,51 @@ For this frequently needed task, we can do it much simpler.
 penguins.remove_nil # => same result as above
 ```
 
+`DataFrame#group` method can be used for the grouping tasks.
+
+```ruby
+starwars = RedAmber::DataFrame.load(URI("https://vincentarelbundock.github.io/Rdatasets/csv/dplyr/starwars.csv"))
+starwars
+
+# =>
+#<RedAmber::DataFrame : 87 x 12 Vectors, 0x000000000000607c>
+   unnamed1 name            height     mass hair_color skin_color  eye_color ... species
+    <int64> <string>       <int64> <double> <string>   <string>    <string>  ... <string>
+ 1        1 Luke Skywalker     172     77.0 blond      fair        blue      ... Human
+ 2        2 C-3PO              167     75.0 NA         gold        yellow    ... Droid
+ 3        3 R2-D2               96     32.0 NA         white, blue red       ... Droid
+ 4        4 Darth Vader        202    136.0 none       white       yellow    ... Human
+ 5        5 Leia Organa        150     49.0 brown      light       brown     ... Human
+ :        : :                    :        : :          :           :         ... :
+85       85 BB8              (nil)    (nil) none       none        black     ... Droid
+86       86 Captain Phasma   (nil)    (nil) unknown    unknown     unknown   ... NA
+87       87 Padmé Amidala      165     45.0 brown      light       brown     ... Human
+
+grouped = starwars.group(:species) { [count(:species), mean(:height, :mass)] }
+grouped.slice { v(:count) > 1 }
+
+# =>
+#<RedAmber::DataFrame : 9 x 4 Vectors, 0x000000000006e848>
+  species    count mean(height) mean(mass)
+  <string> <int64>     <double>   <double>
+1 Human         35        176.6       82.8
+2 Droid          6        131.2       69.8
+3 Wookiee        2        231.0      124.0
+4 Gungan         3        208.7       74.0
+5 NA             4        181.3       48.0
+: :              :            :          :
+7 Twi'lek        2        179.0       55.0
+8 Mirialan       2        168.0       53.1
+9 Kaminoan       2        221.0       88.0 
+```
+
 See [DataFrame.md](doc/DataFrame.md) for details.
 
 
 ## `RedAmber::Vector`
 
 Class `RedAmber::Vector` represents a series of data in the DataFrame.
+Method `RedAmber::DataFrame#[key]` returns a Vector with the key `key`. 
 
 ```ruby
 penguins[:bill_length_mm]
@@ -161,11 +328,34 @@ penguins[:bill_length_mm]
 
 Vectors accepts some [functional methods from Arrow](https://arrow.apache.org/docs/cpp/compute.html).
 
+This is an element-wise comparison and returns a boolean Vector of same size.
+
+![unary element-wise](doc/image/vector/unary_element_wise.png)
+
+```ruby
+penguins[:bill_length_mm] < 40
+
+# =>
+#<RedAmber::Vector(:boolean, size=344):0x000000000007e7ac>
+[true, true, false, nil, true, true, true, true, true, false, true, true, false, ... ]
+```
+
+Next example returns aggregated result.
+
+![unary aggregation](doc/image/vector/unary_aggregation.png)
+
+```ruby
+penguins[:bill_length_mm].mean
+43.92192982456141
+# =>
+
+```
+
 See [Vector.md](doc/Vector.md) for details.
 
 ## Jupyter notebook
 
-[47 Examples of Red Amber](doc/47_examples_of_red_amber.ipynb)
+[53 Examples of Red Amber](doc/examples_of_red_amber.ipynb)
 
 ## Development
 

data/doc/DataFrame.md

@@ -860,16 +860,10 @@ penguins.to_rover
 
 ## Grouping
 
-### `group(aggregating_keys)`
-
-  (
-    This API will change in the future version. Especcially I want to change:
-      - Order of the column of the result (aggregation_keys should be the first)
-      - DataFrame#group will accept a block (heronshoes/red_amber #28)
-  )
+### `group(group_keys)`
 
   `group` creates a class `Group` object. `Group` accepts functions below as a method.
-  Method accepts options as `summary_keys`.
+  Method accepts options as `group_keys`.
 
   Available functions are:
 
@@ -889,8 +883,8 @@ penguins.to_rover
   - [ ] tdigest
   - ✓ variance
 
-  For the each group of `aggregation_keys`, the aggregation `function` is applied and returns a new dataframe with aggregated keys according to `summary_keys`.
-  Aggregated key name is `function(summary_key)` style.
+  For the each group of `group_keys`, the aggregation `function` is applied and returns a new dataframe with aggregated keys according to `summary_keys`.
+  Summary key names are provided by `function(summary_keys)` style.
 
   This is an example of grouping of famous STARWARS dataset.
 
@@ -900,18 +894,18 @@ penguins.to_rover
   starwars
   
   # =>
-  #<RedAmber::DataFrame : 87 x 12 Vectors, 0x00000000000773bc>
-  species     name            height     mass hair_color skin_color  eye_color ... homeworld
-  <string>    <string>       <int64> <double> <string>   <string>    <string>  ... <string>
-  Human     1 Luke Skywalker     172     77.0 blond      fair        blue      ... Tatooine
-  Droid     2 C-3PO              167     75.0 NA         gold        yellow    ... Tatooine
-  Droid     3 R2-D2               96     32.0 NA         white, blue red       ... Naboo
-  Human     4 Darth Vader        202    136.0 none       white       yellow    ... Tatooine
-  Human     5 Leia Organa        150     49.0 brown      light       brown     ... Alderaan
-  :         : :                    :        : :          :           :         ... :
-  Droid    85 BB8              (nil)    (nil) none       none        black     ... NA
-  NA       86 Captain Phasma   (nil)    (nil) unknown    unknown     unknown   ... NA
-  Human    87 Padmé Amidala      165     45.0 brown      light       brown     ... Naboo
+  #<RedAmber::DataFrame : 87 x 12 Vectors, 0x0000000000005a50>
+     unnamed1 name            height     mass hair_color skin_color  eye_color ... species
+      <int64> <string>       <int64> <double> <string>   <string>    <string>  ... <string>
+   1        1 Luke Skywalker     172     77.0 blond      fair        blue      ... Human
+   2        2 C-3PO              167     75.0 NA         gold        yellow    ... Droid
+   3        3 R2-D2               96     32.0 NA         white, blue red       ... Droid
+   4        4 Darth Vader        202    136.0 none       white       yellow    ... Human
+   5        5 Leia Organa        150     49.0 brown      light       brown     ... Human
+   :        : :                    :        : :          :           :         ... :
+  85       85 BB8              (nil)    (nil) none       none        black     ... Droid
+  86       86 Captain Phasma   (nil)    (nil) unknown    unknown     unknown   ... NA
+  87       87 Padmé Amidala      165     45.0 brown      light       brown     ... Human
 
   starwars.tdr(12)
 
@@ -919,7 +913,7 @@ penguins.to_rover
   RedAmber::DataFrame : 87 x 12 Vectors
   Vectors : 4 numeric, 8 strings
   #  key         type   level data_preview
-  1  :""         int64     87 [1, 2, 3, 4, 5, ... ]
+  1  :unnamed1   int64     87 [1, 2, 3, 4, 5, ... ]
   2  :name       string    87 ["Luke Skywalker", "C-3PO", "R2-D2", "Darth Vader", "Leia Organa", ... ]
   3  :height     int64     46 [172, 167, 96, 202, 150, ... ], 6 nils
   4  :mass       double    39 [77.0, 75.0, 32.0, 136.0, 49.0, ... ], 28 nils
@@ -933,74 +927,70 @@ penguins.to_rover
   12 :species    string    38 ["Human", "Droid", "Droid", "Human", "Human", ... ]
   ```
 
-  We can aggregate for `:species` and calculate the mean of `:mass` and `:height`.
+  We can group by `:species` and calculate the count.
 
   ```ruby
-  grouped = starwars.group(:species).mean(:mass, :height)
-  grouped
+  starwars.group(:species).count(:species)
 
   # =>
-  #<RedAmber::DataFrame : 38 x 3 Vectors, 0x000000000008e620>                                 
-     mean(mass) mean(height) species                                                          
-       <double>     <double> <string>                                                         
-   1       82.8        176.6 Human                                                            
-   2       69.8        131.2 Droid                                                            
-   3      124.0        231.0 Wookiee                                                          
-   4       74.0        173.0 Rodian                                                           
-   5     1358.0        175.0 Hutt                                                             
-   :          :            : :                                                                
-  36      159.0        216.0 Kaleesh                                                          
-  37       80.0        206.0 Pau'an
-  38       80.0        188.0 Kel Dor
+  #<RedAmber::DataFrame : 38 x 2 Vectors, 0x000000000001d6f0>                                 
+     species    count                                                                         
+     <string> <int64>                                                                         
+   1 Human         35                                                                         
+   2 Droid          6                                                                         
+   3 Wookiee        2                                                                         
+   4 Rodian         1                                                                         
+   5 Hutt           1                                                                         
+   : :              :                                                                         
+  36 Kaleesh        1                                                                         
+  37 Pau'an         1                                                                         
+  38 Kel Dor        1
   ```
 
-  Select rows for count > 1.
-  
+  We can also calculate the mean of `:mass` and `:height` together.
+
   ```ruby
-  count = starwars.group(:species).count(:species)[:'count(species)'] # => Vector
-  grouped = grouped.slice(count > 1)
+  grouped = starwars.group(:species) { [count(:species), mean(:height, :mass)] }
 
   # =>
-  #<RedAmber::DataFrame : 9 x 3 Vectors, 0x0000000000098260>
-    mean(mass) mean(height) species       
-      <double>     <double> <string>      
-  1       82.8        176.6 Human         
-  2       69.8        131.2 Droid         
-  3      124.0        231.0 Wookiee       
-  4       74.0        208.7 Gungan        
-  5       48.0        181.3 NA            
-  :          :            : :
-  7       55.0        179.0 Twi'lek
-  8       53.1        168.0 Mirialan
-  9       88.0        221.0 Kaminoan
+  #<RedAmber::DataFrame : 38 x 4 Vectors, 0x00000000000407cc>                                 
+     species    count mean(height) mean(mass)                                                 
+     <string> <int64>     <double>   <double>                                                 
+   1 Human         35        176.6       82.8                                                 
+   2 Droid          6        131.2       69.8                                                 
+   3 Wookiee        2        231.0      124.0                                                 
+   4 Rodian         1        173.0       74.0                                                 
+   5 Hutt           1        175.0     1358.0                                                 
+   : :              :            :          :                                                 
+  36 Kaleesh        1        216.0      159.0                                                 
+  37 Pau'an         1        206.0       80.0                                                 
+  38 Kel Dor        1        188.0       80.0
   ```
 
-  Assemble the result and change the order of columns.
-
-  ```ruby
-  grouped.assign(count: count[count > 1]).pick { [2,3,0,1].map{ |i| keys[i] } }
+  Select rows for count > 1.
   
+  ```ruby
+  grouped.slice(grouped[:count] > 1)
+
   # =>
-  #<RedAmber::DataFrame : 9 x 4 Vectors, 0x0000000000141838>                                  
-    species    count mean(mass) mean(height)                                                  
-    <string> <uint8>   <double>     <double>                                                  
-  1 Human         35       82.8        176.6                                                  
-  2 Droid          6       69.8        131.2                                                  
-  3 Wookiee        2      124.0        231.0                                                  
-  4 Gungan         3       74.0        208.7                                                  
-  5 NA             4       48.0        181.3                                                  
-  : :              :          :            :                                                  
-  7 Twi'lek        2       55.0        179.0                                                  
-  8 Mirialan       2       53.1        168.0                                                  
-  9 Kaminoan       2       88.0        221.0
+  #<RedAmber::DataFrame : 9 x 4 Vectors, 0x000000000004c270>
+    species    count mean(height) mean(mass)
+    <string> <int64>     <double>   <double>
+  1 Human         35        176.6       82.8
+  2 Droid          6        131.2       69.8
+  3 Wookiee        2        231.0      124.0
+  4 Gungan         3        208.7       74.0
+  5 NA             4        181.3       48.0
+  : :              :            :          :
+  7 Twi'lek        2        179.0       55.0
+  8 Mirialan       2        168.0       53.1
+  9 Kaminoan       2        221.0       88.0
   ```
 
 ## Combining DataFrames
 
 - [ ] Combining rows to a dataframe
 
-- [ ] Add vars
-
 - [ ] Inner join
 
 - [ ] Left join
@@ -1009,6 +999,6 @@ penguins.to_rover
 
 - [ ] One-hot encoding
 
-## Iteration (not impremented)
+## Iteration
 
 - [ ] each_rows

data/doc/Vector.md

@@ -500,3 +500,28 @@ vector.is_in(1, -1)
 #<RedAmber::Vector(:boolean, size=3):0x000000000000f320>
 [true, false, true]
 ```
+
+### `shift(amount = 1, fill: nil)`
+
+Shift vector's values by specified `amount`. Shifted space is filled by value `fill`.
+
+```ruby
+vector = RedAmber::Vector.new([1, 2, 3, 4, 5])
+vector.shift
+
+# =>
+#<RedAmber::Vector(:uint8, size=5):0x00000000000072d8>  
+[nil, 1, 2, 3, 4]
+
+vector.shift(-2)
+
+# =>
+#<RedAmber::Vector(:uint8, size=5):0x0000000000009970>  
+[3, 4, 5, nil, nil]
+
+vector.shift(fill: Float::NAN)
+
+# =>
+#<RedAmber::Vector(:double, size=5):0x0000000000011d3c>                    
+[NaN, 1.0, 2.0, 3.0, 4.0]
+```