tatara 0.1.0 → 0.2.0

data/docs/tatara/string_float_map.md

@@ -0,0 +1,56 @@
+# Tatara::StringFloatMap
+## About
+
+`Tatara::StringFloatMap` is `Map` class like `static type programming lang`.
+
+`Tatara::StringFloatMap` used by `String` key, and `Float` value.
+But, you can not use `Float` and `Integer` for value.
+
+```ruby
+@f = Tatara::StringFloatMap.new
+@f["A"] = 4.2
+# => Key: "A", Value: 4.2
+@f["B"] = 8
+# => Key: "B", Value: 8.0
+```
+
+But, can not use `Integer` & `Float` for key.
+
+```ruby
+@f = Tatara::StringFloatMap.new
+@f[0] = 4.2
+# => Error!
+@f[4.2] = 4.2
+# => Error!
+```
+
+## Methods
+### Tatara::StringFloatMap#new
+
+Create new `Tatara::StringFloatMap` instance.
+
+```ruby
+@f = Tatara::StringFloatMap.new
+```
+
+### Tatara::StringFloatMap#\[\]
+
+Access by key.
+
+```ruby
+@f = Tatara::StringFloatMap.new
+@f["A"] = 4.2
+puts @f["A"]
+# => 4.2
+```
+
+
+### Tatara::StringFloatMap#\[\]=
+
+Set value by key.
+
+```ruby
+@f = Tatara::StringFloatMap.new
+@f["A"] = 4.2
+# => Set value is 4.2
+```

data/docs/tatara/string_int_map.md

@@ -0,0 +1,55 @@
+# Tatara::StringIntMap
+## About
+
+`Tatara::StringIntMap` is `Map` class like `static type programming lang`.
+
+`Tatara::StringIntMap` used by `String` key, and `Integer` value.
+But, you can use `Float` and `Integer` for value.
+
+```ruby
+@i = Tatara::StringIntMap.new
+@i["A"] = 42
+# => Key: "A", Value: 42.
+@i["B"] = 8.4
+# => Key: "B", Value: 8.
+```
+
+But, can not use `Integer` & `Float` for key.
+
+```ruby
+@i = Tatara::StringIntMap.new
+@i[42] = 42
+# => Error!
+@i[4.2] = 4.2
+# => Error!
+```
+
+## Methods
+### Tatara::StringIntMap#new
+
+Create new `Tatara::StringIntMap` instance.
+
+```ruby
+@i = Tatara::StringIntMap.new
+```
+
+### Tatara::StringIntMap#\[\]
+
+Access by key.
+
+```ruby
+@i = Tatara::StringIntMap.new
+@i["A"] = 42
+puts @i["A"]
+# => 42
+```
+
+### Tatara::StringIntMap#\[\]=
+
+Set value by key.
+
+```ruby
+@i = Tatara::StringIntMap.new
+@i["A"] = 42
+# => Set value is 42.
+```

data/docs/tatara/string_string_map.md

@@ -0,0 +1,55 @@
+# Tatara::StringStringMap
+## About
+
+`Tatara::StringStringMap` is `Map` class like `static type programming lang`.
+
+`Tatara::StringStringMap` used by `String` key, and `String` value.
+But, you can not use `Float` and `Integer` for key & value.
+
+```ruby
+@s = Tatara::StringStringMap.new
+@s["A"] = "42"
+# => Key: "A", Value: "42".
+@s["B"] = "8"
+# => Key: "B", Value: "8".
+```
+
+But, can not set `Integer` & `Float`.
+
+```ruby
+@s = Tatara::StringStringMap.new
+@s["A"] = 42
+# => Error!
+@s["B"] = 4.2
+# => Error!
+```
+
+## Methods
+### Tatara::StringStringMap#new
+
+Create new `Tatara::StringStringMap` instance.
+
+```ruby
+@s = Tatara::StringStringMap.new
+```
+
+### Tatara::StringStringMap#\[\]
+
+Access by key.
+
+```ruby
+@s = Tatara::StringStringMap.new
+@s["A"] = "42"
+puts @i["A"]
+# => "42"
+```
+
+### Tatara::StringStringMap#\[\]=
+
+Set value by key.
+
+```ruby
+@s = Tatara::StringStringMap.new
+@s["A"] = "42"
+# => Set value is "42".
+```

data/docs/tatara/string_vector.md

