carray 3.0.1 → 3.0.3

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 (229) hide show
  1. checksums.yaml +4 -4
  2. data/CHANGELOG.md +824 -0
  3. data/README.md +5 -6
  4. data/carray.gemspec +1 -1
  5. data/ext/ca_axis_dispatch.c +258 -4
  6. data/ext/ca_axis_group.c +368 -184
  7. data/ext/ca_binop_dispatch.c +54 -32
  8. data/ext/ca_binop_dispatch.h +1 -0
  9. data/ext/ca_categorical_iterator.c +90 -41
  10. data/ext/ca_compare.c +8 -2
  11. data/ext/ca_for_buffer.h +21 -68
  12. data/ext/ca_group_iter.c +27 -11
  13. data/ext/ca_kernel_iterator.c +960 -245
  14. data/ext/ca_kernel_iterator.h +352 -181
  15. data/ext/ca_monop_dispatch.c +4 -4
  16. data/ext/ca_monop_dispatch.h +4 -0
  17. data/ext/ca_obj_array.c +194 -42
  18. data/ext/ca_obj_bincmp.c +152 -121
  19. data/ext/ca_obj_binop.c +107 -210
  20. data/ext/ca_obj_bitarray.c +37 -24
  21. data/ext/ca_obj_bitfield.c +95 -62
  22. data/ext/ca_obj_block.c +5 -4
  23. data/ext/ca_obj_byte_swap.c +40 -40
  24. data/ext/ca_obj_const_string.c +180 -50
  25. data/ext/ca_obj_face.c +428 -62
  26. data/ext/ca_obj_face.h +107 -47
  27. data/ext/ca_obj_fake.c +21 -50
  28. data/ext/ca_obj_farray.c +1 -0
  29. data/ext/ca_obj_field.c +16 -3
  30. data/ext/ca_obj_fixlen_string.c +39 -26
  31. data/ext/ca_obj_grid.c +181 -124
  32. data/ext/ca_obj_meld.c +235 -55
  33. data/ext/ca_obj_moncmp.c +61 -61
  34. data/ext/ca_obj_monop.c +125 -107
  35. data/ext/ca_obj_object.c +551 -233
  36. data/ext/ca_obj_record.c +51 -16
  37. data/ext/ca_obj_reduce.c +5 -8
  38. data/ext/ca_obj_refer.c +117 -33
  39. data/ext/ca_obj_remap.c +57 -17
  40. data/ext/ca_obj_repeat.c +21 -5
  41. data/ext/ca_obj_roll.c +115 -11
  42. data/ext/ca_obj_select.c +88 -75
  43. data/ext/ca_obj_select_axis.c +58 -60
  44. data/ext/ca_obj_shift.c +22 -102
  45. data/ext/ca_obj_stack.c +223 -123
  46. data/ext/ca_obj_stride.c +267 -35
  47. data/ext/ca_obj_string.c +25 -22
  48. data/ext/ca_obj_tile.c +32 -16
  49. data/ext/ca_obj_time.c +23 -25
  50. data/ext/ca_obj_timedelta.c +21 -23
  51. data/ext/ca_obj_transpose.c +12 -3
  52. data/ext/ca_obj_triop.c +110 -117
  53. data/ext/ca_obj_window.c +157 -29
  54. data/ext/ca_op_ipower.c +25 -13
  55. data/ext/ca_op_powi.h +57 -30
  56. data/ext/ca_pow5_table.h +656 -0
  57. data/ext/ca_rng_normal.h +42 -0
  58. data/ext/ca_rng_xoshiro256pp.h +105 -0
  59. data/ext/ca_sort_kernels.h +70 -0
  60. data/ext/ca_sweep_engine.c +385 -198
  61. data/ext/ca_sweep_engine.h +31 -23
  62. data/ext/ca_triop_dispatch.c +4 -1
  63. data/ext/ca_triop_dispatch.h +5 -2
  64. data/ext/caframe_csv_reader.c +463 -0
  65. data/ext/carray.h +90 -28
  66. data/ext/carray_access.c +487 -231
  67. data/ext/carray_address_basis.c +731 -0
  68. data/ext/carray_attribute.c +45 -3
  69. data/ext/carray_bincount.c +32 -2
  70. data/ext/carray_broadcast.c +49 -17
  71. data/ext/carray_call_cfunc.c +667 -511
  72. data/ext/carray_cast.c +1556 -247
  73. data/ext/carray_cast_func.rb +34 -21
  74. data/ext/carray_conversion.c +197 -73
  75. data/ext/carray_copy.c +84 -38
  76. data/ext/carray_core.c +591 -119
  77. data/ext/carray_count.c +148 -96
  78. data/ext/carray_element.c +18 -27
  79. data/ext/carray_factorize.c +604 -291
  80. data/ext/carray_generate.c +76 -40
  81. data/ext/carray_histogram.c +152 -94
  82. data/ext/carray_hold.c +2 -1
  83. data/ext/carray_index_classifier.c +63 -96
  84. data/ext/carray_internal.h +400 -1
  85. data/ext/carray_lazy.c +834 -79
  86. data/ext/carray_loop.c +88 -66
  87. data/ext/carray_mask.c +705 -324
  88. data/ext/carray_math_kernel.h +1 -0
  89. data/ext/carray_median_percentile.c +263 -63
  90. data/ext/carray_memory_view.c +254 -248
  91. data/ext/carray_operator.c +1093 -363
  92. data/ext/carray_order.c +133 -69
  93. data/ext/carray_partition.c +102 -56
  94. data/ext/carray_random.c +582 -204
  95. data/ext/carray_scatter.c +308 -65
  96. data/ext/carray_segment.c +257 -0
  97. data/ext/carray_slab.c +183 -70
  98. data/ext/carray_sort.c +235 -240
  99. data/ext/carray_sort_kernel.c +8 -1
  100. data/ext/carray_struct.c +99 -21
  101. data/ext/carray_test.c +167 -64
  102. data/ext/carray_time_text.c +1182 -0
  103. data/ext/carray_utils.c +363 -98
  104. data/ext/extconf.rb +27 -2
  105. data/ext/mk_call_cfunc.rb +103 -118
  106. data/ext/mk_pow5_table.rb +35 -0
  107. data/ext/mkkernel.rb +1349 -851
  108. data/ext/ruby_carray.c +17 -2
  109. data/ext/version.h +4 -4
  110. data/ext/version.rb +4 -2
  111. data/lib/carray/attribute.rb +39 -0
  112. data/lib/carray/autoload_carray.rb +24 -3
  113. data/lib/carray/autoload_method_extension.rb +18 -0
  114. data/lib/carray/axis_group.rb +245 -20
  115. data/lib/carray/basics.rb +95 -25
  116. data/lib/carray/bincount_nd.rb +6 -0
  117. data/lib/carray/block_iterator.rb +200 -54
  118. data/lib/carray/boolean_reduce.rb +21 -29
  119. data/lib/carray/categorical.rb +244 -59
  120. data/lib/carray/categorical_iterator.rb +391 -757
  121. data/lib/carray/complex.rb +36 -29
  122. data/lib/carray/conditional.rb +94 -7
  123. data/lib/carray/const_string.rb +177 -27
  124. data/lib/carray/construct.rb +40 -0
  125. data/lib/carray/data_type_extension.rb +3 -0
  126. data/lib/carray/data_type_limits.rb +91 -0
  127. data/lib/carray/fixlen_string.rb +1 -1
  128. data/lib/carray/frame/concat.rb +157 -6
  129. data/lib/carray/frame/convert.rb +13 -7
  130. data/lib/carray/frame/csv_parser.rb +590 -76
  131. data/lib/carray/frame/describe.rb +79 -0
  132. data/lib/carray/frame/frame.rb +205 -35
  133. data/lib/carray/frame/group.rb +199 -40
  134. data/lib/carray/frame/io.rb +452 -60
  135. data/lib/carray/frame/join.rb +134 -46
  136. data/lib/carray/frame/records.rb +54 -19
  137. data/lib/carray/frame/reshape.rb +448 -0
  138. data/lib/carray/frame/sort.rb +26 -2
  139. data/lib/carray/frame/verbs.rb +726 -56
  140. data/lib/carray/frame.rb +2 -0
  141. data/lib/carray/fuse_source.rb +111 -2
  142. data/lib/carray/fusion.rb +229 -38
  143. data/lib/carray/inspect.rb +71 -20
  144. data/lib/carray/iterator.rb +157 -2
  145. data/lib/carray/lazy.rb +54 -67
  146. data/lib/carray/mask_gap_fill.rb +66 -50
  147. data/lib/carray/math.rb +32 -19
  148. data/lib/carray/meld_reduce.rb +40 -7
  149. data/lib/carray/methods/align_addr.rb +8 -4
  150. data/lib/carray/methods/bincount.rb +2 -2
  151. data/lib/carray/methods/bit_string.rb +14 -3
  152. data/lib/carray/methods/composition.rb +16 -10
  153. data/lib/carray/methods/discovery_along.rb +74 -0
  154. data/lib/carray/methods/factorize.rb +50 -0
  155. data/lib/carray/methods/gather_nd.rb +13 -2
  156. data/lib/carray/methods/insert_block.rb +9 -14
  157. data/lib/carray/methods/is_in.rb +130 -6
  158. data/lib/carray/methods/join.rb +1 -1
  159. data/lib/carray/methods/locate_addr.rb +235 -21
  160. data/lib/carray/methods/mask_duplicates.rb +35 -1
  161. data/lib/carray/methods/mode.rb +18 -1
  162. data/lib/carray/methods/nunique.rb +22 -1
  163. data/lib/carray/methods/repeat.rb +91 -0
  164. data/lib/carray/methods/resize.rb +21 -23
  165. data/lib/carray/methods/snap.rb +34 -12
  166. data/lib/carray/methods/unique.rb +52 -3
  167. data/lib/carray/record_order.rb +208 -0
  168. data/lib/carray/rng.rb +86 -0
  169. data/lib/carray/runtime.rb +14 -11
  170. data/lib/carray/segment_iterator.rb +990 -0
  171. data/lib/carray/serialize.rb +197 -27
  172. data/lib/carray/slab_iterator.rb +109 -40
  173. data/lib/carray/stack.rb +10 -4
  174. data/lib/carray/string_operation_extension.rb +9 -4
  175. data/lib/carray/struct.rb +142 -51
  176. data/lib/carray/struct_builder.rb +110 -14
  177. data/lib/carray/table.rb +2 -2
  178. data/lib/carray/time.rb +535 -105
  179. data/lib/carray/window_iterator.rb +259 -82
  180. data/lib/carray.rb +4 -2
  181. data/yard-stubs/ca_obj_array.rb +4 -4
  182. data/yard-stubs/ca_obj_bitarray.rb +7 -0
  183. data/yard-stubs/ca_obj_bitfield.rb +23 -12
  184. data/yard-stubs/ca_obj_block.rb +2 -7
  185. data/yard-stubs/ca_obj_fake.rb +1 -1
  186. data/yard-stubs/ca_obj_field.rb +1 -1
  187. data/yard-stubs/ca_obj_refer.rb +3 -3
  188. data/yard-stubs/ca_obj_roll.rb +0 -1
  189. data/yard-stubs/ca_obj_stride.rb +10 -7
  190. data/yard-stubs/ca_obj_transpose.rb +1 -1
  191. data/yard-stubs/ca_obj_window.rb +11 -4
  192. data/yard-stubs/carray_access.rb +6 -5
  193. data/yard-stubs/carray_broadcast.rb +2 -2
  194. data/yard-stubs/carray_cast.rb +78 -43
  195. data/yard-stubs/carray_conversion.rb +13 -1
  196. data/yard-stubs/carray_copy.rb +8 -3
  197. data/yard-stubs/carray_core.rb +3 -83
  198. data/yard-stubs/carray_count.rb +16 -2
  199. data/yard-stubs/carray_lazy.rb +210 -1
  200. data/yard-stubs/carray_loop.rb +4 -1
  201. data/yard-stubs/carray_mask.rb +34 -10
  202. data/yard-stubs/carray_math.rb +1499 -4
  203. data/yard-stubs/carray_median_percentile.rb +26 -8
  204. data/yard-stubs/carray_order.rb +43 -82
  205. data/yard-stubs/carray_scatter.rb +10 -3
  206. data/yard-stubs/carray_segment.rb +72 -0
  207. data/yard-stubs/carray_slab.rb +11 -8
  208. data/yard-stubs/carray_sort.rb +50 -8
  209. data/yard-stubs/carray_test.rb +10 -0
  210. data/yard-stubs/carray_utils.rb +0 -26
  211. metadata +19 -19
  212. data/ext/ca_for_each_element.h +0 -239
  213. data/ext/carray_build_flags.h +0 -3
  214. data/ext/carray_config.h +0 -28
  215. data/ext/carray_kernels_bincmp.c +0 -4446
  216. data/ext/carray_kernels_binop.c +0 -11001
  217. data/ext/carray_kernels_init.c +0 -1131
  218. data/ext/carray_kernels_map.c +0 -3467
  219. data/ext/carray_kernels_moncmp.c +0 -2097
  220. data/ext/carray_kernels_monop.c +0 -18313
  221. data/ext/carray_kernels_reduce_aggregate.c +0 -25837
  222. data/ext/carray_kernels_reduce_boolean.c +0 -330
  223. data/ext/carray_kernels_reduce_cumulative.c +0 -14593
  224. data/ext/carray_kernels_reduce_extreme.c +0 -16948
  225. data/ext/carray_kernels_reduce_variance.c +0 -3910
  226. data/ext/carray_kernels_scan.c +0 -3693
  227. data/ext/carray_kernels_search.c +0 -32138
  228. data/ext/carray_kernels_sort.c +0 -10626
  229. data/ext/carray_kernels_triop.c +0 -1392
