tatara 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (36) hide show
  1. checksums.yaml +4 -4
  2. data/.circleci/config.yml +23 -0
  3. data/Gemfile.lock +2 -2
  4. data/README.md +4 -0
  5. data/docs/_config.yml +1 -0
  6. data/docs/index.md +100 -0
  7. data/docs/tatara/float.md +425 -0
  8. data/docs/tatara/float_array.md +256 -0
  9. data/docs/tatara/float_float_map.md +52 -0
  10. data/docs/tatara/float_integer_map.md +52 -0
  11. data/docs/tatara/float_string_map.md +52 -0
  12. data/docs/tatara/float_vector.md +269 -0
  13. data/docs/tatara/integer.md +480 -0
  14. data/docs/tatara/integer_array.md +256 -0
  15. data/docs/tatara/integer_float_map.md +52 -0
  16. data/docs/tatara/integer_integer_map.md +52 -0
  17. data/docs/tatara/integer_string_map.md +52 -0
  18. data/docs/tatara/integer_vector.md +268 -0
  19. data/docs/tatara/string.md +223 -0
  20. data/docs/tatara/string_array.md +254 -0
  21. data/docs/tatara/string_float_map.md +56 -0
  22. data/docs/tatara/string_int_map.md +55 -0
  23. data/docs/tatara/string_string_map.md +55 -0
  24. data/docs/tatara/string_vector.md +270 -0
  25. data/ext/tatara/array/array.hpp +60 -0
  26. data/ext/tatara/float/float.hpp +51 -0
  27. data/ext/tatara/integer/integer.hpp +67 -0
  28. data/ext/tatara/string/string.hpp +28 -0
  29. data/ext/tatara/tatara.cpp +138 -9
  30. data/ext/tatara/vector/vector.hpp +60 -0
  31. data/lib/tatara.rb +2 -0
  32. data/lib/tatara/array/array.rb +37 -0
  33. data/lib/tatara/tatara_ext.rb +6 -0
  34. data/lib/tatara/vector/vector.rb +37 -0
  35. data/lib/tatara/version.rb +1 -1
  36. metadata +27 -3
data/ext/tatara/float/float.hpp CHANGED
@@ -9,13 +9,23 @@ class Float {
9
9
  public:
10
10
  constexpr Float();
11
11
  ~Float();
12
+ constexpr Float& initialize_object(const double var);
12
13
  constexpr double assignment(const double var);
13
14
  constexpr double return_value();
14
15
  constexpr double increment_value();
15
16
  constexpr double decrement_value();
16
17
  std::string to_string();
17
18
  constexpr int to_integer();
19
+ constexpr double plus(const double var);
18
20
  constexpr double plus_equal(const double var);
21
+ constexpr double minus(const double var);
22
+ constexpr double minus_equal(const double var);
23
+ constexpr double multiply(const double var);
24
+ constexpr double multiply_equal(const double var);
25
+ constexpr double divided(const double var);
26
+ constexpr double divided_equal(const double var);
27
+ constexpr double power(const double var);
28
+ constexpr double power_equal(const double var);
19
29
  constexpr double clear();
20
30
  constexpr bool equal(const double var);
21
31
  };
@@ -24,6 +34,11 @@ constexpr Float::Float() {}
24
34
 
25
35
  Float::~Float() {}
26
36
 
37
+ constexpr Float& Float::initialize_object(const double var) {
38
+ this->value = var;
39
+ return *this;
40
+ }
41
+
27
42
  constexpr double Float::assignment(const double var) {
28
43
  return this->value = var;
29
44
  }
@@ -53,10 +68,46 @@ constexpr int Float::to_integer() {
53
68
  return static_cast<int>(this->value);
54
69
  }
55
70
 
71
+ constexpr double Float::plus(const double var) {
72
+ return this->value + var;
73
+ }
74
+
56
75
  constexpr double Float::plus_equal(const double var) {
57
76
  return this->value += var;
58
77
  }
59
78
 
