numo-narray-alt 0.9.4 → 0.9.6

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 (48) hide show
  1. checksums.yaml +4 -4
  2. data/Gemfile +3 -0
  3. data/README.md +22 -3
  4. data/Rakefile +8 -0
  5. data/ext/numo/narray/SFMT-params19937.h +16 -12
  6. data/ext/numo/narray/SFMT.c +12 -5
  7. data/ext/numo/narray/array.c +51 -21
  8. data/ext/numo/narray/data.c +88 -86
  9. data/ext/numo/narray/index.c +51 -28
  10. data/ext/numo/narray/kwargs.c +11 -9
  11. data/ext/numo/narray/math.c +14 -6
  12. data/ext/numo/narray/narray.c +93 -58
  13. data/ext/numo/narray/ndloop.c +52 -63
  14. data/ext/numo/narray/numo/intern.h +9 -3
  15. data/ext/numo/narray/numo/narray.h +20 -20
  16. data/ext/numo/narray/numo/ndloop.h +1 -1
  17. data/ext/numo/narray/numo/template.h +85 -81
  18. data/ext/numo/narray/numo/types/bit.h +76 -0
  19. data/ext/numo/narray/numo/types/complex.h +7 -3
  20. data/ext/numo/narray/numo/types/complex_macro.h +28 -25
  21. data/ext/numo/narray/numo/types/float_macro.h +21 -17
  22. data/ext/numo/narray/numo/types/real_accum.h +22 -22
  23. data/ext/numo/narray/numo/types/robj_macro.h +20 -12
  24. data/ext/numo/narray/numo/types/xint_macro.h +51 -8
  25. data/ext/numo/narray/rand.c +7 -0
  26. data/ext/numo/narray/src/mh/mean.h +102 -0
  27. data/ext/numo/narray/src/mh/rms.h +102 -0
  28. data/ext/numo/narray/src/mh/stddev.h +103 -0
  29. data/ext/numo/narray/src/mh/var.h +102 -0
  30. data/ext/numo/narray/src/t_bit.c +206 -147
  31. data/ext/numo/narray/src/t_dcomplex.c +531 -641
  32. data/ext/numo/narray/src/t_dfloat.c +1341 -1421
  33. data/ext/numo/narray/src/t_int16.c +562 -468
  34. data/ext/numo/narray/src/t_int32.c +562 -468
  35. data/ext/numo/narray/src/t_int64.c +561 -467
  36. data/ext/numo/narray/src/t_int8.c +520 -448
  37. data/ext/numo/narray/src/t_robject.c +519 -619
  38. data/ext/numo/narray/src/t_scomplex.c +524 -659
  39. data/ext/numo/narray/src/t_sfloat.c +1332 -1410
  40. data/ext/numo/narray/src/t_uint16.c +562 -468
  41. data/ext/numo/narray/src/t_uint32.c +562 -468
  42. data/ext/numo/narray/src/t_uint64.c +562 -468
  43. data/ext/numo/narray/src/t_uint8.c +522 -448
  44. data/ext/numo/narray/step.c +7 -2
  45. data/ext/numo/narray/struct.c +31 -24
  46. data/lib/numo/narray/extra.rb +74 -30
  47. data/numo-narray-alt.gemspec +38 -0
  48. metadata +10 -1
data/ext/numo/narray/numo/template.h CHANGED
@@ -6,7 +6,7 @@
6
6
  #ifndef TEMPLATE_H
7
7
  #define TEMPLATE_H
8
8
 
9
- #define INIT_COUNTER(lp, c) \
9
+ #define INIT_COUNTER(lp, c) \
10
10
  { c = (lp)->n[0]; }
11
11
 
12
12
  #define NDL_CNT(lp) ((lp)->n[0])
@@ -16,111 +16,113 @@
16
16
  #define NDL_ESZ(lp, i) ((lp)->args[i].elmsz)
17
17
  #define NDL_SHAPE(lp, i) ((lp)->args[i].shape)
18
18
 
