nmatrix-lapacke 0.2.0 → 0.2.1

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 (29) hide show
  1. checksums.yaml +4 -4
  2. data/ext/nmatrix/data/complex.h +183 -159
  3. data/ext/nmatrix/data/data.h +306 -292
  4. data/ext/nmatrix/data/ruby_object.h +193 -193
  5. data/ext/nmatrix/math/math.h +3 -2
  6. data/ext/nmatrix/math/trsm.h +152 -152
  7. data/ext/nmatrix/nmatrix.h +30 -0
  8. data/ext/nmatrix/ruby_constants.h +35 -35
  9. data/ext/nmatrix/storage/common.h +4 -3
  10. data/ext/nmatrix/storage/dense/dense.h +8 -7
  11. data/ext/nmatrix/storage/list/list.h +7 -6
  12. data/ext/nmatrix/storage/storage.h +12 -11
  13. data/ext/nmatrix/storage/yale/class.h +2 -2
  14. data/ext/nmatrix/storage/yale/iterators/base.h +2 -1
  15. data/ext/nmatrix/storage/yale/iterators/iterator.h +2 -1
  16. data/ext/nmatrix/storage/yale/iterators/row.h +2 -1
  17. data/ext/nmatrix/storage/yale/iterators/row_stored.h +2 -1
  18. data/ext/nmatrix/storage/yale/iterators/row_stored_nd.h +1 -0
  19. data/ext/nmatrix/storage/yale/iterators/stored_diagonal.h +2 -1
  20. data/ext/nmatrix/storage/yale/yale.h +7 -6
  21. data/ext/nmatrix/types.h +3 -2
  22. data/ext/nmatrix/util/sl_list.h +19 -18
  23. data/ext/nmatrix_lapacke/extconf.rb +15 -9
  24. data/ext/nmatrix_lapacke/math_lapacke.cpp +6 -6
  25. data/lib/nmatrix/lapacke.rb +31 -9
  26. data/spec/00_nmatrix_spec.rb +6 -0
  27. data/spec/math_spec.rb +77 -0
  28. data/spec/spec_helper.rb +9 -0
  29. metadata +4 -4
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA1:
3
- metadata.gz: 2089bc8efb9ead1728c09f472fb455208abba531
4
- data.tar.gz: cc47f7942dcd8a7eb27352bcd9ce0a68fa6cf23a
3
+ metadata.gz: eb2bd35041ab2a318db38bc9d91fb399ed239a78
4
+ data.tar.gz: 847ccaae732e318cdf5bbf04a6419532bf5244b9
5
5
  SHA512:
6
- metadata.gz: 22aa85625b98d26fbf83c6e8331a63d7cdb562ecef35b17ca50557deb8bd677a315fb56289553f36476ad9976439cf8d9f44959f96e0237a2b34594298d21ba6
7
- data.tar.gz: 7a3c8c022ce360c84ada662bd3c0eecbcf1975c0d5f256ff152a6868bd5ad9aec1af4a13bf88b3519d9918b3b3ab027aa40861485f610146402ec32ec8618d44
6
+ metadata.gz: a3835ad07419160226e85b9c5e2b47946ea4243d0b4a75a248e8334697969ac556a31c54dd6a4650ede2c6e9a301108c2ab7543c428eded3383e8e19c220460b
7
+ data.tar.gz: cfb08870d965f5ef7cbbc83522ca6aed084992c1f828931a93600ebc6af53d432e61d8a3ffaf7a25461a29c6e7bc8efdd15ed7de9ce79efea53d72f867db8949
data/ext/nmatrix/data/complex.h CHANGED
@@ -32,6 +32,7 @@
32
32
  * Standard Includes
33
33
  */
34
34
 
35
+ #include <ruby.h>
35
36
  #include <type_traits>
36
37
  #include <iostream>
37
38
  #include <cmath>
@@ -67,23 +68,39 @@ typedef Complex<float64_t> Complex128;
67
68
 
68
69
  template <typename Type>
