doc/Vector.md in red_amber-0.2.1 vs doc/Vector.md in red_amber-0.2.2

@@ -5,27 +5,27 @@
 ## Constructor
 
 ### Create from a column in a DataFrame
   
   ```ruby
-  df = RedAmber::DataFrame.new(x: [1, 2, 3])
+  df = DataFrame.new(x: [1, 2, 3])
   df[:x]
   # =>
   #<RedAmber::Vector(:uint8, size=3):0x000000000000f4ec>
   [1, 2, 3]
   ```
 
 ### New from an Array
 
   ```ruby
-  vector = RedAmber::Vector.new([1, 2, 3])
+  vector = Vector.new([1, 2, 3])
   # or
-  vector = RedAmber::Vector.new(1, 2, 3)
+  vector = Vector.new(1, 2, 3)
   # or
-  vector = RedAmber::Vector.new(1..3)
+  vector = Vector.new(1..3)
   # or
-  vector = RedAmber::Vector.new(Arrow::Array([1, 2, 3])
+  vector = Vector.new(Arrow::Array.new([1, 2, 3])
 
   # =>
   #<RedAmber::Vector(:uint8, size=3):0x000000000000f514>
   [1, 2, 3]
   ```
@@ -59,11 +59,11 @@
 
 ### `boolean?`, `numeric?`, `string?`, `temporal?`
 
 ### `type_class`
 
-### `each`
+### `each`, `map`, `collect`
 
   If block is not given, returns Enumerator.
 
 ### `n_nils`, `n_nans`
 
@@ -76,11 +76,11 @@
 ### `inspect(limit: 80)`
 
   - `limit` sets size limit to display a long array.
 
     ```ruby
-    vector = RedAmber::Vector.new((1..50).to_a)
+    vector = Vector.new((1..50).to_a)
     # =>
     #<RedAmber::Vector(:uint8, size=50):0x000000000000f528>
     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, ... ]
     ```
 
@@ -93,39 +93,40 @@
   - 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 = Vector.new(%w[A B C D E])
+indices = 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)`
+### `filter(booleans)`, `select(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])
+array = 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"]
 ```
+`filter` and `select` also accepts a block.
 
 ## Functions
 
 ### Unary aggregations: `vector.func => scalar`
 
@@ -156,21 +157,21 @@
 
 Options can be used as follows.
 See the [document of C++ function](https://arrow.apache.org/docs/cpp/compute.html) for detail.
 
 ```ruby
-double = RedAmber::Vector.new([1, 0/0.0, -1/0.0, 1/0.0, nil, ""])
+double = Vector.new([1, 0/0.0, -1/0.0, 1/0.0, nil, ""])
 #=>
 #<RedAmber::Vector(:double, size=6):0x000000000000f910>
 [1.0, NaN, -Infinity, Infinity, nil, 0.0]
 
 double.count #=> 5
 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])
+boolean = Vector.new([true, true, nil])
 #=>
 #<RedAmber::Vector(:boolean, size=3):0x000000000000f924>
 [true, true, nil]
 
 boolean.all #=> true
@@ -213,11 +214,11 @@
 
 - `: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])
+double = 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
@@ -291,11 +292,11 @@
 
   ```ruby
   array = [0.0/0, Float::NAN]
   array.tally #=> {NaN=>1, NaN=>1}
 
-  vector = RedAmber::Vector.new(array)
+  vector = Vector.new(array)
   vector.tally #=> {NaN=>2}
   vector.value_counts #=> {NaN=>2}
   ```
 ### `index(element)`
 
@@ -308,11 +309,11 @@
 ### `sort_indexes`, `sort_indices`, `array_sort_indices`
 
 ## Coerce
 
 ```ruby
-vector = RedAmber::Vector.new(1,2,3)
+vector = Vector.new(1,2,3)
 # => 
 #<RedAmber::Vector(:uint8, size=3):0x00000000000decc4>            
 [1, 2, 3]                                                         
 
 # Vector's `#*` method
@@ -338,16 +339,17 @@
 ### `replace(specifier, replacer)` => vector
 
 - 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.
+  - If booleans.any is false, no replacement happen and return self.
 - 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])
+vector = Vector.new([1, 2, 3])
 booleans = [true, false, true]
 replacer = [4, 5]
 vector.replace(booleans, replacer)
 # => 
 #<RedAmber::Vector(:uint8, size=3):0x000000000001ee10>
@@ -377,41 +379,31 @@
 - Position of nil in booleans is replaced with nil.
 
 ```ruby
 booleans = [true, false, nil]
 replacer = -1
-vec.replace(booleans, replacer)
+vector.replace(booleans, replacer)
 => 
 #<RedAmber::Vector(:int8, size=3):0x00000000000304d0>
 [-1, 2, nil]
 ```
 
 - replacer can have nil in it.
 
 ```ruby
 booleans = [true, false, true]
 replacer = [nil]
-vec.replace(booleans, replacer)
+vector.replace(booleans, replacer)
 => 
 #<RedAmber::Vector(:int8, size=3):0x00000000000304d0>
 [nil, 2, nil]
 ```
 
-- If no replacer specified, it is same as to specify nil.
-
-```ruby
-booleans = [true, false, true]
-vec.replace(booleans)
-=> 
-#<RedAmber::Vector(:int8, size=3):0x00000000000304d0>
-[nil, 2, nil]
-```
-
 - An example to replace 'NA' to nil.
 
 ```ruby
-vector = RedAmber::Vector.new(['A', 'B', 'NA'])
+vector = Vector.new(['A', 'B', 'NA'])
 vector.replace(vector == 'NA', nil)
 # =>
 #<RedAmber::Vector(:string, size=3):0x000000000000f8ac>
 ["A", "B", nil]
 ```
@@ -419,11 +411,11 @@
 - 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])
+vector = Vector.new([1, 2, 3])
 indices = [2, 1]
 replacer = [4, 5]
 vector.replace(indices, replacer)
 # =>
 #<RedAmber::Vector(:uint8, size=3):0x000000000000f244>
@@ -435,11 +427,11 @@
 
 Propagate the last valid observation forward (or backward).
 Or preserve nil if all previous values are nil or at the end.
 
 ```ruby
-integer = RedAmber::Vector.new([0, 1, nil, 3, nil])
+integer = Vector.new([0, 1, nil, 3, nil])
 integer.fill_nil_forward
 # =>
 #<RedAmber::Vector(:uint8, size=5):0x000000000000f960>
 [0, 1, 1, 3, 3]
 
@@ -457,11 +449,11 @@
 `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])
+indices = 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>
@@ -472,11 +464,11 @@
 
 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]
+vector = Vector.new %W[A B C D]
 values = ['A', 'C', 'X']
 vector.is_in(values)
 
 # =>
 #<RedAmber::Vector(:boolean, size=4):0x000000000000f2a8>
@@ -484,11 +476,11 @@
 ```
 
 `values` are casted to the same Class of Vector.
 
 ```ruby
-vector = RedAmber::Vector.new([1, 2, 255])
+vector = Vector.new([1, 2, 255])
 vector.is_in(1, -1)
 
 # =>
 #<RedAmber::Vector(:boolean, size=3):0x000000000000f320>
 [true, false, true]
@@ -497,10 +489,10 @@
 ### `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 = Vector.new([1, 2, 3, 4, 5])
 vector.shift
 
 # =>
 #<RedAmber::Vector(:uint8, size=5):0x00000000000072d8>  
 [nil, 1, 2, 3, 4]