19
- #define INIT_PTR(lp, i, pt, st) \
20
- { \
21
- pt = ((lp)->args[i]).ptr + ((lp)->args[i].iter[0]).pos; \
22
- st = ((lp)->args[i].iter[0]).step; \
19
+ #define INIT_PTR(lp, i, pt, st) \
20
+ { \
21
+ pt = ((lp)->args[i]).ptr + ((lp)->args[i].iter[0]).pos; \
22
+ st = ((lp)->args[i].iter[0]).step; \
23
23
  }
24
24
 
25
- #define INIT_PTR_IDX(lp, i, pt, st, id) \
26
- { \
27
- pt = ((lp)->args[i]).ptr + ((lp)->args[i].iter[0]).pos; \
28
- st = ((lp)->args[i].iter[0]).step; \
29
- id = ((lp)->args[i].iter[0]).idx; \
25
+ #define INIT_PTR_IDX(lp, i, pt, st, id) \
26
+ { \
27
+ pt = ((lp)->args[i]).ptr + ((lp)->args[i].iter[0]).pos; \
28
+ st = ((lp)->args[i].iter[0]).step; \
29
+ id = ((lp)->args[i].iter[0]).idx; \
30
30
  }
31
31
 
32
- #define INIT_ELMSIZE(lp, i, es) \
32
+ #define INIT_ELMSIZE(lp, i, es) \
33
33
  { es = ((lp)->args[i]).elmsz; }
34
34
 
35
- #define INIT_PTR_BIT(lp, i, ad, ps, st) \
36
- { \
37
- ps = ((lp)->args[i].iter[0]).pos; \
38
- ad = (BIT_DIGIT*)(((lp)->args[i]).ptr); \
39
- st = ((lp)->args[i].iter[0]).step; \
35
+ #define INIT_PTR_BIT(lp, i, ad, ps, st) \
36
+ { \
37
+ ps = ((lp)->args[i].iter[0]).pos; \
38
+ ad = (BIT_DIGIT*)(((lp)->args[i]).ptr); \
39
+ st = ((lp)->args[i].iter[0]).step; \
40
40
  }
41
41
 
42
- #define INIT_PTR_BIT_IDX(lp, i, ad, ps, st, id) \
43
- { \
44
- ps = ((lp)->args[i].iter[0]).pos; \
45
- ad = (BIT_DIGIT*)(((lp)->args[i]).ptr); \
46
- st = ((lp)->args[i].iter[0]).step; \
47
- id = ((lp)->args[i].iter[0]).idx; \
42
+ #define INIT_PTR_BIT_IDX(lp, i, ad, ps, st, id) \
43
+ { \
44
+ ps = ((lp)->args[i].iter[0]).pos; \
45
+ ad = (BIT_DIGIT*)(((lp)->args[i]).ptr); \
46
+ st = ((lp)->args[i].iter[0]).step; \
47
+ id = ((lp)->args[i].iter[0]).idx; \
48
48
  }
49
49
 
50
- #define GET_DATA(ptr, type, val) \
50
+ #define GET_DATA(ptr, type, val) \
51
51
  { val = *(type*)(ptr); }
52
52
 
53
- #define SET_DATA(ptr, type, val) \
53
+ #define SET_DATA(ptr, type, val) \
54
54
  { *(type*)(ptr) = val; }
55
55
 
56
- #define GET_DATA_STRIDE(ptr, step, type, val) \
57
- { \
58
- val = *(type*)(ptr); \
59
- ptr += step; \
56
+ #define GET_DATA_STRIDE(ptr, step, type, val) \
57
+ { \
58
+ val = *(type*)(ptr); \
59
+ ptr += step; \
60
60
  }
61
61
 
62
- #define GET_DATA_INDEX(ptr, idx, type, val) \
63
- { \
64
- val = *(type*)(ptr + *idx); \
65
- idx++; \
62
+ #define GET_DATA_INDEX(ptr, idx, type, val) \
63
+ { \
64
+ val = *(type*)(ptr + *idx); \
65
+ idx++; \
66
66
  }
67
67
 
68
- #define SET_DATA_STRIDE(ptr, step, type, val) \
69
- { \
70
- *(type*)(ptr) = val; \
71
- ptr += step; \
68
+ #define SET_DATA_STRIDE(ptr, step, type, val) \
69
+ { \
70
+ *(type*)(ptr) = val; \
71
+ ptr += step; \
72
72
  }
73
73
 
74
- #define SET_DATA_INDEX(ptr, idx, type, val) \
75
- { \
76
- *(type*)(ptr + *idx) = val; \
77
- idx++; \
74
+ #define SET_DATA_INDEX(ptr, idx, type, val) \
75
+ { \
76
+ *(type*)(ptr + *idx) = val; \
77
+ idx++; \
78
78
  }
79
79
 
80
- #define LOAD_BIT(adr, pos, val) \
81
- { \
82
- size_t dig = (pos) / NB; \
83
- int bit = (pos) % NB; \
84
- val = (((BIT_DIGIT*)(adr))[dig] >> (bit)) & 1u; \
80
+ #define LOAD_BIT(adr, pos, val) \
81
+ { \
82
+ size_t dig = (pos) / NB; \
83
+ int bit = (pos) % NB; \
84
+ val = (((BIT_DIGIT*)(adr))[dig] >> (bit)) & 1u; \
85
85
  }
86
86
 
87
- #define LOAD_BIT_STEP(adr, pos, step, idx, val) \
88
- { \
89
- size_t dig; \
90
- int bit; \
91
- if (idx) { \
92
- dig = ((pos) + *(idx)) / NB; \
93
- bit = ((pos) + *(idx)) % NB; \
94
- idx++; \
95
- } else { \
96
- dig = (pos) / NB; \
97
- bit = (pos) % NB; \
98
- pos += step; \
99
- } \
100
- val = (((BIT_DIGIT*)(adr))[dig] >> bit) & 1u; \
87
+ #define LOAD_BIT_STEP(adr, pos, step, idx, val) \
88
+ { \
89
+ size_t dig; \
90
+ int bit; \
91
+ if (idx) { \
92
+ dig = ((pos) + *(idx)) / NB; \
93
+ bit = ((pos) + *(idx)) % NB; \
94
+ idx++; \
95
+ } else { \
96
+ dig = (pos) / NB; \
97
+ bit = (pos) % NB; \
98
+ pos += step; \
99
+ } \
100
+ val = (((BIT_DIGIT*)(adr))[dig] >> bit) & 1u; \
101
101
  }
102
102
 
103
- #define STORE_BIT(adr, pos, val) \
104
- { \
105
- size_t dig = (pos) / NB; \
106
- int bit = (pos) % NB; \
107
- ((BIT_DIGIT*)(adr))[dig] = (((BIT_DIGIT*)(adr))[dig] & ~(1u << (bit))) | (((val) & 1u) << (bit)); \
103
+ #define STORE_BIT(adr, pos, val) \
104
+ { \
105
+ size_t dig = (pos) / NB; \
106
+ int bit = (pos) % NB; \
107
+ ((BIT_DIGIT*)(adr))[dig] = \
108
+ (((BIT_DIGIT*)(adr))[dig] & ~(1u << (bit))) | (((val) & 1u) << (bit)); \
108
109
  }
109
110
 
110
- #define STORE_BIT_STEP(adr, pos, step, idx, val) \
111
- { \
112
- size_t dig; \
113
- int bit; \
114
- if (idx) { \
115
- dig = ((pos) + *(idx)) / NB; \
116
- bit = ((pos) + *(idx)) % NB; \
117
- idx++; \
118
- } else { \
119
- dig = (pos) / NB; \
120
- bit = (pos) % NB; \
121
- pos += step; \
122
- } \
123
- ((BIT_DIGIT*)(adr))[dig] = (((BIT_DIGIT*)(adr))[dig] & ~(1u << (bit))) | (((val) & 1u) << (bit)); \
111
+ #define STORE_BIT_STEP(adr, pos, step, idx, val) \
112
+ { \
113
+ size_t dig; \
114
+ int bit; \
115
+ if (idx) { \
116
+ dig = ((pos) + *(idx)) / NB; \
117
+ bit = ((pos) + *(idx)) % NB; \
118
+ idx++; \
119
+ } else { \
120
+ dig = (pos) / NB; \
121
+ bit = (pos) % NB; \
122
+ pos += step; \
123
+ } \
124
+ ((BIT_DIGIT*)(adr))[dig] = \
125
+ (((BIT_DIGIT*)(adr))[dig] & ~(1u << (bit))) | (((val) & 1u) << (bit)); \
124
126
  }
125
127
 
126
128
  static inline int is_aligned(const void* ptr, const size_t alignment) {
@@ -131,8 +133,9 @@ static inline int is_aligned_step(const ssize_t step, const size_t alignment) {
131
133
  return ((step) & ((alignment)-1)) == 0;
132
134
  }
133
135
 
134
- static inline int get_count_of_elements_not_aligned_to_simd_size(const void* ptr, const size_t alignment,
135
- const size_t element_size) {
136
+ static inline int get_count_of_elements_not_aligned_to_simd_size(
137
+ const void* ptr, const size_t alignment, const size_t element_size
138
+ ) {
136
139
  size_t cnt = (size_t)(ptr) & ((alignment)-1);
137
140
  return (int)(cnt == 0 ? 0 : (alignment - cnt) / element_size);
138
141
  }
@@ -141,7 +144,8 @@ static inline int is_same_aligned2(const void* ptr1, const void* ptr2, const siz
141
144
  return ((size_t)(ptr1) & ((alignment)-1)) == ((size_t)(ptr2) & ((alignment)-1));
142
145
  }
143
146
 
144
- static inline int is_same_aligned3(const void* ptr1, const void* ptr2, const void* ptr3, const size_t alignment) {
147
+ static inline int
148
+ is_same_aligned3(const void* ptr1, const void* ptr2, const void* ptr3, const size_t alignment) {
145
149
  return (((size_t)(ptr1) & ((alignment)-1)) == ((size_t)(ptr2) & ((alignment)-1))) &&
146
150
  (((size_t)(ptr1) & ((alignment)-1)) == ((size_t)(ptr3) & ((alignment)-1)));
147
151
  }
data/ext/numo/narray/numo/types/bit.h CHANGED
@@ -19,6 +19,9 @@ typedef BIT_DIGIT rtype;
19
19
  #define m_data_to_num(x) INT2FIX(x)
20
20
  #define m_sprintf(s, x) sprintf(s, "%1d", (int)(x))
21
21
 
22
+ #define m_add(x, y) ((x) + (y))
23
+ #define m_div(x, y) ((x) / (y))
24
+
22
25
  #define m_copy(x) (x)
23
26
  #define m_not(x) (~(x))
24
27
  #define m_and(x, y) ((x) & (y))
@@ -36,3 +39,76 @@ static inline BIT_DIGIT m_num_to_data(VALUE num) {
36
39
  }
37
40
  return 0;
38
41
  }
42
+
43
+ static inline double f_mean(size_t n, BIT_DIGIT* p, size_t pos, ssize_t stride, size_t* idx) {
44
+ size_t count = 0;
45
+ double sum = 0.0;
46
+ BIT_DIGIT x;
47
+ if (idx) {
48
+ for (size_t i = n; i--;) {
49
+ LOAD_BIT(p, pos + *idx, x);
50
+ idx++;
51
+ sum += (double)x;
52
+ count++;
53
+ }
54
+ } else {
55
+ for (size_t i = n; i--;) {
56
+ LOAD_BIT(p, pos, x);
57
+ pos += stride;
58
+ sum += (double)x;
59
+ count++;
60
+ }
61
+ }
62
+ return sum / (double)count;
63
+ }
64
+
65
+ static inline double f_var(size_t n, BIT_DIGIT* p, size_t pos, ssize_t stride, size_t* idx) {
66
+ size_t count = 0;
67
+ double sum = 0.0;
68
+ BIT_DIGIT x;
69
+ const double mean = f_mean(n, p, pos, stride, idx);
70
+ if (idx) {
71
+ for (size_t i = n; i--;) {
72
+ LOAD_BIT(p, pos + *idx, x);
73
+ const double d = (double)x - mean;
74
+ idx++;
75
+ sum += d * d;
76
+ count++;
77
+ }
78
+ } else {
79
+ for (size_t i = n; i--;) {
80
+ LOAD_BIT(p, pos, x);
81
+ const double d = (double)x - mean;
82
+ pos += stride;
83
+ sum += d * d;
84
+ count++;
85
+ }
86
+ }
87
+ return sum / (double)(count - 1);
88
+ }
89
+
90
+ static inline double f_stddev(size_t n, BIT_DIGIT* p, size_t pos, ssize_t stride, size_t* idx) {
91
+ return sqrt(f_var(n, p, pos, stride, idx));
92
+ }
93
+
94
+ static inline double f_rms(size_t n, BIT_DIGIT* p, size_t pos, ssize_t stride, size_t* idx) {
95
+ size_t count = 0;
96
+ double sum = 0.0;
97
+ BIT_DIGIT x;
98
+ if (idx) {
99
+ for (size_t i = n; i--;) {
100
+ LOAD_BIT(p, pos + *idx, x);
101
+ idx++;
102
+ sum += (double)(x * x);
103
+ count++;
104
+ }
105
+ } else {
106
+ for (size_t i = n; i--;) {
107
+ LOAD_BIT(p, pos, x);
108
+ pos += stride;
109
+ sum += (double)(x * x);
110
+ count++;
111
+ }
112
+ }
113
+ return sqrt(sum / (double)count);
114
+ }
data/ext/numo/narray/numo/types/complex.h CHANGED
@@ -23,7 +23,9 @@ static inline dtype c_set_imag(dtype x, rtype i) {
23
23
 
24
24
  static inline VALUE COMP2NUM(dtype x) {
25
25
  VALUE v;
26
- v = rb_funcall(rb_intern("Kernel"), rb_intern("Complex"), 2, rb_float_new(REAL(x)), rb_float_new(IMAG(x)));
26
+ v = rb_funcall(
27
+ rb_intern("Kernel"), rb_intern("Complex"), 2, rb_float_new(REAL(x)), rb_float_new(IMAG(x))
28
+ );
27
29
  return v;
28
30
  }
29
31
 
@@ -39,8 +41,10 @@ static inline dtype NUM2COMP(VALUE v) {
39
41
  #define c_ne(x, y) (REAL(x) != REAL(y) || IMAG(x) != IMAG(y))
40
42
  #define c_isnan(x) (isnan(REAL(x)) || isnan(IMAG(x)))
41
43
  #define c_isinf(x) (isinf(REAL(x)) || isinf(IMAG(x)))
42
- #define c_isposinf(x) ((isinf(REAL(x)) && signbit(REAL(x)) == 0) || (isinf(IMAG(x)) && signbit(IMAG(x)) == 0))
43
- #define c_isneginf(x) ((isinf(REAL(x)) && signbit(REAL(x))) || (isinf(IMAG(x)) && signbit(IMAG(x))))
44
+ #define c_isposinf(x) \
45
+ ((isinf(REAL(x)) && signbit(REAL(x)) == 0) || (isinf(IMAG(x)) && signbit(IMAG(x)) == 0))
46
+ #define c_isneginf(x) \
47
+ ((isinf(REAL(x)) && signbit(REAL(x))) || (isinf(IMAG(x)) && signbit(IMAG(x))))
44
48
  #define c_isfinite(x) (isfinite(REAL(x)) && isfinite(IMAG(x)))
45
49
 
46
50
  static inline dtype c_zero(void) {
data/ext/numo/narray/numo/types/complex_macro.h CHANGED
@@ -62,6 +62,7 @@ static inline dtype c_from_dcomplex(dcomplex x) {
62
62
  #define m_sub(x, y) c_sub(x, y)
63
63
  #define m_mul(x, y) c_mul(x, y)
64
64
  #define m_div(x, y) c_div(x, y)
65
+ #define m_div_r(x, y) c_div_r(x, y)
65
66
  #define m_mod(x, y) c_mod(x, y)
66
67
  #define m_pow(x, y) c_pow(x, y)
67
68
  #define m_pow_int(x, y) c_pow_int(x, y)
@@ -75,9 +76,11 @@ static inline dtype c_from_dcomplex(dcomplex x) {
75
76
  #define m_ceil(x) c_new(ceil(REAL(x)), ceil(IMAG(x)))
76
77
  #define m_trunc(x) c_new(trunc(REAL(x)), trunc(IMAG(x)))
77
78
  #define m_rint(x) c_new(rint(REAL(x)), rint(IMAG(x)))
78
- #define m_sign(x) \
79
- c_new(((REAL(x) == 0) ? 0.0 : ((REAL(x) > 0) ? 1.0 : ((REAL(x) < 0) ? -1.0 : REAL(x)))), \
80
- ((IMAG(x) == 0) ? 0.0 : ((IMAG(x) > 0) ? 1.0 : ((IMAG(x) < 0) ? -1.0 : IMAG(x)))))
79
+ #define m_sign(x) \
80
+ c_new( \
81
+ ((REAL(x) == 0) ? 0.0 : ((REAL(x) > 0) ? 1.0 : ((REAL(x) < 0) ? -1.0 : REAL(x)))), \
82
+ ((IMAG(x) == 0) ? 0.0 : ((IMAG(x) > 0) ? 1.0 : ((IMAG(x) < 0) ? -1.0 : IMAG(x)))) \
83
+ )
81
84
  #define m_copysign(x, y) c_new(copysign(REAL(x), REAL(y)), copysign(IMAG(x), IMAG(y)))
82
85
 
83
86
  #define m_im(x) c_im(x)
@@ -124,35 +127,35 @@ static inline dtype c_from_dcomplex(dcomplex x) {
124
127
 
125
128
  #define not_nan(x) (REAL(x) == REAL(x) && IMAG(x) == IMAG(x))
126
129
 
127
- #define m_mulsum(x, y, z) \
130
+ #define m_mulsum(x, y, z) \
128
131
  { z = m_add(m_mul(x, y), z); }
129
- #define m_mulsum_nan(x, y, z) \
130
- { \
131
- if (not_nan(x) && not_nan(y)) { \
132
- z = m_add(m_mul(x, y), z); \
133
- } \
132
+ #define m_mulsum_nan(x, y, z) \
133
+ { \
134
+ if (not_nan(x) && not_nan(y)) { \
135
+ z = m_add(m_mul(x, y), z); \
136
+ } \
134
137
  }
135
138
 
136
- #define m_cumsum(x, y) \
139
+ #define m_cumsum(x, y) \
137
140
  { (x) = m_add(x, y); }
138
- #define m_cumsum_nan(x, y) \
139
- { \
140
- if (!not_nan(x)) { \
141
- (x) = (y); \
142
- } else if (not_nan(y)) { \
143
- (x) = m_add(x, y); \
144
- } \
141
+ #define m_cumsum_nan(x, y) \
142
+ { \
143
+ if (!not_nan(x)) { \
144
+ (x) = (y); \
145
+ } else if (not_nan(y)) { \
146
+ (x) = m_add(x, y); \
147
+ } \
145
148
  }
146
149
 
147
- #define m_cumprod(x, y) \
150
+ #define m_cumprod(x, y) \
148
151
  { (x) = m_mul(x, y); }
149
- #define m_cumprod_nan(x, y) \
150
- { \
151
- if (!not_nan(x)) { \
152
- (x) = (y); \
153
- } else if (not_nan(y)) { \
154
- (x) = m_mul(x, y); \
155
- } \
152
+ #define m_cumprod_nan(x, y) \
153
+ { \
154
+ if (!not_nan(x)) { \
155
+ (x) = (y); \
156
+ } else if (not_nan(y)) { \
157
+ (x) = m_mul(x, y); \
158
+ } \
156
159
  }
157
160
 
158
161
  static inline dtype f_sum(size_t n, char* p, ssize_t stride) {
data/ext/numo/narray/numo/types/float_macro.h CHANGED
@@ -27,12 +27,13 @@ extern double pow(double, double);
27
27
  #define m_sub(x, y) ((x) - (y))
28
28
  #define m_mul(x, y) ((x) * (y))
29
29
  #define m_div(x, y) ((x) / (y))
30
+ #define m_div_r(x, y) m_div(x, m_from_real(y))
30
31
  #define m_div_check(x, y) ((y) == 0)
31
32
  #define m_mod(x, y) fmod(x, y)
32
- #define m_divmod(x, y, a, b) \
33
- { \
34
- a = (x) / (y); \
35
- b = m_mod(x, y); \
33
+ #define m_divmod(x, y, a, b) \
34
+ { \
35
+ a = (x) / (y); \
36
+ b = m_mod(x, y); \
36
37
  }
37
38
  #define m_pow(x, y) pow(x, y)
38
39
  #define m_pow_int(x, y) pow_int(x, y)
@@ -49,11 +50,11 @@ extern double pow(double, double);
49
50
  #define m_sign(x) (((x) == 0) ? 0.0 : (((x) > 0) ? 1.0 : (((x) < 0) ? -1.0 : (x))))
50
51
  #define m_copysign(x, y) copysign(x, y)
51
52
  #define m_signbit(x) signbit(x)
52
- #define m_modf(x, y, z) \
53
- { \
54
- double d; \
55
- y = modf(x, &d); \
56
- z = d; \
53
+ #define m_modf(x, y, z) \
54
+ { \
55
+ double d; \
56
+ y = modf(x, &d); \
57
+ z = d; \
57
58
  }
58
59
 
59
60
  #define m_eq(x, y) ((x) == (y))
@@ -73,18 +74,21 @@ extern double pow(double, double);
73
74
 
74
75
  #define m_sprintf(s, x) sprintf(s, "%g", x)
75
76
 
76
- #define cmp_prnan(a, b) ((qsort_cast(a) == qsort_cast(b)) ? 0 : (qsort_cast(a) > qsort_cast(b)) ? 1 : -1)
77
+ #define cmp_prnan(a, b) \
78
+ ((qsort_cast(a) == qsort_cast(b)) ? 0 : (qsort_cast(a) > qsort_cast(b)) ? 1 : -1)
77
79
 
78
- #define cmp_ignan(a, b) \
79
- (m_isnan(qsort_cast(a)) ? (m_isnan(qsort_cast(b)) ? 0 : 1) \
80
- : (m_isnan(qsort_cast(b)) ? -1 \
81
- : ((qsort_cast(a) == qsort_cast(b)) ? 0 \
82
- : (qsort_cast(a) > qsort_cast(b)) ? 1 \
83
- : -1)))
80
+ #define cmp_ignan(a, b) \
81
+ (m_isnan(qsort_cast(a)) \
82
+ ? (m_isnan(qsort_cast(b)) ? 0 : 1) \
83
+ : (m_isnan(qsort_cast(b)) ? -1 \
84
+ : ((qsort_cast(a) == qsort_cast(b)) ? 0 \
85
+ : (qsort_cast(a) > qsort_cast(b)) ? 1 \
86
+ : -1)))
84
87
 
85
88
  #define cmpgt_prnan(a, b) (qsort_cast(a) > qsort_cast(b))
86
89
 
87
- #define cmpgt_ignan(a, b) ((m_isnan(qsort_cast(a)) && !m_isnan(qsort_cast(b))) || (qsort_cast(a) > qsort_cast(b)))
90
+ #define cmpgt_ignan(a, b) \
91
+ ((m_isnan(qsort_cast(a)) && !m_isnan(qsort_cast(b))) || (qsort_cast(a) > qsort_cast(b)))
88
92
 
89
93
  #define m_sqrt(x) sqrt(x)
90
94
  #define m_cbrt(x) cbrt(x)
data/ext/numo/narray/numo/types/real_accum.h CHANGED
@@ -1,34 +1,34 @@
1
1
  #define not_nan(x) ((x) == (x))
2
2
 
3
- #define m_mulsum(x, y, z) \
3
+ #define m_mulsum(x, y, z) \
4
4
  { z = m_add(m_mul(x, y), z); }
5
- #define m_mulsum_nan(x, y, z) \
6
- { \
7
- if (not_nan(x) && not_nan(y)) { \
8
- z = m_add(m_mul(x, y), z); \
9
- } \
5
+ #define m_mulsum_nan(x, y, z) \
6
+ { \
7
+ if (not_nan(x) && not_nan(y)) { \
8
+ z = m_add(m_mul(x, y), z); \
9
+ } \
10
10
  }
11
11
 
12
- #define m_cumsum(x, y) \
12
+ #define m_cumsum(x, y) \
13
13
  { (x) = m_add(x, y); }
14
- #define m_cumsum_nan(x, y) \
15
- { \
16
- if (!not_nan(x)) { \
17
- (x) = (y); \
18
- } else if (not_nan(y)) { \
19
- (x) = m_add(x, y); \
20
- } \
14
+ #define m_cumsum_nan(x, y) \
15
+ { \
16
+ if (!not_nan(x)) { \
17
+ (x) = (y); \
18
+ } else if (not_nan(y)) { \
19
+ (x) = m_add(x, y); \
20
+ } \
21
21
  }
22
22
 
23
- #define m_cumprod(x, y) \
23
+ #define m_cumprod(x, y) \
24
24
  { (x) = m_mul(x, y); }
25
- #define m_cumprod_nan(x, y) \
26
- { \
27
- if (!not_nan(x)) { \
28
- (x) = (y); \
29
- } else if (not_nan(y)) { \
30
- (x) = m_mul(x, y); \
31
- } \
25
+ #define m_cumprod_nan(x, y) \
26
+ { \
27
+ if (!not_nan(x)) { \
28
+ (x) = (y); \
29
+ } else if (not_nan(y)) { \
30
+ (x) = m_mul(x, y); \
31
+ } \
32
32
  }
33
33
 
34
34
  static inline dtype f_sum(size_t n, char* p, ssize_t stride) {
data/ext/numo/narray/numo/types/robj_macro.h CHANGED
@@ -16,12 +16,13 @@
16
16
  #define m_sub(x, y) rb_funcall(x, '-', 1, y)
17
17
  #define m_mul(x, y) rb_funcall(x, '*', 1, y)
18
18
  #define m_div(x, y) rb_funcall(x, '/', 1, y)
19
+ #define m_div_r(x, y) m_div(x, m_from_real(y))
19
20
  #define m_mod(x, y) rb_funcall(x, '%', 1, y)
20
- #define m_divmod(x, y, a, b) \
21
- { \
22
- x = rb_funcall(x, id_divmod, 1, y); \
23
- a = RARRAY_PTR(x)[0]; \
24
- b = RARRAY_PTR(x)[0]; \
21
+ #define m_divmod(x, y, a, b) \
22
+ { \
23
+ x = rb_funcall(x, id_divmod, 1, y); \
24
+ a = RARRAY_PTR(x)[0]; \
25
+ b = RARRAY_PTR(x)[0]; \
25
26
  }
26
27
  #define m_pow(x, y) rb_funcall(x, id_pow, 1, y)
27
28
  #define m_pow_int(x, y) rb_funcall(x, id_pow, 1, y)
@@ -52,12 +53,18 @@
52
53
  #define m_right_shift(x, y) rb_funcall(x, id_right_shift, 1, y)
53
54
 
54
55
  #define m_isnan(x) ((rb_respond_to(x, id_nan_p)) ? RTEST(rb_funcall(x, id_nan_p, 0)) : 0)
55
- #define m_isinf(x) ((rb_respond_to(x, id_infinite_p)) ? RTEST(rb_funcall(x, id_infinite_p, 0)) : 0)
56
- #define m_isposinf(x) \
57
- ((rb_respond_to(x, id_infinite_p)) ? ((RTEST(rb_funcall(x, id_infinite_p, 0))) ? m_gt(x, INT2FIX(0)) : 0) : 0)
58
- #define m_isneginf(x) \
59
- ((rb_respond_to(x, id_infinite_p)) ? ((RTEST(rb_funcall(x, id_infinite_p, 0))) ? m_lt(x, INT2FIX(0)) : 0) : 0)
60
- #define m_isfinite(x) ((rb_respond_to(x, id_finite_p)) ? RTEST(rb_funcall(x, id_finite_p, 0)) : 0)
56
+ #define m_isinf(x) \
57
+ ((rb_respond_to(x, id_infinite_p)) ? RTEST(rb_funcall(x, id_infinite_p, 0)) : 0)
58
+ #define m_isposinf(x) \
59
+ ((rb_respond_to(x, id_infinite_p)) \
60
+ ? ((RTEST(rb_funcall(x, id_infinite_p, 0))) ? m_gt(x, INT2FIX(0)) : 0) \
61
+ : 0)
62
+ #define m_isneginf(x) \
63
+ ((rb_respond_to(x, id_infinite_p)) \
64
+ ? ((RTEST(rb_funcall(x, id_infinite_p, 0))) ? m_lt(x, INT2FIX(0)) : 0) \
65
+ : 0)
66
+ #define m_isfinite(x) \
67
+ ((rb_respond_to(x, id_finite_p)) ? RTEST(rb_funcall(x, id_finite_p, 0)) : 0)
61
68
 
62
69
  #define m_mulsum_init INT2FIX(0)
63
70
 
@@ -68,7 +75,8 @@ static inline int robj_sprintf(char* s, VALUE x) {
68
75
  return sprintf(s, "%s", StringValuePtr(v));
69
76
  }
70
77
 
71
- #define m_sqrt(x) rb_funcall(rb_const_get(rb_mKernel, rb_intern("Math")), rb_intern("sqrt"), 1, x);
78
+ #define m_sqrt(x) \
79
+ rb_funcall(rb_const_get(rb_mKernel, rb_intern("Math")), rb_intern("sqrt"), 1, x);
72
80
 
73
81
  static inline dtype f_seq(dtype x, dtype y, size_t c) {
74
82
  y = m_mul(y, SIZET2NUM(c));