69
70
  class Complex {
70
- public:
71
- // The real and immaginary parts of the complex number.
72
- Type r;
73
- Type i;
71
+ public:
72
+ // The real and immaginary parts of the complex number.
73
+ Type r;
74
+ Type i;
74
75
 
75
- /*
76
- * Default constructor.
77
- */
78
- inline Complex(Type real = 0, Type imaginary = 0) : r(real), i(imaginary) {}
76
+ /*
77
+ * Default constructor.
78
+ */
79
+ inline Complex(Type real = 0, Type imaginary = 0) : r(real), i(imaginary) {}
80
+
81
+ /*
82
+ * Copy constructors.
83
+ */
84
+ template <typename ComplexType>
85
+ explicit inline Complex(const Complex<ComplexType>& other) : r(other.r), i(other.i) {}
79
86
 
80
- /*
81
- * Copy constructors.
82
- */
83
- template <typename ComplexType>
84
- inline Complex(const Complex<ComplexType>& other) : r(other.r), i(other.i) {}
87
+ template <typename ComplexType>
88
+ inline Complex<Type>& operator=(const Complex<ComplexType>& other) {
89
+ this->r = static_cast<Type>(other.r);
90
+ this->i = static_cast<Type>(other.i);
91
+ return *this;
92
+ }
93
+
94
+ explicit Complex(const RubyObject& other);
85
95
 
86
- Complex(const RubyObject& other);
96
+ Complex<Type>& operator=(const RubyObject& other);
97
+
98
+ template<typename OtherType>
99
+ inline Complex<Type>& operator=(const OtherType& real) {
100
+ this->r = Type(real);
101
+ this->i = Type(0);
102
+ return *this;
103
+ }
87
104
 
88
105
  /*
89
106
  * Complex conjugate function -- creates a copy, but inverted.
@@ -103,20 +120,25 @@ class Complex {
103
120
  return Complex<Type>(conj.r / denom, conj.i / denom);
104
121
  }
105
122
 
123
+ // Negative operator
124
+ inline Complex<Type> operator-() const {
125
+ return Complex<Type>(-this->r, -this->i);
126
+ }
106
127
 
107
128
 
108
- /*
109
- * Binary operator definitions for various types.
110
- */
111
129
 
112
- ////////////////////////////////
113
- // Complex-Complex Operations //
114
- ////////////////////////////////
130
+ /*
131
+ * Binary operator definitions for various types.
132
+ */
115
133
 
116
- template <typename OtherType>
117
- inline Complex<Type> operator+(const Complex<OtherType>& other) const {
118
- return Complex<Type>(this->r + other.r, this->i + other.i);
119
- }
134
+ ////////////////////////////////
135
+ // Complex-Complex Operations //
136
+ ////////////////////////////////
137
+
138
+ template <typename OtherType>
139
+ inline Complex<Type> operator+(const Complex<OtherType>& other) const {
140
+ return Complex<Type>(this->r + other.r, this->i + other.i);
141
+ }
120
142
 
121
143
  template <typename OtherType>
122
144
  inline Complex<Type>& operator+=(const Complex<OtherType>& other) {
@@ -132,15 +154,15 @@ class Complex {
132
154
  return *this;
133
155
  }
134
156
 
135
- template <typename OtherType>
136
- inline Complex<Type> operator-(const Complex<OtherType>& other) const {
137
- return Complex<Type>(this->r - other.r, this->i - other.i);
138
- }
157
+ template <typename OtherType>
158
+ inline Complex<Type> operator-(const Complex<OtherType>& other) const {
159
+ return Complex<Type>(this->r - other.r, this->i - other.i);
160
+ }
139
161
 
140
- template <typename OtherType>
141
- inline Complex<Type> operator*(const Complex<OtherType>& other) const {
142
- return Complex<Type>(this->r * other.r - this->i * other.i, this->r * other.i + this->i * other.r);
143
- }
162
+ template <typename OtherType>
163
+ inline Complex<Type> operator*(const Complex<OtherType>& other) const {
164
+ return Complex<Type>(this->r * other.r - this->i * other.i, this->r * other.i + this->i * other.r);
165
+ }
144
166
 
145
167
  template <typename OtherType>
146
168
  inline Complex<Type>& operator*=(const Complex<OtherType>& other) {
@@ -149,123 +171,125 @@ class Complex {
149
171
  return *this;
150
172
  }
151
173
 
152
- template <typename OtherType>
153
- inline Complex<Type> operator/(const Complex<OtherType>& other) const {
154
- Type new_r, new_i;
155
- Type denom = other.i * other.i + other.r * other.r;
156
-
157
- new_r = (this->r * other.r + this->i * other.i) / denom;
158
- new_i = (this->i * other.r - this->r * other.i) / denom;
159
-
160
- return Complex<Type>(new_r, new_i);
161
- }
162
-
163
- template <typename OtherType>
164
- inline Complex<Type> operator/=(const Complex<OtherType>& other) {
165
- Type new_r, new_i;
166
- Type denom = other.i * other.i + other.r * other.r;
167
-
168
- new_r = (this->r * other.r + this->i * other.i) / denom;
169
- new_i = (this->i * other.r - this->r * other.i) / denom;
170
-
171
- this->r = new_r;
172
- this->i = new_i;
173
- return *this;
174
- }
175
-
176
- template <typename OtherType>
177
- inline bool operator<(const Complex<OtherType>& other) const {
178
- return (this->r < other.r) || ((this->r <= other.r) && (this->i < other.i));
179
- }
180
-
181
- template <typename OtherType>
182
- inline bool operator>(const Complex<OtherType>& other) const {
183
- return (this->r > other.r) || ((this->r >= other.r) && (this->i > other.i));
184
- }
185
-
186
- template <typename OtherType>
187
- inline bool operator==(const Complex<OtherType>& other) const {
188
- return FP_EQUAL(this->r, other.r) && FP_EQUAL(this->i, other.i);
189
- }
190
-
191
- template <typename OtherType>
192
- inline bool operator!=(const Complex<OtherType>& other) const {
193
- return !(*this == other);
194
- }
195
-
196
- template <typename OtherType>
197
- inline bool operator<=(const Complex<OtherType>& other) const {
198
- return (*this < other) || (*this == other);
199
- }
200
-
201
- template <typename OtherType>
202
- inline bool operator>=(const Complex<OtherType>& other) const {
203
- return (*this > other) || (*this == other);
204
- }
205
-
206
- template <typename OtherType>
207
- inline operator Complex<OtherType> () const {
208
- return Complex<OtherType>((OtherType)this->r, (OtherType)this->i);
209
- }
210
-
211
- ///////////////////////////////
212
- // Complex-Native Operations //
213
- ///////////////////////////////
214
-
215
- template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
216
- inline Complex<Type> operator+(const NativeType& other) const {
217
- return *this + Complex<Type>(other);
218
- }
219
-
220
- template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
221
- inline Complex<Type> operator-(const NativeType& other) const {
222
- return *this - Complex<Type>(other);
223
- }
224
-
225
- template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
226
- inline Complex<Type> operator*(const NativeType& other) const {
227
- return *this * Complex<Type>(other);
228
- }
229
-
230
- template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
231
- inline Complex<Type> operator/(const NativeType& other) const {
232
- return *this / Complex<Type>(other);
233
- }
234
-
235
- template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
236
- inline bool operator<(const NativeType& other) const {
237
- return *this < Complex<Type>(other);
238
- }
239
-
240
- template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
241
- inline bool operator>(const NativeType& other) const {
242
- return *this > Complex<Type>(other);
243
- }
244
-
245
- template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
246
- inline bool operator==(const NativeType& other) const {
247
- return *this == Complex<Type>(other);
248
- }
249
-
250
- template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
251
- inline bool operator!=(const NativeType& other) const {
252
- return *this != Complex<Type>(other);
253
- }
254
-
255
- template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
256
- inline bool operator<=(const NativeType& other) const {
257
- return *this <= Complex<Type>(other);
258
- }
259
-
260
- template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
261
- inline bool operator>=(const NativeType& other) const {
262
- return *this >= Complex<Type>(other);
263
- }
264
-
265
- template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
266
- inline operator NativeType () const {
267
- return (NativeType)this->r;
268
- }
174
+ template <typename OtherType>
175
+ inline Complex<Type> operator/(const Complex<OtherType>& other) const {
176
+ Type new_r, new_i;
177
+ Type denom = other.i * other.i + other.r * other.r;
178
+
179
+ new_r = (this->r * other.r + this->i * other.i) / denom;
180
+ new_i = (this->i * other.r - this->r * other.i) / denom;
181
+
182
+ return Complex<Type>(new_r, new_i);
183
+ }
184
+
185
+ template <typename OtherType>
186
+ inline Complex<Type> operator/=(const Complex<OtherType>& other) {
187
+ Type new_r, new_i;
188
+ Type denom = other.i * other.i + other.r * other.r;
189
+
190
+ new_r = (this->r * other.r + this->i * other.i) / denom;
191
+ new_i = (this->i * other.r - this->r * other.i) / denom;
192
+
193
+ this->r = new_r;
194
+ this->i = new_i;
195
+ return *this;
196
+ }
197
+
198
+ template <typename OtherType>
199
+ inline bool operator<(const Complex<OtherType>& other) const {
200
+ return (this->r < other.r) || ((this->r <= other.r) && (this->i < other.i));
201
+ }
202
+
203
+ template <typename OtherType>
204
+ inline bool operator>(const Complex<OtherType>& other) const {
205
+ return (this->r > other.r) || ((this->r >= other.r) && (this->i > other.i));
206
+ }
207
+
208
+ template <typename OtherType>
209
+ inline bool operator==(const Complex<OtherType>& other) const {
210
+ return FP_EQUAL(this->r, other.r) && FP_EQUAL(this->i, other.i);
211
+ }
212
+
213
+ template <typename OtherType>
214
+ inline bool operator!=(const Complex<OtherType>& other) const {
215
+ return !(*this == other);
216
+ }
217
+
218
+ template <typename OtherType>
219
+ inline bool operator<=(const Complex<OtherType>& other) const {
220
+ return (*this < other) || (*this == other);
221
+ }
222
+
223
+ template <typename OtherType>
224
+ inline bool operator>=(const Complex<OtherType>& other) const {
225
+ return (*this > other) || (*this == other);
226
+ }
227
+
228
+ template <typename OtherType>
229
+ inline operator Complex<OtherType> () const {
230
+ return Complex<OtherType>((OtherType)this->r, (OtherType)this->i);
231
+ }
232
+
233
+ ///////////////////////////////
234
+ // Complex-Native Operations //
235
+ ///////////////////////////////
236
+
237
+ template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
238
+ inline Complex<Type> operator+(const NativeType& other) const {
239
+ return *this + Complex<Type>(other);
240
+ }
241
+
242
+ template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
243
+ inline Complex<Type> operator-(const NativeType& other) const {
244
+ return *this - Complex<Type>(other);
245
+ }
246
+
247
+ template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
248
+ inline Complex<Type> operator*(const NativeType& other) const {
249
+ return *this * Complex<Type>(other);
250
+ }
251
+
252
+ template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
253
+ inline Complex<Type> operator/(const NativeType& other) const {
254
+ return *this / Complex<Type>(other);
255
+ }
256
+
257
+ template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
258
+ inline bool operator<(const NativeType& other) const {
259
+ return *this < Complex<Type>(other);
260
+ }
261
+
262
+ template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
263
+ inline bool operator>(const NativeType& other) const {
264
+ return *this > Complex<Type>(other);
265
+ }
266
+
267
+ template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
268
+ inline bool operator==(const NativeType& other) const {
269
+ return *this == Complex<Type>(other);
270
+ }
271
+
272
+ template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
273
+ inline bool operator!=(const NativeType& other) const {
274
+ return *this != Complex<Type>(other);
275
+ }
276
+
277
+ template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
278
+ inline bool operator<=(const NativeType& other) const {
279
+ return *this <= Complex<Type>(other);
280
+ }
281
+
282
+ template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
283
+ inline bool operator>=(const NativeType& other) const {
284
+ return *this >= Complex<Type>(other);
285
+ }
286
+
287
+ template <typename NativeType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
288
+ inline operator NativeType () const {
289
+ return (NativeType)this->r;
290
+ }
291
+
292
+ operator RubyObject () const;
269
293
  };
270
294
 
271
295
  ///////////////////////////////
@@ -274,52 +298,52 @@ class Complex {
274
298
 
275
299
  template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
276
300
  inline Complex<ComplexType> operator+(const NativeType& left, const Complex<ComplexType>& right) {
277
- return Complex<ComplexType>(left) + right;
301
+ return Complex<ComplexType>(left) + right;
278
302
  }
279
303
 
280
304
  template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
281
305
  inline Complex<ComplexType> operator-(const NativeType& left, const Complex<ComplexType>& right) {
282
- return Complex<ComplexType>(left) - right;
306
+ return Complex<ComplexType>(left) - right;
283
307
  }
284
308
 
285
309
  template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
286
310
  inline Complex<ComplexType> operator*(const NativeType& left, const Complex<ComplexType>& right) {
287
- return Complex<ComplexType>(left) * right;
311
+ return Complex<ComplexType>(left) * right;
288
312
  }
289
313
 
290
314
  template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
291
315
  inline Complex<ComplexType> operator/(const NativeType& left, const Complex<ComplexType>& right) {
292
- return Complex<ComplexType>(left) / right;
316
+ return Complex<ComplexType>(left) / right;
293
317
  }
294
318
 
295
319
  template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
296
320
  inline bool operator<(const NativeType left, const Complex<ComplexType>& right) {
297
- return Complex<ComplexType>(left) < right;
321
+ return Complex<ComplexType>(left) < right;
298
322
  }
299
323
 
300
324
  template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
301
325
  inline bool operator>(const NativeType left, const Complex<ComplexType>& right) {
302
- return Complex<ComplexType>(left) > right;
326
+ return Complex<ComplexType>(left) > right;
303
327
  }
304
328
 
305
329
  template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
306
330
  inline bool operator==(const NativeType left, const Complex<ComplexType>& right) {
307
- return Complex<ComplexType>(left) == right;
331
+ return Complex<ComplexType>(left) == right;
308
332
  }
309
333
 
310
334
  template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
311
335
  inline bool operator!=(const NativeType left, const Complex<ComplexType>& right) {
312
- return Complex<ComplexType>(left) != right;
336
+ return Complex<ComplexType>(left) != right;
313
337
  }
314
338
 
315
339
  template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
316
340
  inline bool operator<=(const NativeType left, const Complex<ComplexType>& right) {
317
- return Complex<ComplexType>(left) <= right;
341
+ return Complex<ComplexType>(left) <= right;
318
342
  }
319
343
 
320
344
  template <typename NativeType, typename ComplexType, typename = typename std::enable_if<std::is_arithmetic<NativeType>::value>::type>
321
345
  inline bool operator>=(const NativeType left, const Complex<ComplexType>& right) {
322
- return Complex<ComplexType>(left) >= right;
346
+ return Complex<ComplexType>(left) >= right;
323
347
  }
324
348
 
325
349
  template <typename Type>
data/ext/nmatrix/data/data.h CHANGED
@@ -31,6 +31,8 @@
31
31
  /*
32
32
  * Standard Includes
33
33
  */
34
+
35
+ #include <ruby.h>
34
36
  #include <string>
35
37
 
36
38
  /*
@@ -51,11 +53,11 @@ namespace nm {
51
53
  * Constants
52
54
  */
53
55
 
54
- const int NUM_DTYPES = 10;
55
- const int NUM_ITYPES = 4;
56
- const int NUM_EWOPS = 12;
57
- const int NUM_UNARYOPS = 24;
58
- const int NUM_NONCOM_EWOPS = 3;
56
+ const int NUM_DTYPES = 10;
57
+ const int NUM_ITYPES = 4;
58
+ const int NUM_EWOPS = 12;
59
+ const int NUM_UNARYOPS = 24;
60
+ const int NUM_NONCOM_EWOPS = 3;
59
61
 
60
62
  enum ewop_t {
61
63
  EW_ADD,
@@ -114,32 +116,45 @@ namespace nm {
114
116
 
115
117
  template <typename Type>
116
118
  Complex<Type>::Complex(const RubyObject& other) {
119
+ *this = other;
120
+ }
121
+
122
+ template <typename Type>
123
+ Complex<Type>& Complex<Type>::operator=(const RubyObject& other) {
117
124
  switch(TYPE(other.rval)) {
118
125
  case T_COMPLEX:
119
- r = NUM2DBL(rb_funcall(other.rval, rb_intern("real"), 0));
120
- i = NUM2DBL(rb_funcall(other.rval, rb_intern("imag"), 0));
126
+ this->r = NUM2DBL(rb_funcall(other.rval, rb_intern("real"), 0));
127
+ this->i = NUM2DBL(rb_funcall(other.rval, rb_intern("imag"), 0));
121
128
  break;
122
129
  case T_FLOAT:
123
130
  case T_FIXNUM:
124
131
  case T_BIGNUM:
125
- r = NUM2DBL(other.rval);
126
- i = 0.0;
132
+ this->r = NUM2DBL(other.rval);
133
+ this->i = 0.0;
127
134
  break;
128
135
  default:
129
136
  rb_raise(rb_eTypeError, "not sure how to convert this type of VALUE to a complex");
130
137
  }
138
+ return *this;
139
+ }
140
+
141
+ template<typename Type>
142
+ Complex<Type>::operator RubyObject () const {
143
+ return RubyObject(*this);
131
144
  }
145
+
146
+ nm::RubyObject rubyobj_from_cval(void* val, nm::dtype_t dtype);
132
147
  } // end of namespace nm
133
148
 
134
149
  /*
135
150
  * Macros
136
151
  */
137
152
 
138
- #define STYPE_MARK_TABLE(name) \
139
- static void (*(name)[nm::NUM_STYPES])(STORAGE*) = { \
140
- nm_dense_storage_mark, \
141
- nm_list_storage_mark, \
142
- nm_yale_storage_mark \
153
+ #define STYPE_MARK_TABLE(name) \
154
+ static void (*(name)[nm::NUM_STYPES])(STORAGE*) = { \
155
+ nm_dense_storage_mark, \
156
+ nm_list_storage_mark, \
157
+ nm_yale_storage_mark \
143
158
  };
144
159
 
145
160
  #define STYPE_REGISTER_TABLE(name) \
@@ -170,45 +185,45 @@ namespace nm {
170
185
  #define DTYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_DTYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
171
186
 
172
187
  #define NAMED_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
173
- static ret (*(name)[nm::NUM_DTYPES])(__VA_ARGS__) = { \
174
- fun<uint8_t>, \
175
- fun<int8_t>, \
176
- fun<int16_t>, \
177
- fun<int32_t>, \
178
- fun<int64_t>, \
179
- fun<float32_t>, \
180
- fun<float64_t>, \
181
- fun<nm::Complex64>, \
182
- fun<nm::Complex128>, \
183
- fun<nm::RubyObject> \
184
- };
188
+ static ret (*(name)[nm::NUM_DTYPES])(__VA_ARGS__) = { \
189
+ fun<uint8_t>, \
190
+ fun<int8_t>, \
191
+ fun<int16_t>, \
192
+ fun<int32_t>, \
193
+ fun<int64_t>, \
194
+ fun<float32_t>, \
195
+ fun<float64_t>, \
196
+ fun<nm::Complex64>, \
197
+ fun<nm::Complex128>, \
198
+ fun<nm::RubyObject> \
199
+ };
185
200
 
186
201
  #define DTYPE_OBJECT_STATIC_TABLE(obj, fun, ret, ...) \
187
- static ret (*(ttable)[nm::NUM_DTYPES])(__VA_ARGS__) = { \
188
- obj<uint8_t>::fun, \
189
- obj<int8_t>::fun, \
190
- obj<int16_t>::fun, \
191
- obj<int32_t>::fun, \
192
- obj<int64_t>::fun, \
193
- obj<float32_t>::fun, \
194
- obj<float64_t>::fun, \
195
- obj<nm::Complex64>::fun, \
196
- obj<nm::Complex128>::fun, \
197
- obj<nm::RubyObject>::fun \
198
- };
202
+ static ret (*(ttable)[nm::NUM_DTYPES])(__VA_ARGS__) = { \
203
+ obj<uint8_t>::fun, \
204
+ obj<int8_t>::fun, \
205
+ obj<int16_t>::fun, \
206
+ obj<int32_t>::fun, \
207
+ obj<int64_t>::fun, \
208
+ obj<float32_t>::fun, \
209
+ obj<float64_t>::fun, \
210
+ obj<nm::Complex64>::fun, \
211
+ obj<nm::Complex128>::fun, \
212
+ obj<nm::RubyObject>::fun \
213
+ };
199
214
 
200
215
  #define NAMED_DTYPE_TEMPLATE_TABLE_NO_ROBJ(name, fun, ret, ...) \
201
- static ret (*(name)[nm::NUM_DTYPES])(__VA_ARGS__) = { \
202
- fun<uint8_t>, \
203
- fun<int8_t>, \
204
- fun<int16_t>, \
205
- fun<int32_t>, \
206
- fun<int64_t>, \
207
- fun<float32_t>, \
208
- fun<float64_t>, \
209
- fun<nm::Complex64>, \
210
- fun<nm::Complex128> \
211
- };
216
+ static ret (*(name)[nm::NUM_DTYPES])(__VA_ARGS__) = { \
217
+ fun<uint8_t>, \
218
+ fun<int8_t>, \
219
+ fun<int16_t>, \
220
+ fun<int32_t>, \
221
+ fun<int64_t>, \
222
+ fun<float32_t>, \
223
+ fun<float64_t>, \
224
+ fun<nm::Complex64>, \
225
+ fun<nm::Complex128> \
226
+ };
212
227
 
213
228
 
214
229
  /*
@@ -221,9 +236,9 @@ namespace nm {
221
236
  */
222
237
  #define LR_DTYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_LR_DTYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
223
238
 
224
- #define NAMED_LR_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
225
- static ret (*(name)[nm::NUM_DTYPES][nm::NUM_DTYPES])(__VA_ARGS__) = { \
226
- {fun<uint8_t, uint8_t>, fun<uint8_t, int8_t>, fun<uint8_t, int16_t>, fun<uint8_t, int32_t>, fun<uint8_t, int64_t>, fun<uint8_t, float32_t>, fun<uint8_t, float64_t>, fun<uint8_t, nm::Complex64>, fun<uint8_t, nm::Complex128>, fun<uint8_t, nm::RubyObject>}, \
239
+ #define NAMED_LR_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
240
+ static ret (*(name)[nm::NUM_DTYPES][nm::NUM_DTYPES])(__VA_ARGS__) = { \
241
+ {fun<uint8_t, uint8_t>, fun<uint8_t, int8_t>, fun<uint8_t, int16_t>, fun<uint8_t, int32_t>, fun<uint8_t, int64_t>, fun<uint8_t, float32_t>, fun<uint8_t, float64_t>, fun<uint8_t, nm::Complex64>, fun<uint8_t, nm::Complex128>, fun<uint8_t, nm::RubyObject>}, \
227
242
  {fun<int8_t, uint8_t>, fun<int8_t, int8_t>, fun<int8_t, int16_t>, fun<int8_t, int32_t>, fun<int8_t, int64_t>, fun<int8_t, float32_t>, fun<int8_t, float64_t>, fun<int8_t, nm::Complex64>, fun<int8_t, nm::Complex128>, fun<int8_t, nm::RubyObject>}, \
228
243
  {fun<int16_t, uint8_t>, fun<int16_t, int8_t>, fun<int16_t, int16_t>, fun<int16_t, int32_t>, fun<int16_t, int64_t>, fun<int16_t, float32_t>, fun<int16_t, float64_t>, fun<int16_t, nm::Complex64>, fun<int16_t, nm::Complex128>, fun<int16_t, nm::RubyObject>}, \
229
244
  {fun<int32_t, uint8_t>, fun<int32_t, int8_t>, fun<int32_t, int16_t>, fun<int32_t, int32_t>, fun<int32_t, int64_t>, fun<int32_t, float32_t>, fun<int32_t, float64_t>, fun<int32_t, nm::Complex64>, fun<int32_t, nm::Complex128>, fun<int32_t, nm::RubyObject>}, \
@@ -241,252 +256,252 @@ namespace nm {
241
256
  */
242
257
  #define OP_LR_DTYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_OP_LR_DTYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
243
258
 
244
- #define NAMED_OP_LR_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
245
- static ret (*(name)[nm::NUM_EWOPS][nm::NUM_DTYPES][nm::NUM_DTYPES])(__VA_ARGS__) = { \
246
- { \
247
- {fun<nm::EW_ADD, uint8_t, uint8_t>, fun<nm::EW_ADD, uint8_t, int8_t>, fun<nm::EW_ADD, uint8_t, int16_t>, fun<nm::EW_ADD, uint8_t, int32_t>, fun<nm::EW_ADD, uint8_t, int64_t>, \
248
- fun<nm::EW_ADD, uint8_t, float32_t>, fun<nm::EW_ADD, uint8_t, float64_t>, fun<nm::EW_ADD, uint8_t, nm::Complex64>, fun<nm::EW_ADD, uint8_t, nm::Complex128>, \
249
- fun<nm::EW_ADD, int8_t, float32_t>, fun<nm::EW_ADD, int8_t, float64_t>, fun<nm::EW_ADD, int8_t, nm::Complex64>, fun<nm::EW_ADD, int8_t, nm::Complex128>, \
250
- NULL}, \
251
- \
252
- {fun<nm::EW_ADD, int16_t, uint8_t>, fun<nm::EW_ADD, int16_t, int8_t>, fun<nm::EW_ADD, int16_t, int16_t>, fun<nm::EW_ADD, int16_t, int32_t>, fun<nm::EW_ADD, int16_t, int64_t>, \
253
- fun<nm::EW_ADD, int16_t, float32_t>, fun<nm::EW_ADD, int16_t, float64_t>, fun<nm::EW_ADD, int16_t, nm::Complex64>, fun<nm::EW_ADD, int16_t, nm::Complex128>, \
254
- NULL}, \
255
- \
256
- {fun<nm::EW_ADD, int32_t, uint8_t>, fun<nm::EW_ADD, int32_t, int8_t>, fun<nm::EW_ADD, int32_t, int16_t>, fun<nm::EW_ADD, int32_t, int32_t>, fun<nm::EW_ADD, int32_t, int64_t>, \
257
- fun<nm::EW_ADD, int32_t, float32_t>, fun<nm::EW_ADD, int32_t, float64_t>, fun<nm::EW_ADD, int32_t, nm::Complex64>, fun<nm::EW_ADD, int32_t, nm::Complex128>, \
258
- NULL}, \
259
- \
260
- {fun<nm::EW_ADD, int64_t, uint8_t>, fun<nm::EW_ADD, int64_t, int8_t>, fun<nm::EW_ADD, int64_t, int16_t>, fun<nm::EW_ADD, int64_t, int32_t>, fun<nm::EW_ADD, int64_t, int64_t>, \
261
- fun<nm::EW_ADD, int64_t, float32_t>, fun<nm::EW_ADD, int64_t, float64_t>, fun<nm::EW_ADD, int64_t, nm::Complex64>, fun<nm::EW_ADD, int64_t, nm::Complex128>, \
262
- NULL}, \
263
- \
264
- {fun<nm::EW_ADD, float32_t, uint8_t>, fun<nm::EW_ADD, float32_t, int8_t>, fun<nm::EW_ADD, float32_t, int16_t>, fun<nm::EW_ADD, float32_t, int32_t>, fun<nm::EW_ADD, float32_t, int64_t>, \
265
- fun<nm::EW_ADD, float32_t, float32_t>, fun<nm::EW_ADD, float32_t, float64_t>, fun<nm::EW_ADD, float32_t, nm::Complex64>, fun<nm::EW_ADD, float32_t, nm::Complex128>, \
266
- NULL}, \
267
- \
268
- {fun<nm::EW_ADD, float64_t, uint8_t>, fun<nm::EW_ADD, float64_t, int8_t>, fun<nm::EW_ADD, float64_t, int16_t>, fun<nm::EW_ADD, float64_t, int32_t>, fun<nm::EW_ADD, float64_t, int64_t>, \
269
- fun<nm::EW_ADD, float64_t, float32_t>, fun<nm::EW_ADD, float64_t, float64_t>, fun<nm::EW_ADD, float64_t, nm::Complex64>, fun<nm::EW_ADD, float64_t, nm::Complex128>, \
270
- NULL}, \
271
- \
272
- {fun<nm::EW_ADD, nm::Complex64, uint8_t>, fun<nm::EW_ADD, nm::Complex64, int8_t>, fun<nm::EW_ADD, nm::Complex64, int16_t>, fun<nm::EW_ADD, nm::Complex64, int32_t>, \
273
- fun<nm::EW_ADD, nm::Complex64, int64_t>, fun<nm::EW_ADD, nm::Complex64, float32_t>, fun<nm::EW_ADD, nm::Complex64, float64_t>, fun<nm::EW_ADD, nm::Complex64, nm::Complex64>, \
274
- fun<nm::EW_ADD, nm::Complex64, nm::Complex128>, \
275
- NULL}, \
276
- \
277
- {fun<nm::EW_ADD, nm::Complex128, uint8_t>, fun<nm::EW_ADD, nm::Complex128, int8_t>, fun<nm::EW_ADD, nm::Complex128, int16_t>, fun<nm::EW_ADD, nm::Complex128, int32_t>, \
278
- fun<nm::EW_ADD, nm::Complex128, int64_t>, fun<nm::EW_ADD, nm::Complex128, float32_t>, fun<nm::EW_ADD, nm::Complex128, float64_t>, fun<nm::EW_ADD, nm::Complex128, nm::Complex64>, \
279
- fun<nm::EW_ADD, nm::Complex128, nm::Complex128>, \
280
- NULL}, \
281
- {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_ADD, nm::RubyObject, nm::RubyObject>} \
282
- }, \
283
- \
284
- { \
285
- {fun<nm::EW_SUB, uint8_t, uint8_t>, fun<nm::EW_SUB, uint8_t, int8_t>, fun<nm::EW_SUB, uint8_t, int16_t>, fun<nm::EW_SUB, uint8_t, int32_t>, fun<nm::EW_SUB, uint8_t, int64_t>, \
286
- fun<nm::EW_SUB, uint8_t, float32_t>, fun<nm::EW_SUB, uint8_t, float64_t>, fun<nm::EW_SUB, uint8_t, nm::Complex64>, fun<nm::EW_SUB, uint8_t, nm::Complex128>, \
287
- NULL}, \
288
- \
289
- {fun<nm::EW_SUB, int8_t, uint8_t>, fun<nm::EW_SUB, int8_t, int8_t>, fun<nm::EW_SUB, int8_t, int16_t>, fun<nm::EW_SUB, int8_t, int32_t>, fun<nm::EW_SUB, int8_t, int64_t>, \
290
- fun<nm::EW_SUB, int8_t, float32_t>, fun<nm::EW_SUB, int8_t, float64_t>, fun<nm::EW_SUB, int8_t, nm::Complex64>, fun<nm::EW_SUB, int8_t, nm::Complex128>, \
291
- NULL}, \
292
- \
293
- {fun<nm::EW_SUB, int16_t, uint8_t>, fun<nm::EW_SUB, int16_t, int8_t>, fun<nm::EW_SUB, int16_t, int16_t>, fun<nm::EW_SUB, int16_t, int32_t>, fun<nm::EW_SUB, int16_t, int64_t>, \
294
- fun<nm::EW_SUB, int16_t, float32_t>, fun<nm::EW_SUB, int16_t, float64_t>, fun<nm::EW_SUB, int16_t, nm::Complex64>, fun<nm::EW_SUB, int16_t, nm::Complex128>, \
295
- NULL}, \
296
- \
297
- {fun<nm::EW_SUB, int32_t, uint8_t>, fun<nm::EW_SUB, int32_t, int8_t>, fun<nm::EW_SUB, int32_t, int16_t>, fun<nm::EW_SUB, int32_t, int32_t>, fun<nm::EW_SUB, int32_t, int64_t>, \
298
- fun<nm::EW_SUB, int32_t, float32_t>, fun<nm::EW_SUB, int32_t, float64_t>, fun<nm::EW_SUB, int32_t, nm::Complex64>, fun<nm::EW_SUB, int32_t, nm::Complex128>, \
299
- NULL}, \
300
- \
301
- {fun<nm::EW_SUB, int64_t, uint8_t>, fun<nm::EW_SUB, int64_t, int8_t>, fun<nm::EW_SUB, int64_t, int16_t>, fun<nm::EW_SUB, int64_t, int32_t>, fun<nm::EW_SUB, int64_t, int64_t>, \
302
- fun<nm::EW_SUB, int64_t, float32_t>, fun<nm::EW_SUB, int64_t, float64_t>, fun<nm::EW_SUB, int64_t, nm::Complex64>, fun<nm::EW_SUB, int64_t, nm::Complex128>, \
303
- NULL}, \
304
- \
305
- {fun<nm::EW_SUB, float32_t, uint8_t>, fun<nm::EW_SUB, float32_t, int8_t>, fun<nm::EW_SUB, float32_t, int16_t>, fun<nm::EW_SUB, float32_t, int32_t>, fun<nm::EW_SUB, float32_t, int64_t>, \
306
- fun<nm::EW_SUB, float32_t, float32_t>, fun<nm::EW_SUB, float32_t, float64_t>, fun<nm::EW_SUB, float32_t, nm::Complex64>, fun<nm::EW_SUB, float32_t, nm::Complex128>, \
307
- NULL}, \
308
- \
309
- {fun<nm::EW_SUB, float64_t, uint8_t>, fun<nm::EW_SUB, float64_t, int8_t>, fun<nm::EW_SUB, float64_t, int16_t>, fun<nm::EW_SUB, float64_t, int32_t>, fun<nm::EW_SUB, float64_t, int64_t>, \
310
- fun<nm::EW_SUB, float64_t, float32_t>, fun<nm::EW_SUB, float64_t, float64_t>, fun<nm::EW_SUB, float64_t, nm::Complex64>, fun<nm::EW_SUB, float64_t, nm::Complex128>, \
311
- NULL}, \
312
- \
313
- {fun<nm::EW_SUB, nm::Complex64, uint8_t>, fun<nm::EW_SUB, nm::Complex64, int8_t>, fun<nm::EW_SUB, nm::Complex64, int16_t>, fun<nm::EW_SUB, nm::Complex64, int32_t>, \
314
- fun<nm::EW_SUB, nm::Complex64, int64_t>, fun<nm::EW_SUB, nm::Complex64, float32_t>, fun<nm::EW_SUB, nm::Complex64, float64_t>, fun<nm::EW_SUB, nm::Complex64, nm::Complex64>, \
315
- fun<nm::EW_SUB, nm::Complex64, nm::Complex128>, \
316
- NULL}, \
317
- \
318
- {fun<nm::EW_SUB, nm::Complex128, uint8_t>, fun<nm::EW_SUB, nm::Complex128, int8_t>, fun<nm::EW_SUB, nm::Complex128, int16_t>, fun<nm::EW_SUB, nm::Complex128, int32_t>, \
319
- fun<nm::EW_SUB, nm::Complex128, int64_t>, fun<nm::EW_SUB, nm::Complex128, float32_t>, fun<nm::EW_SUB, nm::Complex128, float64_t>, fun<nm::EW_SUB, nm::Complex128, nm::Complex64>, \
320
- fun<nm::EW_SUB, nm::Complex128, nm::Complex128>, \
321
- \
322
- {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_SUB, nm::RubyObject, nm::RubyObject>} \
323
- }, \
324
- \
325
- { \
326
- {fun<nm::EW_MUL, uint8_t, uint8_t>, fun<nm::EW_MUL, uint8_t, int8_t>, fun<nm::EW_MUL, uint8_t, int16_t>, fun<nm::EW_MUL, uint8_t, int32_t>, fun<nm::EW_MUL, uint8_t, int64_t>, \
327
- fun<nm::EW_MUL, uint8_t, float32_t>, fun<nm::EW_MUL, uint8_t, float64_t>, fun<nm::EW_MUL, uint8_t, nm::Complex64>, fun<nm::EW_MUL, uint8_t, nm::Complex128>, \
328
- NULL}, \
329
- \
330
- {fun<nm::EW_MUL, int8_t, uint8_t>, fun<nm::EW_MUL, int8_t, int8_t>, fun<nm::EW_MUL, int8_t, int16_t>, fun<nm::EW_MUL, int8_t, int32_t>, fun<nm::EW_MUL, int8_t, int64_t>, \
331
- fun<nm::EW_MUL, int8_t, float32_t>, fun<nm::EW_MUL, int8_t, float64_t>, fun<nm::EW_MUL, int8_t, nm::Complex64>, fun<nm::EW_MUL, int8_t, nm::Complex128>, \
332
- NULL}, \
333
- \
334
- {fun<nm::EW_MUL, int16_t, uint8_t>, fun<nm::EW_MUL, int16_t, int8_t>, fun<nm::EW_MUL, int16_t, int16_t>, fun<nm::EW_MUL, int16_t, int32_t>, fun<nm::EW_MUL, int16_t, int64_t>, \
335
- fun<nm::EW_MUL, int16_t, float32_t>, fun<nm::EW_MUL, int16_t, float64_t>, fun<nm::EW_MUL, int16_t, nm::Complex64>, fun<nm::EW_MUL, int16_t, nm::Complex128>, \
336
- NULL}, \
337
- \
338
- {fun<nm::EW_MUL, int32_t, uint8_t>, fun<nm::EW_MUL, int32_t, int8_t>, fun<nm::EW_MUL, int32_t, int16_t>, fun<nm::EW_MUL, int32_t, int32_t>, fun<nm::EW_MUL, int32_t, int64_t>, \
339
- fun<nm::EW_MUL, int32_t, float32_t>, fun<nm::EW_MUL, int32_t, float64_t>, fun<nm::EW_MUL, int32_t, nm::Complex64>, fun<nm::EW_MUL, int32_t, nm::Complex128>, \
340
- NULL}, \
341
- \
342
- {fun<nm::EW_MUL, int64_t, uint8_t>, fun<nm::EW_MUL, int64_t, int8_t>, fun<nm::EW_MUL, int64_t, int16_t>, fun<nm::EW_MUL, int64_t, int32_t>, fun<nm::EW_MUL, int64_t, int64_t>, \
343
- fun<nm::EW_MUL, int64_t, float32_t>, fun<nm::EW_MUL, int64_t, float64_t>, fun<nm::EW_MUL, int64_t, nm::Complex64>, fun<nm::EW_MUL, int64_t, nm::Complex128>, \
344
- NULL}, \
345
- \
346
- {fun<nm::EW_MUL, float32_t, uint8_t>, fun<nm::EW_MUL, float32_t, int8_t>, fun<nm::EW_MUL, float32_t, int16_t>, fun<nm::EW_MUL, float32_t, int32_t>, fun<nm::EW_MUL, float32_t, int64_t>, \
347
- fun<nm::EW_MUL, float32_t, float32_t>, fun<nm::EW_MUL, float32_t, float64_t>, fun<nm::EW_MUL, float32_t, nm::Complex64>, fun<nm::EW_MUL, float32_t, nm::Complex128>, \
348
- NULL}, \
349
- \
350
- {fun<nm::EW_MUL, float64_t, uint8_t>, fun<nm::EW_MUL, float64_t, int8_t>, fun<nm::EW_MUL, float64_t, int16_t>, fun<nm::EW_MUL, float64_t, int32_t>, fun<nm::EW_MUL, float64_t, int64_t>, \
351
- fun<nm::EW_MUL, float64_t, float32_t>, fun<nm::EW_MUL, float64_t, float64_t>, fun<nm::EW_MUL, float64_t, nm::Complex64>, fun<nm::EW_MUL, float64_t, nm::Complex128>, \
352
- NULL}, \
353
- \
354
- {fun<nm::EW_MUL, nm::Complex64, uint8_t>, fun<nm::EW_MUL, nm::Complex64, int8_t>, fun<nm::EW_MUL, nm::Complex64, int16_t>, fun<nm::EW_MUL, nm::Complex64, int32_t>, \
355
- fun<nm::EW_MUL, nm::Complex64, int64_t>, fun<nm::EW_MUL, nm::Complex64, float32_t>, fun<nm::EW_MUL, nm::Complex64, float64_t>, fun<nm::EW_MUL, nm::Complex64, nm::Complex64>, \
356
- fun<nm::EW_MUL, nm::Complex64, nm::Complex128>, \
357
- NULL}, \
358
- \
359
- {fun<nm::EW_MUL, nm::Complex128, uint8_t>, fun<nm::EW_MUL, nm::Complex128, int8_t>, fun<nm::EW_MUL, nm::Complex128, int16_t>, fun<nm::EW_MUL, nm::Complex128, int32_t>, \
360
- fun<nm::EW_MUL, nm::Complex128, int64_t>, fun<nm::EW_MUL, nm::Complex128, float32_t>, fun<nm::EW_MUL, nm::Complex128, float64_t>, fun<nm::EW_MUL, nm::Complex128, nm::Complex64>, \
361
- fun<nm::EW_MUL, nm::Complex128, nm::Complex128>, \
362
- \
363
- { \
364
- {fun<nm::EW_DIV, uint8_t, uint8_t>, fun<nm::EW_DIV, uint8_t, int8_t>, fun<nm::EW_DIV, uint8_t, int16_t>, fun<nm::EW_DIV, uint8_t, int32_t>, fun<nm::EW_DIV, uint8_t, int64_t>, \
365
- fun<nm::EW_DIV, uint8_t, float32_t>, fun<nm::EW_DIV, uint8_t, float64_t>, fun<nm::EW_DIV, uint8_t, nm::Complex64>, fun<nm::EW_DIV, uint8_t, nm::Complex128>, \
366
- NULL}, \
367
- \
368
- {fun<nm::EW_DIV, int8_t, uint8_t>, fun<nm::EW_DIV, int8_t, int8_t>, fun<nm::EW_DIV, int8_t, int16_t>, fun<nm::EW_DIV, int8_t, int32_t>, fun<nm::EW_DIV, int8_t, int64_t>, \
369
- fun<nm::EW_DIV, int8_t, float32_t>, fun<nm::EW_DIV, int8_t, float64_t>, fun<nm::EW_DIV, int8_t, nm::Complex64>, fun<nm::EW_DIV, int8_t, nm::Complex128>, \
370
- NULL}, \
371
- \
372
- {fun<nm::EW_DIV, int16_t, uint8_t>, fun<nm::EW_DIV, int16_t, int8_t>, fun<nm::EW_DIV, int16_t, int16_t>, fun<nm::EW_DIV, int16_t, int32_t>, fun<nm::EW_DIV, int16_t, int64_t>, \
373
- fun<nm::EW_DIV, int16_t, float32_t>, fun<nm::EW_DIV, int16_t, float64_t>, fun<nm::EW_DIV, int16_t, nm::Complex64>, fun<nm::EW_DIV, int16_t, nm::Complex128>, \
374
- NULL}, \
375
- \
376
- {fun<nm::EW_DIV, int32_t, uint8_t>, fun<nm::EW_DIV, int32_t, int8_t>, fun<nm::EW_DIV, int32_t, int16_t>, fun<nm::EW_DIV, int32_t, int32_t>, fun<nm::EW_DIV, int32_t, int64_t>, \
377
- fun<nm::EW_DIV, int32_t, float32_t>, fun<nm::EW_DIV, int32_t, float64_t>, fun<nm::EW_DIV, int32_t, nm::Complex64>, fun<nm::EW_DIV, int32_t, nm::Complex128>, \
378
- NULL}, \
379
- \
380
- {fun<nm::EW_DIV, int64_t, uint8_t>, fun<nm::EW_DIV, int64_t, int8_t>, fun<nm::EW_DIV, int64_t, int16_t>, fun<nm::EW_DIV, int64_t, int32_t>, fun<nm::EW_DIV, int64_t, int64_t>, \
381
- fun<nm::EW_DIV, int64_t, float32_t>, fun<nm::EW_DIV, int64_t, float64_t>, fun<nm::EW_DIV, int64_t, nm::Complex64>, fun<nm::EW_DIV, int64_t, nm::Complex128>, \
382
- NULL}, \
383
- \
384
- {fun<nm::EW_DIV, float32_t, uint8_t>, fun<nm::EW_DIV, float32_t, int8_t>, fun<nm::EW_DIV, float32_t, int16_t>, fun<nm::EW_DIV, float32_t, int32_t>, fun<nm::EW_DIV, float32_t, int64_t>, \
385
- fun<nm::EW_DIV, float32_t, float32_t>, fun<nm::EW_DIV, float32_t, float64_t>, fun<nm::EW_DIV, float32_t, nm::Complex64>, fun<nm::EW_DIV, float32_t, nm::Complex128>, \
386
- NULL}, \
387
- \
388
- {fun<nm::EW_DIV, float64_t, uint8_t>, fun<nm::EW_DIV, float64_t, int8_t>, fun<nm::EW_DIV, float64_t, int16_t>, fun<nm::EW_DIV, float64_t, int32_t>, fun<nm::EW_DIV, float64_t, int64_t>, \
389
- fun<nm::EW_DIV, float64_t, float32_t>, fun<nm::EW_DIV, float64_t, float64_t>, fun<nm::EW_DIV, float64_t, nm::Complex64>, fun<nm::EW_DIV, float64_t, nm::Complex128>, \
390
- NULL}, \
391
- \
392
- {fun<nm::EW_DIV, nm::Complex64, uint8_t>, fun<nm::EW_DIV, nm::Complex64, int8_t>, fun<nm::EW_DIV, nm::Complex64, int16_t>, fun<nm::EW_DIV, nm::Complex64, int32_t>, \
393
- fun<nm::EW_DIV, nm::Complex64, int64_t>, fun<nm::EW_DIV, nm::Complex64, float32_t>, fun<nm::EW_DIV, nm::Complex64, float64_t>, fun<nm::EW_DIV, nm::Complex64, nm::Complex64>, \
394
- fun<nm::EW_DIV, nm::Complex64, nm::Complex128>, \
395
- NULL}, \
396
- \
397
- {fun<nm::EW_DIV, nm::Complex128, uint8_t>, fun<nm::EW_DIV, nm::Complex128, int8_t>, fun<nm::EW_DIV, nm::Complex128, int16_t>, fun<nm::EW_DIV, nm::Complex128, int32_t>, \
398
- fun<nm::EW_DIV, nm::Complex128, int64_t>, fun<nm::EW_DIV, nm::Complex128, float32_t>, fun<nm::EW_DIV, nm::Complex128, float64_t>, fun<nm::EW_DIV, nm::Complex128, nm::Complex64>, \
399
- fun<nm::EW_DIV, nm::Complex128, nm::Complex128>, \
400
- NULL}, \
259
+ #define NAMED_OP_LR_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
260
+ static ret (*(name)[nm::NUM_EWOPS][nm::NUM_DTYPES][nm::NUM_DTYPES])(__VA_ARGS__) = { \
261
+ { \
262
+ {fun<nm::EW_ADD, uint8_t, uint8_t>, fun<nm::EW_ADD, uint8_t, int8_t>, fun<nm::EW_ADD, uint8_t, int16_t>, fun<nm::EW_ADD, uint8_t, int32_t>, fun<nm::EW_ADD, uint8_t, int64_t>, \
263
+ fun<nm::EW_ADD, uint8_t, float32_t>, fun<nm::EW_ADD, uint8_t, float64_t>, fun<nm::EW_ADD, uint8_t, nm::Complex64>, fun<nm::EW_ADD, uint8_t, nm::Complex128>, \
264
+ fun<nm::EW_ADD, int8_t, float32_t>, fun<nm::EW_ADD, int8_t, float64_t>, fun<nm::EW_ADD, int8_t, nm::Complex64>, fun<nm::EW_ADD, int8_t, nm::Complex128>, \
265
+ NULL}, \
266
+ \
267
+ {fun<nm::EW_ADD, int16_t, uint8_t>, fun<nm::EW_ADD, int16_t, int8_t>, fun<nm::EW_ADD, int16_t, int16_t>, fun<nm::EW_ADD, int16_t, int32_t>, fun<nm::EW_ADD, int16_t, int64_t>, \
268
+ fun<nm::EW_ADD, int16_t, float32_t>, fun<nm::EW_ADD, int16_t, float64_t>, fun<nm::EW_ADD, int16_t, nm::Complex64>, fun<nm::EW_ADD, int16_t, nm::Complex128>, \
269
+ NULL}, \
270
+ \
271
+ {fun<nm::EW_ADD, int32_t, uint8_t>, fun<nm::EW_ADD, int32_t, int8_t>, fun<nm::EW_ADD, int32_t, int16_t>, fun<nm::EW_ADD, int32_t, int32_t>, fun<nm::EW_ADD, int32_t, int64_t>, \
272
+ fun<nm::EW_ADD, int32_t, float32_t>, fun<nm::EW_ADD, int32_t, float64_t>, fun<nm::EW_ADD, int32_t, nm::Complex64>, fun<nm::EW_ADD, int32_t, nm::Complex128>, \
273
+ NULL}, \
274
+ \
275
+ {fun<nm::EW_ADD, int64_t, uint8_t>, fun<nm::EW_ADD, int64_t, int8_t>, fun<nm::EW_ADD, int64_t, int16_t>, fun<nm::EW_ADD, int64_t, int32_t>, fun<nm::EW_ADD, int64_t, int64_t>, \
276
+ fun<nm::EW_ADD, int64_t, float32_t>, fun<nm::EW_ADD, int64_t, float64_t>, fun<nm::EW_ADD, int64_t, nm::Complex64>, fun<nm::EW_ADD, int64_t, nm::Complex128>, \
277
+ NULL}, \
278
+ \
279
+ {fun<nm::EW_ADD, float32_t, uint8_t>, fun<nm::EW_ADD, float32_t, int8_t>, fun<nm::EW_ADD, float32_t, int16_t>, fun<nm::EW_ADD, float32_t, int32_t>, fun<nm::EW_ADD, float32_t, int64_t>, \
280
+ fun<nm::EW_ADD, float32_t, float32_t>, fun<nm::EW_ADD, float32_t, float64_t>, fun<nm::EW_ADD, float32_t, nm::Complex64>, fun<nm::EW_ADD, float32_t, nm::Complex128>, \
281
+ NULL}, \
282
+ \
283
+ {fun<nm::EW_ADD, float64_t, uint8_t>, fun<nm::EW_ADD, float64_t, int8_t>, fun<nm::EW_ADD, float64_t, int16_t>, fun<nm::EW_ADD, float64_t, int32_t>, fun<nm::EW_ADD, float64_t, int64_t>, \
284
+ fun<nm::EW_ADD, float64_t, float32_t>, fun<nm::EW_ADD, float64_t, float64_t>, fun<nm::EW_ADD, float64_t, nm::Complex64>, fun<nm::EW_ADD, float64_t, nm::Complex128>, \
285
+ NULL}, \
286
+ \
287
+ {fun<nm::EW_ADD, nm::Complex64, uint8_t>, fun<nm::EW_ADD, nm::Complex64, int8_t>, fun<nm::EW_ADD, nm::Complex64, int16_t>, fun<nm::EW_ADD, nm::Complex64, int32_t>, \
288
+ fun<nm::EW_ADD, nm::Complex64, int64_t>, fun<nm::EW_ADD, nm::Complex64, float32_t>, fun<nm::EW_ADD, nm::Complex64, float64_t>, fun<nm::EW_ADD, nm::Complex64, nm::Complex64>, \
289
+ fun<nm::EW_ADD, nm::Complex64, nm::Complex128>, \
290
+ NULL}, \
291
+ \
292
+ {fun<nm::EW_ADD, nm::Complex128, uint8_t>, fun<nm::EW_ADD, nm::Complex128, int8_t>, fun<nm::EW_ADD, nm::Complex128, int16_t>, fun<nm::EW_ADD, nm::Complex128, int32_t>, \
293
+ fun<nm::EW_ADD, nm::Complex128, int64_t>, fun<nm::EW_ADD, nm::Complex128, float32_t>, fun<nm::EW_ADD, nm::Complex128, float64_t>, fun<nm::EW_ADD, nm::Complex128, nm::Complex64>, \
294
+ fun<nm::EW_ADD, nm::Complex128, nm::Complex128>, \
295
+ NULL}, \
296
+ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_ADD, nm::RubyObject, nm::RubyObject>} \
297
+ }, \
298
+ \
299
+ { \
300
+ {fun<nm::EW_SUB, uint8_t, uint8_t>, fun<nm::EW_SUB, uint8_t, int8_t>, fun<nm::EW_SUB, uint8_t, int16_t>, fun<nm::EW_SUB, uint8_t, int32_t>, fun<nm::EW_SUB, uint8_t, int64_t>, \
301
+ fun<nm::EW_SUB, uint8_t, float32_t>, fun<nm::EW_SUB, uint8_t, float64_t>, fun<nm::EW_SUB, uint8_t, nm::Complex64>, fun<nm::EW_SUB, uint8_t, nm::Complex128>, \
302
+ NULL}, \
303
+ \
304
+ {fun<nm::EW_SUB, int8_t, uint8_t>, fun<nm::EW_SUB, int8_t, int8_t>, fun<nm::EW_SUB, int8_t, int16_t>, fun<nm::EW_SUB, int8_t, int32_t>, fun<nm::EW_SUB, int8_t, int64_t>, \
305
+ fun<nm::EW_SUB, int8_t, float32_t>, fun<nm::EW_SUB, int8_t, float64_t>, fun<nm::EW_SUB, int8_t, nm::Complex64>, fun<nm::EW_SUB, int8_t, nm::Complex128>, \
306
+ NULL}, \
307
+ \
308
+ {fun<nm::EW_SUB, int16_t, uint8_t>, fun<nm::EW_SUB, int16_t, int8_t>, fun<nm::EW_SUB, int16_t, int16_t>, fun<nm::EW_SUB, int16_t, int32_t>, fun<nm::EW_SUB, int16_t, int64_t>, \
309
+ fun<nm::EW_SUB, int16_t, float32_t>, fun<nm::EW_SUB, int16_t, float64_t>, fun<nm::EW_SUB, int16_t, nm::Complex64>, fun<nm::EW_SUB, int16_t, nm::Complex128>, \
310
+ NULL}, \
311
+ \
312
+ {fun<nm::EW_SUB, int32_t, uint8_t>, fun<nm::EW_SUB, int32_t, int8_t>, fun<nm::EW_SUB, int32_t, int16_t>, fun<nm::EW_SUB, int32_t, int32_t>, fun<nm::EW_SUB, int32_t, int64_t>, \
313
+ fun<nm::EW_SUB, int32_t, float32_t>, fun<nm::EW_SUB, int32_t, float64_t>, fun<nm::EW_SUB, int32_t, nm::Complex64>, fun<nm::EW_SUB, int32_t, nm::Complex128>, \
314
+ NULL}, \
315
+ \
316
+ {fun<nm::EW_SUB, int64_t, uint8_t>, fun<nm::EW_SUB, int64_t, int8_t>, fun<nm::EW_SUB, int64_t, int16_t>, fun<nm::EW_SUB, int64_t, int32_t>, fun<nm::EW_SUB, int64_t, int64_t>, \
317
+ fun<nm::EW_SUB, int64_t, float32_t>, fun<nm::EW_SUB, int64_t, float64_t>, fun<nm::EW_SUB, int64_t, nm::Complex64>, fun<nm::EW_SUB, int64_t, nm::Complex128>, \
318
+ NULL}, \
319
+ \
320
+ {fun<nm::EW_SUB, float32_t, uint8_t>, fun<nm::EW_SUB, float32_t, int8_t>, fun<nm::EW_SUB, float32_t, int16_t>, fun<nm::EW_SUB, float32_t, int32_t>, fun<nm::EW_SUB, float32_t, int64_t>, \
321
+ fun<nm::EW_SUB, float32_t, float32_t>, fun<nm::EW_SUB, float32_t, float64_t>, fun<nm::EW_SUB, float32_t, nm::Complex64>, fun<nm::EW_SUB, float32_t, nm::Complex128>, \
322
+ NULL}, \
323
+ \
324
+ {fun<nm::EW_SUB, float64_t, uint8_t>, fun<nm::EW_SUB, float64_t, int8_t>, fun<nm::EW_SUB, float64_t, int16_t>, fun<nm::EW_SUB, float64_t, int32_t>, fun<nm::EW_SUB, float64_t, int64_t>, \
325
+ fun<nm::EW_SUB, float64_t, float32_t>, fun<nm::EW_SUB, float64_t, float64_t>, fun<nm::EW_SUB, float64_t, nm::Complex64>, fun<nm::EW_SUB, float64_t, nm::Complex128>, \
326
+ NULL}, \
327
+ \
328
+ {fun<nm::EW_SUB, nm::Complex64, uint8_t>, fun<nm::EW_SUB, nm::Complex64, int8_t>, fun<nm::EW_SUB, nm::Complex64, int16_t>, fun<nm::EW_SUB, nm::Complex64, int32_t>, \
329
+ fun<nm::EW_SUB, nm::Complex64, int64_t>, fun<nm::EW_SUB, nm::Complex64, float32_t>, fun<nm::EW_SUB, nm::Complex64, float64_t>, fun<nm::EW_SUB, nm::Complex64, nm::Complex64>, \
330
+ fun<nm::EW_SUB, nm::Complex64, nm::Complex128>, \
331
+ NULL}, \
332
+ \
333
+ {fun<nm::EW_SUB, nm::Complex128, uint8_t>, fun<nm::EW_SUB, nm::Complex128, int8_t>, fun<nm::EW_SUB, nm::Complex128, int16_t>, fun<nm::EW_SUB, nm::Complex128, int32_t>, \
334
+ fun<nm::EW_SUB, nm::Complex128, int64_t>, fun<nm::EW_SUB, nm::Complex128, float32_t>, fun<nm::EW_SUB, nm::Complex128, float64_t>, fun<nm::EW_SUB, nm::Complex128, nm::Complex64>, \
335
+ fun<nm::EW_SUB, nm::Complex128, nm::Complex128>, \
336
+ \
337
+ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_SUB, nm::RubyObject, nm::RubyObject>} \
338
+ }, \
339
+ \
340
+ { \
341
+ {fun<nm::EW_MUL, uint8_t, uint8_t>, fun<nm::EW_MUL, uint8_t, int8_t>, fun<nm::EW_MUL, uint8_t, int16_t>, fun<nm::EW_MUL, uint8_t, int32_t>, fun<nm::EW_MUL, uint8_t, int64_t>, \
342
+ fun<nm::EW_MUL, uint8_t, float32_t>, fun<nm::EW_MUL, uint8_t, float64_t>, fun<nm::EW_MUL, uint8_t, nm::Complex64>, fun<nm::EW_MUL, uint8_t, nm::Complex128>, \
343
+ NULL}, \
344
+ \
345
+ {fun<nm::EW_MUL, int8_t, uint8_t>, fun<nm::EW_MUL, int8_t, int8_t>, fun<nm::EW_MUL, int8_t, int16_t>, fun<nm::EW_MUL, int8_t, int32_t>, fun<nm::EW_MUL, int8_t, int64_t>, \
346
+ fun<nm::EW_MUL, int8_t, float32_t>, fun<nm::EW_MUL, int8_t, float64_t>, fun<nm::EW_MUL, int8_t, nm::Complex64>, fun<nm::EW_MUL, int8_t, nm::Complex128>, \
347
+ NULL}, \
348
+ \
349
+ {fun<nm::EW_MUL, int16_t, uint8_t>, fun<nm::EW_MUL, int16_t, int8_t>, fun<nm::EW_MUL, int16_t, int16_t>, fun<nm::EW_MUL, int16_t, int32_t>, fun<nm::EW_MUL, int16_t, int64_t>, \
350
+ fun<nm::EW_MUL, int16_t, float32_t>, fun<nm::EW_MUL, int16_t, float64_t>, fun<nm::EW_MUL, int16_t, nm::Complex64>, fun<nm::EW_MUL, int16_t, nm::Complex128>, \
351
+ NULL}, \
352
+ \
353
+ {fun<nm::EW_MUL, int32_t, uint8_t>, fun<nm::EW_MUL, int32_t, int8_t>, fun<nm::EW_MUL, int32_t, int16_t>, fun<nm::EW_MUL, int32_t, int32_t>, fun<nm::EW_MUL, int32_t, int64_t>, \
354
+ fun<nm::EW_MUL, int32_t, float32_t>, fun<nm::EW_MUL, int32_t, float64_t>, fun<nm::EW_MUL, int32_t, nm::Complex64>, fun<nm::EW_MUL, int32_t, nm::Complex128>, \
355
+ NULL}, \
356
+ \
357
+ {fun<nm::EW_MUL, int64_t, uint8_t>, fun<nm::EW_MUL, int64_t, int8_t>, fun<nm::EW_MUL, int64_t, int16_t>, fun<nm::EW_MUL, int64_t, int32_t>, fun<nm::EW_MUL, int64_t, int64_t>, \
358
+ fun<nm::EW_MUL, int64_t, float32_t>, fun<nm::EW_MUL, int64_t, float64_t>, fun<nm::EW_MUL, int64_t, nm::Complex64>, fun<nm::EW_MUL, int64_t, nm::Complex128>, \
359
+ NULL}, \
360
+ \
361
+ {fun<nm::EW_MUL, float32_t, uint8_t>, fun<nm::EW_MUL, float32_t, int8_t>, fun<nm::EW_MUL, float32_t, int16_t>, fun<nm::EW_MUL, float32_t, int32_t>, fun<nm::EW_MUL, float32_t, int64_t>, \
362
+ fun<nm::EW_MUL, float32_t, float32_t>, fun<nm::EW_MUL, float32_t, float64_t>, fun<nm::EW_MUL, float32_t, nm::Complex64>, fun<nm::EW_MUL, float32_t, nm::Complex128>, \
363
+ NULL}, \
364
+ \
365
+ {fun<nm::EW_MUL, float64_t, uint8_t>, fun<nm::EW_MUL, float64_t, int8_t>, fun<nm::EW_MUL, float64_t, int16_t>, fun<nm::EW_MUL, float64_t, int32_t>, fun<nm::EW_MUL, float64_t, int64_t>, \
366
+ fun<nm::EW_MUL, float64_t, float32_t>, fun<nm::EW_MUL, float64_t, float64_t>, fun<nm::EW_MUL, float64_t, nm::Complex64>, fun<nm::EW_MUL, float64_t, nm::Complex128>, \
367
+ NULL}, \
368
+ \
369
+ {fun<nm::EW_MUL, nm::Complex64, uint8_t>, fun<nm::EW_MUL, nm::Complex64, int8_t>, fun<nm::EW_MUL, nm::Complex64, int16_t>, fun<nm::EW_MUL, nm::Complex64, int32_t>, \
370
+ fun<nm::EW_MUL, nm::Complex64, int64_t>, fun<nm::EW_MUL, nm::Complex64, float32_t>, fun<nm::EW_MUL, nm::Complex64, float64_t>, fun<nm::EW_MUL, nm::Complex64, nm::Complex64>, \
371
+ fun<nm::EW_MUL, nm::Complex64, nm::Complex128>, \
372
+ NULL}, \
373
+ \
374
+ {fun<nm::EW_MUL, nm::Complex128, uint8_t>, fun<nm::EW_MUL, nm::Complex128, int8_t>, fun<nm::EW_MUL, nm::Complex128, int16_t>, fun<nm::EW_MUL, nm::Complex128, int32_t>, \
375
+ fun<nm::EW_MUL, nm::Complex128, int64_t>, fun<nm::EW_MUL, nm::Complex128, float32_t>, fun<nm::EW_MUL, nm::Complex128, float64_t>, fun<nm::EW_MUL, nm::Complex128, nm::Complex64>, \
376
+ fun<nm::EW_MUL, nm::Complex128, nm::Complex128>, \
377
+ \
378
+ { \
379
+ {fun<nm::EW_DIV, uint8_t, uint8_t>, fun<nm::EW_DIV, uint8_t, int8_t>, fun<nm::EW_DIV, uint8_t, int16_t>, fun<nm::EW_DIV, uint8_t, int32_t>, fun<nm::EW_DIV, uint8_t, int64_t>, \
380
+ fun<nm::EW_DIV, uint8_t, float32_t>, fun<nm::EW_DIV, uint8_t, float64_t>, fun<nm::EW_DIV, uint8_t, nm::Complex64>, fun<nm::EW_DIV, uint8_t, nm::Complex128>, \
381
+ NULL}, \
382
+ \
383
+ {fun<nm::EW_DIV, int8_t, uint8_t>, fun<nm::EW_DIV, int8_t, int8_t>, fun<nm::EW_DIV, int8_t, int16_t>, fun<nm::EW_DIV, int8_t, int32_t>, fun<nm::EW_DIV, int8_t, int64_t>, \
384
+ fun<nm::EW_DIV, int8_t, float32_t>, fun<nm::EW_DIV, int8_t, float64_t>, fun<nm::EW_DIV, int8_t, nm::Complex64>, fun<nm::EW_DIV, int8_t, nm::Complex128>, \
385
+ NULL}, \
386
+ \
387
+ {fun<nm::EW_DIV, int16_t, uint8_t>, fun<nm::EW_DIV, int16_t, int8_t>, fun<nm::EW_DIV, int16_t, int16_t>, fun<nm::EW_DIV, int16_t, int32_t>, fun<nm::EW_DIV, int16_t, int64_t>, \
388
+ fun<nm::EW_DIV, int16_t, float32_t>, fun<nm::EW_DIV, int16_t, float64_t>, fun<nm::EW_DIV, int16_t, nm::Complex64>, fun<nm::EW_DIV, int16_t, nm::Complex128>, \
389
+ NULL}, \
390
+ \
391
+ {fun<nm::EW_DIV, int32_t, uint8_t>, fun<nm::EW_DIV, int32_t, int8_t>, fun<nm::EW_DIV, int32_t, int16_t>, fun<nm::EW_DIV, int32_t, int32_t>, fun<nm::EW_DIV, int32_t, int64_t>, \
392
+ fun<nm::EW_DIV, int32_t, float32_t>, fun<nm::EW_DIV, int32_t, float64_t>, fun<nm::EW_DIV, int32_t, nm::Complex64>, fun<nm::EW_DIV, int32_t, nm::Complex128>, \
393
+ NULL}, \
394
+ \
395
+ {fun<nm::EW_DIV, int64_t, uint8_t>, fun<nm::EW_DIV, int64_t, int8_t>, fun<nm::EW_DIV, int64_t, int16_t>, fun<nm::EW_DIV, int64_t, int32_t>, fun<nm::EW_DIV, int64_t, int64_t>, \
396
+ fun<nm::EW_DIV, int64_t, float32_t>, fun<nm::EW_DIV, int64_t, float64_t>, fun<nm::EW_DIV, int64_t, nm::Complex64>, fun<nm::EW_DIV, int64_t, nm::Complex128>, \
397
+ NULL}, \
398
+ \
399
+ {fun<nm::EW_DIV, float32_t, uint8_t>, fun<nm::EW_DIV, float32_t, int8_t>, fun<nm::EW_DIV, float32_t, int16_t>, fun<nm::EW_DIV, float32_t, int32_t>, fun<nm::EW_DIV, float32_t, int64_t>, \
400
+ fun<nm::EW_DIV, float32_t, float32_t>, fun<nm::EW_DIV, float32_t, float64_t>, fun<nm::EW_DIV, float32_t, nm::Complex64>, fun<nm::EW_DIV, float32_t, nm::Complex128>, \
401
+ NULL}, \
402
+ \
403
+ {fun<nm::EW_DIV, float64_t, uint8_t>, fun<nm::EW_DIV, float64_t, int8_t>, fun<nm::EW_DIV, float64_t, int16_t>, fun<nm::EW_DIV, float64_t, int32_t>, fun<nm::EW_DIV, float64_t, int64_t>, \
404
+ fun<nm::EW_DIV, float64_t, float32_t>, fun<nm::EW_DIV, float64_t, float64_t>, fun<nm::EW_DIV, float64_t, nm::Complex64>, fun<nm::EW_DIV, float64_t, nm::Complex128>, \
405
+ NULL}, \
406
+ \
407
+ {fun<nm::EW_DIV, nm::Complex64, uint8_t>, fun<nm::EW_DIV, nm::Complex64, int8_t>, fun<nm::EW_DIV, nm::Complex64, int16_t>, fun<nm::EW_DIV, nm::Complex64, int32_t>, \
408
+ fun<nm::EW_DIV, nm::Complex64, int64_t>, fun<nm::EW_DIV, nm::Complex64, float32_t>, fun<nm::EW_DIV, nm::Complex64, float64_t>, fun<nm::EW_DIV, nm::Complex64, nm::Complex64>, \
409
+ fun<nm::EW_DIV, nm::Complex64, nm::Complex128>, \
410
+ NULL}, \
411
+ \
412
+ {fun<nm::EW_DIV, nm::Complex128, uint8_t>, fun<nm::EW_DIV, nm::Complex128, int8_t>, fun<nm::EW_DIV, nm::Complex128, int16_t>, fun<nm::EW_DIV, nm::Complex128, int32_t>, \
413
+ fun<nm::EW_DIV, nm::Complex128, int64_t>, fun<nm::EW_DIV, nm::Complex128, float32_t>, fun<nm::EW_DIV, nm::Complex128, float64_t>, fun<nm::EW_DIV, nm::Complex128, nm::Complex64>, \
414
+ fun<nm::EW_DIV, nm::Complex128, nm::Complex128>, \
415
+ NULL}, \
401
416
  \
402
- {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_DIV, nm::RubyObject, nm::RubyObject>} \
403
- }, \
404
- \
417
+ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_DIV, nm::RubyObject, nm::RubyObject>} \
418
+ }, \
419
+ \
405
420
  { \
406
- {fun<nm::EW_POW, uint8_t, uint8_t>, fun<nm::EW_POW, uint8_t, int8_t>, fun<nm::EW_POW, uint8_t, int16_t>, fun<nm::EW_POW, uint8_t, int32_t>, fun<nm::EW_POW, uint8_t, int64_t>, \
407
- fun<nm::EW_POW, uint8_t, float32_t>, fun<nm::EW_POW, uint8_t, float64_t>, fun<nm::EW_POW, uint8_t, nm::Complex64>, fun<nm::EW_POW, uint8_t, nm::Complex128>, \
408
- NULL}, \
421
+ {fun<nm::EW_POW, uint8_t, uint8_t>, fun<nm::EW_POW, uint8_t, int8_t>, fun<nm::EW_POW, uint8_t, int16_t>, fun<nm::EW_POW, uint8_t, int32_t>, fun<nm::EW_POW, uint8_t, int64_t>, \
422
+ fun<nm::EW_POW, uint8_t, float32_t>, fun<nm::EW_POW, uint8_t, float64_t>, fun<nm::EW_POW, uint8_t, nm::Complex64>, fun<nm::EW_POW, uint8_t, nm::Complex128>, \
423
+ NULL}, \
409
424
  \
410
- {fun<nm::EW_POW, int8_t, uint8_t>, fun<nm::EW_POW, int8_t, int8_t>, fun<nm::EW_POW, int8_t, int16_t>, fun<nm::EW_POW, int8_t, int32_t>, fun<nm::EW_POW, int8_t, int64_t>, \
411
- fun<nm::EW_POW, int8_t, float32_t>, fun<nm::EW_POW, int8_t, float64_t>, fun<nm::EW_POW, int8_t, nm::Complex64>, fun<nm::EW_POW, int8_t, nm::Complex128>, \
412
- NULL}, \
425
+ {fun<nm::EW_POW, int8_t, uint8_t>, fun<nm::EW_POW, int8_t, int8_t>, fun<nm::EW_POW, int8_t, int16_t>, fun<nm::EW_POW, int8_t, int32_t>, fun<nm::EW_POW, int8_t, int64_t>, \
426
+ fun<nm::EW_POW, int8_t, float32_t>, fun<nm::EW_POW, int8_t, float64_t>, fun<nm::EW_POW, int8_t, nm::Complex64>, fun<nm::EW_POW, int8_t, nm::Complex128>, \
427
+ NULL}, \
413
428
  \
414
- {fun<nm::EW_POW, int16_t, uint8_t>, fun<nm::EW_POW, int16_t, int8_t>, fun<nm::EW_POW, int16_t, int16_t>, fun<nm::EW_POW, int16_t, int32_t>, fun<nm::EW_POW, int16_t, int64_t>, \
415
- fun<nm::EW_POW, int16_t, float32_t>, fun<nm::EW_POW, int16_t, float64_t>, fun<nm::EW_POW, int16_t, nm::Complex64>, fun<nm::EW_POW, int16_t, nm::Complex128>, \
416
- NULL}, \
429
+ {fun<nm::EW_POW, int16_t, uint8_t>, fun<nm::EW_POW, int16_t, int8_t>, fun<nm::EW_POW, int16_t, int16_t>, fun<nm::EW_POW, int16_t, int32_t>, fun<nm::EW_POW, int16_t, int64_t>, \
430
+ fun<nm::EW_POW, int16_t, float32_t>, fun<nm::EW_POW, int16_t, float64_t>, fun<nm::EW_POW, int16_t, nm::Complex64>, fun<nm::EW_POW, int16_t, nm::Complex128>, \
431
+ NULL}, \
417
432
  \
418
- {fun<nm::EW_POW, int32_t, uint8_t>, fun<nm::EW_POW, int32_t, int8_t>, fun<nm::EW_POW, int32_t, int16_t>, fun<nm::EW_POW, int32_t, int32_t>, fun<nm::EW_POW, int32_t, int64_t>, \
419
- fun<nm::EW_POW, int32_t, float32_t>, fun<nm::EW_POW, int32_t, float64_t>, fun<nm::EW_POW, int32_t, nm::Complex64>, fun<nm::EW_POW, int32_t, nm::Complex128>, \
420
- NULL}, \
433
+ {fun<nm::EW_POW, int32_t, uint8_t>, fun<nm::EW_POW, int32_t, int8_t>, fun<nm::EW_POW, int32_t, int16_t>, fun<nm::EW_POW, int32_t, int32_t>, fun<nm::EW_POW, int32_t, int64_t>, \
434
+ fun<nm::EW_POW, int32_t, float32_t>, fun<nm::EW_POW, int32_t, float64_t>, fun<nm::EW_POW, int32_t, nm::Complex64>, fun<nm::EW_POW, int32_t, nm::Complex128>, \
435
+ NULL}, \
421
436
  \
422
- {fun<nm::EW_POW, int64_t, uint8_t>, fun<nm::EW_POW, int64_t, int8_t>, fun<nm::EW_POW, int64_t, int16_t>, fun<nm::EW_POW, int64_t, int32_t>, fun<nm::EW_POW, int64_t, int64_t>, \
423
- fun<nm::EW_POW, int64_t, float32_t>, fun<nm::EW_POW, int64_t, float64_t>, fun<nm::EW_POW, int64_t, nm::Complex64>, fun<nm::EW_POW, int64_t, nm::Complex128>, \
424
- NULL}, \
437
+ {fun<nm::EW_POW, int64_t, uint8_t>, fun<nm::EW_POW, int64_t, int8_t>, fun<nm::EW_POW, int64_t, int16_t>, fun<nm::EW_POW, int64_t, int32_t>, fun<nm::EW_POW, int64_t, int64_t>, \
438
+ fun<nm::EW_POW, int64_t, float32_t>, fun<nm::EW_POW, int64_t, float64_t>, fun<nm::EW_POW, int64_t, nm::Complex64>, fun<nm::EW_POW, int64_t, nm::Complex128>, \
439
+ NULL}, \
425
440
  \
426
- {fun<nm::EW_POW, float32_t, uint8_t>, fun<nm::EW_POW, float32_t, int8_t>, fun<nm::EW_POW, float32_t, int16_t>, fun<nm::EW_POW, float32_t, int32_t>, fun<nm::EW_POW, float32_t, int64_t>, \
427
- fun<nm::EW_POW, float32_t, float32_t>, fun<nm::EW_POW, float32_t, float64_t>, fun<nm::EW_POW, float32_t, nm::Complex64>, fun<nm::EW_POW, float32_t, nm::Complex128>, \
428
- NULL}, \
441
+ {fun<nm::EW_POW, float32_t, uint8_t>, fun<nm::EW_POW, float32_t, int8_t>, fun<nm::EW_POW, float32_t, int16_t>, fun<nm::EW_POW, float32_t, int32_t>, fun<nm::EW_POW, float32_t, int64_t>, \
442
+ fun<nm::EW_POW, float32_t, float32_t>, fun<nm::EW_POW, float32_t, float64_t>, fun<nm::EW_POW, float32_t, nm::Complex64>, fun<nm::EW_POW, float32_t, nm::Complex128>, \
443
+ NULL}, \
429
444
  \
430
- {fun<nm::EW_POW, float64_t, uint8_t>, fun<nm::EW_POW, float64_t, int8_t>, fun<nm::EW_POW, float64_t, int16_t>, fun<nm::EW_POW, float64_t, int32_t>, fun<nm::EW_POW, float64_t, int64_t>, \
431
- fun<nm::EW_POW, float64_t, float32_t>, fun<nm::EW_POW, float64_t, float64_t>, fun<nm::EW_POW, float64_t, nm::Complex64>, fun<nm::EW_POW, float64_t, nm::Complex128>, \
432
- NULL}, \
445
+ {fun<nm::EW_POW, float64_t, uint8_t>, fun<nm::EW_POW, float64_t, int8_t>, fun<nm::EW_POW, float64_t, int16_t>, fun<nm::EW_POW, float64_t, int32_t>, fun<nm::EW_POW, float64_t, int64_t>, \
446
+ fun<nm::EW_POW, float64_t, float32_t>, fun<nm::EW_POW, float64_t, float64_t>, fun<nm::EW_POW, float64_t, nm::Complex64>, fun<nm::EW_POW, float64_t, nm::Complex128>, \
447
+ NULL}, \
433
448
  \
434
- {fun<nm::EW_POW, nm::Complex64, uint8_t>, fun<nm::EW_POW, nm::Complex64, int8_t>, fun<nm::EW_POW, nm::Complex64, int16_t>, fun<nm::EW_POW, nm::Complex64, int32_t>, \
435
- fun<nm::EW_POW, nm::Complex64, int64_t>, fun<nm::EW_POW, nm::Complex64, float32_t>, fun<nm::EW_POW, nm::Complex64, float64_t>, fun<nm::EW_POW, nm::Complex64, nm::Complex64>, \
436
- fun<nm::EW_POW, nm::Complex64, nm::Complex128>, \
437
- NULL}, \
449
+ {fun<nm::EW_POW, nm::Complex64, uint8_t>, fun<nm::EW_POW, nm::Complex64, int8_t>, fun<nm::EW_POW, nm::Complex64, int16_t>, fun<nm::EW_POW, nm::Complex64, int32_t>, \
450
+ fun<nm::EW_POW, nm::Complex64, int64_t>, fun<nm::EW_POW, nm::Complex64, float32_t>, fun<nm::EW_POW, nm::Complex64, float64_t>, fun<nm::EW_POW, nm::Complex64, nm::Complex64>, \
451
+ fun<nm::EW_POW, nm::Complex64, nm::Complex128>, \
452
+ NULL}, \
438
453
  \
439
- {fun<nm::EW_POW, nm::Complex128, uint8_t>, fun<nm::EW_POW, nm::Complex128, int8_t>, fun<nm::EW_POW, nm::Complex128, int16_t>, fun<nm::EW_POW, nm::Complex128, int32_t>, \
440
- fun<nm::EW_POW, nm::Complex128, int64_t>, fun<nm::EW_POW, nm::Complex128, float32_t>, fun<nm::EW_POW, nm::Complex128, float64_t>, fun<nm::EW_POW, nm::Complex128, nm::Complex64>, \
441
- fun<nm::EW_POW, nm::Complex128, nm::Complex128>, \
442
- NULL}, \
454
+ {fun<nm::EW_POW, nm::Complex128, uint8_t>, fun<nm::EW_POW, nm::Complex128, int8_t>, fun<nm::EW_POW, nm::Complex128, int16_t>, fun<nm::EW_POW, nm::Complex128, int32_t>, \
455
+ fun<nm::EW_POW, nm::Complex128, int64_t>, fun<nm::EW_POW, nm::Complex128, float32_t>, fun<nm::EW_POW, nm::Complex128, float64_t>, fun<nm::EW_POW, nm::Complex128, nm::Complex64>, \
456
+ fun<nm::EW_POW, nm::Complex128, nm::Complex128>, \
457
+ NULL}, \
443
458
  \
444
- {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_POW, nm::RubyObject, nm::RubyObject>} \
459
+ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_POW, nm::RubyObject, nm::RubyObject>} \
445
460
  }, \
446
461
  \
447
- { \
448
- {fun<nm::EW_MOD, uint8_t, uint8_t>, fun<nm::EW_MOD, uint8_t, int8_t>, fun<nm::EW_MOD, uint8_t, int16_t>, fun<nm::EW_MOD, uint8_t, int32_t>, fun<nm::EW_MOD, uint8_t, int64_t>, \
449
- fun<nm::EW_MOD, uint8_t, float32_t>, fun<nm::EW_MOD, uint8_t, float64_t>, fun<nm::EW_MOD, uint8_t, nm::Complex64>, fun<nm::EW_MOD, uint8_t, nm::Complex128>, \
450
- NULL}, \
451
- \
452
- {fun<nm::EW_MOD, int8_t, uint8_t>, fun<nm::EW_MOD, int8_t, int8_t>, fun<nm::EW_MOD, int8_t, int16_t>, fun<nm::EW_MOD, int8_t, int32_t>, fun<nm::EW_MOD, int8_t, int64_t>, \
453
- fun<nm::EW_MOD, int8_t, float32_t>, fun<nm::EW_MOD, int8_t, float64_t>, fun<nm::EW_MOD, int8_t, nm::Complex64>, fun<nm::EW_MOD, int8_t, nm::Complex128>, \
454
- NULL}, \
455
- \
456
- {fun<nm::EW_MOD, int16_t, uint8_t>, fun<nm::EW_MOD, int16_t, int8_t>, fun<nm::EW_MOD, int16_t, int16_t>, fun<nm::EW_MOD, int16_t, int32_t>, fun<nm::EW_MOD, int16_t, int64_t>, \
457
- fun<nm::EW_MOD, int16_t, float32_t>, fun<nm::EW_MOD, int16_t, float64_t>, fun<nm::EW_MOD, int16_t, nm::Complex64>, fun<nm::EW_MOD, int16_t, nm::Complex128>, \
458
- NULL}, \
459
- \
460
- {fun<nm::EW_MOD, int32_t, uint8_t>, fun<nm::EW_MOD, int32_t, int8_t>, fun<nm::EW_MOD, int32_t, int16_t>, fun<nm::EW_MOD, int32_t, int32_t>, fun<nm::EW_MOD, int32_t, int64_t>, \
461
- fun<nm::EW_MOD, int32_t, float32_t>, fun<nm::EW_MOD, int32_t, float64_t>, fun<nm::EW_MOD, int32_t, nm::Complex64>, fun<nm::EW_MOD, int32_t, nm::Complex128>, \
462
- NULL}, \
463
- \
464
- {fun<nm::EW_MOD, int64_t, uint8_t>, fun<nm::EW_MOD, int64_t, int8_t>, fun<nm::EW_MOD, int64_t, int16_t>, fun<nm::EW_MOD, int64_t, int32_t>, fun<nm::EW_MOD, int64_t, int64_t>, \
465
- fun<nm::EW_MOD, int64_t, float32_t>, fun<nm::EW_MOD, int64_t, float64_t>, fun<nm::EW_MOD, int64_t, nm::Complex64>, fun<nm::EW_MOD, int64_t, nm::Complex128>, \
466
- NULL}, \
467
- \
468
- {fun<nm::EW_MOD, float32_t, uint8_t>, fun<nm::EW_MOD, float32_t, int8_t>, fun<nm::EW_MOD, float32_t, int16_t>, fun<nm::EW_MOD, float32_t, int32_t>, fun<nm::EW_MOD, float32_t, int64_t>, \
469
- fun<nm::EW_MOD, float32_t, float32_t>, fun<nm::EW_MOD, float32_t, float64_t>, fun<nm::EW_MOD, float32_t, nm::Complex64>, fun<nm::EW_MOD, float32_t, nm::Complex128>, \
470
- NULL}, \
471
- \
472
- {fun<nm::EW_MOD, float64_t, uint8_t>, fun<nm::EW_MOD, float64_t, int8_t>, fun<nm::EW_MOD, float64_t, int16_t>, fun<nm::EW_MOD, float64_t, int32_t>, fun<nm::EW_MOD, float64_t, int64_t>, \
473
- fun<nm::EW_MOD, float64_t, float32_t>, fun<nm::EW_MOD, float64_t, float64_t>, fun<nm::EW_MOD, float64_t, nm::Complex64>, fun<nm::EW_MOD, float64_t, nm::Complex128>, \
474
- NULL}, \
475
- \
476
- {fun<nm::EW_MOD, nm::Complex64, uint8_t>, fun<nm::EW_MOD, nm::Complex64, int8_t>, fun<nm::EW_MOD, nm::Complex64, int16_t>, fun<nm::EW_MOD, nm::Complex64, int32_t>, \
477
- fun<nm::EW_MOD, nm::Complex64, int64_t>, fun<nm::EW_MOD, nm::Complex64, float32_t>, fun<nm::EW_MOD, nm::Complex64, float64_t>, fun<nm::EW_MOD, nm::Complex64, nm::Complex64>, \
478
- fun<nm::EW_MOD, nm::Complex64, nm::Complex128>, \
479
- NULL}, \
480
- \
481
- {fun<nm::EW_MOD, nm::Complex128, uint8_t>, fun<nm::EW_MOD, nm::Complex128, int8_t>, fun<nm::EW_MOD, nm::Complex128, int16_t>, fun<nm::EW_MOD, nm::Complex128, int32_t>, \
482
- fun<nm::EW_MOD, nm::Complex128, int64_t>, fun<nm::EW_MOD, nm::Complex128, float32_t>, fun<nm::EW_MOD, nm::Complex128, float64_t>, fun<nm::EW_MOD, nm::Complex128, nm::Complex64>, \
483
- fun<nm::EW_MOD, nm::Complex128, nm::Complex128>, \
484
- NULL}, \
462
+ { \
463
+ {fun<nm::EW_MOD, uint8_t, uint8_t>, fun<nm::EW_MOD, uint8_t, int8_t>, fun<nm::EW_MOD, uint8_t, int16_t>, fun<nm::EW_MOD, uint8_t, int32_t>, fun<nm::EW_MOD, uint8_t, int64_t>, \
464
+ fun<nm::EW_MOD, uint8_t, float32_t>, fun<nm::EW_MOD, uint8_t, float64_t>, fun<nm::EW_MOD, uint8_t, nm::Complex64>, fun<nm::EW_MOD, uint8_t, nm::Complex128>, \
465
+ NULL}, \
466
+ \
467
+ {fun<nm::EW_MOD, int8_t, uint8_t>, fun<nm::EW_MOD, int8_t, int8_t>, fun<nm::EW_MOD, int8_t, int16_t>, fun<nm::EW_MOD, int8_t, int32_t>, fun<nm::EW_MOD, int8_t, int64_t>, \
468
+ fun<nm::EW_MOD, int8_t, float32_t>, fun<nm::EW_MOD, int8_t, float64_t>, fun<nm::EW_MOD, int8_t, nm::Complex64>, fun<nm::EW_MOD, int8_t, nm::Complex128>, \
469
+ NULL}, \
470
+ \
471
+ {fun<nm::EW_MOD, int16_t, uint8_t>, fun<nm::EW_MOD, int16_t, int8_t>, fun<nm::EW_MOD, int16_t, int16_t>, fun<nm::EW_MOD, int16_t, int32_t>, fun<nm::EW_MOD, int16_t, int64_t>, \
472
+ fun<nm::EW_MOD, int16_t, float32_t>, fun<nm::EW_MOD, int16_t, float64_t>, fun<nm::EW_MOD, int16_t, nm::Complex64>, fun<nm::EW_MOD, int16_t, nm::Complex128>, \
473
+ NULL}, \
474
+ \
475
+ {fun<nm::EW_MOD, int32_t, uint8_t>, fun<nm::EW_MOD, int32_t, int8_t>, fun<nm::EW_MOD, int32_t, int16_t>, fun<nm::EW_MOD, int32_t, int32_t>, fun<nm::EW_MOD, int32_t, int64_t>, \
476
+ fun<nm::EW_MOD, int32_t, float32_t>, fun<nm::EW_MOD, int32_t, float64_t>, fun<nm::EW_MOD, int32_t, nm::Complex64>, fun<nm::EW_MOD, int32_t, nm::Complex128>, \
477
+ NULL}, \
478
+ \
479
+ {fun<nm::EW_MOD, int64_t, uint8_t>, fun<nm::EW_MOD, int64_t, int8_t>, fun<nm::EW_MOD, int64_t, int16_t>, fun<nm::EW_MOD, int64_t, int32_t>, fun<nm::EW_MOD, int64_t, int64_t>, \
480
+ fun<nm::EW_MOD, int64_t, float32_t>, fun<nm::EW_MOD, int64_t, float64_t>, fun<nm::EW_MOD, int64_t, nm::Complex64>, fun<nm::EW_MOD, int64_t, nm::Complex128>, \
481
+ NULL}, \
482
+ \
483
+ {fun<nm::EW_MOD, float32_t, uint8_t>, fun<nm::EW_MOD, float32_t, int8_t>, fun<nm::EW_MOD, float32_t, int16_t>, fun<nm::EW_MOD, float32_t, int32_t>, fun<nm::EW_MOD, float32_t, int64_t>, \
484
+ fun<nm::EW_MOD, float32_t, float32_t>, fun<nm::EW_MOD, float32_t, float64_t>, fun<nm::EW_MOD, float32_t, nm::Complex64>, fun<nm::EW_MOD, float32_t, nm::Complex128>, \
485
+ NULL}, \
486
+ \
487
+ {fun<nm::EW_MOD, float64_t, uint8_t>, fun<nm::EW_MOD, float64_t, int8_t>, fun<nm::EW_MOD, float64_t, int16_t>, fun<nm::EW_MOD, float64_t, int32_t>, fun<nm::EW_MOD, float64_t, int64_t>, \
488
+ fun<nm::EW_MOD, float64_t, float32_t>, fun<nm::EW_MOD, float64_t, float64_t>, fun<nm::EW_MOD, float64_t, nm::Complex64>, fun<nm::EW_MOD, float64_t, nm::Complex128>, \
489
+ NULL}, \
490
+ \
491
+ {fun<nm::EW_MOD, nm::Complex64, uint8_t>, fun<nm::EW_MOD, nm::Complex64, int8_t>, fun<nm::EW_MOD, nm::Complex64, int16_t>, fun<nm::EW_MOD, nm::Complex64, int32_t>, \
492
+ fun<nm::EW_MOD, nm::Complex64, int64_t>, fun<nm::EW_MOD, nm::Complex64, float32_t>, fun<nm::EW_MOD, nm::Complex64, float64_t>, fun<nm::EW_MOD, nm::Complex64, nm::Complex64>, \
493
+ fun<nm::EW_MOD, nm::Complex64, nm::Complex128>, \
494
+ NULL}, \
495
+ \
496
+ {fun<nm::EW_MOD, nm::Complex128, uint8_t>, fun<nm::EW_MOD, nm::Complex128, int8_t>, fun<nm::EW_MOD, nm::Complex128, int16_t>, fun<nm::EW_MOD, nm::Complex128, int32_t>, \
497
+ fun<nm::EW_MOD, nm::Complex128, int64_t>, fun<nm::EW_MOD, nm::Complex128, float32_t>, fun<nm::EW_MOD, nm::Complex128, float64_t>, fun<nm::EW_MOD, nm::Complex128, nm::Complex64>, \
498
+ fun<nm::EW_MOD, nm::Complex128, nm::Complex128>, \
499
+ NULL}, \
485
500
  \
486
- {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_MOD, nm::RubyObject, nm::RubyObject>} \
487
- }, \
488
- \
489
- { \
501
+ {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_MOD, nm::RubyObject, nm::RubyObject>} \
502
+ }, \
503
+ \
504
+ { \
490
505
  {fun<nm::EW_EQEQ, uint8_t, uint8_t>, fun<nm::EW_EQEQ, uint8_t, int8_t>, fun<nm::EW_EQEQ, uint8_t, int16_t>, fun<nm::EW_EQEQ, uint8_t, int32_t>, \
491
506
  fun<nm::EW_EQEQ, uint8_t, int64_t>, fun<nm::EW_EQEQ, uint8_t, float32_t>, fun<nm::EW_EQEQ, uint8_t, float64_t>, fun<nm::EW_EQEQ, uint8_t, nm::Complex64>, \
492
507
  fun<nm::EW_EQEQ, uint8_t, nm::Complex128>, \
@@ -552,7 +567,7 @@ namespace nm {
552
567
  {fun<nm::EW_GEQ, nm::Complex128, uint8_t>, fun<nm::EW_GEQ, nm::Complex128, int8_t>, fun<nm::EW_GEQ, nm::Complex128, int16_t>, fun<nm::EW_GEQ, nm::Complex128, int32_t>, fun<nm::EW_GEQ, nm::Complex128, int64_t>, fun<nm::EW_GEQ, nm::Complex128, float32_t>, fun<nm::EW_GEQ, nm::Complex128, float64_t>, fun<nm::EW_GEQ, nm::Complex128, nm::Complex64>, fun<nm::EW_GEQ, nm::Complex128, nm::Complex128>, NULL}, \
553
568
  {NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, fun<nm::EW_GEQ, nm::RubyObject, nm::RubyObject>} \
554
569
  } \
555
- };
570
+ };
556
571
 
557
572
  /*
558
573
  * Defines a static array that holds function pointers to an elementwise op,
@@ -561,8 +576,8 @@ namespace nm {
561
576
  #define OP_ITYPE_DTYPE_TEMPLATE_TABLE(fun, ret, ...) NAMED_OP_ITYPE_DTYPE_TEMPLATE_TABLE(ttable, fun, ret, __VA_ARGS__)
562
577
 
563
578
  #define NAMED_OP_ITYPE_DTYPE_TEMPLATE_TABLE(name, fun, ret, ...) \
564
- static ret (*(name)[nm::NUM_EWOPS][nm::NUM_ITYPES][nm::NUM_DTYPES])(__VA_ARGS__) = \
565
- {{{fun<nm::EW_ADD, uint8_t, uint8_t>,fun<nm::EW_ADD, uint8_t, int8_t>,fun<nm::EW_ADD, uint8_t, int16_t>,fun<nm::EW_ADD, uint8_t, int32_t>,fun<nm::EW_ADD, uint8_t, int64_t>,fun<nm::EW_ADD, uint8_t, float32_t>,fun<nm::EW_ADD, uint8_t, float64_t>,fun<nm::EW_ADD, uint8_t, nm::Complex64>,fun<nm::EW_ADD, uint8_t, nm::Complex128>,fun<nm::EW_ADD, uint8_t, nm::RubyObject>},\
579
+ static ret (*(name)[nm::NUM_EWOPS][nm::NUM_ITYPES][nm::NUM_DTYPES])(__VA_ARGS__) = \
580
+ {{{fun<nm::EW_ADD, uint8_t, uint8_t>,fun<nm::EW_ADD, uint8_t, int8_t>,fun<nm::EW_ADD, uint8_t, int16_t>,fun<nm::EW_ADD, uint8_t, int32_t>,fun<nm::EW_ADD, uint8_t, int64_t>,fun<nm::EW_ADD, uint8_t, float32_t>,fun<nm::EW_ADD, uint8_t, float64_t>,fun<nm::EW_ADD, uint8_t, nm::Complex64>,fun<nm::EW_ADD, uint8_t, nm::Complex128>,fun<nm::EW_ADD, uint8_t, nm::RubyObject>},\
566
581
  {fun<nm::EW_ADD, uint16_t, uint8_t>,fun<nm::EW_ADD, uint16_t, int8_t>,fun<nm::EW_ADD, uint16_t, int16_t>,fun<nm::EW_ADD, uint16_t, int32_t>,fun<nm::EW_ADD, uint16_t, int64_t>,fun<nm::EW_ADD, uint16_t, float32_t>,fun<nm::EW_ADD, uint16_t, float64_t>,fun<nm::EW_ADD, uint16_t, nm::Complex64>,fun<nm::EW_ADD, uint16_t, nm::Complex128>,fun<nm::EW_ADD, uint16_t, nm::RubyObject>},\
567
582
  {fun<nm::EW_ADD, uint32_t, uint8_t>,fun<nm::EW_ADD, uint32_t, int8_t>,fun<nm::EW_ADD, uint32_t, int16_t>,fun<nm::EW_ADD, uint32_t, int32_t>,fun<nm::EW_ADD, uint32_t, int64_t>,fun<nm::EW_ADD, uint32_t, float32_t>,fun<nm::EW_ADD, uint32_t, float64_t>,fun<nm::EW_ADD, uint32_t, nm::Complex64>,fun<nm::EW_ADD, uint32_t, nm::Complex128>,fun<nm::EW_ADD, uint32_t, nm::RubyObject>},\
568
583
  {fun<nm::EW_ADD, uint64_t, uint8_t>,fun<nm::EW_ADD, uint64_t, int8_t>,fun<nm::EW_ADD, uint64_t, int16_t>,fun<nm::EW_ADD, uint64_t, int32_t>,fun<nm::EW_ADD, uint64_t, int64_t>,fun<nm::EW_ADD, uint64_t, float32_t>,fun<nm::EW_ADD, uint64_t, float64_t>,fun<nm::EW_ADD, uint64_t, nm::Complex64>,fun<nm::EW_ADD, uint64_t, nm::Complex128>,fun<nm::EW_ADD, uint64_t, nm::RubyObject>}},\
@@ -616,8 +631,8 @@ extern "C" {
616
631
  */
617
632
 
618
633
  // regular data types
619
- extern const char* const DTYPE_NAMES[nm::NUM_DTYPES];
620
- extern const size_t DTYPE_SIZES[nm::NUM_DTYPES];
634
+ extern const char* const DTYPE_NAMES[nm::NUM_DTYPES];
635
+ extern const size_t DTYPE_SIZES[nm::NUM_DTYPES];
621
636
 
622
637
  extern const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES];
623
638
 
@@ -627,9 +642,8 @@ extern const nm::dtype_t Upcast[nm::NUM_DTYPES][nm::NUM_DTYPES];
627
642
  */
628
643
 
629
644
 
630
- void* rubyobj_to_cval(VALUE val, nm::dtype_t dtype);
631
- void rubyval_to_cval(VALUE val, nm::dtype_t dtype, void* loc);
632
- nm::RubyObject rubyobj_from_cval(void* val, nm::dtype_t dtype);
645
+ void* rubyobj_to_cval(VALUE val, nm::dtype_t dtype);
646
+ void rubyval_to_cval(VALUE val, nm::dtype_t dtype, void* loc);
633
647
 
634
648
  void nm_init_data();
635
649