79
+ constexpr double Float::minus(const double var) {
80
+ return this->value - var;
81
+ }
82
+
83
+ constexpr double Float::minus_equal(const double var) {
84
+ return this->value -= var;
85
+ }
86
+
87
+ constexpr double Float::multiply(const double var) {
88
+ return this->value * var;
89
+ }
90
+
91
+ constexpr double Float::multiply_equal(const double var) {
92
+ return this->value *= var;
93
+ }
94
+
95
+ constexpr double Float::divided(const double var) {
96
+ return this->value / var;
97
+ }
98
+
99
+ constexpr double Float::divided_equal(const double var) {
100
+ return this->value /= var;
101
+ }
102
+
103
+ constexpr double Float::power(const double var) {
104
+ return std::pow(this->value, var);
105
+ }
106
+
107
+ constexpr double Float::power_equal(const double var) {
108
+ return this->value = std::pow(this->value, var);
109
+ }
110
+
60
111
  constexpr double Float::clear() {
61
112
  return this->value = 0.0;
62
113
  }
data/ext/tatara/integer/integer.hpp CHANGED
@@ -2,6 +2,7 @@
2
2
  #define INTEGER_H_
3
3
 
4
4
  #include <string>
5
+ #include <cmath>
5
6
 
6
7
  class Integer {
7
8
  int value = 0;
@@ -9,12 +10,25 @@ class Integer {
9
10
  public:
10
11
  constexpr Integer();
11
12
  ~Integer();
13
+ constexpr Integer& initialize_object(const int var);
12
14
  constexpr int assignment(const int var);
13
15
  constexpr int return_value();
14
16
  constexpr int increment_value();
15
17
  constexpr int decrement_value();
16
18
  std::string to_string();
19
+ constexpr double to_float();
20
+ constexpr int plus(int var);
17
21
  constexpr int plus_equal(int var);
22
+ constexpr int minus(int var);
23
+ constexpr int minus_equal(int var);
24
+ constexpr int divided(int var);
25
+ constexpr int divided_equal(int var);
26
+ constexpr int multiply(int var);
27
+ constexpr int multiply_equal(int var);
28
+ constexpr int mod(int var);
29
+ constexpr int mod_equal(int var);
30
+ constexpr int power(int var);
31
+ constexpr int power_equal(int var);
18
32
  constexpr int clear();
19
33
  constexpr bool equal(const int var);
20
34
  };
@@ -23,6 +37,11 @@ constexpr Integer::Integer() {}
23
37
 
24
38
  Integer::~Integer(){}
25
39
 
40
+ constexpr Integer& Integer::initialize_object(const int var) {
41
+ this->value = var;
42
+ return *this;
43
+ }
44
+
26
45
  constexpr int Integer::assignment(const int var) {
27
46
  return this->value = var;
28
47
  }
@@ -43,10 +62,58 @@ std::string Integer::to_string() {
43
62
  return std::to_string(this->value);
44
63
  }
45
64
 
65
+ constexpr double Integer::to_float() {
66
+ return static_cast<double>(this->value);
67
+ }
68
+
69
+ constexpr int Integer::plus(int var) {
70
+ return this->value + var;
71
+ }
72
+
46
73
  constexpr int Integer::plus_equal(int var) {
47
74
  return this->value += var;
48
75
  }
49
76
 
77
+ constexpr int Integer::minus(int var) {
78
+ return this->value - var;
79
+ }
80
+
81
+ constexpr int Integer::minus_equal(int var) {
82
+ return this->value -= var;
83
+ }
84
+
85
+ constexpr int Integer::divided(int var) {
86
+ return this->value / var;
87
+ }
88
+
89
+ constexpr int Integer::divided_equal(int var) {
90
+ return this->value /= var;
91
+ }
92
+
93
+ constexpr int Integer::multiply(int var) {
94
+ return this->value * var;
95
+ }
96
+
97
+ constexpr int Integer::multiply_equal(int var) {
98
+ return this->value *= var;
99
+ }
100
+
101
+ constexpr int Integer::mod(int var) {
102
+ return this->value % var;
103
+ }
104
+
105
+ constexpr int Integer::mod_equal(int var) {
106
+ return this->value %= var;
107
+ }
108
+
109
+ constexpr int Integer::power(int var) {
110
+ return std::pow(this->value, var);
111
+ }
112
+
113
+ constexpr int Integer::power_equal(int var) {
114
+ return this->value = std::pow(this->value, var);
115
+ }
116
+
50
117
  constexpr int Integer::clear() {
51
118
  return this->value = 0;
52
119
  }
data/ext/tatara/string/string.hpp CHANGED
@@ -8,18 +8,28 @@ class CppString {
8
8
  public:
9
9
  CppString();
10
10
  ~CppString();
11
+ CppString& initialize_object(const std::string var);
11
12
  std::string assignment(const std::string var);
12
13
  std::string return_value();
14
+ std::string index_access(const int index);
13
15
  int to_integer();
16
+ double to_float();
14
17
  std::string plus_equal(const std::string var);
15
18
  std::string clear();
16
19
  bool equal(const std::string var);
20
+ std::string slice(const int start, const int end);
21
+ std::string slice_des(const int start, const int end);
17
22
  };
18
23
 
19
24
  CppString::CppString() {}
20
25
 
21
26
  CppString::~CppString() {}
22
27
 
28
+ CppString& CppString::initialize_object(const std::string var) {
29
+ this->value = var;
30
+ return *this;
31
+ }
32
+
23
33
  std::string CppString::assignment(const std::string var) {
24
34
  return this->value = var;
25
35
  }
@@ -28,10 +38,19 @@ std::string CppString::return_value() {
28
38
  return this->value;
29
39
  }
30
40
 
41
+ std::string CppString::index_access(const int index) {
42
+ std::string s{this->value[index]};
43
+ return s;
44
+ }
45
+
31
46
  int CppString::to_integer() {
32
47
  return std::stoi(this->value);
33
48
  }
34
49
 
50
+ double CppString::to_float() {
51
+ return std::stof(this->value);
52
+ }
53
+
35
54
  std::string CppString::plus_equal(const std::string var) {
36
55
  return this->value += var;
37
56
  }
@@ -44,4 +63,13 @@ bool CppString::equal(const std::string var) {
44
63
  return this->value == var;
45
64
  }
46
65
 
66
+ std::string CppString::slice(const int start, const int end) {
67
+ return this->value.substr(start, end);
68
+ }
69
+
70
+ std::string CppString::slice_des(const int start, const int end) {
71
+ this->value = this->value.substr(start, end);
72
+ return this->value;
73
+ }
74
+
47
75
  #endif
data/ext/tatara/tatara.cpp CHANGED
@@ -17,34 +17,97 @@ extern "C" {
17
17
  Data_Type<Integer> rbcInteger = define_class_under<Integer>(rb_mTatara, "Integer")
18
18
  .define_constructor(Constructor<Integer>())
19
19
  .define_method("value", &Integer::return_value)
20
+ .define_method("val", &Integer::return_value)
20
21
  .define_method("value=", &Integer::assignment)
22
+ .define_method("val=", &Integer::assignment)
23
+ .define_method("value+", &Integer::plus)
24
+ .define_method("val+", &Integer::plus)
21
25
  .define_method("value+=", &Integer::plus_equal)
26
+ .define_method("val+=", &Integer::plus_equal)
27
+ .define_method("value-", &Integer::minus)
28
+ .define_method("val-", &Integer::minus)
29
+ .define_method("value-=", &Integer::minus_equal)
30
+ .define_method("val-=", &Integer::minus_equal)
31
+ .define_method("value/", &Integer::divided)
32
+ .define_method("val/", &Integer::divided)
33
+ .define_method("value/=", &Integer::divided_equal)
34
+ .define_method("val/=", &Integer::divided_equal)
35
+ .define_method("value*", &Integer::multiply)
36
+ .define_method("val*", &Integer::multiply)
37
+ .define_method("value*=", &Integer::multiply_equal)
38
+ .define_method("val*=", &Integer::multiply_equal)
39
+ .define_method("value%", &Integer::mod)
40
+ .define_method("value%=", &Integer::mod_equal)
41
+ .define_method("value**", &Integer::power)
42
+ .define_method("val**", &Integer::power)
43
+ .define_method("value**=", &Integer::power_equal)
44
+ .define_method("val**=", &Integer::power_equal)
22
45
  .define_method("inc", &Integer::increment_value)
46
+ .define_method("increment", &Integer::increment_value)
23
47
  .define_method("dec", &Integer::decrement_value)
48
+ .define_method("decrement", &Integer::decrement_value)
24
49
  .define_method("to_s", &Integer::to_string)
50
+ .define_method("to_f", &Integer::to_float)
25
51
  .define_method("clear", &Integer::clear)
26
- .define_method("value==", &Integer::equal);
52
+ .define_method("value==", &Integer::equal)
53
+ .define_method("val==", &Integer::equal)
54
+ .define_method("equal?", &Integer::equal)
55
+ .define_method("<<", &Integer::initialize_object);
27
56
 
28
57
  Data_Type<Float> rbcFloat = define_class_under<Float>(rb_mTatara, "Float")
29
58
  .define_constructor(Constructor<Float>())
30
59
  .define_method("value", &Float::return_value)
60
+ .define_method("val", &Float::return_value)
31
61
  .define_method("value=", &Float::assignment)
62
+ .define_method("val=", &Float::assignment)
63
+ .define_method("value+", &Float::plus)
64
+ .define_method("val+", &Float::plus)
32
65
  .define_method("value+=", &Float::plus_equal)
66
+ .define_method("val+=", &Float::plus_equal)
67
+ .define_method("value-", &Float::minus)
68
+ .define_method("val-", &Float::minus)
69
+ .define_method("value-=", &Float::minus_equal)
70
+ .define_method("val-=", &Float::minus_equal)
71
+ .define_method("value*", &Float::multiply)
72
+ .define_method("val*", &Float::multiply)
73
+ .define_method("value*=", &Float::multiply_equal)
74
+ .define_method("val*=", &Float::multiply_equal)
75
+ .define_method("value/", &Float::divided)
76
+ .define_method("val/", &Float::divided)
77
+ .define_method("value/=", &Float::divided_equal)
78
+ .define_method("val/=", &Float::divided_equal)
79
+ .define_method("value**", &Float::power)
80
+ .define_method("val**", &Float::power)
81
+ .define_method("value**=", &Float::power_equal)
82
+ .define_method("val**=", &Float::power_equal)
33
83
  .define_method("inc", &Float::increment_value)
34
84
  .define_method("dec", &Float::decrement_value)
35
85
  .define_method("to_s", &Float::to_string)
36
86
  .define_method("to_i", &Float::to_integer)
37
87
  .define_method("clear", &Float::clear)
38
- .define_method("value==", &Float::equal);
88
+ .define_method("value==", &Float::equal)
89
+ .define_method("val==", &Float::equal)
90
+ .define_method("equal?", &Float::equal)
91
+ .define_method("<<", &Float::initialize_object);
39
92
 
40
93
  Data_Type<CppString> rbcString = define_class_under<CppString>(rb_mTatara, "String")
41
94
  .define_constructor(Constructor<CppString>())
42
95
  .define_method("value", &CppString::return_value)
96
+ .define_method("val", &CppString::return_value)
43
97
  .define_method("value=", &CppString::assignment)
98
+ .define_method("val=", &CppString::assignment)
44
99
  .define_method("value+=", &CppString::plus_equal)
100
+ .define_method("val+=", &CppString::plus_equal)
45
101
  .define_method("to_i", &CppString::to_integer)
102
+ .define_method("to_f", &CppString::to_float)
46
103
  .define_method("clear", &CppString::clear)
47
- .define_method("value==", &CppString::equal);
104
+ .define_method("value==", &CppString::equal)
105
+ .define_method("val==", &CppString::equal)
106
+ .define_method("equal?", &CppString::equal)
107
+ .define_method("<<", &CppString::initialize_object)
108
+ .define_method("[]", &CppString::index_access)
109
+ .define_method("slice", &CppString::slice)
110
+ .define_method("slice!", &CppString::slice_des);
48
111
 
49
112
  Data_Type<Vector<int>> rb_cIntVector = define_class_under<Vector<int>>(rb_mTatara, "IntVector")
50
113
  .define_constructor(Constructor<Vector<int>>())
@@ -55,7 +118,13 @@ extern "C" {
55
118
  .define_method("emplace_back", &Vector<int>::emplace_back)
56
119
  .define_method("size", &Vector<int>::size)
57
120
  .define_method("clear", &Vector<int>::clear)
58
- .define_method("sum", &Vector<int>::sum);
121
+ .define_method("sum", &Vector<int>::sum)
122
+ .define_method("<<", &Vector<int>::push_back_object)
123
+ .define_method("intersection", &Vector<int>::intersection)
124
+ .define_method("sort", &Vector<int>::sort)
125
+ .define_method("sort!", &Vector<int>::destructive_sort)
126
+ .define_method("reverse", &Vector<int>::reverse)
127
+ .define_method("reverse!", &Vector<int>::destructive_reverse);
59
128
 
60
129
  Data_Type<Vector<double>> rb_cFloatVector = define_class_under<Vector<double>>(rb_mTatara, "FloatVector")
61
130
  .define_constructor(Constructor<Vector<double>>())
@@ -66,7 +135,13 @@ extern "C" {
66
135
  .define_method("emplace_back", &Vector<double>::emplace_back)
67
136
  .define_method("size", &Vector<double>::size)
68
137
  .define_method("clear", &Vector<double>::clear)
69
- .define_method("sum", &Vector<double>::sum);
138
+ .define_method("sum", &Vector<double>::sum)
139
+ .define_method("<<", &Vector<double>::push_back_object)
140
+ .define_method("intersection", &Vector<double>::intersection)
141
+ .define_method("sort", &Vector<double>::sort)
142
+ .define_method("sort!", &Vector<double>::destructive_sort)
143
+ .define_method("reverse", &Vector<double>::reverse)
144
+ .define_method("reverse!", &Vector<double>::destructive_reverse);
70
145
 
71
146
  Data_Type<Vector<std::string>> rb_cStringVector = define_class_under<Vector<std::string>>(rb_mTatara, "StringVector")
72
147
  .define_constructor(Constructor<Vector<std::string>>())
@@ -77,7 +152,13 @@ extern "C" {
77
152
  .define_method("emplace_back", & Vector<std::string>::emplace_back)
78
153
  .define_method("size", &Vector<std::string>::size)
79
154
  .define_method("clear", &Vector<std::string>::clear)
80
- .define_method("sum", &Vector<std::string>::sum);
155
+ .define_method("sum", &Vector<std::string>::sum)
156
+ .define_method("<<", &Vector<std::string>::push_back_object)
157
+ .define_method("intersection", &Vector<std::string>::intersection)
158
+ .define_method("sort", &Vector<std::string>::sort)
159
+ .define_method("sort!", &Vector<std::string>::destructive_sort)
160
+ .define_method("reverse", &Vector<std::string>::reverse)
161
+ .define_method("reverse!", &Vector<std::string>::destructive_reverse);
81
162
 
82
163
  Data_Type<CppArray<int>> rb_cIntArray = define_class_under<CppArray<int>>(rb_mTatara, "IntArray")
83
164
  .define_constructor(Constructor<CppArray<int>>())
@@ -87,7 +168,13 @@ extern "C" {
87
168
  .define_method("[]=", &CppArray<int>::bracket_equal)
88
169
  .define_method("push", &CppArray<int>::emplace_back)
89
170
  .define_method("size", &CppArray<int>::size)
90
- .define_method("clear", &CppArray<int>::clear);
171
+ .define_method("clear", &CppArray<int>::clear)
172
+ .define_method("<<", &CppArray<int>::push_back_object)
173
+ .define_method("intersection", &CppArray<int>::intersection)
174
+ .define_method("sort", &CppArray<int>::sort)
175
+ .define_method("sort!", &CppArray<int>::destructive_sort)
176
+ .define_method("reverse", &CppArray<int>::reverse)
177
+ .define_method("reverse!", &CppArray<int>::destructive_reverse);
91
178
 
92
179
  Data_Type<CppArray<double>> rb_cFloatArray = define_class_under<CppArray<double>>(rb_mTatara, "FloatArray")
93
180
  .define_constructor(Constructor<CppArray<double>>())
@@ -97,7 +184,13 @@ extern "C" {
97
184
  .define_method("[]=", &CppArray<double>::bracket_equal)
98
185
  .define_method("push", &CppArray<double>::emplace_back)
99
186
  .define_method("size", &CppArray<double>::size)
100
- .define_method("clear", &CppArray<double>::clear);
187
+ .define_method("clear", &CppArray<double>::clear)
188
+ .define_method("<<", &CppArray<double>::push_back_object)
189
+ .define_method("intersection", &CppArray<double>::intersection)
190
+ .define_method("sort", &CppArray<double>::sort)
191
+ .define_method("sort!", &CppArray<double>::destructive_sort)
192
+ .define_method("reverse", &CppArray<double>::reverse)
193
+ .define_method("reverse!", &CppArray<double>::destructive_reverse);
101
194
 
102
195
  Data_Type<CppArray<std::string>> rb_cStringArray = define_class_under<CppArray<std::string>>(rb_mTatara, "StringArray")
103
196
  .define_constructor(Constructor<CppArray<std::string>>())
@@ -107,7 +200,13 @@ extern "C" {
107
200
  .define_method("[]=", &CppArray<std::string>::bracket_equal)
108
201
  .define_method("push", &CppArray<std::string>::emplace_back)
109
202
  .define_method("size", &CppArray<std::string>::size)
110
- .define_method("clear", &CppArray<std::string>::clear);
203
+ .define_method("clear", &CppArray<std::string>::clear)
204
+ .define_method("<<", &CppArray<std::string>::push_back_object)
205
+ .define_method("intersection", &CppArray<std::string>::intersection)
206
+ .define_method("sort", &CppArray<std::string>::sort)
207
+ .define_method("sort!", &CppArray<std::string>::destructive_sort)
208
+ .define_method("reverse", &CppArray<std::string>::reverse)
209
+ .define_method("reverse!", &CppArray<std::string>::destructive_reverse);
111
210
 
112
211
  Data_Type<Map<std::string, int>> rb_cStringIntMap = define_class_under<Map<std::string, int>>(rb_mTatara, "StringIntMap")
113
212
  .define_constructor(Constructor<Map<std::string, int>>())
@@ -123,5 +222,35 @@ extern "C" {
123
222
  .define_constructor(Constructor<Map<std::string, std::string>>())
124
223
  .define_method("[]", &Map<std::string, std::string>::bracket)
125
224
  .define_method("[]=", &Map<std::string, std::string>::bracket_equal);
225
+
226
+ Data_Type<Map<int, int>> rb_cIntIntMap = define_class_under<Map<int, int>>(rb_mTatara, "IntIntMap")
227
+ .define_constructor(Constructor<Map<int, int>>())
228
+ .define_method("[]", &Map<int, int>::bracket)
229
+ .define_method("[]=", &Map<int, int>::bracket_equal);
230
+
231
+ Data_Type<Map<int, double>> rb_cIntFloatMap = define_class_under<Map<int, double>>(rb_mTatara, "IntFloatMap")
232
+ .define_constructor(Constructor<Map<int, double>>())
233
+ .define_method("[]", &Map<int, double>::bracket)
234
+ .define_method("[]=", &Map<int, double>::bracket_equal);
235
+
236
+ Data_Type<Map<int, std::string>> rb_cIntStringMap = define_class_under<Map<int, std::string>>(rb_mTatara, "IntStringMap")
237
+ .define_constructor(Constructor<Map<int, std::string>>())
238
+ .define_method("[]", &Map<int, std::string>::bracket)
239
+ .define_method("[]=", &Map<int, std::string>::bracket_equal);
240
+
241
+ Data_Type<Map<double, int>> rb_cFloatIntMap = define_class_under<Map<double, int>>(rb_mTatara, "FloatIntMap")
242
+ .define_constructor(Constructor<Map<double, int>>())
243
+ .define_method("[]", &Map<double, int>::bracket)
244
+ .define_method("[]=", &Map<double, int>::bracket_equal);
245
+
246
+ Data_Type<Map<double, double>> rb_cFloatFloatMap = define_class_under<Map<double, double>>(rb_mTatara, "FloatFloatMap")
247
+ .define_constructor(Constructor<Map<double, double>>())
248
+ .define_method("[]", &Map<double, double>::bracket)
249
+ .define_method("[]=", &Map<double, double>::bracket_equal);
250
+
251
+ Data_Type<Map<double, std::string>> rb_cFloatStringMap = define_class_under<Map<double, std::string>>(rb_mTatara, "FloatStringMap")
252
+ .define_constructor(Constructor<Map<double, std::string>>())
253
+ .define_method("[]", &Map<double, std::string>::bracket)
254
+ .define_method("[]=", &Map<double, std::string>::bracket_equal);
126
255
  }
127
256
  }