@@ -0,0 +1,270 @@
+# Tatara::StringVector
+## About
+
+`Tatara::StringVector` is `Vector` class like `static type programming lang`.
+
+`Tatara::StringVector` use `String` value.
+But, you can not use `Integer` & `Float` for value.
+
+```ruby
+@s = Tatara::StringVector.new
+@s[0] = "42"
+# => Set value "42" for index of 0.
+@s[1] = "8.4"
+# => Set value "8.4" for index of 1.
+```
+
+But, can not use `Integer` & `Float` for value.
+
+```ruby
+@s = Tatara::StringVector.new
+@s[0] = 42
+# => Error!
+```
+
+
+## Methods
+### Tatara::StringVector#new
+
+Create new `Tatara::StringVector` instance.
+
+```ruby
+@s = Tatara::StringVector.new
+```
+
+### Tatara::StringVector#\[\]
+
+Access by index.
+
+```ruby
+@s = Tatara::StringVector.new
+@s[0] = "42"
+puts @s[0]
+# => "42"
+```
+
+### Tatara::StringVector#\[\]=
+
+Set value by index.
+
+```ruby
+@s = Tatara::StringVector.new
+@s[0] = "42"
+# => Set value "42" for index of 0.
+```
+
+### Tatara::StringVector#emplace_back
+
+Create new value on end of `Tatara::StringVector`.
+
+```ruby
+@s = Tatara::StringVector.new
+@s.emplace_back("42")
+# => Set value "42" on end of `Tatara::StringVector`
+```
+
+### Tatara::StringVector#size
+
+Size of `Tatara::StringVector`.
+
+```ruby
+@s = Tatara::StringVector.new
+puts @s.size
+# => 0
+@s.emplace_back("42")
+puts @s.size
+# => 1
+```
+
+### Tatara::StringVector#clear
+
+Clear `Tatara::StringVector`.
+
+```ruby
+@s = Tatara::StringVector.new
+@s.emplace_back("42")
+puts @s.size
+# => 1
+@s.clear
+puts @s.size
+# => 0
+```
+
+### Tatara::StringVector#sum
+
+Sum value's for `Tatara::StringVector`.
+
+```ruby
+@s = Tatara::StringVector.new
+("A".."C").each{|s|
+    @s.emplace_back(s)
+}
+puts @s.sum
+# => "ABC"
+```
+
+### Tatara::StringVector#operator<<
+
+Create new value on end of `Tatara::StringVector`.
+
+```ruby
+@s = Tatara::StringVector.new
+@s << "42"
+# => Set value "42" on end of `Tatara::StringVector`
+```
+
+### Tatara::StringVector#map
+
+`map` method for `Tatara::StringVector`.  
+It's likes `Array#map`
+
+```ruby
+@s = Tatara::StringVector.new
+("A".."C").each{|s| @s << s }
+# => Set new value's
+@s.map{|s|
+    puts s
+}
+# => A B C
+```
+
+### Tatara::StringVector#map!
+
+`map!` method for `Tatara::StringVector`.  
+It's likes `Array#map!`
+
+```ruby
+@s = Tatara::StringVector.new
+("A".."C").each{|s| @s << s }
+# => Set new value's
+@s.map!{|s| s.succ }
+@s.map{|s|
+    puts s
+}
+# => B C D
+```
+
+### Tatara::StringVector#each
+
+`each` method for `Tatara::StringVector`.  
+It's likes `Array#each`
+
+```ruby
+@s = Tatara::StringVector.new
+("A".."C").each{|s| @s << s }
+# => Set new value's
+@s.each{|s|
+    puts s
+}
+# => A B C
+```
+
+
+### Tatara::StringVector#each_with_index
+
+`each_with_index` method for `Tatara::StringVector`.  
+It's likes `Array#each_with_index`
+
+```ruby
+@s = Tatara::StringVector.new
+("A".."C").each{|s| @s << s }
+# => Set new value's
+@s.each_with_index{|v, i|
+    puts "#{i}:#{v}"
+}
+# => 1:A 2:B 3:C
+```
+
+### Tatara::Stringvector#intersection
+
+Intersection value's
+
+```ruby
+@s1 = Tatara::StringVector.new
+("A".."C").each{|s| @s1 << s}
+@s2 = Tatara::StringVector.new
+("C".."F").each{|s| @s2 << s}
+@s = @s1.intersection @s2
+# => ["C"]
+```
+
+### Tatara::StringVector#operator&
+
+Intersection value's
+
+```ruby
+@s1 = Tatara::StringVector.new
+("A".."C").each{|s| @s1 << s}
+@s2 = Tatara::StringVector.new
+("C".."F").each{|s| @s2 << s}
+@s = @s1 & @s2
+# => ["C"]
+```
+
+### Tatara::StringVector#sort
+
+Sort value's.
+
+```ruby
+@s = Tatara::StringVector.new
+["9", "1", "4"].each{|s| @s << s }
+@s = @s.sort
+# => ["1", "4", "9"]
+```
+
+### Tatara::StringVector#sort!
+
+Sort value's.
+
+```ruby
+@s = Tatara::StringVector.new
+["9", "1", "4"].each{|s| @s << s }
+@s.sort!
+# => ["1", "4", "9"]
+```
+
+### Tatara::StringVector#reverse
+
+Reverse value's.
+
+```ruby
+@s = Tatara::StringVector.new
+["9", "1", "4"].each{|s| @s << s }
+@s = @s.reverse
+# => ["4", "1", "9"]
+```
+
+### Tatara::StringVector#reverse!
+
+Reverse value's.
+
+```ruby
+@s = Tatara::StringVector.new
+["9", "1", "4"].each{|s| @s << s }
+@s.reverse!
+# => ["4", "1", "9"]
+```
+
+### Tatara::StringVector#first
+
+Get first value of `Tatara::StringVector`.
+
+```ruby
+@s = Tatara::StringVector.new
+("A".."C").each{|s| @s << s }
+# => Set new value's
+puts @s.first
+# => A
+```
+
+### Tatara::StringVector#last
+
+Get last value of `Tatara::StringVector`.
+
+```ruby
+@s = Tatara::StringVector.new
+("A".."C").each{|s| @s << s }
+# => Set new value's
+puts @s.last
+# => "C"
+```