@@ -1,2097 +0,0 @@
1
- /* ---------------------------------------------------------------------------
2
-
3
- carray_kernels.c -- GENERATED by ext/mkkernel.rb -- DO NOT EDIT
4
-
5
- Kernel definitions live in mkkernel.rb (search for `MkKernel.reduce`).
6
- Regenerate by running:
7
-
8
- cd ext && ruby mkkernel.rb > carray_kernels.c
9
-
10
- extconf.rb regenerates automatically when mkkernel.rb is touched.
11
-
12
- --------------------------------------------------------------------------- */
13
-
14
- #include "carray.h"
15
- #include "ca_kernel_iterator.h"
16
- #include "ca_sort_kernels.h" /* sort kernels: internal, not via the carray.h umbrella */
17
- #include "carray_internal.h" /* ca_lazy_arena_*, ca_is_lazy_view (streaming reduce) */
18
- #include "ca_obj_face.h" /* rb_ca_strip_face_value (Face ordering gate) */
19
- #include <math.h>
20
- #include <stdint.h>
21
- #include <stdlib.h> /* qsort, mergesort (HAVE_MERGESORT) -- for :sort kind */
22
-
23
- /* MEMO_REDUCTION_FASTPATH_ENTITY_ONLY_GUARD Tier 2: CAStack identity is
24
- probed by operation-table function pointer (obj_type is runtime-
25
- assigned, so no CA_OBJ_STACK compile-time constant exists). */
26
- extern ca_operation_function_t ca_stack_func;
27
- /* BOOL2VAL: bool -> Ruby (Qtrue/Qfalse). Used as ruby_scalar wrapper
28
- for the all/any flat-reduction Ruby surface so `a.all` / `a.any`
29
- return real true/false, not Integer 0/1. (BOOL2OBJ already exists
30
- but returns Integer per CArray's boolean-as-int convention.) */
31
- #ifndef CARRAY_BOOL2VAL_DEFINED
32
- #define CARRAY_BOOL2VAL_DEFINED
33
- static inline VALUE BOOL2VAL (boolean8_t x) { return x ? Qtrue : Qfalse; }
34
- #endif
35
-
36
- #include "ca_op_powi.h"
37
- #include "ca_op_cmplx64.h"
38
-
39
- /* ===== moncmp is_nan ============================================ */
40
-
41
- static void
42
- ca_moncmp_is_nan_int8_t (ca_size_t n, boolean8_t *m,
43
- char *ptr1, ca_size_t i1,
44
- boolean8_t *ptr2, ca_size_t i2)
45
- {
46
- int8_t *q1 = (int8_t *) ptr1;
47
- int8_t *p1 = q1;
48
- boolean8_t *q2 = (boolean8_t *) ptr2;
49
- boolean8_t *p2 = q2;
50
- ca_size_t k;
51
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
52
- if ( m ) {
53
- boolean8_t *pm;
54
- for (k=0; k<n; k++) {
55
- pm = m + k;
56
- if ( ! *pm ) {
57
- p1 = q1 + k*i1;
58
- p2 = q2 + k*i2;
59
- { (*p2) = 0; }
60
- }
61
- }
62
- } else {
63
- for (k=0; k<n; k++) {
64
- p1 = q1 + k*i1;
65
- p2 = q2 + k*i2;
66
- { (*p2) = 0; }
67
- }
68
- }
69
- }
70
-
71
- static void
72
- ca_moncmp_is_nan_uint8_t (ca_size_t n, boolean8_t *m,
73
- char *ptr1, ca_size_t i1,
74
- boolean8_t *ptr2, ca_size_t i2)
75
- {
76
- uint8_t *q1 = (uint8_t *) ptr1;
77
- uint8_t *p1 = q1;
78
- boolean8_t *q2 = (boolean8_t *) ptr2;
79
- boolean8_t *p2 = q2;
80
- ca_size_t k;
81
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
82
- if ( m ) {
83
- boolean8_t *pm;
84
- for (k=0; k<n; k++) {
85
- pm = m + k;
86
- if ( ! *pm ) {
87
- p1 = q1 + k*i1;
88
- p2 = q2 + k*i2;
89
- { (*p2) = 0; }
90
- }
91
- }
92
- } else {
93
- for (k=0; k<n; k++) {
94
- p1 = q1 + k*i1;
95
- p2 = q2 + k*i2;
96
- { (*p2) = 0; }
97
- }
98
- }
99
- }
100
-
101
- static void
102
- ca_moncmp_is_nan_int16_t (ca_size_t n, boolean8_t *m,
103
- char *ptr1, ca_size_t i1,
104
- boolean8_t *ptr2, ca_size_t i2)
105
- {
106
- int16_t *q1 = (int16_t *) ptr1;
107
- int16_t *p1 = q1;
108
- boolean8_t *q2 = (boolean8_t *) ptr2;
109
- boolean8_t *p2 = q2;
110
- ca_size_t k;
111
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
112
- if ( m ) {
113
- boolean8_t *pm;
114
- for (k=0; k<n; k++) {
115
- pm = m + k;
116
- if ( ! *pm ) {
117
- p1 = q1 + k*i1;
118
- p2 = q2 + k*i2;
119
- { (*p2) = 0; }
120
- }
121
- }
122
- } else {
123
- for (k=0; k<n; k++) {
124
- p1 = q1 + k*i1;
125
- p2 = q2 + k*i2;
126
- { (*p2) = 0; }
127
- }
128
- }
129
- }
130
-
131
- static void
132
- ca_moncmp_is_nan_uint16_t (ca_size_t n, boolean8_t *m,
133
- char *ptr1, ca_size_t i1,
134
- boolean8_t *ptr2, ca_size_t i2)
135
- {
136
- uint16_t *q1 = (uint16_t *) ptr1;
137
- uint16_t *p1 = q1;
138
- boolean8_t *q2 = (boolean8_t *) ptr2;
139
- boolean8_t *p2 = q2;
140
- ca_size_t k;
141
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
142
- if ( m ) {
143
- boolean8_t *pm;
144
- for (k=0; k<n; k++) {
145
- pm = m + k;
146
- if ( ! *pm ) {
147
- p1 = q1 + k*i1;
148
- p2 = q2 + k*i2;
149
- { (*p2) = 0; }
150
- }
151
- }
152
- } else {
153
- for (k=0; k<n; k++) {
154
- p1 = q1 + k*i1;
155
- p2 = q2 + k*i2;
156
- { (*p2) = 0; }
157
- }
158
- }
159
- }
160
-
161
- static void
162
- ca_moncmp_is_nan_int32_t (ca_size_t n, boolean8_t *m,
163
- char *ptr1, ca_size_t i1,
164
- boolean8_t *ptr2, ca_size_t i2)
165
- {
166
- int32_t *q1 = (int32_t *) ptr1;
167
- int32_t *p1 = q1;
168
- boolean8_t *q2 = (boolean8_t *) ptr2;
169
- boolean8_t *p2 = q2;
170
- ca_size_t k;
171
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
172
- if ( m ) {
173
- boolean8_t *pm;
174
- for (k=0; k<n; k++) {
175
- pm = m + k;
176
- if ( ! *pm ) {
177
- p1 = q1 + k*i1;
178
- p2 = q2 + k*i2;
179
- { (*p2) = 0; }
180
- }
181
- }
182
- } else {
183
- for (k=0; k<n; k++) {
184
- p1 = q1 + k*i1;
185
- p2 = q2 + k*i2;
186
- { (*p2) = 0; }
187
- }
188
- }
189
- }
190
-
191
- static void
192
- ca_moncmp_is_nan_uint32_t (ca_size_t n, boolean8_t *m,
193
- char *ptr1, ca_size_t i1,
194
- boolean8_t *ptr2, ca_size_t i2)
195
- {
196
- uint32_t *q1 = (uint32_t *) ptr1;
197
- uint32_t *p1 = q1;
198
- boolean8_t *q2 = (boolean8_t *) ptr2;
199
- boolean8_t *p2 = q2;
200
- ca_size_t k;
201
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
202
- if ( m ) {
203
- boolean8_t *pm;
204
- for (k=0; k<n; k++) {
205
- pm = m + k;
206
- if ( ! *pm ) {
207
- p1 = q1 + k*i1;
208
- p2 = q2 + k*i2;
209
- { (*p2) = 0; }
210
- }
211
- }
212
- } else {
213
- for (k=0; k<n; k++) {
214
- p1 = q1 + k*i1;
215
- p2 = q2 + k*i2;
216
- { (*p2) = 0; }
217
- }
218
- }
219
- }
220
-
221
- static void
222
- ca_moncmp_is_nan_int64_t (ca_size_t n, boolean8_t *m,
223
- char *ptr1, ca_size_t i1,
224
- boolean8_t *ptr2, ca_size_t i2)
225
- {
226
- int64_t *q1 = (int64_t *) ptr1;
227
- int64_t *p1 = q1;
228
- boolean8_t *q2 = (boolean8_t *) ptr2;
229
- boolean8_t *p2 = q2;
230
- ca_size_t k;
231
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
232
- if ( m ) {
233
- boolean8_t *pm;
234
- for (k=0; k<n; k++) {
235
- pm = m + k;
236
- if ( ! *pm ) {
237
- p1 = q1 + k*i1;
238
- p2 = q2 + k*i2;
239
- { (*p2) = 0; }
240
- }
241
- }
242
- } else {
243
- for (k=0; k<n; k++) {
244
- p1 = q1 + k*i1;
245
- p2 = q2 + k*i2;
246
- { (*p2) = 0; }
247
- }
248
- }
249
- }
250
-
251
- static void
252
- ca_moncmp_is_nan_uint64_t (ca_size_t n, boolean8_t *m,
253
- char *ptr1, ca_size_t i1,
254
- boolean8_t *ptr2, ca_size_t i2)
255
- {
256
- uint64_t *q1 = (uint64_t *) ptr1;
257
- uint64_t *p1 = q1;
258
- boolean8_t *q2 = (boolean8_t *) ptr2;
259
- boolean8_t *p2 = q2;
260
- ca_size_t k;
261
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
262
- if ( m ) {
263
- boolean8_t *pm;
264
- for (k=0; k<n; k++) {
265
- pm = m + k;
266
- if ( ! *pm ) {
267
- p1 = q1 + k*i1;
268
- p2 = q2 + k*i2;
269
- { (*p2) = 0; }
270
- }
271
- }
272
- } else {
273
- for (k=0; k<n; k++) {
274
- p1 = q1 + k*i1;
275
- p2 = q2 + k*i2;
276
- { (*p2) = 0; }
277
- }
278
- }
279
- }
280
-
281
- static void
282
- ca_moncmp_is_nan_float32_t (ca_size_t n, boolean8_t *m,
283
- char *ptr1, ca_size_t i1,
284
- boolean8_t *ptr2, ca_size_t i2)
285
- {
286
- float *q1 = (float *) ptr1;
287
- float *p1 = q1;
288
- boolean8_t *q2 = (boolean8_t *) ptr2;
289
- boolean8_t *p2 = q2;
290
- ca_size_t k;
291
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
292
- if ( m ) {
293
- boolean8_t *pm;
294
- for (k=0; k<n; k++) {
295
- pm = m + k;
296
- if ( ! *pm ) {
297
- p1 = q1 + k*i1;
298
- p2 = q2 + k*i2;
299
- { (*p2) = isnan(*p1); }
300
- }
301
- }
302
- } else {
303
- for (k=0; k<n; k++) {
304
- p1 = q1 + k*i1;
305
- p2 = q2 + k*i2;
306
- { (*p2) = isnan(*p1); }
307
- }
308
- }
309
- }
310
-
311
- static void
312
- ca_moncmp_is_nan_float64_t (ca_size_t n, boolean8_t *m,
313
- char *ptr1, ca_size_t i1,
314
- boolean8_t *ptr2, ca_size_t i2)
315
- {
316
- double *q1 = (double *) ptr1;
317
- double *p1 = q1;
318
- boolean8_t *q2 = (boolean8_t *) ptr2;
319
- boolean8_t *p2 = q2;
320
- ca_size_t k;
321
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
322
- if ( m ) {
323
- boolean8_t *pm;
324
- for (k=0; k<n; k++) {
325
- pm = m + k;
326
- if ( ! *pm ) {
327
- p1 = q1 + k*i1;
328
- p2 = q2 + k*i2;
329
- { (*p2) = isnan(*p1); }
330
- }
331
- }
332
- } else {
333
- for (k=0; k<n; k++) {
334
- p1 = q1 + k*i1;
335
- p2 = q2 + k*i2;
336
- { (*p2) = isnan(*p1); }
337
- }
338
- }
339
- }
340
-
341
- static void
342
- ca_moncmp_is_nan_cmplx64_t (ca_size_t n, boolean8_t *m,
343
- char *ptr1, ca_size_t i1,
344
- boolean8_t *ptr2, ca_size_t i2)
345
- {
346
- cmplx64_t *q1 = (cmplx64_t *) ptr1;
347
- cmplx64_t *p1 = q1;
348
- boolean8_t *q2 = (boolean8_t *) ptr2;
349
- boolean8_t *p2 = q2;
350
- ca_size_t k;
351
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
352
- if ( m ) {
353
- boolean8_t *pm;
354
- for (k=0; k<n; k++) {
355
- pm = m + k;
356
- if ( ! *pm ) {
357
- p1 = q1 + k*i1;
358
- p2 = q2 + k*i2;
359
- { (*p2) = (isnan(creal(*p1)) || isnan(cimag(*p1))); }
360
- }
361
- }
362
- } else {
363
- for (k=0; k<n; k++) {
364
- p1 = q1 + k*i1;
365
- p2 = q2 + k*i2;
366
- { (*p2) = (isnan(creal(*p1)) || isnan(cimag(*p1))); }
367
- }
368
- }
369
- }
370
-
371
- static void
372
- ca_moncmp_is_nan_cmplx128_t (ca_size_t n, boolean8_t *m,
373
- char *ptr1, ca_size_t i1,
374
- boolean8_t *ptr2, ca_size_t i2)
375
- {
376
- cmplx128_t *q1 = (cmplx128_t *) ptr1;
377
- cmplx128_t *p1 = q1;
378
- boolean8_t *q2 = (boolean8_t *) ptr2;
379
- boolean8_t *p2 = q2;
380
- ca_size_t k;
381
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
382
- if ( m ) {
383
- boolean8_t *pm;
384
- for (k=0; k<n; k++) {
385
- pm = m + k;
386
- if ( ! *pm ) {
387
- p1 = q1 + k*i1;
388
- p2 = q2 + k*i2;
389
- { (*p2) = (isnan(creal(*p1)) || isnan(cimag(*p1))); }
390
- }
391
- }
392
- } else {
393
- for (k=0; k<n; k++) {
394
- p1 = q1 + k*i1;
395
- p2 = q2 + k*i2;
396
- { (*p2) = (isnan(creal(*p1)) || isnan(cimag(*p1))); }
397
- }
398
- }
399
- }
400
-
401
- static void
402
- ca_moncmp_is_nan_VALUE (ca_size_t n, boolean8_t *m,
403
- char *ptr1, ca_size_t i1,
404
- boolean8_t *ptr2, ca_size_t i2)
405
- {
406
- VALUE *q1 = (VALUE *) ptr1;
407
- VALUE *p1 = q1;
408
- boolean8_t *q2 = (boolean8_t *) ptr2;
409
- boolean8_t *p2 = q2;
410
- ca_size_t k;
411
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
412
- if ( m ) {
413
- boolean8_t *pm;
414
- for (k=0; k<n; k++) {
415
- pm = m + k;
416
- if ( ! *pm ) {
417
- p1 = q1 + k*i1;
418
- p2 = q2 + k*i2;
419
- { (*p2) = rb_funcall((*p1), rb_intern("nan?"), 0); }
420
- }
421
- }
422
- } else {
423
- for (k=0; k<n; k++) {
424
- p1 = q1 + k*i1;
425
- p2 = q2 + k*i2;
426
- { (*p2) = rb_funcall((*p1), rb_intern("nan?"), 0); }
427
- }
428
- }
429
- }
430
-
431
- ca_moncmp_func_t
432
- ca_moncmp_is_nan[CA_NTYPE] = {
433
- ca_moncmp_not_implement,
434
- ca_moncmp_not_implement,
435
- ca_moncmp_is_nan_int8_t,
436
- ca_moncmp_is_nan_uint8_t,
437
- ca_moncmp_is_nan_int16_t,
438
- ca_moncmp_is_nan_uint16_t,
439
- ca_moncmp_is_nan_int32_t,
440
- ca_moncmp_is_nan_uint32_t,
441
- ca_moncmp_is_nan_int64_t,
442
- ca_moncmp_is_nan_uint64_t,
443
- ca_moncmp_is_nan_float32_t,
444
- ca_moncmp_is_nan_float64_t,
445
- ca_moncmp_not_implement,
446
- ca_moncmp_is_nan_cmplx64_t,
447
- ca_moncmp_is_nan_cmplx128_t,
448
- ca_moncmp_not_implement,
449
- ca_moncmp_is_nan_VALUE,
450
- };
451
-
452
- VALUE rb_ca_is_nan (VALUE self)
453
- { return rb_ca_call_moncmp(self, ca_moncmp_is_nan); }
454
-
455
- /* ===== moncmp is_inf ============================================ */
456
-
457
- static void
458
- ca_moncmp_is_inf_int8_t (ca_size_t n, boolean8_t *m,
459
- char *ptr1, ca_size_t i1,
460
- boolean8_t *ptr2, ca_size_t i2)
461
- {
462
- int8_t *q1 = (int8_t *) ptr1;
463
- int8_t *p1 = q1;
464
- boolean8_t *q2 = (boolean8_t *) ptr2;
465
- boolean8_t *p2 = q2;
466
- ca_size_t k;
467
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
468
- if ( m ) {
469
- boolean8_t *pm;
470
- for (k=0; k<n; k++) {
471
- pm = m + k;
472
- if ( ! *pm ) {
473
- p1 = q1 + k*i1;
474
- p2 = q2 + k*i2;
475
- { (*p2) = 0; }
476
- }
477
- }
478
- } else {
479
- for (k=0; k<n; k++) {
480
- p1 = q1 + k*i1;
481
- p2 = q2 + k*i2;
482
- { (*p2) = 0; }
483
- }
484
- }
485
- }
486
-
487
- static void
488
- ca_moncmp_is_inf_uint8_t (ca_size_t n, boolean8_t *m,
489
- char *ptr1, ca_size_t i1,
490
- boolean8_t *ptr2, ca_size_t i2)
491
- {
492
- uint8_t *q1 = (uint8_t *) ptr1;
493
- uint8_t *p1 = q1;
494
- boolean8_t *q2 = (boolean8_t *) ptr2;
495
- boolean8_t *p2 = q2;
496
- ca_size_t k;
497
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
498
- if ( m ) {
499
- boolean8_t *pm;
500
- for (k=0; k<n; k++) {
501
- pm = m + k;
502
- if ( ! *pm ) {
503
- p1 = q1 + k*i1;
504
- p2 = q2 + k*i2;
505
- { (*p2) = 0; }
506
- }
507
- }
508
- } else {
509
- for (k=0; k<n; k++) {
510
- p1 = q1 + k*i1;
511
- p2 = q2 + k*i2;
512
- { (*p2) = 0; }
513
- }
514
- }
515
- }
516
-
517
- static void
518
- ca_moncmp_is_inf_int16_t (ca_size_t n, boolean8_t *m,
519
- char *ptr1, ca_size_t i1,
520
- boolean8_t *ptr2, ca_size_t i2)
521
- {
522
- int16_t *q1 = (int16_t *) ptr1;
523
- int16_t *p1 = q1;
524
- boolean8_t *q2 = (boolean8_t *) ptr2;
525
- boolean8_t *p2 = q2;
526
- ca_size_t k;
527
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
528
- if ( m ) {
529
- boolean8_t *pm;
530
- for (k=0; k<n; k++) {
531
- pm = m + k;
532
- if ( ! *pm ) {
533
- p1 = q1 + k*i1;
534
- p2 = q2 + k*i2;
535
- { (*p2) = 0; }
536
- }
537
- }
538
- } else {
539
- for (k=0; k<n; k++) {
540
- p1 = q1 + k*i1;
541
- p2 = q2 + k*i2;
542
- { (*p2) = 0; }
543
- }
544
- }
545
- }
546
-
547
- static void
548
- ca_moncmp_is_inf_uint16_t (ca_size_t n, boolean8_t *m,
549
- char *ptr1, ca_size_t i1,
550
- boolean8_t *ptr2, ca_size_t i2)
551
- {
552
- uint16_t *q1 = (uint16_t *) ptr1;
553
- uint16_t *p1 = q1;
554
- boolean8_t *q2 = (boolean8_t *) ptr2;
555
- boolean8_t *p2 = q2;
556
- ca_size_t k;
557
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
558
- if ( m ) {
559
- boolean8_t *pm;
560
- for (k=0; k<n; k++) {
561
- pm = m + k;
562
- if ( ! *pm ) {
563
- p1 = q1 + k*i1;
564
- p2 = q2 + k*i2;
565
- { (*p2) = 0; }
566
- }
567
- }
568
- } else {
569
- for (k=0; k<n; k++) {
570
- p1 = q1 + k*i1;
571
- p2 = q2 + k*i2;
572
- { (*p2) = 0; }
573
- }
574
- }
575
- }
576
-
577
- static void
578
- ca_moncmp_is_inf_int32_t (ca_size_t n, boolean8_t *m,
579
- char *ptr1, ca_size_t i1,
580
- boolean8_t *ptr2, ca_size_t i2)
581
- {
582
- int32_t *q1 = (int32_t *) ptr1;
583
- int32_t *p1 = q1;
584
- boolean8_t *q2 = (boolean8_t *) ptr2;
585
- boolean8_t *p2 = q2;
586
- ca_size_t k;
587
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
588
- if ( m ) {
589
- boolean8_t *pm;
590
- for (k=0; k<n; k++) {
591
- pm = m + k;
592
- if ( ! *pm ) {
593
- p1 = q1 + k*i1;
594
- p2 = q2 + k*i2;
595
- { (*p2) = 0; }
596
- }
597
- }
598
- } else {
599
- for (k=0; k<n; k++) {
600
- p1 = q1 + k*i1;
601
- p2 = q2 + k*i2;
602
- { (*p2) = 0; }
603
- }
604
- }
605
- }
606
-
607
- static void
608
- ca_moncmp_is_inf_uint32_t (ca_size_t n, boolean8_t *m,
609
- char *ptr1, ca_size_t i1,
610
- boolean8_t *ptr2, ca_size_t i2)
611
- {
612
- uint32_t *q1 = (uint32_t *) ptr1;
613
- uint32_t *p1 = q1;
614
- boolean8_t *q2 = (boolean8_t *) ptr2;
615
- boolean8_t *p2 = q2;
616
- ca_size_t k;
617
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
618
- if ( m ) {
619
- boolean8_t *pm;
620
- for (k=0; k<n; k++) {
621
- pm = m + k;
622
- if ( ! *pm ) {
623
- p1 = q1 + k*i1;
624
- p2 = q2 + k*i2;
625
- { (*p2) = 0; }
626
- }
627
- }
628
- } else {
629
- for (k=0; k<n; k++) {
630
- p1 = q1 + k*i1;
631
- p2 = q2 + k*i2;
632
- { (*p2) = 0; }
633
- }
634
- }
635
- }
636
-
637
- static void
638
- ca_moncmp_is_inf_int64_t (ca_size_t n, boolean8_t *m,
639
- char *ptr1, ca_size_t i1,
640
- boolean8_t *ptr2, ca_size_t i2)
641
- {
642
- int64_t *q1 = (int64_t *) ptr1;
643
- int64_t *p1 = q1;
644
- boolean8_t *q2 = (boolean8_t *) ptr2;
645
- boolean8_t *p2 = q2;
646
- ca_size_t k;
647
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
648
- if ( m ) {
649
- boolean8_t *pm;
650
- for (k=0; k<n; k++) {
651
- pm = m + k;
652
- if ( ! *pm ) {
653
- p1 = q1 + k*i1;
654
- p2 = q2 + k*i2;
655
- { (*p2) = 0; }
656
- }
657
- }
658
- } else {
659
- for (k=0; k<n; k++) {
660
- p1 = q1 + k*i1;
661
- p2 = q2 + k*i2;
662
- { (*p2) = 0; }
663
- }
664
- }
665
- }
666
-
667
- static void
668
- ca_moncmp_is_inf_uint64_t (ca_size_t n, boolean8_t *m,
669
- char *ptr1, ca_size_t i1,
670
- boolean8_t *ptr2, ca_size_t i2)
671
- {
672
- uint64_t *q1 = (uint64_t *) ptr1;
673
- uint64_t *p1 = q1;
674
- boolean8_t *q2 = (boolean8_t *) ptr2;
675
- boolean8_t *p2 = q2;
676
- ca_size_t k;
677
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
678
- if ( m ) {
679
- boolean8_t *pm;
680
- for (k=0; k<n; k++) {
681
- pm = m + k;
682
- if ( ! *pm ) {
683
- p1 = q1 + k*i1;
684
- p2 = q2 + k*i2;
685
- { (*p2) = 0; }
686
- }
687
- }
688
- } else {
689
- for (k=0; k<n; k++) {
690
- p1 = q1 + k*i1;
691
- p2 = q2 + k*i2;
692
- { (*p2) = 0; }
693
- }
694
- }
695
- }
696
-
697
- static void
698
- ca_moncmp_is_inf_float32_t (ca_size_t n, boolean8_t *m,
699
- char *ptr1, ca_size_t i1,
700
- boolean8_t *ptr2, ca_size_t i2)
701
- {
702
- float *q1 = (float *) ptr1;
703
- float *p1 = q1;
704
- boolean8_t *q2 = (boolean8_t *) ptr2;
705
- boolean8_t *p2 = q2;
706
- ca_size_t k;
707
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
708
- if ( m ) {
709
- boolean8_t *pm;
710
- for (k=0; k<n; k++) {
711
- pm = m + k;
712
- if ( ! *pm ) {
713
- p1 = q1 + k*i1;
714
- p2 = q2 + k*i2;
715
- { (*p2) = isinf(*p1); }
716
- }
717
- }
718
- } else {
719
- for (k=0; k<n; k++) {
720
- p1 = q1 + k*i1;
721
- p2 = q2 + k*i2;
722
- { (*p2) = isinf(*p1); }
723
- }
724
- }
725
- }
726
-
727
- static void
728
- ca_moncmp_is_inf_float64_t (ca_size_t n, boolean8_t *m,
729
- char *ptr1, ca_size_t i1,
730
- boolean8_t *ptr2, ca_size_t i2)
731
- {
732
- double *q1 = (double *) ptr1;
733
- double *p1 = q1;
734
- boolean8_t *q2 = (boolean8_t *) ptr2;
735
- boolean8_t *p2 = q2;
736
- ca_size_t k;
737
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
738
- if ( m ) {
739
- boolean8_t *pm;
740
- for (k=0; k<n; k++) {
741
- pm = m + k;
742
- if ( ! *pm ) {
743
- p1 = q1 + k*i1;
744
- p2 = q2 + k*i2;
745
- { (*p2) = isinf(*p1); }
746
- }
747
- }
748
- } else {
749
- for (k=0; k<n; k++) {
750
- p1 = q1 + k*i1;
751
- p2 = q2 + k*i2;
752
- { (*p2) = isinf(*p1); }
753
- }
754
- }
755
- }
756
-
757
- static void
758
- ca_moncmp_is_inf_cmplx64_t (ca_size_t n, boolean8_t *m,
759
- char *ptr1, ca_size_t i1,
760
- boolean8_t *ptr2, ca_size_t i2)
761
- {
762
- cmplx64_t *q1 = (cmplx64_t *) ptr1;
763
- cmplx64_t *p1 = q1;
764
- boolean8_t *q2 = (boolean8_t *) ptr2;
765
- boolean8_t *p2 = q2;
766
- ca_size_t k;
767
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
768
- if ( m ) {
769
- boolean8_t *pm;
770
- for (k=0; k<n; k++) {
771
- pm = m + k;
772
- if ( ! *pm ) {
773
- p1 = q1 + k*i1;
774
- p2 = q2 + k*i2;
775
- { (*p2) = (isinf(creal(*p1)) || isinf(cimag(*p1))); }
776
- }
777
- }
778
- } else {
779
- for (k=0; k<n; k++) {
780
- p1 = q1 + k*i1;
781
- p2 = q2 + k*i2;
782
- { (*p2) = (isinf(creal(*p1)) || isinf(cimag(*p1))); }
783
- }
784
- }
785
- }
786
-
787
- static void
788
- ca_moncmp_is_inf_cmplx128_t (ca_size_t n, boolean8_t *m,
789
- char *ptr1, ca_size_t i1,
790
- boolean8_t *ptr2, ca_size_t i2)
791
- {
792
- cmplx128_t *q1 = (cmplx128_t *) ptr1;
793
- cmplx128_t *p1 = q1;
794
- boolean8_t *q2 = (boolean8_t *) ptr2;
795
- boolean8_t *p2 = q2;
796
- ca_size_t k;
797
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
798
- if ( m ) {
799
- boolean8_t *pm;
800
- for (k=0; k<n; k++) {
801
- pm = m + k;
802
- if ( ! *pm ) {
803
- p1 = q1 + k*i1;
804
- p2 = q2 + k*i2;
805
- { (*p2) = (isinf(creal(*p1)) || isinf(cimag(*p1))); }
806
- }
807
- }
808
- } else {
809
- for (k=0; k<n; k++) {
810
- p1 = q1 + k*i1;
811
- p2 = q2 + k*i2;
812
- { (*p2) = (isinf(creal(*p1)) || isinf(cimag(*p1))); }
813
- }
814
- }
815
- }
816
-
817
- static void
818
- ca_moncmp_is_inf_VALUE (ca_size_t n, boolean8_t *m,
819
- char *ptr1, ca_size_t i1,
820
- boolean8_t *ptr2, ca_size_t i2)
821
- {
822
- VALUE *q1 = (VALUE *) ptr1;
823
- VALUE *p1 = q1;
824
- boolean8_t *q2 = (boolean8_t *) ptr2;
825
- boolean8_t *p2 = q2;
826
- ca_size_t k;
827
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
828
- if ( m ) {
829
- boolean8_t *pm;
830
- for (k=0; k<n; k++) {
831
- pm = m + k;
832
- if ( ! *pm ) {
833
- p1 = q1 + k*i1;
834
- p2 = q2 + k*i2;
835
- { (*p2) = rb_funcall((*p1), rb_intern("infinite?"), 0); }
836
- }
837
- }
838
- } else {
839
- for (k=0; k<n; k++) {
840
- p1 = q1 + k*i1;
841
- p2 = q2 + k*i2;
842
- { (*p2) = rb_funcall((*p1), rb_intern("infinite?"), 0); }
843
- }
844
- }
845
- }
846
-
847
- ca_moncmp_func_t
848
- ca_moncmp_is_inf[CA_NTYPE] = {
849
- ca_moncmp_not_implement,
850
- ca_moncmp_not_implement,
851
- ca_moncmp_is_inf_int8_t,
852
- ca_moncmp_is_inf_uint8_t,
853
- ca_moncmp_is_inf_int16_t,
854
- ca_moncmp_is_inf_uint16_t,
855
- ca_moncmp_is_inf_int32_t,
856
- ca_moncmp_is_inf_uint32_t,
857
- ca_moncmp_is_inf_int64_t,
858
- ca_moncmp_is_inf_uint64_t,
859
- ca_moncmp_is_inf_float32_t,
860
- ca_moncmp_is_inf_float64_t,
861
- ca_moncmp_not_implement,
862
- ca_moncmp_is_inf_cmplx64_t,
863
- ca_moncmp_is_inf_cmplx128_t,
864
- ca_moncmp_not_implement,
865
- ca_moncmp_is_inf_VALUE,
866
- };
867
-
868
- VALUE rb_ca_is_inf (VALUE self)
869
- { return rb_ca_call_moncmp(self, ca_moncmp_is_inf); }
870
-
871
- /* ===== moncmp is_finite ============================================ */
872
-
873
- static void
874
- ca_moncmp_is_finite_int8_t (ca_size_t n, boolean8_t *m,
875
- char *ptr1, ca_size_t i1,
876
- boolean8_t *ptr2, ca_size_t i2)
877
- {
878
- int8_t *q1 = (int8_t *) ptr1;
879
- int8_t *p1 = q1;
880
- boolean8_t *q2 = (boolean8_t *) ptr2;
881
- boolean8_t *p2 = q2;
882
- ca_size_t k;
883
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
884
- if ( m ) {
885
- boolean8_t *pm;
886
- for (k=0; k<n; k++) {
887
- pm = m + k;
888
- if ( ! *pm ) {
889
- p1 = q1 + k*i1;
890
- p2 = q2 + k*i2;
891
- { (*p2) = 1; }
892
- }
893
- }
894
- } else {
895
- for (k=0; k<n; k++) {
896
- p1 = q1 + k*i1;
897
- p2 = q2 + k*i2;
898
- { (*p2) = 1; }
899
- }
900
- }
901
- }
902
-
903
- static void
904
- ca_moncmp_is_finite_uint8_t (ca_size_t n, boolean8_t *m,
905
- char *ptr1, ca_size_t i1,
906
- boolean8_t *ptr2, ca_size_t i2)
907
- {
908
- uint8_t *q1 = (uint8_t *) ptr1;
909
- uint8_t *p1 = q1;
910
- boolean8_t *q2 = (boolean8_t *) ptr2;
911
- boolean8_t *p2 = q2;
912
- ca_size_t k;
913
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
914
- if ( m ) {
915
- boolean8_t *pm;
916
- for (k=0; k<n; k++) {
917
- pm = m + k;
918
- if ( ! *pm ) {
919
- p1 = q1 + k*i1;
920
- p2 = q2 + k*i2;
921
- { (*p2) = 1; }
922
- }
923
- }
924
- } else {
925
- for (k=0; k<n; k++) {
926
- p1 = q1 + k*i1;
927
- p2 = q2 + k*i2;
928
- { (*p2) = 1; }
929
- }
930
- }
931
- }
932
-
933
- static void
934
- ca_moncmp_is_finite_int16_t (ca_size_t n, boolean8_t *m,
935
- char *ptr1, ca_size_t i1,
936
- boolean8_t *ptr2, ca_size_t i2)
937
- {
938
- int16_t *q1 = (int16_t *) ptr1;
939
- int16_t *p1 = q1;
940
- boolean8_t *q2 = (boolean8_t *) ptr2;
941
- boolean8_t *p2 = q2;
942
- ca_size_t k;
943
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
944
- if ( m ) {
945
- boolean8_t *pm;
946
- for (k=0; k<n; k++) {
947
- pm = m + k;
948
- if ( ! *pm ) {
949
- p1 = q1 + k*i1;
950
- p2 = q2 + k*i2;
951
- { (*p2) = 1; }
952
- }
953
- }
954
- } else {
955
- for (k=0; k<n; k++) {
956
- p1 = q1 + k*i1;
957
- p2 = q2 + k*i2;
958
- { (*p2) = 1; }
959
- }
960
- }
961
- }
962
-
963
- static void
964
- ca_moncmp_is_finite_uint16_t (ca_size_t n, boolean8_t *m,
965
- char *ptr1, ca_size_t i1,
966
- boolean8_t *ptr2, ca_size_t i2)
967
- {
968
- uint16_t *q1 = (uint16_t *) ptr1;
969
- uint16_t *p1 = q1;
970
- boolean8_t *q2 = (boolean8_t *) ptr2;
971
- boolean8_t *p2 = q2;
972
- ca_size_t k;
973
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
974
- if ( m ) {
975
- boolean8_t *pm;
976
- for (k=0; k<n; k++) {
977
- pm = m + k;
978
- if ( ! *pm ) {
979
- p1 = q1 + k*i1;
980
- p2 = q2 + k*i2;
981
- { (*p2) = 1; }
982
- }
983
- }
984
- } else {
985
- for (k=0; k<n; k++) {
986
- p1 = q1 + k*i1;
987
- p2 = q2 + k*i2;
988
- { (*p2) = 1; }
989
- }
990
- }
991
- }
992
-
993
- static void
994
- ca_moncmp_is_finite_int32_t (ca_size_t n, boolean8_t *m,
995
- char *ptr1, ca_size_t i1,
996
- boolean8_t *ptr2, ca_size_t i2)
997
- {
998
- int32_t *q1 = (int32_t *) ptr1;
999
- int32_t *p1 = q1;
1000
- boolean8_t *q2 = (boolean8_t *) ptr2;
1001
- boolean8_t *p2 = q2;
1002
- ca_size_t k;
1003
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1004
- if ( m ) {
1005
- boolean8_t *pm;
1006
- for (k=0; k<n; k++) {
1007
- pm = m + k;
1008
- if ( ! *pm ) {
1009
- p1 = q1 + k*i1;
1010
- p2 = q2 + k*i2;
1011
- { (*p2) = 1; }
1012
- }
1013
- }
1014
- } else {
1015
- for (k=0; k<n; k++) {
1016
- p1 = q1 + k*i1;
1017
- p2 = q2 + k*i2;
1018
- { (*p2) = 1; }
1019
- }
1020
- }
1021
- }
1022
-
1023
- static void
1024
- ca_moncmp_is_finite_uint32_t (ca_size_t n, boolean8_t *m,
1025
- char *ptr1, ca_size_t i1,
1026
- boolean8_t *ptr2, ca_size_t i2)
1027
- {
1028
- uint32_t *q1 = (uint32_t *) ptr1;
1029
- uint32_t *p1 = q1;
1030
- boolean8_t *q2 = (boolean8_t *) ptr2;
1031
- boolean8_t *p2 = q2;
1032
- ca_size_t k;
1033
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1034
- if ( m ) {
1035
- boolean8_t *pm;
1036
- for (k=0; k<n; k++) {
1037
- pm = m + k;
1038
- if ( ! *pm ) {
1039
- p1 = q1 + k*i1;
1040
- p2 = q2 + k*i2;
1041
- { (*p2) = 1; }
1042
- }
1043
- }
1044
- } else {
1045
- for (k=0; k<n; k++) {
1046
- p1 = q1 + k*i1;
1047
- p2 = q2 + k*i2;
1048
- { (*p2) = 1; }
1049
- }
1050
- }
1051
- }
1052
-
1053
- static void
1054
- ca_moncmp_is_finite_int64_t (ca_size_t n, boolean8_t *m,
1055
- char *ptr1, ca_size_t i1,
1056
- boolean8_t *ptr2, ca_size_t i2)
1057
- {
1058
- int64_t *q1 = (int64_t *) ptr1;
1059
- int64_t *p1 = q1;
1060
- boolean8_t *q2 = (boolean8_t *) ptr2;
1061
- boolean8_t *p2 = q2;
1062
- ca_size_t k;
1063
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1064
- if ( m ) {
1065
- boolean8_t *pm;
1066
- for (k=0; k<n; k++) {
1067
- pm = m + k;
1068
- if ( ! *pm ) {
1069
- p1 = q1 + k*i1;
1070
- p2 = q2 + k*i2;
1071
- { (*p2) = 1; }
1072
- }
1073
- }
1074
- } else {
1075
- for (k=0; k<n; k++) {
1076
- p1 = q1 + k*i1;
1077
- p2 = q2 + k*i2;
1078
- { (*p2) = 1; }
1079
- }
1080
- }
1081
- }
1082
-
1083
- static void
1084
- ca_moncmp_is_finite_uint64_t (ca_size_t n, boolean8_t *m,
1085
- char *ptr1, ca_size_t i1,
1086
- boolean8_t *ptr2, ca_size_t i2)
1087
- {
1088
- uint64_t *q1 = (uint64_t *) ptr1;
1089
- uint64_t *p1 = q1;
1090
- boolean8_t *q2 = (boolean8_t *) ptr2;
1091
- boolean8_t *p2 = q2;
1092
- ca_size_t k;
1093
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1094
- if ( m ) {
1095
- boolean8_t *pm;
1096
- for (k=0; k<n; k++) {
1097
- pm = m + k;
1098
- if ( ! *pm ) {
1099
- p1 = q1 + k*i1;
1100
- p2 = q2 + k*i2;
1101
- { (*p2) = 1; }
1102
- }
1103
- }
1104
- } else {
1105
- for (k=0; k<n; k++) {
1106
- p1 = q1 + k*i1;
1107
- p2 = q2 + k*i2;
1108
- { (*p2) = 1; }
1109
- }
1110
- }
1111
- }
1112
-
1113
- static void
1114
- ca_moncmp_is_finite_float32_t (ca_size_t n, boolean8_t *m,
1115
- char *ptr1, ca_size_t i1,
1116
- boolean8_t *ptr2, ca_size_t i2)
1117
- {
1118
- float *q1 = (float *) ptr1;
1119
- float *p1 = q1;
1120
- boolean8_t *q2 = (boolean8_t *) ptr2;
1121
- boolean8_t *p2 = q2;
1122
- ca_size_t k;
1123
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1124
- if ( m ) {
1125
- boolean8_t *pm;
1126
- for (k=0; k<n; k++) {
1127
- pm = m + k;
1128
- if ( ! *pm ) {
1129
- p1 = q1 + k*i1;
1130
- p2 = q2 + k*i2;
1131
- { (*p2) = isfinite(*p1); }
1132
- }
1133
- }
1134
- } else {
1135
- for (k=0; k<n; k++) {
1136
- p1 = q1 + k*i1;
1137
- p2 = q2 + k*i2;
1138
- { (*p2) = isfinite(*p1); }
1139
- }
1140
- }
1141
- }
1142
-
1143
- static void
1144
- ca_moncmp_is_finite_float64_t (ca_size_t n, boolean8_t *m,
1145
- char *ptr1, ca_size_t i1,
1146
- boolean8_t *ptr2, ca_size_t i2)
1147
- {
1148
- double *q1 = (double *) ptr1;
1149
- double *p1 = q1;
1150
- boolean8_t *q2 = (boolean8_t *) ptr2;
1151
- boolean8_t *p2 = q2;
1152
- ca_size_t k;
1153
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1154
- if ( m ) {
1155
- boolean8_t *pm;
1156
- for (k=0; k<n; k++) {
1157
- pm = m + k;
1158
- if ( ! *pm ) {
1159
- p1 = q1 + k*i1;
1160
- p2 = q2 + k*i2;
1161
- { (*p2) = isfinite(*p1); }
1162
- }
1163
- }
1164
- } else {
1165
- for (k=0; k<n; k++) {
1166
- p1 = q1 + k*i1;
1167
- p2 = q2 + k*i2;
1168
- { (*p2) = isfinite(*p1); }
1169
- }
1170
- }
1171
- }
1172
-
1173
- static void
1174
- ca_moncmp_is_finite_cmplx64_t (ca_size_t n, boolean8_t *m,
1175
- char *ptr1, ca_size_t i1,
1176
- boolean8_t *ptr2, ca_size_t i2)
1177
- {
1178
- cmplx64_t *q1 = (cmplx64_t *) ptr1;
1179
- cmplx64_t *p1 = q1;
1180
- boolean8_t *q2 = (boolean8_t *) ptr2;
1181
- boolean8_t *p2 = q2;
1182
- ca_size_t k;
1183
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1184
- if ( m ) {
1185
- boolean8_t *pm;
1186
- for (k=0; k<n; k++) {
1187
- pm = m + k;
1188
- if ( ! *pm ) {
1189
- p1 = q1 + k*i1;
1190
- p2 = q2 + k*i2;
1191
- { (*p2) = (isfinite(creal(*p1)) && isfinite(cimag(*p1))); }
1192
- }
1193
- }
1194
- } else {
1195
- for (k=0; k<n; k++) {
1196
- p1 = q1 + k*i1;
1197
- p2 = q2 + k*i2;
1198
- { (*p2) = (isfinite(creal(*p1)) && isfinite(cimag(*p1))); }
1199
- }
1200
- }
1201
- }
1202
-
1203
- static void
1204
- ca_moncmp_is_finite_cmplx128_t (ca_size_t n, boolean8_t *m,
1205
- char *ptr1, ca_size_t i1,
1206
- boolean8_t *ptr2, ca_size_t i2)
1207
- {
1208
- cmplx128_t *q1 = (cmplx128_t *) ptr1;
1209
- cmplx128_t *p1 = q1;
1210
- boolean8_t *q2 = (boolean8_t *) ptr2;
1211
- boolean8_t *p2 = q2;
1212
- ca_size_t k;
1213
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1214
- if ( m ) {
1215
- boolean8_t *pm;
1216
- for (k=0; k<n; k++) {
1217
- pm = m + k;
1218
- if ( ! *pm ) {
1219
- p1 = q1 + k*i1;
1220
- p2 = q2 + k*i2;
1221
- { (*p2) = (isfinite(creal(*p1)) && isfinite(cimag(*p1))); }
1222
- }
1223
- }
1224
- } else {
1225
- for (k=0; k<n; k++) {
1226
- p1 = q1 + k*i1;
1227
- p2 = q2 + k*i2;
1228
- { (*p2) = (isfinite(creal(*p1)) && isfinite(cimag(*p1))); }
1229
- }
1230
- }
1231
- }
1232
-
1233
- static void
1234
- ca_moncmp_is_finite_VALUE (ca_size_t n, boolean8_t *m,
1235
- char *ptr1, ca_size_t i1,
1236
- boolean8_t *ptr2, ca_size_t i2)
1237
- {
1238
- VALUE *q1 = (VALUE *) ptr1;
1239
- VALUE *p1 = q1;
1240
- boolean8_t *q2 = (boolean8_t *) ptr2;
1241
- boolean8_t *p2 = q2;
1242
- ca_size_t k;
1243
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1244
- if ( m ) {
1245
- boolean8_t *pm;
1246
- for (k=0; k<n; k++) {
1247
- pm = m + k;
1248
- if ( ! *pm ) {
1249
- p1 = q1 + k*i1;
1250
- p2 = q2 + k*i2;
1251
- { (*p2) = rb_funcall((*p1), rb_intern("finite?"), 0); }
1252
- }
1253
- }
1254
- } else {
1255
- for (k=0; k<n; k++) {
1256
- p1 = q1 + k*i1;
1257
- p2 = q2 + k*i2;
1258
- { (*p2) = rb_funcall((*p1), rb_intern("finite?"), 0); }
1259
- }
1260
- }
1261
- }
1262
-
1263
- ca_moncmp_func_t
1264
- ca_moncmp_is_finite[CA_NTYPE] = {
1265
- ca_moncmp_not_implement,
1266
- ca_moncmp_not_implement,
1267
- ca_moncmp_is_finite_int8_t,
1268
- ca_moncmp_is_finite_uint8_t,
1269
- ca_moncmp_is_finite_int16_t,
1270
- ca_moncmp_is_finite_uint16_t,
1271
- ca_moncmp_is_finite_int32_t,
1272
- ca_moncmp_is_finite_uint32_t,
1273
- ca_moncmp_is_finite_int64_t,
1274
- ca_moncmp_is_finite_uint64_t,
1275
- ca_moncmp_is_finite_float32_t,
1276
- ca_moncmp_is_finite_float64_t,
1277
- ca_moncmp_not_implement,
1278
- ca_moncmp_is_finite_cmplx64_t,
1279
- ca_moncmp_is_finite_cmplx128_t,
1280
- ca_moncmp_not_implement,
1281
- ca_moncmp_is_finite_VALUE,
1282
- };
1283
-
1284
- VALUE rb_ca_is_finite (VALUE self)
1285
- { return rb_ca_call_moncmp(self, ca_moncmp_is_finite); }
1286
-
1287
- /* ===== moncmp is_invalid ============================================ */
1288
-
1289
- static void
1290
- ca_moncmp_is_invalid_boolean8_t (ca_size_t n, boolean8_t *m,
1291
- char *ptr1, ca_size_t i1,
1292
- boolean8_t *ptr2, ca_size_t i2)
1293
- {
1294
- boolean8_t *q1 = (boolean8_t *) ptr1;
1295
- boolean8_t *p1 = q1;
1296
- boolean8_t *q2 = (boolean8_t *) ptr2;
1297
- boolean8_t *p2 = q2;
1298
- ca_size_t k;
1299
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1300
- if ( m ) {
1301
- boolean8_t *pm;
1302
- for (k=0; k<n; k++) {
1303
- pm = m + k;
1304
- if ( ! *pm ) {
1305
- p1 = q1 + k*i1;
1306
- p2 = q2 + k*i2;
1307
- { (*p2) = 0; }
1308
- }
1309
- }
1310
- } else {
1311
- for (k=0; k<n; k++) {
1312
- p1 = q1 + k*i1;
1313
- p2 = q2 + k*i2;
1314
- { (*p2) = 0; }
1315
- }
1316
- }
1317
- }
1318
-
1319
- static void
1320
- ca_moncmp_is_invalid_int8_t (ca_size_t n, boolean8_t *m,
1321
- char *ptr1, ca_size_t i1,
1322
- boolean8_t *ptr2, ca_size_t i2)
1323
- {
1324
- int8_t *q1 = (int8_t *) ptr1;
1325
- int8_t *p1 = q1;
1326
- boolean8_t *q2 = (boolean8_t *) ptr2;
1327
- boolean8_t *p2 = q2;
1328
- ca_size_t k;
1329
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1330
- if ( m ) {
1331
- boolean8_t *pm;
1332
- for (k=0; k<n; k++) {
1333
- pm = m + k;
1334
- if ( ! *pm ) {
1335
- p1 = q1 + k*i1;
1336
- p2 = q2 + k*i2;
1337
- { (*p2) = 0; }
1338
- }
1339
- }
1340
- } else {
1341
- for (k=0; k<n; k++) {
1342
- p1 = q1 + k*i1;
1343
- p2 = q2 + k*i2;
1344
- { (*p2) = 0; }
1345
- }
1346
- }
1347
- }
1348
-
1349
- static void
1350
- ca_moncmp_is_invalid_uint8_t (ca_size_t n, boolean8_t *m,
1351
- char *ptr1, ca_size_t i1,
1352
- boolean8_t *ptr2, ca_size_t i2)
1353
- {
1354
- uint8_t *q1 = (uint8_t *) ptr1;
1355
- uint8_t *p1 = q1;
1356
- boolean8_t *q2 = (boolean8_t *) ptr2;
1357
- boolean8_t *p2 = q2;
1358
- ca_size_t k;
1359
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1360
- if ( m ) {
1361
- boolean8_t *pm;
1362
- for (k=0; k<n; k++) {
1363
- pm = m + k;
1364
- if ( ! *pm ) {
1365
- p1 = q1 + k*i1;
1366
- p2 = q2 + k*i2;
1367
- { (*p2) = 0; }
1368
- }
1369
- }
1370
- } else {
1371
- for (k=0; k<n; k++) {
1372
- p1 = q1 + k*i1;
1373
- p2 = q2 + k*i2;
1374
- { (*p2) = 0; }
1375
- }
1376
- }
1377
- }
1378
-
1379
- static void
1380
- ca_moncmp_is_invalid_int16_t (ca_size_t n, boolean8_t *m,
1381
- char *ptr1, ca_size_t i1,
1382
- boolean8_t *ptr2, ca_size_t i2)
1383
- {
1384
- int16_t *q1 = (int16_t *) ptr1;
1385
- int16_t *p1 = q1;
1386
- boolean8_t *q2 = (boolean8_t *) ptr2;
1387
- boolean8_t *p2 = q2;
1388
- ca_size_t k;
1389
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1390
- if ( m ) {
1391
- boolean8_t *pm;
1392
- for (k=0; k<n; k++) {
1393
- pm = m + k;
1394
- if ( ! *pm ) {
1395
- p1 = q1 + k*i1;
1396
- p2 = q2 + k*i2;
1397
- { (*p2) = 0; }
1398
- }
1399
- }
1400
- } else {
1401
- for (k=0; k<n; k++) {
1402
- p1 = q1 + k*i1;
1403
- p2 = q2 + k*i2;
1404
- { (*p2) = 0; }
1405
- }
1406
- }
1407
- }
1408
-
1409
- static void
1410
- ca_moncmp_is_invalid_uint16_t (ca_size_t n, boolean8_t *m,
1411
- char *ptr1, ca_size_t i1,
1412
- boolean8_t *ptr2, ca_size_t i2)
1413
- {
1414
- uint16_t *q1 = (uint16_t *) ptr1;
1415
- uint16_t *p1 = q1;
1416
- boolean8_t *q2 = (boolean8_t *) ptr2;
1417
- boolean8_t *p2 = q2;
1418
- ca_size_t k;
1419
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1420
- if ( m ) {
1421
- boolean8_t *pm;
1422
- for (k=0; k<n; k++) {
1423
- pm = m + k;
1424
- if ( ! *pm ) {
1425
- p1 = q1 + k*i1;
1426
- p2 = q2 + k*i2;
1427
- { (*p2) = 0; }
1428
- }
1429
- }
1430
- } else {
1431
- for (k=0; k<n; k++) {
1432
- p1 = q1 + k*i1;
1433
- p2 = q2 + k*i2;
1434
- { (*p2) = 0; }
1435
- }
1436
- }
1437
- }
1438
-
1439
- static void
1440
- ca_moncmp_is_invalid_int32_t (ca_size_t n, boolean8_t *m,
1441
- char *ptr1, ca_size_t i1,
1442
- boolean8_t *ptr2, ca_size_t i2)
1443
- {
1444
- int32_t *q1 = (int32_t *) ptr1;
1445
- int32_t *p1 = q1;
1446
- boolean8_t *q2 = (boolean8_t *) ptr2;
1447
- boolean8_t *p2 = q2;
1448
- ca_size_t k;
1449
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1450
- if ( m ) {
1451
- boolean8_t *pm;
1452
- for (k=0; k<n; k++) {
1453
- pm = m + k;
1454
- if ( ! *pm ) {
1455
- p1 = q1 + k*i1;
1456
- p2 = q2 + k*i2;
1457
- { (*p2) = 0; }
1458
- }
1459
- }
1460
- } else {
1461
- for (k=0; k<n; k++) {
1462
- p1 = q1 + k*i1;
1463
- p2 = q2 + k*i2;
1464
- { (*p2) = 0; }
1465
- }
1466
- }
1467
- }
1468
-
1469
- static void
1470
- ca_moncmp_is_invalid_uint32_t (ca_size_t n, boolean8_t *m,
1471
- char *ptr1, ca_size_t i1,
1472
- boolean8_t *ptr2, ca_size_t i2)
1473
- {
1474
- uint32_t *q1 = (uint32_t *) ptr1;
1475
- uint32_t *p1 = q1;
1476
- boolean8_t *q2 = (boolean8_t *) ptr2;
1477
- boolean8_t *p2 = q2;
1478
- ca_size_t k;
1479
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1480
- if ( m ) {
1481
- boolean8_t *pm;
1482
- for (k=0; k<n; k++) {
1483
- pm = m + k;
1484
- if ( ! *pm ) {
1485
- p1 = q1 + k*i1;
1486
- p2 = q2 + k*i2;
1487
- { (*p2) = 0; }
1488
- }
1489
- }
1490
- } else {
1491
- for (k=0; k<n; k++) {
1492
- p1 = q1 + k*i1;
1493
- p2 = q2 + k*i2;
1494
- { (*p2) = 0; }
1495
- }
1496
- }
1497
- }
1498
-
1499
- static void
1500
- ca_moncmp_is_invalid_int64_t (ca_size_t n, boolean8_t *m,
1501
- char *ptr1, ca_size_t i1,
1502
- boolean8_t *ptr2, ca_size_t i2)
1503
- {
1504
- int64_t *q1 = (int64_t *) ptr1;
1505
- int64_t *p1 = q1;
1506
- boolean8_t *q2 = (boolean8_t *) ptr2;
1507
- boolean8_t *p2 = q2;
1508
- ca_size_t k;
1509
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1510
- if ( m ) {
1511
- boolean8_t *pm;
1512
- for (k=0; k<n; k++) {
1513
- pm = m + k;
1514
- if ( ! *pm ) {
1515
- p1 = q1 + k*i1;
1516
- p2 = q2 + k*i2;
1517
- { (*p2) = 0; }
1518
- }
1519
- }
1520
- } else {
1521
- for (k=0; k<n; k++) {
1522
- p1 = q1 + k*i1;
1523
- p2 = q2 + k*i2;
1524
- { (*p2) = 0; }
1525
- }
1526
- }
1527
- }
1528
-
1529
- static void
1530
- ca_moncmp_is_invalid_uint64_t (ca_size_t n, boolean8_t *m,
1531
- char *ptr1, ca_size_t i1,
1532
- boolean8_t *ptr2, ca_size_t i2)
1533
- {
1534
- uint64_t *q1 = (uint64_t *) ptr1;
1535
- uint64_t *p1 = q1;
1536
- boolean8_t *q2 = (boolean8_t *) ptr2;
1537
- boolean8_t *p2 = q2;
1538
- ca_size_t k;
1539
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1540
- if ( m ) {
1541
- boolean8_t *pm;
1542
- for (k=0; k<n; k++) {
1543
- pm = m + k;
1544
- if ( ! *pm ) {
1545
- p1 = q1 + k*i1;
1546
- p2 = q2 + k*i2;
1547
- { (*p2) = 0; }
1548
- }
1549
- }
1550
- } else {
1551
- for (k=0; k<n; k++) {
1552
- p1 = q1 + k*i1;
1553
- p2 = q2 + k*i2;
1554
- { (*p2) = 0; }
1555
- }
1556
- }
1557
- }
1558
-
1559
- static void
1560
- ca_moncmp_is_invalid_float32_t (ca_size_t n, boolean8_t *m,
1561
- char *ptr1, ca_size_t i1,
1562
- boolean8_t *ptr2, ca_size_t i2)
1563
- {
1564
- float *q1 = (float *) ptr1;
1565
- float *p1 = q1;
1566
- boolean8_t *q2 = (boolean8_t *) ptr2;
1567
- boolean8_t *p2 = q2;
1568
- ca_size_t k;
1569
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1570
- if ( m ) {
1571
- boolean8_t *pm;
1572
- for (k=0; k<n; k++) {
1573
- pm = m + k;
1574
- if ( ! *pm ) {
1575
- p1 = q1 + k*i1;
1576
- p2 = q2 + k*i2;
1577
- { (*p2) = (!isfinite(*p1)); }
1578
- }
1579
- }
1580
- } else {
1581
- for (k=0; k<n; k++) {
1582
- p1 = q1 + k*i1;
1583
- p2 = q2 + k*i2;
1584
- { (*p2) = (!isfinite(*p1)); }
1585
- }
1586
- }
1587
- }
1588
-
1589
- static void
1590
- ca_moncmp_is_invalid_float64_t (ca_size_t n, boolean8_t *m,
1591
- char *ptr1, ca_size_t i1,
1592
- boolean8_t *ptr2, ca_size_t i2)
1593
- {
1594
- double *q1 = (double *) ptr1;
1595
- double *p1 = q1;
1596
- boolean8_t *q2 = (boolean8_t *) ptr2;
1597
- boolean8_t *p2 = q2;
1598
- ca_size_t k;
1599
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1600
- if ( m ) {
1601
- boolean8_t *pm;
1602
- for (k=0; k<n; k++) {
1603
- pm = m + k;
1604
- if ( ! *pm ) {
1605
- p1 = q1 + k*i1;
1606
- p2 = q2 + k*i2;
1607
- { (*p2) = (!isfinite(*p1)); }
1608
- }
1609
- }
1610
- } else {
1611
- for (k=0; k<n; k++) {
1612
- p1 = q1 + k*i1;
1613
- p2 = q2 + k*i2;
1614
- { (*p2) = (!isfinite(*p1)); }
1615
- }
1616
- }
1617
- }
1618
-
1619
- static void
1620
- ca_moncmp_is_invalid_cmplx64_t (ca_size_t n, boolean8_t *m,
1621
- char *ptr1, ca_size_t i1,
1622
- boolean8_t *ptr2, ca_size_t i2)
1623
- {
1624
- cmplx64_t *q1 = (cmplx64_t *) ptr1;
1625
- cmplx64_t *p1 = q1;
1626
- boolean8_t *q2 = (boolean8_t *) ptr2;
1627
- boolean8_t *p2 = q2;
1628
- ca_size_t k;
1629
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1630
- if ( m ) {
1631
- boolean8_t *pm;
1632
- for (k=0; k<n; k++) {
1633
- pm = m + k;
1634
- if ( ! *pm ) {
1635
- p1 = q1 + k*i1;
1636
- p2 = q2 + k*i2;
1637
- { (*p2) = (!isfinite(creal(*p1)) || !isfinite(cimag(*p1))); }
1638
- }
1639
- }
1640
- } else {
1641
- for (k=0; k<n; k++) {
1642
- p1 = q1 + k*i1;
1643
- p2 = q2 + k*i2;
1644
- { (*p2) = (!isfinite(creal(*p1)) || !isfinite(cimag(*p1))); }
1645
- }
1646
- }
1647
- }
1648
-
1649
- static void
1650
- ca_moncmp_is_invalid_cmplx128_t (ca_size_t n, boolean8_t *m,
1651
- char *ptr1, ca_size_t i1,
1652
- boolean8_t *ptr2, ca_size_t i2)
1653
- {
1654
- cmplx128_t *q1 = (cmplx128_t *) ptr1;
1655
- cmplx128_t *p1 = q1;
1656
- boolean8_t *q2 = (boolean8_t *) ptr2;
1657
- boolean8_t *p2 = q2;
1658
- ca_size_t k;
1659
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1660
- if ( m ) {
1661
- boolean8_t *pm;
1662
- for (k=0; k<n; k++) {
1663
- pm = m + k;
1664
- if ( ! *pm ) {
1665
- p1 = q1 + k*i1;
1666
- p2 = q2 + k*i2;
1667
- { (*p2) = (!isfinite(creal(*p1)) || !isfinite(cimag(*p1))); }
1668
- }
1669
- }
1670
- } else {
1671
- for (k=0; k<n; k++) {
1672
- p1 = q1 + k*i1;
1673
- p2 = q2 + k*i2;
1674
- { (*p2) = (!isfinite(creal(*p1)) || !isfinite(cimag(*p1))); }
1675
- }
1676
- }
1677
- }
1678
-
1679
- static void
1680
- ca_moncmp_is_invalid_VALUE (ca_size_t n, boolean8_t *m,
1681
- char *ptr1, ca_size_t i1,
1682
- boolean8_t *ptr2, ca_size_t i2)
1683
- {
1684
- VALUE *q1 = (VALUE *) ptr1;
1685
- VALUE *p1 = q1;
1686
- boolean8_t *q2 = (boolean8_t *) ptr2;
1687
- boolean8_t *p2 = q2;
1688
- ca_size_t k;
1689
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1690
- if ( m ) {
1691
- boolean8_t *pm;
1692
- for (k=0; k<n; k++) {
1693
- pm = m + k;
1694
- if ( ! *pm ) {
1695
- p1 = q1 + k*i1;
1696
- p2 = q2 + k*i2;
1697
- { (*p2) = (RTEST(rb_funcall((*p1), rb_intern("finite?"), 0)) ? 0 : 1); }
1698
- }
1699
- }
1700
- } else {
1701
- for (k=0; k<n; k++) {
1702
- p1 = q1 + k*i1;
1703
- p2 = q2 + k*i2;
1704
- { (*p2) = (RTEST(rb_funcall((*p1), rb_intern("finite?"), 0)) ? 0 : 1); }
1705
- }
1706
- }
1707
- }
1708
-
1709
- ca_moncmp_func_t
1710
- ca_moncmp_is_invalid[CA_NTYPE] = {
1711
- ca_moncmp_not_implement,
1712
- ca_moncmp_is_invalid_boolean8_t,
1713
- ca_moncmp_is_invalid_int8_t,
1714
- ca_moncmp_is_invalid_uint8_t,
1715
- ca_moncmp_is_invalid_int16_t,
1716
- ca_moncmp_is_invalid_uint16_t,
1717
- ca_moncmp_is_invalid_int32_t,
1718
- ca_moncmp_is_invalid_uint32_t,
1719
- ca_moncmp_is_invalid_int64_t,
1720
- ca_moncmp_is_invalid_uint64_t,
1721
- ca_moncmp_is_invalid_float32_t,
1722
- ca_moncmp_is_invalid_float64_t,
1723
- ca_moncmp_not_implement,
1724
- ca_moncmp_is_invalid_cmplx64_t,
1725
- ca_moncmp_is_invalid_cmplx128_t,
1726
- ca_moncmp_not_implement,
1727
- ca_moncmp_is_invalid_VALUE,
1728
- };
1729
-
1730
- VALUE rb_ca_is_invalid (VALUE self)
1731
- { return rb_ca_call_moncmp(self, ca_moncmp_is_invalid); }
1732
-
1733
- /* ===== moncmp signbit ============================================ */
1734
-
1735
- static void
1736
- ca_moncmp_signbit_int8_t (ca_size_t n, boolean8_t *m,
1737
- char *ptr1, ca_size_t i1,
1738
- boolean8_t *ptr2, ca_size_t i2)
1739
- {
1740
- int8_t *q1 = (int8_t *) ptr1;
1741
- int8_t *p1 = q1;
1742
- boolean8_t *q2 = (boolean8_t *) ptr2;
1743
- boolean8_t *p2 = q2;
1744
- ca_size_t k;
1745
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1746
- if ( m ) {
1747
- boolean8_t *pm;
1748
- for (k=0; k<n; k++) {
1749
- pm = m + k;
1750
- if ( ! *pm ) {
1751
- p1 = q1 + k*i1;
1752
- p2 = q2 + k*i2;
1753
- { (*p2) = ((*p1) < 0); }
1754
- }
1755
- }
1756
- } else {
1757
- for (k=0; k<n; k++) {
1758
- p1 = q1 + k*i1;
1759
- p2 = q2 + k*i2;
1760
- { (*p2) = ((*p1) < 0); }
1761
- }
1762
- }
1763
- }
1764
-
1765
- static void
1766
- ca_moncmp_signbit_int16_t (ca_size_t n, boolean8_t *m,
1767
- char *ptr1, ca_size_t i1,
1768
- boolean8_t *ptr2, ca_size_t i2)
1769
- {
1770
- int16_t *q1 = (int16_t *) ptr1;
1771
- int16_t *p1 = q1;
1772
- boolean8_t *q2 = (boolean8_t *) ptr2;
1773
- boolean8_t *p2 = q2;
1774
- ca_size_t k;
1775
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1776
- if ( m ) {
1777
- boolean8_t *pm;
1778
- for (k=0; k<n; k++) {
1779
- pm = m + k;
1780
- if ( ! *pm ) {
1781
- p1 = q1 + k*i1;
1782
- p2 = q2 + k*i2;
1783
- { (*p2) = ((*p1) < 0); }
1784
- }
1785
- }
1786
- } else {
1787
- for (k=0; k<n; k++) {
1788
- p1 = q1 + k*i1;
1789
- p2 = q2 + k*i2;
1790
- { (*p2) = ((*p1) < 0); }
1791
- }
1792
- }
1793
- }
1794
-
1795
- static void
1796
- ca_moncmp_signbit_int32_t (ca_size_t n, boolean8_t *m,
1797
- char *ptr1, ca_size_t i1,
1798
- boolean8_t *ptr2, ca_size_t i2)
1799
- {
1800
- int32_t *q1 = (int32_t *) ptr1;
1801
- int32_t *p1 = q1;
1802
- boolean8_t *q2 = (boolean8_t *) ptr2;
1803
- boolean8_t *p2 = q2;
1804
- ca_size_t k;
1805
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1806
- if ( m ) {
1807
- boolean8_t *pm;
1808
- for (k=0; k<n; k++) {
1809
- pm = m + k;
1810
- if ( ! *pm ) {
1811
- p1 = q1 + k*i1;
1812
- p2 = q2 + k*i2;
1813
- { (*p2) = ((*p1) < 0); }
1814
- }
1815
- }
1816
- } else {
1817
- for (k=0; k<n; k++) {
1818
- p1 = q1 + k*i1;
1819
- p2 = q2 + k*i2;
1820
- { (*p2) = ((*p1) < 0); }
1821
- }
1822
- }
1823
- }
1824
-
1825
- static void
1826
- ca_moncmp_signbit_int64_t (ca_size_t n, boolean8_t *m,
1827
- char *ptr1, ca_size_t i1,
1828
- boolean8_t *ptr2, ca_size_t i2)
1829
- {
1830
- int64_t *q1 = (int64_t *) ptr1;
1831
- int64_t *p1 = q1;
1832
- boolean8_t *q2 = (boolean8_t *) ptr2;
1833
- boolean8_t *p2 = q2;
1834
- ca_size_t k;
1835
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1836
- if ( m ) {
1837
- boolean8_t *pm;
1838
- for (k=0; k<n; k++) {
1839
- pm = m + k;
1840
- if ( ! *pm ) {
1841
- p1 = q1 + k*i1;
1842
- p2 = q2 + k*i2;
1843
- { (*p2) = ((*p1) < 0); }
1844
- }
1845
- }
1846
- } else {
1847
- for (k=0; k<n; k++) {
1848
- p1 = q1 + k*i1;
1849
- p2 = q2 + k*i2;
1850
- { (*p2) = ((*p1) < 0); }
1851
- }
1852
- }
1853
- }
1854
-
1855
- static void
1856
- ca_moncmp_signbit_uint8_t (ca_size_t n, boolean8_t *m,
1857
- char *ptr1, ca_size_t i1,
1858
- boolean8_t *ptr2, ca_size_t i2)
1859
- {
1860
- uint8_t *q1 = (uint8_t *) ptr1;
1861
- uint8_t *p1 = q1;
1862
- boolean8_t *q2 = (boolean8_t *) ptr2;
1863
- boolean8_t *p2 = q2;
1864
- ca_size_t k;
1865
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1866
- if ( m ) {
1867
- boolean8_t *pm;
1868
- for (k=0; k<n; k++) {
1869
- pm = m + k;
1870
- if ( ! *pm ) {
1871
- p1 = q1 + k*i1;
1872
- p2 = q2 + k*i2;
1873
- { (*p2) = 0; }
1874
- }
1875
- }
1876
- } else {
1877
- for (k=0; k<n; k++) {
1878
- p1 = q1 + k*i1;
1879
- p2 = q2 + k*i2;
1880
- { (*p2) = 0; }
1881
- }
1882
- }
1883
- }
1884
-
1885
- static void
1886
- ca_moncmp_signbit_uint16_t (ca_size_t n, boolean8_t *m,
1887
- char *ptr1, ca_size_t i1,
1888
- boolean8_t *ptr2, ca_size_t i2)
1889
- {
1890
- uint16_t *q1 = (uint16_t *) ptr1;
1891
- uint16_t *p1 = q1;
1892
- boolean8_t *q2 = (boolean8_t *) ptr2;
1893
- boolean8_t *p2 = q2;
1894
- ca_size_t k;
1895
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1896
- if ( m ) {
1897
- boolean8_t *pm;
1898
- for (k=0; k<n; k++) {
1899
- pm = m + k;
1900
- if ( ! *pm ) {
1901
- p1 = q1 + k*i1;
1902
- p2 = q2 + k*i2;
1903
- { (*p2) = 0; }
1904
- }
1905
- }
1906
- } else {
1907
- for (k=0; k<n; k++) {
1908
- p1 = q1 + k*i1;
1909
- p2 = q2 + k*i2;
1910
- { (*p2) = 0; }
1911
- }
1912
- }
1913
- }
1914
-
1915
- static void
1916
- ca_moncmp_signbit_uint32_t (ca_size_t n, boolean8_t *m,
1917
- char *ptr1, ca_size_t i1,
1918
- boolean8_t *ptr2, ca_size_t i2)
1919
- {
1920
- uint32_t *q1 = (uint32_t *) ptr1;
1921
- uint32_t *p1 = q1;
1922
- boolean8_t *q2 = (boolean8_t *) ptr2;
1923
- boolean8_t *p2 = q2;
1924
- ca_size_t k;
1925
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1926
- if ( m ) {
1927
- boolean8_t *pm;
1928
- for (k=0; k<n; k++) {
1929
- pm = m + k;
1930
- if ( ! *pm ) {
1931
- p1 = q1 + k*i1;
1932
- p2 = q2 + k*i2;
1933
- { (*p2) = 0; }
1934
- }
1935
- }
1936
- } else {
1937
- for (k=0; k<n; k++) {
1938
- p1 = q1 + k*i1;
1939
- p2 = q2 + k*i2;
1940
- { (*p2) = 0; }
1941
- }
1942
- }
1943
- }
1944
-
1945
- static void
1946
- ca_moncmp_signbit_uint64_t (ca_size_t n, boolean8_t *m,
1947
- char *ptr1, ca_size_t i1,
1948
- boolean8_t *ptr2, ca_size_t i2)
1949
- {
1950
- uint64_t *q1 = (uint64_t *) ptr1;
1951
- uint64_t *p1 = q1;
1952
- boolean8_t *q2 = (boolean8_t *) ptr2;
1953
- boolean8_t *p2 = q2;
1954
- ca_size_t k;
1955
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1956
- if ( m ) {
1957
- boolean8_t *pm;
1958
- for (k=0; k<n; k++) {
1959
- pm = m + k;
1960
- if ( ! *pm ) {
1961
- p1 = q1 + k*i1;
1962
- p2 = q2 + k*i2;
1963
- { (*p2) = 0; }
1964
- }
1965
- }
1966
- } else {
1967
- for (k=0; k<n; k++) {
1968
- p1 = q1 + k*i1;
1969
- p2 = q2 + k*i2;
1970
- { (*p2) = 0; }
1971
- }
1972
- }
1973
- }
1974
-
1975
- static void
1976
- ca_moncmp_signbit_float32_t (ca_size_t n, boolean8_t *m,
1977
- char *ptr1, ca_size_t i1,
1978
- boolean8_t *ptr2, ca_size_t i2)
1979
- {
1980
- float *q1 = (float *) ptr1;
1981
- float *p1 = q1;
1982
- boolean8_t *q2 = (boolean8_t *) ptr2;
1983
- boolean8_t *p2 = q2;
1984
- ca_size_t k;
1985
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
1986
- if ( m ) {
1987
- boolean8_t *pm;
1988
- for (k=0; k<n; k++) {
1989
- pm = m + k;
1990
- if ( ! *pm ) {
1991
- p1 = q1 + k*i1;
1992
- p2 = q2 + k*i2;
1993
- { (*p2) = signbit(*p1); }
1994
- }
1995
- }
1996
- } else {
1997
- for (k=0; k<n; k++) {
1998
- p1 = q1 + k*i1;
1999
- p2 = q2 + k*i2;
2000
- { (*p2) = signbit(*p1); }
2001
- }
2002
- }
2003
- }
2004
-
2005
- static void
2006
- ca_moncmp_signbit_float64_t (ca_size_t n, boolean8_t *m,
2007
- char *ptr1, ca_size_t i1,
2008
- boolean8_t *ptr2, ca_size_t i2)
2009
- {
2010
- double *q1 = (double *) ptr1;
2011
- double *p1 = q1;
2012
- boolean8_t *q2 = (boolean8_t *) ptr2;
2013
- boolean8_t *p2 = q2;
2014
- ca_size_t k;
2015
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
2016
- if ( m ) {
2017
- boolean8_t *pm;
2018
- for (k=0; k<n; k++) {
2019
- pm = m + k;
2020
- if ( ! *pm ) {
2021
- p1 = q1 + k*i1;
2022
- p2 = q2 + k*i2;
2023
- { (*p2) = signbit(*p1); }
2024
- }
2025
- }
2026
- } else {
2027
- for (k=0; k<n; k++) {
2028
- p1 = q1 + k*i1;
2029
- p2 = q2 + k*i2;
2030
- { (*p2) = signbit(*p1); }
2031
- }
2032
- }
2033
- }
2034
-
2035
- static void
2036
- ca_moncmp_signbit_VALUE (ca_size_t n, boolean8_t *m,
2037
- char *ptr1, ca_size_t i1,
2038
- boolean8_t *ptr2, ca_size_t i2)
2039
- {
2040
- VALUE *q1 = (VALUE *) ptr1;
2041
- VALUE *p1 = q1;
2042
- boolean8_t *q2 = (boolean8_t *) ptr2;
2043
- boolean8_t *p2 = q2;
2044
- ca_size_t k;
2045
- (void) p1; /* expr may not reference *p1 (e.g. constant predicate) */
2046
- if ( m ) {
2047
- boolean8_t *pm;
2048
- for (k=0; k<n; k++) {
2049
- pm = m + k;
2050
- if ( ! *pm ) {
2051
- p1 = q1 + k*i1;
2052
- p2 = q2 + k*i2;
2053
- { (*p2) = (RTEST(rb_funcall((*p1), rb_intern("negative?"), 0)) ? 1 : 0); }
2054
- }
2055
- }
2056
- } else {
2057
- for (k=0; k<n; k++) {
2058
- p1 = q1 + k*i1;
2059
- p2 = q2 + k*i2;
2060
- { (*p2) = (RTEST(rb_funcall((*p1), rb_intern("negative?"), 0)) ? 1 : 0); }
2061
- }
2062
- }
2063
- }
2064
-
2065
- ca_moncmp_func_t
2066
- ca_moncmp_signbit[CA_NTYPE] = {
2067
- ca_moncmp_not_implement,
2068
- ca_moncmp_not_implement,
2069
- ca_moncmp_signbit_int8_t,
2070
- ca_moncmp_signbit_uint8_t,
2071
- ca_moncmp_signbit_int16_t,
2072
- ca_moncmp_signbit_uint16_t,
2073
- ca_moncmp_signbit_int32_t,
2074
- ca_moncmp_signbit_uint32_t,
2075
- ca_moncmp_signbit_int64_t,
2076
- ca_moncmp_signbit_uint64_t,
2077
- ca_moncmp_signbit_float32_t,
2078
- ca_moncmp_signbit_float64_t,
2079
- ca_moncmp_not_implement,
2080
- ca_moncmp_not_implement,
2081
- ca_moncmp_not_implement,
2082
- ca_moncmp_not_implement,
2083
- ca_moncmp_signbit_VALUE,
2084
- };
2085
-
2086
- VALUE rb_ca_signbit (VALUE self)
2087
- { return rb_ca_call_moncmp(self, ca_moncmp_signbit); }
2088
-
2089
- void
2090
- Init_carray_kernels_moncmp (void)
2091
- {
2092
- rb_define_method(rb_cCArray, "is_nan", rb_ca_is_nan, 0);
2093
- rb_define_method(rb_cCArray, "is_inf", rb_ca_is_inf, 0);
2094
- rb_define_method(rb_cCArray, "is_finite", rb_ca_is_finite, 0);
2095
- rb_define_method(rb_cCArray, "is_invalid", rb_ca_is_invalid, 0);
2096
- rb_define_method(rb_cCArray, "signbit", rb_ca_signbit, 0);
2097
- }