red_amber 0.1.3 → 0.1.6

data/doc/Vector.md

@@ -0,0 +1,449 @@
+# Vector
+
+Class `RedAmber::Vector` represents a series of data in the DataFrame.
+
+## Constructor
+
+### Create from a column in a DataFrame
+  
+  ```ruby
+  df = RedAmber::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])
+  # 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]
+  ```
+
+## Properties
+
+### `to_s`
+
+### `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?`
+
+### `type_class`
+
+### [ ] `each` (not impremented yet)
+
+### [ ] `chunked?` (not impremented yet)
+
+### [ ] `n_chunks` (not impremented yet)
+
+### [ ] `each_chunk` (not impremented yet)
+
+### `n_nils`, `n_nans`
+
+  - `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.
+
+    ```ruby
+    vector = RedAmber::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, ... ]
+    ```
+
+## 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`
+
+  ![unary aggregation](doc/image/../../image/vector/unary_aggregation_w_option.png)
+
+| Method    |Boolean|Numeric|String|Options|Remarks|
+| ----------- | --- | --- | --- | --- | --- |
+| ✓ `all?`     |  ✓  |     |     | ✓ ScalarAggregate| alias `all` |
+| ✓ `any?`     |  ✓  |     |     | ✓ ScalarAggregate| alias `any` |
+| ✓ `approximate_median`|  |✓|  | ✓ ScalarAggregate| alias `median`|
+| ✓ `count`   |  ✓  |  ✓  |  ✓  | ✓  Count  |     |
+| ✓ `count_distinct`| ✓ | ✓ | ✓ | ✓  Count  |alias `count_uniq`|
+|[ ]`index`   | [ ] | [ ] | [ ] |[ ] Index  |     |
+| ✓ `max`     |  ✓  |  ✓  |  ✓  | ✓ ScalarAggregate|     |
+| ✓ `mean`    |  ✓  |  ✓  |     | ✓ ScalarAggregate|     |
+| ✓ `min`     |  ✓  |  ✓  |  ✓  | ✓ ScalarAggregate|     |
+| ✓ `min_max` |  ✓  |  ✓  |  ✓  | ✓ ScalarAggregate|     |
+|[ ]`mode`    |     | [ ] |     |[ ] Mode    |     |
+| ✓ `product` |  ✓  |  ✓  |     | ✓ ScalarAggregate|     |
+|[ ]`quantile`|     | [ ] |     |[ ] Quantile|     |
+| ✓ `sd    `  |     |  ✓  |     |          |ddof: 1 at `stddev`|
+| ✓ `stddev`  |     |  ✓  |     | ✓ Variance|ddof: 0 by default|
+| ✓ `sum`     |  ✓  |  ✓  |     | ✓ ScalarAggregate|     |
+|[ ]`tdigest` |     | [ ] |     |[ ] TDigest |     |
+| ✓ `var    `|     |  ✓  |     |   |ddof: 1 at `variance`<br>alias `unbiased_variance`|
+| ✓ `variance`|     |  ✓  |     | ✓ Variance|ddof: 0 by default|
+
+
+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, ""])
+#=>
+#<RedAmber::Vector(:double, size=6):0x000000000000f910>
+[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
+
+boolean = RedAmber::Vector.new([true, true, nil])
+#=>
+#<RedAmber::Vector(:boolean, size=3):0x000000000000f924>
+[true, true, nil]
+
+boolean.all #=> true
+boolean.all(opts: {skip_nulls: true}) #=> true
+boolean.all(opts: {skip_nulls: false}) #=> false
+```
+
+### Unary element-wise: `vector.func => vector`
+
+  ![unary element-wise](doc/image/../../image/vector/unary_element_wise.png)
+
+| Method    |Boolean|Numeric|String|Options|Remarks|
+| ------------ | --- | --- | --- | --- | ----- |
+| ✓ `-@`       |     |  ✓  |     |     |as `-vector`|
+| ✓ `negate`   |     |  ✓  |     |     |`-@`   |
+| ✓ `abs`      |     |  ✓  |     |     |       |
+|[ ]`acos`     |     | [ ] |     |     |       |
+|[ ]`asin`     |     | [ ] |     |     |       |
+| ✓ `atan`     |     |  ✓  |     |     |       |
+| ✓ `bit_wise_not`|  | (✓) |     |     |integer only|
+| ✓ `ceil`     |     |  ✓  |     |     |       |
+| ✓ `cos`      |     |  ✓  |     |     |       |
+| ✓`fill_nil_backward`| ✓ | ✓ | ✓ |    |       |
+| ✓`fill_nil_forward` | ✓ | ✓ | ✓ |    |       |
+| ✓ `floor`    |     |  ✓  |     |     |       |
+| ✓ `invert`   |  ✓  |     |     |     |`!`, alias `not`|
+|[ ]`ln`       |     | [ ] |     |     |       |
+|[ ]`log10`    |     | [ ] |     |     |       |
+|[ ]`log1p`    |     | [ ] |     |     |       |
+|[ ]`log2`     |     | [ ] |     |     |       |
+| ✓ `round`    |     |  ✓  |     | ✓ Round (:mode, :n_digits)|    |
+| ✓ `round_to_multiple`| | ✓ |   | ✓ RoundToMultiple :mode, :multiple| multiple must be an Arrow::Scalar|
+| ✓ `sign`     |     |  ✓  |     |     |       |
+| ✓ `sin`      |     |  ✓  |     |     |       |
+| ✓`sort_indexes`| ✓  | ✓  | ✓  |:order|alias `sort_indices`|
+| ✓ `tan`      |     |  ✓  |     |     |       |
+| ✓ `trunc`    |     |  ✓  |     |     |       |
+
+### Binary element-wise: `vector.func(vector) => vector`
+
+  ![binary element-wise](doc/image/../../image/vector/binary_element_wise.png)
+
+| Method       |Boolean|Numeric|String|Options|Remarks|
+| ----------------- | --- | --- | --- | --- | ----- |
+| ✓ `add`           |     |  ✓  |     |     | `+`   |
+| ✓ `atan2`         |     |  ✓  |     |     |       |
+| ✓ `and_kleene`    |  ✓  |     |     |     | `&`   |
+| ✓ `and_org   `    |  ✓  |     |     |     |`and` in Red Arrow|
+| ✓ `and_not`       |  ✓  |     |     |     |       |
+| ✓ `and_not_kleene`|  ✓  |     |     |     |       |
+| ✓ `bit_wise_and`  |     | (✓) |     |     |integer only|
+| ✓ `bit_wise_or`   |     | (✓) |     |     |integer only|
+| ✓ `bit_wise_xor`  |     | (✓) |     |     |integer only|
+| ✓ `divide`        |     |  ✓  |     |     | `/`   |
+| ✓ `equal`         |  ✓  |  ✓  |  ✓  |     |`==`, alias `eq`|
+| ✓ `greater`       |  ✓  |  ✓  |  ✓  |     |`>`, alias `gt`|
+| ✓ `greater_equal` |  ✓  |  ✓  |  ✓  |     |`>=`, alias `ge`|
+| ✓ `is_finite`     |     |  ✓  |     |     |       |
+| ✓ `is_inf`        |     |  ✓  |     |     |       |
+| ✓ `is_na`         |  ✓  |  ✓  |  ✓  |     |       |
+| ✓ `is_nan`        |     |  ✓  |     |     |       |
+|[ ]`is_nil`        |  ✓  |  ✓  |  ✓  |[ ] Null|alias `is_null`|
+| ✓ `is_valid`      |  ✓  |  ✓  |  ✓  |     |       |
+| ✓ `less`          |  ✓  |  ✓  |  ✓  |     |`<`, alias `lt`|
+| ✓ `less_equal`    |  ✓  |  ✓  |  ✓  |     |`<=`, alias `le`|
+|[ ]`logb`          |     | [ ] |     |     |       |
+|[ ]`mod`           |     | [ ] |     |     | `%`   |
+| ✓ `multiply`      |     |  ✓  |     |     | `*`   |
+| ✓ `not_equal`     |  ✓  |  ✓  |  ✓  |     |`!=`, alias `ne`|
+| ✓ `or_kleene`     |  ✓  |     |     |     | `\|`  |
+| ✓ `or_org`        |  ✓  |     |     |     |`or` in Red Arrow|
+| ✓ `power`         |     |  ✓  |     |     | `**`  |
+| ✓ `subtract`      |     |  ✓  |     |     | `-`   |
+| ✓ `shift_left`    |     | (✓) |     |     |`<<`, integer only|
+| ✓ `shift_right`   |     | (✓) |     |     |`>>`, integer only|
+| ✓ `xor`           |  ✓  |     |     |     | `^`   |
+
+### `uniq`
+
+  Returns a new array with distinct elements.
+
+(Not impremented functions)
+
+### `tally` and `value_counts`
+
+  Compute counts of unique elements and return a Hash.
+
+  It returns almost same result as Ruby's tally. These methods consider NaNs are same.
+
+  ```ruby
+  array = [0.0/0, Float::NAN]
+  array.tally #=> {NaN=>1, NaN=>1}
+
+  vector = RedAmber::Vector.new(array)
+  vector.tally #=> {NaN=>2}
+  vector.value_counts #=> {NaN=>2}
+  ```
+### `index(element)`
+
+  Returns index of specified element.
+
+### `sort_indexes`, `sort_indices`, `array_sort_indices`
+
+### [ ] `sort`, `sort_by`
+### [ ] argmin, argmax
+### [ ] (array functions)
+### [ ] (strings functions)
+### [ ] (temporal functions)
+### [ ] (conditional functions)
+### [ ] (index functions)
+### [ ] (other functions)
+
+## Coerce (not impremented)
+
+## Update vector's value
+### `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.
+- 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]
+replacer = [4, 5]
+vector.replace(booleans, replacer)
+# => 
+#<RedAmber::Vector(:uint8, size=3):0x000000000001ee10>
+[4, 2, 5] 
+```
+
+- Scalar value in replacer can be broadcasted.
+
+```ruby
+replacer = 0
+vector.replace(booleans, replacer)
+# => 
+#<RedAmber::Vector(:uint8, size=3):0x000000000001ee10>
+[0, 2, 0] 
+```
+
+- Returned data type is automatically up-casted by replacer.
+
+```ruby
+replacer = 1.0
+vector.replace(booleans, replacer)
+# => 
+#<RedAmber::Vector(:double, size=3):0x0000000000025d78>
+[1.0, 2.0, 1.0]
+```
+
+- Position of nil in booleans is replaced with nil.
+
+```ruby
+booleans = [true, false, nil]
+replacer = -1
+vec.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)
+=> 
+#<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.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).
+Or preserve nil if all previous values are nil or at the end.
+
+```ruby
+integer = RedAmber::Vector.new([0, 1, nil, 3, nil])
+integer.fill_nil_forward
+# =>
+#<RedAmber::Vector(:uint8, size=5):0x000000000000f960>
+[0, 1, 1, 3, 3]
+
+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/doc/tdr.md

@@ -0,0 +1,56 @@
+# TDR (Transposed DataFrame Representation)
+
+([Japanese version](tdr_ja.md) of this document is available)
+
+TDR is a presentation style of 2D data. It shows columnar vector values in *row Vector* and observations in *column* just like a **transposed** table.
+
+![TDR Image](image/tdr.png) 
+
+Row-oriented data table (1) and columnar data table (2) have different data allocation in memory within a context of Arrow Columnar Format. But they have the same data placement (in rows and columns) in our brain.
+
+TDR (3) is a logical concept of data placement to transpose rows and columns in a columnar table (2).
+
+![TDR and Table Image](image/tdr_and_table.png)
+
+TDR is not an implementation in software but a logical image in our mind.
+
+TDR is consistent with the 'transposed' tidy data concept. The only thing we should do is not to use the positional words 'row' and 'column'.
+
+![tidy data in TDR](image/tidy_data_in_TDR.png)
+
+TDR is one of a simple way to create DataFrame object in many libraries. For example, we can initalize Arrow::Table in Red Arrow like the right below and get table as left.
+
+![Arrow Table New](image/arrow_table_new.png)
+
+We are using TDR style code naturally. For other example:
+  - Ruby: Daru::DataFrame, Rover::DataFrame accept same arguments.
+  - Python: similar style in Pandas for pd.DataFrame(data_in_dict)
+  - R: similar style in tidyr for tibble(x = 1:3, y = c("A", "B", "C"))
+
+There are other ways to initialize data frame, but they are not intuitive.
+
+## Table and TDR API
+
+The API based on TDR is draft and RedAmber is a small experiment to test the TDR concept. The following is a comparison of Table and TDR (draft).
+
+|     |Basic Table|Transposed DataFrame|Comment for TDR|
+|-----------|---------|------------|---|
+|name in TDR|`Table`|`TDR`|**T**ransposed **D**ataFrame **R**epresentation|
+|variable   |located in a column|a key and a `Vector` in lateral|select by keys|
+|observation|located in a row|sliced in vertical|select by indices|
+|number of variables|n_columns etc. |`n_keys`  |`n_cols` is available as an alias|
+|number of observations|n_rows etc. |`size` |`n_rows` is available as an alias|
+|shape      |[n_rows, n_columns]  |`shape`=`[size, n_keys]` |same order as Table|
+|Select variables|select, filter, [ ], etc.|`pick` or `[keys]`  |accepts arguments or a block|
+|Reject variables|drop, etc.|`drop`  |accepts arguments or a block|
+|Select observations|slice, [ ], iloc, etc.|`slice` or `[indices]` |accepts arguments or a block|
+|Reject observations|drop, etc.|`remove`  |accepts arguments or a block|
+|Add variables|mutate, assign, etc.|`assign`  |accepts arguments or a block|
+|update variables|transmute, [ ]=, etc.|`assign`  |accepts arguments or a block|
+|inner join| inner_join(a,b)<br>merge(a, b, how='inner')|`a.inner_join(b)` |with a option on:|
+|left join| left_join(a,b)<br>merge(a, b, how='left')|`a.join(b)` |naturally join from bottom<br>with a option on:|
+|right join| right_join(a,b))<br>merge(a, b, how='right')|`b.join(a)` |naturally join from bottom<br>with a option on:|
+
+## Q and A for TDR
+
+（Not prepared yet)

data/doc/tdr_ja.md

@@ -0,0 +1,56 @@
+# TDR (Transposed DataFrame Representation)
+
+([英語版](tdr.md) もあります)
+
+TDR は、２次元のデータの表現方法につけた名前です。TDR では下の図のように同じ型のデータに key というラベルをつけて横に並べ、それらを縦に積み重ねてデータを表現します。
+
+![TDR Image](image/tdr.png) 
+
+Arrow Columnar Format では、csv のような従来の行指向データ(1)に対して、列方向に連続したデータ(2)を取り扱います。この行、列という言葉は私たちの脳内イメージを規定していて、データフレームの構造といえば(1)または(2)のような形を思い浮かべることでしょう。しかし、本質は連続したデータの配置にあるので、我々の頭の中では(3)のように行と列を入れ替えて考えてもいいはずです。
+
+![TDR and Table Image](image/tdr_and_table.png)
+
+大事なことは、TDR は頭の中の論理的なイメージであって、実装上のアーキテクチャではないということです。
+
+TDR は、整然データ(tidy data)の考え方とも矛盾しません。TDR における整然データは行と列を入れ替えた形で全く同じデータを表しています。一つだけ気をつけることは、混乱を避けるため、位置や方向に関するワードである行(row)や列(column)を避けるべきであるということです。
+
+![tidy data in TDR](image/tidy_data_in_TDR.png)
+
+TDR は、現時点でも2次元データを楽に初期化できる記法で、ごく自然に使われています。例えば、Red Arrow ではArrow::Table を初期化する際に下の図の右のように書けます。
+
+![Arrow Table New](image/arrow_table_new.png)
+
+これはごく自然な書き方ですが、この形は TDR の形と一致しています。その他の例として:
+  - Ruby: Daru::DataFrame, Rover::DataFrame でも上と同じように書けます。
+  - Python: Pandas で pd.DataFrame(data_in_dict) のように dict を使う場合が同じです。
+  - R: tidyr で tibble(x = 1:3, y = c("A", "B", "C")) のように書けます。
+
+それぞれのライブラリーで、データフレームを初期化するやり方はこれだけではありませんが、他の方法は少し回りくどいような印象があります。
+
+TDR で考えた方がちょっぴりうまくいくというのは単なる仮説ですが、その理由は「この惑星では横書きでコードを書く」からではないかと私は考えています。
+
+## Table and TDR API
+
+TDR に基づいた API はまだ暫定板の段階であり、RedAmber は TDR の実験の場であると考えています。下記の表に TDR と行x列形式の Table のAPIの比較を示します（暫定版）。
+
+|     |従来の Table|Transposed DataFrame|TDRに対するコメント|
+|-----------|---------|------------|---|
+|TDRでの呼称|`Table`|`TDR`|**T**ransposed **D**ataFrame **R**epresentationの略|
+|変数 |列に配置|`variables`<br>key と `Vector` として横方向に配置|key で選択|
+|観測 |行に配置|`observations`<br>縦方向に切った一つ一つはslice|index や `slice` メソッドで選択|
+|変数(列)の数|ncol, n_columns など |`n_keys`  |`n_cols` をエイリアスとして設定|
+|観測(行)の数|nrow, n_rows など |`size` |`n_rows` をエイリアスとして設定|
+|形状      |[nrow, ncol]  |`shape`=`[size, n_keys]` |行, 列の順番は同じ|
+|変数(列)の選択|select, filter, [ ], など|`pick` or `[keys]`  |引数またはブロックで指定|
+|変数(列)の削除|drop, など|`drop`  |引数またはブロックで指定|
+|観測(行)の選択|slice, [ ], iloc, など|`slice` or `[indices]` |引数またはブロックで指定|
+|観測(行)の削除|drop, など|`remove`  |引数またはブロックで指定|
+|変数(列)の追加|mutate, assign, など|`assign`  |引数またはブロックで指定|
+|変数(列)の更新|transmute, [ ]=, など|`assign`  |引数またはブロックで指定|
+|内部結合| inner_join(a,b)<br>merge(a, b, how='inner')|`a.inner_join(b)` |オプション on:|
+|左結合| left_join(a,b)<br>merge(a, b, how='left')|`a.join(b)` |自然に下にくっつける<br>オプション on:|
+|右結合| right_join(a,b))<br>merge(a, b, how='right')|`b.join(a)` |自然に下にくっつける<br>オプション on:|
+
+## Q and A for TDR
+
+（作成中)

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