data/ext/tatara/array/array.hpp

@@ -1,6 +1,8 @@
 #ifndef ARRAY__TEMPLATE_H_
 #define ARRAY__TEMPLATE_H_
 
+#include <algorithm>
+#include <iterator>
 #include <vector>
 
 template <class T>
@@ -16,6 +18,12 @@ class CppArray {
         constexpr void emplace_back(const T var);
         constexpr int size();
         constexpr void clear();
+        constexpr CppArray<T>& push_back_object(const T var);
+        constexpr CppArray<T> intersection(const CppArray<T> array);
+        constexpr CppArray<T> sort();
+        constexpr CppArray<T>& destructive_sort();
+        constexpr CppArray<T> reverse();
+        constexpr CppArray<T>& destructive_reverse();
 };
 
 template <class T>
@@ -59,4 +67,56 @@ constexpr void CppArray<T>::clear() {
     this->container.clear();
 }
 
+template <class T>
+constexpr CppArray<T>& CppArray<T>::push_back_object(const T var) {
+    this->container.emplace_back(std::move(var));
+    return *this;
+}
+
+template <class T>
+constexpr CppArray<T> CppArray<T>::intersection(const CppArray<T> array) {
+
+    std::vector<T> result;
+
+    std::set_intersection(
+        this->container.begin(), this->container.end(),
+        array.container.begin(), array.container.end(),
+        std::inserter(result, result.end())
+    );
+
+    CppArray<T> object;
+
+    object.container = std::move(result);
+
+    return object;
+}
+
+template <class T>
+constexpr CppArray<T> CppArray<T>::sort() {
+    CppArray<T> object;
+    object.container = this->container;
+    std::sort(object.container.begin(), object.container.end());
+    return object;
+}
+
+template <class T>
+constexpr CppArray<T>& CppArray<T>::destructive_sort() {
+    std::sort(this->container.begin(), this->container.end());
+    return *this;
+}
+
+template <class T>
+constexpr CppArray<T> CppArray<T>::reverse() {
+    CppArray<T> object;
+    object.container = this->container;
+    std::reverse(object.container.begin(), object.container.end());
+    return object;
+}
+
+template <class T>
+constexpr CppArray<T>& CppArray<T>::destructive_reverse() {
+    std::reverse(this->container.begin(), this->container.end());
+    return *this;
+}
+
 #endif