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,4446 +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
- /* ===== bincmp feq ============================================ */
40
-
41
- static void
42
- ca_bincmp_feq_float32_t (ca_size_t n, boolean8_t *m,
43
- char *ptr1, ca_size_t b1, ca_size_t i1,
44
- char *ptr2, ca_size_t b2, ca_size_t i2,
45
- char *ptr3, ca_size_t b3, ca_size_t i3,
46
- double tol)
47
- {
48
- float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
49
- float *p1 = q1, *p2 = q2;
50
- boolean8_t *q3 = (boolean8_t *) ptr3;
51
- boolean8_t *p3 = q3;
52
- ca_size_t k;
53
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
54
- (void) tol;
55
- if ( m ) {
56
- boolean8_t *pm;
57
- for (k=0; k<n; k++) {
58
- pm = m + k;
59
- if ( ! *pm ) {
60
- p1 = q1 + k*i1;
61
- p2 = q2 + k*i2;
62
- p3 = q3 + k*i3;
63
- {
64
- float f1a = fabs((float64_t) *p1);
65
- float f2a = fabs((float64_t) *p2);
66
- float fmax = (f1a > f2a) ? f1a : f2a;
67
- (*p3) = ( fabs(((float64_t) *p1)-( (float64_t) *p2)) <= fmax * FLT_EPSILON ) ? 1 : 0;
68
- }
69
- }
70
- }
71
- } else {
72
- for (k=0; k<n; k++) {
73
- p1 = q1 + k*i1;
74
- p2 = q2 + k*i2;
75
- p3 = q3 + k*i3;
76
- {
77
- float f1a = fabs((float64_t) *p1);
78
- float f2a = fabs((float64_t) *p2);
79
- float fmax = (f1a > f2a) ? f1a : f2a;
80
- (*p3) = ( fabs(((float64_t) *p1)-( (float64_t) *p2)) <= fmax * FLT_EPSILON ) ? 1 : 0;
81
- }
82
- }
83
- }
84
- }
85
-
86
- static void
87
- ca_bincmp_feq_float64_t (ca_size_t n, boolean8_t *m,
88
- char *ptr1, ca_size_t b1, ca_size_t i1,
89
- char *ptr2, ca_size_t b2, ca_size_t i2,
90
- char *ptr3, ca_size_t b3, ca_size_t i3,
91
- double tol)
92
- {
93
- double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
94
- double *p1 = q1, *p2 = q2;
95
- boolean8_t *q3 = (boolean8_t *) ptr3;
96
- boolean8_t *p3 = q3;
97
- ca_size_t k;
98
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
99
- (void) tol;
100
- if ( m ) {
101
- boolean8_t *pm;
102
- for (k=0; k<n; k++) {
103
- pm = m + k;
104
- if ( ! *pm ) {
105
- p1 = q1 + k*i1;
106
- p2 = q2 + k*i2;
107
- p3 = q3 + k*i3;
108
- {
109
- double f1a = fabs((float64_t) *p1);
110
- double f2a = fabs((float64_t) *p2);
111
- double fmax = (f1a > f2a) ? f1a : f2a;
112
- (*p3) = ( fabs(((float64_t) *p1)-( (float64_t) *p2)) <= fmax * DBL_EPSILON ) ? 1 : 0;
113
- }
114
- }
115
- }
116
- } else {
117
- for (k=0; k<n; k++) {
118
- p1 = q1 + k*i1;
119
- p2 = q2 + k*i2;
120
- p3 = q3 + k*i3;
121
- {
122
- double f1a = fabs((float64_t) *p1);
123
- double f2a = fabs((float64_t) *p2);
124
- double fmax = (f1a > f2a) ? f1a : f2a;
125
- (*p3) = ( fabs(((float64_t) *p1)-( (float64_t) *p2)) <= fmax * DBL_EPSILON ) ? 1 : 0;
126
- }
127
- }
128
- }
129
- }
130
-
131
- ca_bincmp_func_t
132
- ca_bincmp_feq[CA_NTYPE] = {
133
- ca_bincmp_not_implement,
134
- ca_bincmp_not_implement,
135
- ca_bincmp_not_implement,
136
- ca_bincmp_not_implement,
137
- ca_bincmp_not_implement,
138
- ca_bincmp_not_implement,
139
- ca_bincmp_not_implement,
140
- ca_bincmp_not_implement,
141
- ca_bincmp_not_implement,
142
- ca_bincmp_not_implement,
143
- ca_bincmp_feq_float32_t,
144
- ca_bincmp_feq_float64_t,
145
- ca_bincmp_not_implement,
146
- ca_bincmp_not_implement,
147
- ca_bincmp_not_implement,
148
- ca_bincmp_not_implement,
149
- ca_bincmp_not_implement,
150
- };
151
-
152
- VALUE rb_ca_feq (VALUE self, VALUE other)
153
- {
154
- if ( ! rb_ca_test_castable(other) ) {
155
- return rb_ca_binop_pass_to_other(self, other, rb_intern("feq"));
156
- }
157
- return rb_ca_call_bincmp(self, other, ca_bincmp_feq, 0.0);
158
- }
159
-
160
- /* ===== bincmp eq ============================================ */
161
-
162
- static void
163
- ca_bincmp_eq_fixlen (ca_size_t n, boolean8_t *m,
164
- char *ptr1, ca_size_t b1, ca_size_t i1,
165
- char *ptr2, ca_size_t b2, ca_size_t i2,
166
- char *ptr3, ca_size_t b3, ca_size_t i3,
167
- double tol)
168
- {
169
- char *q1 = ptr1, *q2 = ptr2;
170
- char *p1 = q1, *p2 = q2;
171
- boolean8_t *q3 = (boolean8_t *) ptr3;
172
- boolean8_t *p3 = q3;
173
- ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
174
- ca_size_t k;
175
- (void) tol;
176
- if ( m ) {
177
- boolean8_t *pm;
178
- for (k=0; k<n; k++) {
179
- pm = m + k;
180
- if ( ! *pm ) {
181
- p1 = q1 + k*s1;
182
- p2 = q2 + k*s2;
183
- p3 = q3 + k*s3;
184
- { (*p3) = ( b1 == b2 && (! memcmp(p1, p2, b1)) ); }
185
- }
186
- }
187
- } else {
188
- for (k=0; k<n; k++) {
189
- p1 = q1 + k*s1;
190
- p2 = q2 + k*s2;
191
- p3 = q3 + k*s3;
192
- { (*p3) = ( b1 == b2 && (! memcmp(p1, p2, b1)) ); }
193
- }
194
- }
195
- }
196
-
197
- static void
198
- ca_bincmp_eq_boolean8_t (ca_size_t n, boolean8_t *m,
199
- char *ptr1, ca_size_t b1, ca_size_t i1,
200
- char *ptr2, ca_size_t b2, ca_size_t i2,
201
- char *ptr3, ca_size_t b3, ca_size_t i3,
202
- double tol)
203
- {
204
- boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
205
- boolean8_t *p1 = q1, *p2 = q2;
206
- boolean8_t *q3 = (boolean8_t *) ptr3;
207
- boolean8_t *p3 = q3;
208
- ca_size_t k;
209
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
210
- (void) tol;
211
- if ( m ) {
212
- boolean8_t *pm;
213
- for (k=0; k<n; k++) {
214
- pm = m + k;
215
- if ( ! *pm ) {
216
- p1 = q1 + k*i1;
217
- p2 = q2 + k*i2;
218
- p3 = q3 + k*i3;
219
- { (*p3) = ( (*p1) == (*p2) ); }
220
- }
221
- }
222
- } else {
223
- for (k=0; k<n; k++) {
224
- p1 = q1 + k*i1;
225
- p2 = q2 + k*i2;
226
- p3 = q3 + k*i3;
227
- { (*p3) = ( (*p1) == (*p2) ); }
228
- }
229
- }
230
- }
231
-
232
- static void
233
- ca_bincmp_eq_int8_t (ca_size_t n, boolean8_t *m,
234
- char *ptr1, ca_size_t b1, ca_size_t i1,
235
- char *ptr2, ca_size_t b2, ca_size_t i2,
236
- char *ptr3, ca_size_t b3, ca_size_t i3,
237
- double tol)
238
- {
239
- int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
240
- int8_t *p1 = q1, *p2 = q2;
241
- boolean8_t *q3 = (boolean8_t *) ptr3;
242
- boolean8_t *p3 = q3;
243
- ca_size_t k;
244
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
245
- (void) tol;
246
- if ( m ) {
247
- boolean8_t *pm;
248
- for (k=0; k<n; k++) {
249
- pm = m + k;
250
- if ( ! *pm ) {
251
- p1 = q1 + k*i1;
252
- p2 = q2 + k*i2;
253
- p3 = q3 + k*i3;
254
- { (*p3) = ( (*p1) == (*p2) ); }
255
- }
256
- }
257
- } else {
258
- for (k=0; k<n; k++) {
259
- p1 = q1 + k*i1;
260
- p2 = q2 + k*i2;
261
- p3 = q3 + k*i3;
262
- { (*p3) = ( (*p1) == (*p2) ); }
263
- }
264
- }
265
- }
266
-
267
- static void
268
- ca_bincmp_eq_uint8_t (ca_size_t n, boolean8_t *m,
269
- char *ptr1, ca_size_t b1, ca_size_t i1,
270
- char *ptr2, ca_size_t b2, ca_size_t i2,
271
- char *ptr3, ca_size_t b3, ca_size_t i3,
272
- double tol)
273
- {
274
- uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
275
- uint8_t *p1 = q1, *p2 = q2;
276
- boolean8_t *q3 = (boolean8_t *) ptr3;
277
- boolean8_t *p3 = q3;
278
- ca_size_t k;
279
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
280
- (void) tol;
281
- if ( m ) {
282
- boolean8_t *pm;
283
- for (k=0; k<n; k++) {
284
- pm = m + k;
285
- if ( ! *pm ) {
286
- p1 = q1 + k*i1;
287
- p2 = q2 + k*i2;
288
- p3 = q3 + k*i3;
289
- { (*p3) = ( (*p1) == (*p2) ); }
290
- }
291
- }
292
- } else {
293
- for (k=0; k<n; k++) {
294
- p1 = q1 + k*i1;
295
- p2 = q2 + k*i2;
296
- p3 = q3 + k*i3;
297
- { (*p3) = ( (*p1) == (*p2) ); }
298
- }
299
- }
300
- }
301
-
302
- static void
303
- ca_bincmp_eq_int16_t (ca_size_t n, boolean8_t *m,
304
- char *ptr1, ca_size_t b1, ca_size_t i1,
305
- char *ptr2, ca_size_t b2, ca_size_t i2,
306
- char *ptr3, ca_size_t b3, ca_size_t i3,
307
- double tol)
308
- {
309
- int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
310
- int16_t *p1 = q1, *p2 = q2;
311
- boolean8_t *q3 = (boolean8_t *) ptr3;
312
- boolean8_t *p3 = q3;
313
- ca_size_t k;
314
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
315
- (void) tol;
316
- if ( m ) {
317
- boolean8_t *pm;
318
- for (k=0; k<n; k++) {
319
- pm = m + k;
320
- if ( ! *pm ) {
321
- p1 = q1 + k*i1;
322
- p2 = q2 + k*i2;
323
- p3 = q3 + k*i3;
324
- { (*p3) = ( (*p1) == (*p2) ); }
325
- }
326
- }
327
- } else {
328
- for (k=0; k<n; k++) {
329
- p1 = q1 + k*i1;
330
- p2 = q2 + k*i2;
331
- p3 = q3 + k*i3;
332
- { (*p3) = ( (*p1) == (*p2) ); }
333
- }
334
- }
335
- }
336
-
337
- static void
338
- ca_bincmp_eq_uint16_t (ca_size_t n, boolean8_t *m,
339
- char *ptr1, ca_size_t b1, ca_size_t i1,
340
- char *ptr2, ca_size_t b2, ca_size_t i2,
341
- char *ptr3, ca_size_t b3, ca_size_t i3,
342
- double tol)
343
- {
344
- uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
345
- uint16_t *p1 = q1, *p2 = q2;
346
- boolean8_t *q3 = (boolean8_t *) ptr3;
347
- boolean8_t *p3 = q3;
348
- ca_size_t k;
349
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
350
- (void) tol;
351
- if ( m ) {
352
- boolean8_t *pm;
353
- for (k=0; k<n; k++) {
354
- pm = m + k;
355
- if ( ! *pm ) {
356
- p1 = q1 + k*i1;
357
- p2 = q2 + k*i2;
358
- p3 = q3 + k*i3;
359
- { (*p3) = ( (*p1) == (*p2) ); }
360
- }
361
- }
362
- } else {
363
- for (k=0; k<n; k++) {
364
- p1 = q1 + k*i1;
365
- p2 = q2 + k*i2;
366
- p3 = q3 + k*i3;
367
- { (*p3) = ( (*p1) == (*p2) ); }
368
- }
369
- }
370
- }
371
-
372
- static void
373
- ca_bincmp_eq_int32_t (ca_size_t n, boolean8_t *m,
374
- char *ptr1, ca_size_t b1, ca_size_t i1,
375
- char *ptr2, ca_size_t b2, ca_size_t i2,
376
- char *ptr3, ca_size_t b3, ca_size_t i3,
377
- double tol)
378
- {
379
- int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
380
- int32_t *p1 = q1, *p2 = q2;
381
- boolean8_t *q3 = (boolean8_t *) ptr3;
382
- boolean8_t *p3 = q3;
383
- ca_size_t k;
384
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
385
- (void) tol;
386
- if ( m ) {
387
- boolean8_t *pm;
388
- for (k=0; k<n; k++) {
389
- pm = m + k;
390
- if ( ! *pm ) {
391
- p1 = q1 + k*i1;
392
- p2 = q2 + k*i2;
393
- p3 = q3 + k*i3;
394
- { (*p3) = ( (*p1) == (*p2) ); }
395
- }
396
- }
397
- } else {
398
- for (k=0; k<n; k++) {
399
- p1 = q1 + k*i1;
400
- p2 = q2 + k*i2;
401
- p3 = q3 + k*i3;
402
- { (*p3) = ( (*p1) == (*p2) ); }
403
- }
404
- }
405
- }
406
-
407
- static void
408
- ca_bincmp_eq_uint32_t (ca_size_t n, boolean8_t *m,
409
- char *ptr1, ca_size_t b1, ca_size_t i1,
410
- char *ptr2, ca_size_t b2, ca_size_t i2,
411
- char *ptr3, ca_size_t b3, ca_size_t i3,
412
- double tol)
413
- {
414
- uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
415
- uint32_t *p1 = q1, *p2 = q2;
416
- boolean8_t *q3 = (boolean8_t *) ptr3;
417
- boolean8_t *p3 = q3;
418
- ca_size_t k;
419
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
420
- (void) tol;
421
- if ( m ) {
422
- boolean8_t *pm;
423
- for (k=0; k<n; k++) {
424
- pm = m + k;
425
- if ( ! *pm ) {
426
- p1 = q1 + k*i1;
427
- p2 = q2 + k*i2;
428
- p3 = q3 + k*i3;
429
- { (*p3) = ( (*p1) == (*p2) ); }
430
- }
431
- }
432
- } else {
433
- for (k=0; k<n; k++) {
434
- p1 = q1 + k*i1;
435
- p2 = q2 + k*i2;
436
- p3 = q3 + k*i3;
437
- { (*p3) = ( (*p1) == (*p2) ); }
438
- }
439
- }
440
- }
441
-
442
- static void
443
- ca_bincmp_eq_int64_t (ca_size_t n, boolean8_t *m,
444
- char *ptr1, ca_size_t b1, ca_size_t i1,
445
- char *ptr2, ca_size_t b2, ca_size_t i2,
446
- char *ptr3, ca_size_t b3, ca_size_t i3,
447
- double tol)
448
- {
449
- int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
450
- int64_t *p1 = q1, *p2 = q2;
451
- boolean8_t *q3 = (boolean8_t *) ptr3;
452
- boolean8_t *p3 = q3;
453
- ca_size_t k;
454
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
455
- (void) tol;
456
- if ( m ) {
457
- boolean8_t *pm;
458
- for (k=0; k<n; k++) {
459
- pm = m + k;
460
- if ( ! *pm ) {
461
- p1 = q1 + k*i1;
462
- p2 = q2 + k*i2;
463
- p3 = q3 + k*i3;
464
- { (*p3) = ( (*p1) == (*p2) ); }
465
- }
466
- }
467
- } else {
468
- for (k=0; k<n; k++) {
469
- p1 = q1 + k*i1;
470
- p2 = q2 + k*i2;
471
- p3 = q3 + k*i3;
472
- { (*p3) = ( (*p1) == (*p2) ); }
473
- }
474
- }
475
- }
476
-
477
- static void
478
- ca_bincmp_eq_uint64_t (ca_size_t n, boolean8_t *m,
479
- char *ptr1, ca_size_t b1, ca_size_t i1,
480
- char *ptr2, ca_size_t b2, ca_size_t i2,
481
- char *ptr3, ca_size_t b3, ca_size_t i3,
482
- double tol)
483
- {
484
- uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
485
- uint64_t *p1 = q1, *p2 = q2;
486
- boolean8_t *q3 = (boolean8_t *) ptr3;
487
- boolean8_t *p3 = q3;
488
- ca_size_t k;
489
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
490
- (void) tol;
491
- if ( m ) {
492
- boolean8_t *pm;
493
- for (k=0; k<n; k++) {
494
- pm = m + k;
495
- if ( ! *pm ) {
496
- p1 = q1 + k*i1;
497
- p2 = q2 + k*i2;
498
- p3 = q3 + k*i3;
499
- { (*p3) = ( (*p1) == (*p2) ); }
500
- }
501
- }
502
- } else {
503
- for (k=0; k<n; k++) {
504
- p1 = q1 + k*i1;
505
- p2 = q2 + k*i2;
506
- p3 = q3 + k*i3;
507
- { (*p3) = ( (*p1) == (*p2) ); }
508
- }
509
- }
510
- }
511
-
512
- static void
513
- ca_bincmp_eq_float32_t (ca_size_t n, boolean8_t *m,
514
- char *ptr1, ca_size_t b1, ca_size_t i1,
515
- char *ptr2, ca_size_t b2, ca_size_t i2,
516
- char *ptr3, ca_size_t b3, ca_size_t i3,
517
- double tol)
518
- {
519
- float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
520
- float *p1 = q1, *p2 = q2;
521
- boolean8_t *q3 = (boolean8_t *) ptr3;
522
- boolean8_t *p3 = q3;
523
- ca_size_t k;
524
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
525
- (void) tol;
526
- if ( m ) {
527
- boolean8_t *pm;
528
- for (k=0; k<n; k++) {
529
- pm = m + k;
530
- if ( ! *pm ) {
531
- p1 = q1 + k*i1;
532
- p2 = q2 + k*i2;
533
- p3 = q3 + k*i3;
534
- { (*p3) = ( (*p1) == (*p2) ); }
535
- }
536
- }
537
- } else {
538
- for (k=0; k<n; k++) {
539
- p1 = q1 + k*i1;
540
- p2 = q2 + k*i2;
541
- p3 = q3 + k*i3;
542
- { (*p3) = ( (*p1) == (*p2) ); }
543
- }
544
- }
545
- }
546
-
547
- static void
548
- ca_bincmp_eq_float64_t (ca_size_t n, boolean8_t *m,
549
- char *ptr1, ca_size_t b1, ca_size_t i1,
550
- char *ptr2, ca_size_t b2, ca_size_t i2,
551
- char *ptr3, ca_size_t b3, ca_size_t i3,
552
- double tol)
553
- {
554
- double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
555
- double *p1 = q1, *p2 = q2;
556
- boolean8_t *q3 = (boolean8_t *) ptr3;
557
- boolean8_t *p3 = q3;
558
- ca_size_t k;
559
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
560
- (void) tol;
561
- if ( m ) {
562
- boolean8_t *pm;
563
- for (k=0; k<n; k++) {
564
- pm = m + k;
565
- if ( ! *pm ) {
566
- p1 = q1 + k*i1;
567
- p2 = q2 + k*i2;
568
- p3 = q3 + k*i3;
569
- { (*p3) = ( (*p1) == (*p2) ); }
570
- }
571
- }
572
- } else {
573
- for (k=0; k<n; k++) {
574
- p1 = q1 + k*i1;
575
- p2 = q2 + k*i2;
576
- p3 = q3 + k*i3;
577
- { (*p3) = ( (*p1) == (*p2) ); }
578
- }
579
- }
580
- }
581
-
582
- static void
583
- ca_bincmp_eq_VALUE (ca_size_t n, boolean8_t *m,
584
- char *ptr1, ca_size_t b1, ca_size_t i1,
585
- char *ptr2, ca_size_t b2, ca_size_t i2,
586
- char *ptr3, ca_size_t b3, ca_size_t i3,
587
- double tol)
588
- {
589
- VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
590
- VALUE *p1 = q1, *p2 = q2;
591
- boolean8_t *q3 = (boolean8_t *) ptr3;
592
- boolean8_t *p3 = q3;
593
- ca_size_t k;
594
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
595
- (void) tol;
596
- if ( m ) {
597
- boolean8_t *pm;
598
- for (k=0; k<n; k++) {
599
- pm = m + k;
600
- if ( ! *pm ) {
601
- p1 = q1 + k*i1;
602
- p2 = q2 + k*i2;
603
- p3 = q3 + k*i3;
604
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=="), 1, (*p2))) ? 1 : 0; }
605
- }
606
- }
607
- } else {
608
- for (k=0; k<n; k++) {
609
- p1 = q1 + k*i1;
610
- p2 = q2 + k*i2;
611
- p3 = q3 + k*i3;
612
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=="), 1, (*p2))) ? 1 : 0; }
613
- }
614
- }
615
- }
616
-
617
- static void
618
- ca_bincmp_eq_cmplx64_t (ca_size_t n, boolean8_t *m,
619
- char *ptr1, ca_size_t b1, ca_size_t i1,
620
- char *ptr2, ca_size_t b2, ca_size_t i2,
621
- char *ptr3, ca_size_t b3, ca_size_t i3,
622
- double tol)
623
- {
624
- cmplx64_t *q1 = (cmplx64_t *) ptr1, *q2 = (cmplx64_t *) ptr2;
625
- cmplx64_t *p1 = q1, *p2 = q2;
626
- boolean8_t *q3 = (boolean8_t *) ptr3;
627
- boolean8_t *p3 = q3;
628
- ca_size_t k;
629
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
630
- (void) tol;
631
- if ( m ) {
632
- boolean8_t *pm;
633
- for (k=0; k<n; k++) {
634
- pm = m + k;
635
- if ( ! *pm ) {
636
- p1 = q1 + k*i1;
637
- p2 = q2 + k*i2;
638
- p3 = q3 + k*i3;
639
- { (*p3) = (*p1) == (*p2); }
640
- }
641
- }
642
- } else {
643
- for (k=0; k<n; k++) {
644
- p1 = q1 + k*i1;
645
- p2 = q2 + k*i2;
646
- p3 = q3 + k*i3;
647
- { (*p3) = (*p1) == (*p2); }
648
- }
649
- }
650
- }
651
-
652
- static void
653
- ca_bincmp_eq_cmplx128_t (ca_size_t n, boolean8_t *m,
654
- char *ptr1, ca_size_t b1, ca_size_t i1,
655
- char *ptr2, ca_size_t b2, ca_size_t i2,
656
- char *ptr3, ca_size_t b3, ca_size_t i3,
657
- double tol)
658
- {
659
- cmplx128_t *q1 = (cmplx128_t *) ptr1, *q2 = (cmplx128_t *) ptr2;
660
- cmplx128_t *p1 = q1, *p2 = q2;
661
- boolean8_t *q3 = (boolean8_t *) ptr3;
662
- boolean8_t *p3 = q3;
663
- ca_size_t k;
664
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
665
- (void) tol;
666
- if ( m ) {
667
- boolean8_t *pm;
668
- for (k=0; k<n; k++) {
669
- pm = m + k;
670
- if ( ! *pm ) {
671
- p1 = q1 + k*i1;
672
- p2 = q2 + k*i2;
673
- p3 = q3 + k*i3;
674
- { (*p3) = (*p1) == (*p2); }
675
- }
676
- }
677
- } else {
678
- for (k=0; k<n; k++) {
679
- p1 = q1 + k*i1;
680
- p2 = q2 + k*i2;
681
- p3 = q3 + k*i3;
682
- { (*p3) = (*p1) == (*p2); }
683
- }
684
- }
685
- }
686
-
687
- ca_bincmp_func_t
688
- ca_bincmp_eq[CA_NTYPE] = {
689
- ca_bincmp_eq_fixlen,
690
- ca_bincmp_eq_boolean8_t,
691
- ca_bincmp_eq_int8_t,
692
- ca_bincmp_eq_uint8_t,
693
- ca_bincmp_eq_int16_t,
694
- ca_bincmp_eq_uint16_t,
695
- ca_bincmp_eq_int32_t,
696
- ca_bincmp_eq_uint32_t,
697
- ca_bincmp_eq_int64_t,
698
- ca_bincmp_eq_uint64_t,
699
- ca_bincmp_eq_float32_t,
700
- ca_bincmp_eq_float64_t,
701
- ca_bincmp_not_implement,
702
- ca_bincmp_eq_cmplx64_t,
703
- ca_bincmp_eq_cmplx128_t,
704
- ca_bincmp_not_implement,
705
- ca_bincmp_eq_VALUE,
706
- };
707
-
708
- VALUE rb_ca_eq (VALUE self, VALUE other)
709
- {
710
- if ( ! rb_ca_test_castable(other) ) {
711
- return rb_ca_binop_pass_to_other(self, other, rb_intern("eq"));
712
- }
713
- return rb_ca_call_bincmp(self, other, ca_bincmp_eq, 0.0);
714
- }
715
-
716
- /* ===== bincmp ne ============================================ */
717
-
718
- static void
719
- ca_bincmp_ne_fixlen (ca_size_t n, boolean8_t *m,
720
- char *ptr1, ca_size_t b1, ca_size_t i1,
721
- char *ptr2, ca_size_t b2, ca_size_t i2,
722
- char *ptr3, ca_size_t b3, ca_size_t i3,
723
- double tol)
724
- {
725
- char *q1 = ptr1, *q2 = ptr2;
726
- char *p1 = q1, *p2 = q2;
727
- boolean8_t *q3 = (boolean8_t *) ptr3;
728
- boolean8_t *p3 = q3;
729
- ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
730
- ca_size_t k;
731
- (void) tol;
732
- if ( m ) {
733
- boolean8_t *pm;
734
- for (k=0; k<n; k++) {
735
- pm = m + k;
736
- if ( ! *pm ) {
737
- p1 = q1 + k*s1;
738
- p2 = q2 + k*s2;
739
- p3 = q3 + k*s3;
740
- { (*p3) = ( b1 != b2 || memcmp(p1, p2, b1) ); }
741
- }
742
- }
743
- } else {
744
- for (k=0; k<n; k++) {
745
- p1 = q1 + k*s1;
746
- p2 = q2 + k*s2;
747
- p3 = q3 + k*s3;
748
- { (*p3) = ( b1 != b2 || memcmp(p1, p2, b1) ); }
749
- }
750
- }
751
- }
752
-
753
- static void
754
- ca_bincmp_ne_boolean8_t (ca_size_t n, boolean8_t *m,
755
- char *ptr1, ca_size_t b1, ca_size_t i1,
756
- char *ptr2, ca_size_t b2, ca_size_t i2,
757
- char *ptr3, ca_size_t b3, ca_size_t i3,
758
- double tol)
759
- {
760
- boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
761
- boolean8_t *p1 = q1, *p2 = q2;
762
- boolean8_t *q3 = (boolean8_t *) ptr3;
763
- boolean8_t *p3 = q3;
764
- ca_size_t k;
765
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
766
- (void) tol;
767
- if ( m ) {
768
- boolean8_t *pm;
769
- for (k=0; k<n; k++) {
770
- pm = m + k;
771
- if ( ! *pm ) {
772
- p1 = q1 + k*i1;
773
- p2 = q2 + k*i2;
774
- p3 = q3 + k*i3;
775
- { (*p3) = ( (*p1) != (*p2) ); }
776
- }
777
- }
778
- } else {
779
- for (k=0; k<n; k++) {
780
- p1 = q1 + k*i1;
781
- p2 = q2 + k*i2;
782
- p3 = q3 + k*i3;
783
- { (*p3) = ( (*p1) != (*p2) ); }
784
- }
785
- }
786
- }
787
-
788
- static void
789
- ca_bincmp_ne_int8_t (ca_size_t n, boolean8_t *m,
790
- char *ptr1, ca_size_t b1, ca_size_t i1,
791
- char *ptr2, ca_size_t b2, ca_size_t i2,
792
- char *ptr3, ca_size_t b3, ca_size_t i3,
793
- double tol)
794
- {
795
- int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
796
- int8_t *p1 = q1, *p2 = q2;
797
- boolean8_t *q3 = (boolean8_t *) ptr3;
798
- boolean8_t *p3 = q3;
799
- ca_size_t k;
800
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
801
- (void) tol;
802
- if ( m ) {
803
- boolean8_t *pm;
804
- for (k=0; k<n; k++) {
805
- pm = m + k;
806
- if ( ! *pm ) {
807
- p1 = q1 + k*i1;
808
- p2 = q2 + k*i2;
809
- p3 = q3 + k*i3;
810
- { (*p3) = ( (*p1) != (*p2) ); }
811
- }
812
- }
813
- } else {
814
- for (k=0; k<n; k++) {
815
- p1 = q1 + k*i1;
816
- p2 = q2 + k*i2;
817
- p3 = q3 + k*i3;
818
- { (*p3) = ( (*p1) != (*p2) ); }
819
- }
820
- }
821
- }
822
-
823
- static void
824
- ca_bincmp_ne_uint8_t (ca_size_t n, boolean8_t *m,
825
- char *ptr1, ca_size_t b1, ca_size_t i1,
826
- char *ptr2, ca_size_t b2, ca_size_t i2,
827
- char *ptr3, ca_size_t b3, ca_size_t i3,
828
- double tol)
829
- {
830
- uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
831
- uint8_t *p1 = q1, *p2 = q2;
832
- boolean8_t *q3 = (boolean8_t *) ptr3;
833
- boolean8_t *p3 = q3;
834
- ca_size_t k;
835
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
836
- (void) tol;
837
- if ( m ) {
838
- boolean8_t *pm;
839
- for (k=0; k<n; k++) {
840
- pm = m + k;
841
- if ( ! *pm ) {
842
- p1 = q1 + k*i1;
843
- p2 = q2 + k*i2;
844
- p3 = q3 + k*i3;
845
- { (*p3) = ( (*p1) != (*p2) ); }
846
- }
847
- }
848
- } else {
849
- for (k=0; k<n; k++) {
850
- p1 = q1 + k*i1;
851
- p2 = q2 + k*i2;
852
- p3 = q3 + k*i3;
853
- { (*p3) = ( (*p1) != (*p2) ); }
854
- }
855
- }
856
- }
857
-
858
- static void
859
- ca_bincmp_ne_int16_t (ca_size_t n, boolean8_t *m,
860
- char *ptr1, ca_size_t b1, ca_size_t i1,
861
- char *ptr2, ca_size_t b2, ca_size_t i2,
862
- char *ptr3, ca_size_t b3, ca_size_t i3,
863
- double tol)
864
- {
865
- int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
866
- int16_t *p1 = q1, *p2 = q2;
867
- boolean8_t *q3 = (boolean8_t *) ptr3;
868
- boolean8_t *p3 = q3;
869
- ca_size_t k;
870
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
871
- (void) tol;
872
- if ( m ) {
873
- boolean8_t *pm;
874
- for (k=0; k<n; k++) {
875
- pm = m + k;
876
- if ( ! *pm ) {
877
- p1 = q1 + k*i1;
878
- p2 = q2 + k*i2;
879
- p3 = q3 + k*i3;
880
- { (*p3) = ( (*p1) != (*p2) ); }
881
- }
882
- }
883
- } else {
884
- for (k=0; k<n; k++) {
885
- p1 = q1 + k*i1;
886
- p2 = q2 + k*i2;
887
- p3 = q3 + k*i3;
888
- { (*p3) = ( (*p1) != (*p2) ); }
889
- }
890
- }
891
- }
892
-
893
- static void
894
- ca_bincmp_ne_uint16_t (ca_size_t n, boolean8_t *m,
895
- char *ptr1, ca_size_t b1, ca_size_t i1,
896
- char *ptr2, ca_size_t b2, ca_size_t i2,
897
- char *ptr3, ca_size_t b3, ca_size_t i3,
898
- double tol)
899
- {
900
- uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
901
- uint16_t *p1 = q1, *p2 = q2;
902
- boolean8_t *q3 = (boolean8_t *) ptr3;
903
- boolean8_t *p3 = q3;
904
- ca_size_t k;
905
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
906
- (void) tol;
907
- if ( m ) {
908
- boolean8_t *pm;
909
- for (k=0; k<n; k++) {
910
- pm = m + k;
911
- if ( ! *pm ) {
912
- p1 = q1 + k*i1;
913
- p2 = q2 + k*i2;
914
- p3 = q3 + k*i3;
915
- { (*p3) = ( (*p1) != (*p2) ); }
916
- }
917
- }
918
- } else {
919
- for (k=0; k<n; k++) {
920
- p1 = q1 + k*i1;
921
- p2 = q2 + k*i2;
922
- p3 = q3 + k*i3;
923
- { (*p3) = ( (*p1) != (*p2) ); }
924
- }
925
- }
926
- }
927
-
928
- static void
929
- ca_bincmp_ne_int32_t (ca_size_t n, boolean8_t *m,
930
- char *ptr1, ca_size_t b1, ca_size_t i1,
931
- char *ptr2, ca_size_t b2, ca_size_t i2,
932
- char *ptr3, ca_size_t b3, ca_size_t i3,
933
- double tol)
934
- {
935
- int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
936
- int32_t *p1 = q1, *p2 = q2;
937
- boolean8_t *q3 = (boolean8_t *) ptr3;
938
- boolean8_t *p3 = q3;
939
- ca_size_t k;
940
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
941
- (void) tol;
942
- if ( m ) {
943
- boolean8_t *pm;
944
- for (k=0; k<n; k++) {
945
- pm = m + k;
946
- if ( ! *pm ) {
947
- p1 = q1 + k*i1;
948
- p2 = q2 + k*i2;
949
- p3 = q3 + k*i3;
950
- { (*p3) = ( (*p1) != (*p2) ); }
951
- }
952
- }
953
- } else {
954
- for (k=0; k<n; k++) {
955
- p1 = q1 + k*i1;
956
- p2 = q2 + k*i2;
957
- p3 = q3 + k*i3;
958
- { (*p3) = ( (*p1) != (*p2) ); }
959
- }
960
- }
961
- }
962
-
963
- static void
964
- ca_bincmp_ne_uint32_t (ca_size_t n, boolean8_t *m,
965
- char *ptr1, ca_size_t b1, ca_size_t i1,
966
- char *ptr2, ca_size_t b2, ca_size_t i2,
967
- char *ptr3, ca_size_t b3, ca_size_t i3,
968
- double tol)
969
- {
970
- uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
971
- uint32_t *p1 = q1, *p2 = q2;
972
- boolean8_t *q3 = (boolean8_t *) ptr3;
973
- boolean8_t *p3 = q3;
974
- ca_size_t k;
975
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
976
- (void) tol;
977
- if ( m ) {
978
- boolean8_t *pm;
979
- for (k=0; k<n; k++) {
980
- pm = m + k;
981
- if ( ! *pm ) {
982
- p1 = q1 + k*i1;
983
- p2 = q2 + k*i2;
984
- p3 = q3 + k*i3;
985
- { (*p3) = ( (*p1) != (*p2) ); }
986
- }
987
- }
988
- } else {
989
- for (k=0; k<n; k++) {
990
- p1 = q1 + k*i1;
991
- p2 = q2 + k*i2;
992
- p3 = q3 + k*i3;
993
- { (*p3) = ( (*p1) != (*p2) ); }
994
- }
995
- }
996
- }
997
-
998
- static void
999
- ca_bincmp_ne_int64_t (ca_size_t n, boolean8_t *m,
1000
- char *ptr1, ca_size_t b1, ca_size_t i1,
1001
- char *ptr2, ca_size_t b2, ca_size_t i2,
1002
- char *ptr3, ca_size_t b3, ca_size_t i3,
1003
- double tol)
1004
- {
1005
- int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
1006
- int64_t *p1 = q1, *p2 = q2;
1007
- boolean8_t *q3 = (boolean8_t *) ptr3;
1008
- boolean8_t *p3 = q3;
1009
- ca_size_t k;
1010
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1011
- (void) tol;
1012
- if ( m ) {
1013
- boolean8_t *pm;
1014
- for (k=0; k<n; k++) {
1015
- pm = m + k;
1016
- if ( ! *pm ) {
1017
- p1 = q1 + k*i1;
1018
- p2 = q2 + k*i2;
1019
- p3 = q3 + k*i3;
1020
- { (*p3) = ( (*p1) != (*p2) ); }
1021
- }
1022
- }
1023
- } else {
1024
- for (k=0; k<n; k++) {
1025
- p1 = q1 + k*i1;
1026
- p2 = q2 + k*i2;
1027
- p3 = q3 + k*i3;
1028
- { (*p3) = ( (*p1) != (*p2) ); }
1029
- }
1030
- }
1031
- }
1032
-
1033
- static void
1034
- ca_bincmp_ne_uint64_t (ca_size_t n, boolean8_t *m,
1035
- char *ptr1, ca_size_t b1, ca_size_t i1,
1036
- char *ptr2, ca_size_t b2, ca_size_t i2,
1037
- char *ptr3, ca_size_t b3, ca_size_t i3,
1038
- double tol)
1039
- {
1040
- uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
1041
- uint64_t *p1 = q1, *p2 = q2;
1042
- boolean8_t *q3 = (boolean8_t *) ptr3;
1043
- boolean8_t *p3 = q3;
1044
- ca_size_t k;
1045
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1046
- (void) tol;
1047
- if ( m ) {
1048
- boolean8_t *pm;
1049
- for (k=0; k<n; k++) {
1050
- pm = m + k;
1051
- if ( ! *pm ) {
1052
- p1 = q1 + k*i1;
1053
- p2 = q2 + k*i2;
1054
- p3 = q3 + k*i3;
1055
- { (*p3) = ( (*p1) != (*p2) ); }
1056
- }
1057
- }
1058
- } else {
1059
- for (k=0; k<n; k++) {
1060
- p1 = q1 + k*i1;
1061
- p2 = q2 + k*i2;
1062
- p3 = q3 + k*i3;
1063
- { (*p3) = ( (*p1) != (*p2) ); }
1064
- }
1065
- }
1066
- }
1067
-
1068
- static void
1069
- ca_bincmp_ne_float32_t (ca_size_t n, boolean8_t *m,
1070
- char *ptr1, ca_size_t b1, ca_size_t i1,
1071
- char *ptr2, ca_size_t b2, ca_size_t i2,
1072
- char *ptr3, ca_size_t b3, ca_size_t i3,
1073
- double tol)
1074
- {
1075
- float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
1076
- float *p1 = q1, *p2 = q2;
1077
- boolean8_t *q3 = (boolean8_t *) ptr3;
1078
- boolean8_t *p3 = q3;
1079
- ca_size_t k;
1080
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1081
- (void) tol;
1082
- if ( m ) {
1083
- boolean8_t *pm;
1084
- for (k=0; k<n; k++) {
1085
- pm = m + k;
1086
- if ( ! *pm ) {
1087
- p1 = q1 + k*i1;
1088
- p2 = q2 + k*i2;
1089
- p3 = q3 + k*i3;
1090
- { (*p3) = ( (*p1) != (*p2) ); }
1091
- }
1092
- }
1093
- } else {
1094
- for (k=0; k<n; k++) {
1095
- p1 = q1 + k*i1;
1096
- p2 = q2 + k*i2;
1097
- p3 = q3 + k*i3;
1098
- { (*p3) = ( (*p1) != (*p2) ); }
1099
- }
1100
- }
1101
- }
1102
-
1103
- static void
1104
- ca_bincmp_ne_float64_t (ca_size_t n, boolean8_t *m,
1105
- char *ptr1, ca_size_t b1, ca_size_t i1,
1106
- char *ptr2, ca_size_t b2, ca_size_t i2,
1107
- char *ptr3, ca_size_t b3, ca_size_t i3,
1108
- double tol)
1109
- {
1110
- double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
1111
- double *p1 = q1, *p2 = q2;
1112
- boolean8_t *q3 = (boolean8_t *) ptr3;
1113
- boolean8_t *p3 = q3;
1114
- ca_size_t k;
1115
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1116
- (void) tol;
1117
- if ( m ) {
1118
- boolean8_t *pm;
1119
- for (k=0; k<n; k++) {
1120
- pm = m + k;
1121
- if ( ! *pm ) {
1122
- p1 = q1 + k*i1;
1123
- p2 = q2 + k*i2;
1124
- p3 = q3 + k*i3;
1125
- { (*p3) = ( (*p1) != (*p2) ); }
1126
- }
1127
- }
1128
- } else {
1129
- for (k=0; k<n; k++) {
1130
- p1 = q1 + k*i1;
1131
- p2 = q2 + k*i2;
1132
- p3 = q3 + k*i3;
1133
- { (*p3) = ( (*p1) != (*p2) ); }
1134
- }
1135
- }
1136
- }
1137
-
1138
- static void
1139
- ca_bincmp_ne_VALUE (ca_size_t n, boolean8_t *m,
1140
- char *ptr1, ca_size_t b1, ca_size_t i1,
1141
- char *ptr2, ca_size_t b2, ca_size_t i2,
1142
- char *ptr3, ca_size_t b3, ca_size_t i3,
1143
- double tol)
1144
- {
1145
- VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
1146
- VALUE *p1 = q1, *p2 = q2;
1147
- boolean8_t *q3 = (boolean8_t *) ptr3;
1148
- boolean8_t *p3 = q3;
1149
- ca_size_t k;
1150
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1151
- (void) tol;
1152
- if ( m ) {
1153
- boolean8_t *pm;
1154
- for (k=0; k<n; k++) {
1155
- pm = m + k;
1156
- if ( ! *pm ) {
1157
- p1 = q1 + k*i1;
1158
- p2 = q2 + k*i2;
1159
- p3 = q3 + k*i3;
1160
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=="), 1, (*p2))) ? 0 : 1; }
1161
- }
1162
- }
1163
- } else {
1164
- for (k=0; k<n; k++) {
1165
- p1 = q1 + k*i1;
1166
- p2 = q2 + k*i2;
1167
- p3 = q3 + k*i3;
1168
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=="), 1, (*p2))) ? 0 : 1; }
1169
- }
1170
- }
1171
- }
1172
-
1173
- static void
1174
- ca_bincmp_ne_cmplx64_t (ca_size_t n, boolean8_t *m,
1175
- char *ptr1, ca_size_t b1, ca_size_t i1,
1176
- char *ptr2, ca_size_t b2, ca_size_t i2,
1177
- char *ptr3, ca_size_t b3, ca_size_t i3,
1178
- double tol)
1179
- {
1180
- cmplx64_t *q1 = (cmplx64_t *) ptr1, *q2 = (cmplx64_t *) ptr2;
1181
- cmplx64_t *p1 = q1, *p2 = q2;
1182
- boolean8_t *q3 = (boolean8_t *) ptr3;
1183
- boolean8_t *p3 = q3;
1184
- ca_size_t k;
1185
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1186
- (void) tol;
1187
- if ( m ) {
1188
- boolean8_t *pm;
1189
- for (k=0; k<n; k++) {
1190
- pm = m + k;
1191
- if ( ! *pm ) {
1192
- p1 = q1 + k*i1;
1193
- p2 = q2 + k*i2;
1194
- p3 = q3 + k*i3;
1195
- { (*p3) = (*p1) != (*p2); }
1196
- }
1197
- }
1198
- } else {
1199
- for (k=0; k<n; k++) {
1200
- p1 = q1 + k*i1;
1201
- p2 = q2 + k*i2;
1202
- p3 = q3 + k*i3;
1203
- { (*p3) = (*p1) != (*p2); }
1204
- }
1205
- }
1206
- }
1207
-
1208
- static void
1209
- ca_bincmp_ne_cmplx128_t (ca_size_t n, boolean8_t *m,
1210
- char *ptr1, ca_size_t b1, ca_size_t i1,
1211
- char *ptr2, ca_size_t b2, ca_size_t i2,
1212
- char *ptr3, ca_size_t b3, ca_size_t i3,
1213
- double tol)
1214
- {
1215
- cmplx128_t *q1 = (cmplx128_t *) ptr1, *q2 = (cmplx128_t *) ptr2;
1216
- cmplx128_t *p1 = q1, *p2 = q2;
1217
- boolean8_t *q3 = (boolean8_t *) ptr3;
1218
- boolean8_t *p3 = q3;
1219
- ca_size_t k;
1220
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1221
- (void) tol;
1222
- if ( m ) {
1223
- boolean8_t *pm;
1224
- for (k=0; k<n; k++) {
1225
- pm = m + k;
1226
- if ( ! *pm ) {
1227
- p1 = q1 + k*i1;
1228
- p2 = q2 + k*i2;
1229
- p3 = q3 + k*i3;
1230
- { (*p3) = (*p1) != (*p2); }
1231
- }
1232
- }
1233
- } else {
1234
- for (k=0; k<n; k++) {
1235
- p1 = q1 + k*i1;
1236
- p2 = q2 + k*i2;
1237
- p3 = q3 + k*i3;
1238
- { (*p3) = (*p1) != (*p2); }
1239
- }
1240
- }
1241
- }
1242
-
1243
- ca_bincmp_func_t
1244
- ca_bincmp_ne[CA_NTYPE] = {
1245
- ca_bincmp_ne_fixlen,
1246
- ca_bincmp_ne_boolean8_t,
1247
- ca_bincmp_ne_int8_t,
1248
- ca_bincmp_ne_uint8_t,
1249
- ca_bincmp_ne_int16_t,
1250
- ca_bincmp_ne_uint16_t,
1251
- ca_bincmp_ne_int32_t,
1252
- ca_bincmp_ne_uint32_t,
1253
- ca_bincmp_ne_int64_t,
1254
- ca_bincmp_ne_uint64_t,
1255
- ca_bincmp_ne_float32_t,
1256
- ca_bincmp_ne_float64_t,
1257
- ca_bincmp_not_implement,
1258
- ca_bincmp_ne_cmplx64_t,
1259
- ca_bincmp_ne_cmplx128_t,
1260
- ca_bincmp_not_implement,
1261
- ca_bincmp_ne_VALUE,
1262
- };
1263
-
1264
- VALUE rb_ca_ne (VALUE self, VALUE other)
1265
- {
1266
- if ( ! rb_ca_test_castable(other) ) {
1267
- return rb_ca_binop_pass_to_other(self, other, rb_intern("ne"));
1268
- }
1269
- return rb_ca_call_bincmp(self, other, ca_bincmp_ne, 0.0);
1270
- }
1271
-
1272
- /* ===== bincmp gt ============================================ */
1273
-
1274
- static void
1275
- ca_bincmp_gt_fixlen (ca_size_t n, boolean8_t *m,
1276
- char *ptr1, ca_size_t b1, ca_size_t i1,
1277
- char *ptr2, ca_size_t b2, ca_size_t i2,
1278
- char *ptr3, ca_size_t b3, ca_size_t i3,
1279
- double tol)
1280
- {
1281
- char *q1 = ptr1, *q2 = ptr2;
1282
- char *p1 = q1, *p2 = q2;
1283
- boolean8_t *q3 = (boolean8_t *) ptr3;
1284
- boolean8_t *p3 = q3;
1285
- ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
1286
- ca_size_t k;
1287
- (void) tol;
1288
- if ( m ) {
1289
- boolean8_t *pm;
1290
- for (k=0; k<n; k++) {
1291
- pm = m + k;
1292
- if ( ! *pm ) {
1293
- p1 = q1 + k*s1;
1294
- p2 = q2 + k*s2;
1295
- p3 = q3 + k*s3;
1296
- {
1297
- int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
1298
- (*p3) = ( cmp > 0 || ( cmp == 0 && b1 > b2 ) );
1299
- }
1300
- }
1301
- }
1302
- } else {
1303
- for (k=0; k<n; k++) {
1304
- p1 = q1 + k*s1;
1305
- p2 = q2 + k*s2;
1306
- p3 = q3 + k*s3;
1307
- {
1308
- int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
1309
- (*p3) = ( cmp > 0 || ( cmp == 0 && b1 > b2 ) );
1310
- }
1311
- }
1312
- }
1313
- }
1314
-
1315
- static void
1316
- ca_bincmp_gt_boolean8_t (ca_size_t n, boolean8_t *m,
1317
- char *ptr1, ca_size_t b1, ca_size_t i1,
1318
- char *ptr2, ca_size_t b2, ca_size_t i2,
1319
- char *ptr3, ca_size_t b3, ca_size_t i3,
1320
- double tol)
1321
- {
1322
- boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
1323
- boolean8_t *p1 = q1, *p2 = q2;
1324
- boolean8_t *q3 = (boolean8_t *) ptr3;
1325
- boolean8_t *p3 = q3;
1326
- ca_size_t k;
1327
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1328
- (void) tol;
1329
- if ( m ) {
1330
- boolean8_t *pm;
1331
- for (k=0; k<n; k++) {
1332
- pm = m + k;
1333
- if ( ! *pm ) {
1334
- p1 = q1 + k*i1;
1335
- p2 = q2 + k*i2;
1336
- p3 = q3 + k*i3;
1337
- { (*p3) = ( (*p1) > (*p2) ); }
1338
- }
1339
- }
1340
- } else {
1341
- for (k=0; k<n; k++) {
1342
- p1 = q1 + k*i1;
1343
- p2 = q2 + k*i2;
1344
- p3 = q3 + k*i3;
1345
- { (*p3) = ( (*p1) > (*p2) ); }
1346
- }
1347
- }
1348
- }
1349
-
1350
- static void
1351
- ca_bincmp_gt_int8_t (ca_size_t n, boolean8_t *m,
1352
- char *ptr1, ca_size_t b1, ca_size_t i1,
1353
- char *ptr2, ca_size_t b2, ca_size_t i2,
1354
- char *ptr3, ca_size_t b3, ca_size_t i3,
1355
- double tol)
1356
- {
1357
- int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
1358
- int8_t *p1 = q1, *p2 = q2;
1359
- boolean8_t *q3 = (boolean8_t *) ptr3;
1360
- boolean8_t *p3 = q3;
1361
- ca_size_t k;
1362
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1363
- (void) tol;
1364
- if ( m ) {
1365
- boolean8_t *pm;
1366
- for (k=0; k<n; k++) {
1367
- pm = m + k;
1368
- if ( ! *pm ) {
1369
- p1 = q1 + k*i1;
1370
- p2 = q2 + k*i2;
1371
- p3 = q3 + k*i3;
1372
- { (*p3) = ( (*p1) > (*p2) ); }
1373
- }
1374
- }
1375
- } else {
1376
- for (k=0; k<n; k++) {
1377
- p1 = q1 + k*i1;
1378
- p2 = q2 + k*i2;
1379
- p3 = q3 + k*i3;
1380
- { (*p3) = ( (*p1) > (*p2) ); }
1381
- }
1382
- }
1383
- }
1384
-
1385
- static void
1386
- ca_bincmp_gt_uint8_t (ca_size_t n, boolean8_t *m,
1387
- char *ptr1, ca_size_t b1, ca_size_t i1,
1388
- char *ptr2, ca_size_t b2, ca_size_t i2,
1389
- char *ptr3, ca_size_t b3, ca_size_t i3,
1390
- double tol)
1391
- {
1392
- uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
1393
- uint8_t *p1 = q1, *p2 = q2;
1394
- boolean8_t *q3 = (boolean8_t *) ptr3;
1395
- boolean8_t *p3 = q3;
1396
- ca_size_t k;
1397
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1398
- (void) tol;
1399
- if ( m ) {
1400
- boolean8_t *pm;
1401
- for (k=0; k<n; k++) {
1402
- pm = m + k;
1403
- if ( ! *pm ) {
1404
- p1 = q1 + k*i1;
1405
- p2 = q2 + k*i2;
1406
- p3 = q3 + k*i3;
1407
- { (*p3) = ( (*p1) > (*p2) ); }
1408
- }
1409
- }
1410
- } else {
1411
- for (k=0; k<n; k++) {
1412
- p1 = q1 + k*i1;
1413
- p2 = q2 + k*i2;
1414
- p3 = q3 + k*i3;
1415
- { (*p3) = ( (*p1) > (*p2) ); }
1416
- }
1417
- }
1418
- }
1419
-
1420
- static void
1421
- ca_bincmp_gt_int16_t (ca_size_t n, boolean8_t *m,
1422
- char *ptr1, ca_size_t b1, ca_size_t i1,
1423
- char *ptr2, ca_size_t b2, ca_size_t i2,
1424
- char *ptr3, ca_size_t b3, ca_size_t i3,
1425
- double tol)
1426
- {
1427
- int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
1428
- int16_t *p1 = q1, *p2 = q2;
1429
- boolean8_t *q3 = (boolean8_t *) ptr3;
1430
- boolean8_t *p3 = q3;
1431
- ca_size_t k;
1432
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1433
- (void) tol;
1434
- if ( m ) {
1435
- boolean8_t *pm;
1436
- for (k=0; k<n; k++) {
1437
- pm = m + k;
1438
- if ( ! *pm ) {
1439
- p1 = q1 + k*i1;
1440
- p2 = q2 + k*i2;
1441
- p3 = q3 + k*i3;
1442
- { (*p3) = ( (*p1) > (*p2) ); }
1443
- }
1444
- }
1445
- } else {
1446
- for (k=0; k<n; k++) {
1447
- p1 = q1 + k*i1;
1448
- p2 = q2 + k*i2;
1449
- p3 = q3 + k*i3;
1450
- { (*p3) = ( (*p1) > (*p2) ); }
1451
- }
1452
- }
1453
- }
1454
-
1455
- static void
1456
- ca_bincmp_gt_uint16_t (ca_size_t n, boolean8_t *m,
1457
- char *ptr1, ca_size_t b1, ca_size_t i1,
1458
- char *ptr2, ca_size_t b2, ca_size_t i2,
1459
- char *ptr3, ca_size_t b3, ca_size_t i3,
1460
- double tol)
1461
- {
1462
- uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
1463
- uint16_t *p1 = q1, *p2 = q2;
1464
- boolean8_t *q3 = (boolean8_t *) ptr3;
1465
- boolean8_t *p3 = q3;
1466
- ca_size_t k;
1467
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1468
- (void) tol;
1469
- if ( m ) {
1470
- boolean8_t *pm;
1471
- for (k=0; k<n; k++) {
1472
- pm = m + k;
1473
- if ( ! *pm ) {
1474
- p1 = q1 + k*i1;
1475
- p2 = q2 + k*i2;
1476
- p3 = q3 + k*i3;
1477
- { (*p3) = ( (*p1) > (*p2) ); }
1478
- }
1479
- }
1480
- } else {
1481
- for (k=0; k<n; k++) {
1482
- p1 = q1 + k*i1;
1483
- p2 = q2 + k*i2;
1484
- p3 = q3 + k*i3;
1485
- { (*p3) = ( (*p1) > (*p2) ); }
1486
- }
1487
- }
1488
- }
1489
-
1490
- static void
1491
- ca_bincmp_gt_int32_t (ca_size_t n, boolean8_t *m,
1492
- char *ptr1, ca_size_t b1, ca_size_t i1,
1493
- char *ptr2, ca_size_t b2, ca_size_t i2,
1494
- char *ptr3, ca_size_t b3, ca_size_t i3,
1495
- double tol)
1496
- {
1497
- int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
1498
- int32_t *p1 = q1, *p2 = q2;
1499
- boolean8_t *q3 = (boolean8_t *) ptr3;
1500
- boolean8_t *p3 = q3;
1501
- ca_size_t k;
1502
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1503
- (void) tol;
1504
- if ( m ) {
1505
- boolean8_t *pm;
1506
- for (k=0; k<n; k++) {
1507
- pm = m + k;
1508
- if ( ! *pm ) {
1509
- p1 = q1 + k*i1;
1510
- p2 = q2 + k*i2;
1511
- p3 = q3 + k*i3;
1512
- { (*p3) = ( (*p1) > (*p2) ); }
1513
- }
1514
- }
1515
- } else {
1516
- for (k=0; k<n; k++) {
1517
- p1 = q1 + k*i1;
1518
- p2 = q2 + k*i2;
1519
- p3 = q3 + k*i3;
1520
- { (*p3) = ( (*p1) > (*p2) ); }
1521
- }
1522
- }
1523
- }
1524
-
1525
- static void
1526
- ca_bincmp_gt_uint32_t (ca_size_t n, boolean8_t *m,
1527
- char *ptr1, ca_size_t b1, ca_size_t i1,
1528
- char *ptr2, ca_size_t b2, ca_size_t i2,
1529
- char *ptr3, ca_size_t b3, ca_size_t i3,
1530
- double tol)
1531
- {
1532
- uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
1533
- uint32_t *p1 = q1, *p2 = q2;
1534
- boolean8_t *q3 = (boolean8_t *) ptr3;
1535
- boolean8_t *p3 = q3;
1536
- ca_size_t k;
1537
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1538
- (void) tol;
1539
- if ( m ) {
1540
- boolean8_t *pm;
1541
- for (k=0; k<n; k++) {
1542
- pm = m + k;
1543
- if ( ! *pm ) {
1544
- p1 = q1 + k*i1;
1545
- p2 = q2 + k*i2;
1546
- p3 = q3 + k*i3;
1547
- { (*p3) = ( (*p1) > (*p2) ); }
1548
- }
1549
- }
1550
- } else {
1551
- for (k=0; k<n; k++) {
1552
- p1 = q1 + k*i1;
1553
- p2 = q2 + k*i2;
1554
- p3 = q3 + k*i3;
1555
- { (*p3) = ( (*p1) > (*p2) ); }
1556
- }
1557
- }
1558
- }
1559
-
1560
- static void
1561
- ca_bincmp_gt_int64_t (ca_size_t n, boolean8_t *m,
1562
- char *ptr1, ca_size_t b1, ca_size_t i1,
1563
- char *ptr2, ca_size_t b2, ca_size_t i2,
1564
- char *ptr3, ca_size_t b3, ca_size_t i3,
1565
- double tol)
1566
- {
1567
- int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
1568
- int64_t *p1 = q1, *p2 = q2;
1569
- boolean8_t *q3 = (boolean8_t *) ptr3;
1570
- boolean8_t *p3 = q3;
1571
- ca_size_t k;
1572
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1573
- (void) tol;
1574
- if ( m ) {
1575
- boolean8_t *pm;
1576
- for (k=0; k<n; k++) {
1577
- pm = m + k;
1578
- if ( ! *pm ) {
1579
- p1 = q1 + k*i1;
1580
- p2 = q2 + k*i2;
1581
- p3 = q3 + k*i3;
1582
- { (*p3) = ( (*p1) > (*p2) ); }
1583
- }
1584
- }
1585
- } else {
1586
- for (k=0; k<n; k++) {
1587
- p1 = q1 + k*i1;
1588
- p2 = q2 + k*i2;
1589
- p3 = q3 + k*i3;
1590
- { (*p3) = ( (*p1) > (*p2) ); }
1591
- }
1592
- }
1593
- }
1594
-
1595
- static void
1596
- ca_bincmp_gt_uint64_t (ca_size_t n, boolean8_t *m,
1597
- char *ptr1, ca_size_t b1, ca_size_t i1,
1598
- char *ptr2, ca_size_t b2, ca_size_t i2,
1599
- char *ptr3, ca_size_t b3, ca_size_t i3,
1600
- double tol)
1601
- {
1602
- uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
1603
- uint64_t *p1 = q1, *p2 = q2;
1604
- boolean8_t *q3 = (boolean8_t *) ptr3;
1605
- boolean8_t *p3 = q3;
1606
- ca_size_t k;
1607
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1608
- (void) tol;
1609
- if ( m ) {
1610
- boolean8_t *pm;
1611
- for (k=0; k<n; k++) {
1612
- pm = m + k;
1613
- if ( ! *pm ) {
1614
- p1 = q1 + k*i1;
1615
- p2 = q2 + k*i2;
1616
- p3 = q3 + k*i3;
1617
- { (*p3) = ( (*p1) > (*p2) ); }
1618
- }
1619
- }
1620
- } else {
1621
- for (k=0; k<n; k++) {
1622
- p1 = q1 + k*i1;
1623
- p2 = q2 + k*i2;
1624
- p3 = q3 + k*i3;
1625
- { (*p3) = ( (*p1) > (*p2) ); }
1626
- }
1627
- }
1628
- }
1629
-
1630
- static void
1631
- ca_bincmp_gt_float32_t (ca_size_t n, boolean8_t *m,
1632
- char *ptr1, ca_size_t b1, ca_size_t i1,
1633
- char *ptr2, ca_size_t b2, ca_size_t i2,
1634
- char *ptr3, ca_size_t b3, ca_size_t i3,
1635
- double tol)
1636
- {
1637
- float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
1638
- float *p1 = q1, *p2 = q2;
1639
- boolean8_t *q3 = (boolean8_t *) ptr3;
1640
- boolean8_t *p3 = q3;
1641
- ca_size_t k;
1642
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1643
- (void) tol;
1644
- if ( m ) {
1645
- boolean8_t *pm;
1646
- for (k=0; k<n; k++) {
1647
- pm = m + k;
1648
- if ( ! *pm ) {
1649
- p1 = q1 + k*i1;
1650
- p2 = q2 + k*i2;
1651
- p3 = q3 + k*i3;
1652
- { (*p3) = ( (*p1) > (*p2) ); }
1653
- }
1654
- }
1655
- } else {
1656
- for (k=0; k<n; k++) {
1657
- p1 = q1 + k*i1;
1658
- p2 = q2 + k*i2;
1659
- p3 = q3 + k*i3;
1660
- { (*p3) = ( (*p1) > (*p2) ); }
1661
- }
1662
- }
1663
- }
1664
-
1665
- static void
1666
- ca_bincmp_gt_float64_t (ca_size_t n, boolean8_t *m,
1667
- char *ptr1, ca_size_t b1, ca_size_t i1,
1668
- char *ptr2, ca_size_t b2, ca_size_t i2,
1669
- char *ptr3, ca_size_t b3, ca_size_t i3,
1670
- double tol)
1671
- {
1672
- double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
1673
- double *p1 = q1, *p2 = q2;
1674
- boolean8_t *q3 = (boolean8_t *) ptr3;
1675
- boolean8_t *p3 = q3;
1676
- ca_size_t k;
1677
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1678
- (void) tol;
1679
- if ( m ) {
1680
- boolean8_t *pm;
1681
- for (k=0; k<n; k++) {
1682
- pm = m + k;
1683
- if ( ! *pm ) {
1684
- p1 = q1 + k*i1;
1685
- p2 = q2 + k*i2;
1686
- p3 = q3 + k*i3;
1687
- { (*p3) = ( (*p1) > (*p2) ); }
1688
- }
1689
- }
1690
- } else {
1691
- for (k=0; k<n; k++) {
1692
- p1 = q1 + k*i1;
1693
- p2 = q2 + k*i2;
1694
- p3 = q3 + k*i3;
1695
- { (*p3) = ( (*p1) > (*p2) ); }
1696
- }
1697
- }
1698
- }
1699
-
1700
- static void
1701
- ca_bincmp_gt_VALUE (ca_size_t n, boolean8_t *m,
1702
- char *ptr1, ca_size_t b1, ca_size_t i1,
1703
- char *ptr2, ca_size_t b2, ca_size_t i2,
1704
- char *ptr3, ca_size_t b3, ca_size_t i3,
1705
- double tol)
1706
- {
1707
- VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
1708
- VALUE *p1 = q1, *p2 = q2;
1709
- boolean8_t *q3 = (boolean8_t *) ptr3;
1710
- boolean8_t *p3 = q3;
1711
- ca_size_t k;
1712
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1713
- (void) tol;
1714
- if ( m ) {
1715
- boolean8_t *pm;
1716
- for (k=0; k<n; k++) {
1717
- pm = m + k;
1718
- if ( ! *pm ) {
1719
- p1 = q1 + k*i1;
1720
- p2 = q2 + k*i2;
1721
- p3 = q3 + k*i3;
1722
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern(">"), 1, (*p2))) ? 1 : 0; }
1723
- }
1724
- }
1725
- } else {
1726
- for (k=0; k<n; k++) {
1727
- p1 = q1 + k*i1;
1728
- p2 = q2 + k*i2;
1729
- p3 = q3 + k*i3;
1730
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern(">"), 1, (*p2))) ? 1 : 0; }
1731
- }
1732
- }
1733
- }
1734
-
1735
- ca_bincmp_func_t
1736
- ca_bincmp_gt[CA_NTYPE] = {
1737
- ca_bincmp_gt_fixlen,
1738
- ca_bincmp_gt_boolean8_t,
1739
- ca_bincmp_gt_int8_t,
1740
- ca_bincmp_gt_uint8_t,
1741
- ca_bincmp_gt_int16_t,
1742
- ca_bincmp_gt_uint16_t,
1743
- ca_bincmp_gt_int32_t,
1744
- ca_bincmp_gt_uint32_t,
1745
- ca_bincmp_gt_int64_t,
1746
- ca_bincmp_gt_uint64_t,
1747
- ca_bincmp_gt_float32_t,
1748
- ca_bincmp_gt_float64_t,
1749
- ca_bincmp_not_implement,
1750
- ca_bincmp_not_implement,
1751
- ca_bincmp_not_implement,
1752
- ca_bincmp_not_implement,
1753
- ca_bincmp_gt_VALUE,
1754
- };
1755
-
1756
- VALUE rb_ca_gt (VALUE self, VALUE other)
1757
- {
1758
- if ( ! rb_ca_test_castable(other) ) {
1759
- return rb_ca_binop_pass_to_other(self, other, rb_intern("gt"));
1760
- }
1761
- return rb_ca_call_bincmp(self, other, ca_bincmp_gt, 0.0);
1762
- }
1763
-
1764
- /* ===== bincmp lt ============================================ */
1765
-
1766
- static void
1767
- ca_bincmp_lt_fixlen (ca_size_t n, boolean8_t *m,
1768
- char *ptr1, ca_size_t b1, ca_size_t i1,
1769
- char *ptr2, ca_size_t b2, ca_size_t i2,
1770
- char *ptr3, ca_size_t b3, ca_size_t i3,
1771
- double tol)
1772
- {
1773
- char *q1 = ptr1, *q2 = ptr2;
1774
- char *p1 = q1, *p2 = q2;
1775
- boolean8_t *q3 = (boolean8_t *) ptr3;
1776
- boolean8_t *p3 = q3;
1777
- ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
1778
- ca_size_t k;
1779
- (void) tol;
1780
- if ( m ) {
1781
- boolean8_t *pm;
1782
- for (k=0; k<n; k++) {
1783
- pm = m + k;
1784
- if ( ! *pm ) {
1785
- p1 = q1 + k*s1;
1786
- p2 = q2 + k*s2;
1787
- p3 = q3 + k*s3;
1788
- {
1789
- int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
1790
- (*p3) = ( cmp < 0 || ( cmp == 0 && b1 < b2 ) );
1791
- }
1792
- }
1793
- }
1794
- } else {
1795
- for (k=0; k<n; k++) {
1796
- p1 = q1 + k*s1;
1797
- p2 = q2 + k*s2;
1798
- p3 = q3 + k*s3;
1799
- {
1800
- int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
1801
- (*p3) = ( cmp < 0 || ( cmp == 0 && b1 < b2 ) );
1802
- }
1803
- }
1804
- }
1805
- }
1806
-
1807
- static void
1808
- ca_bincmp_lt_boolean8_t (ca_size_t n, boolean8_t *m,
1809
- char *ptr1, ca_size_t b1, ca_size_t i1,
1810
- char *ptr2, ca_size_t b2, ca_size_t i2,
1811
- char *ptr3, ca_size_t b3, ca_size_t i3,
1812
- double tol)
1813
- {
1814
- boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
1815
- boolean8_t *p1 = q1, *p2 = q2;
1816
- boolean8_t *q3 = (boolean8_t *) ptr3;
1817
- boolean8_t *p3 = q3;
1818
- ca_size_t k;
1819
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1820
- (void) tol;
1821
- if ( m ) {
1822
- boolean8_t *pm;
1823
- for (k=0; k<n; k++) {
1824
- pm = m + k;
1825
- if ( ! *pm ) {
1826
- p1 = q1 + k*i1;
1827
- p2 = q2 + k*i2;
1828
- p3 = q3 + k*i3;
1829
- { (*p3) = ( (*p1) < (*p2) ); }
1830
- }
1831
- }
1832
- } else {
1833
- for (k=0; k<n; k++) {
1834
- p1 = q1 + k*i1;
1835
- p2 = q2 + k*i2;
1836
- p3 = q3 + k*i3;
1837
- { (*p3) = ( (*p1) < (*p2) ); }
1838
- }
1839
- }
1840
- }
1841
-
1842
- static void
1843
- ca_bincmp_lt_int8_t (ca_size_t n, boolean8_t *m,
1844
- char *ptr1, ca_size_t b1, ca_size_t i1,
1845
- char *ptr2, ca_size_t b2, ca_size_t i2,
1846
- char *ptr3, ca_size_t b3, ca_size_t i3,
1847
- double tol)
1848
- {
1849
- int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
1850
- int8_t *p1 = q1, *p2 = q2;
1851
- boolean8_t *q3 = (boolean8_t *) ptr3;
1852
- boolean8_t *p3 = q3;
1853
- ca_size_t k;
1854
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1855
- (void) tol;
1856
- if ( m ) {
1857
- boolean8_t *pm;
1858
- for (k=0; k<n; k++) {
1859
- pm = m + k;
1860
- if ( ! *pm ) {
1861
- p1 = q1 + k*i1;
1862
- p2 = q2 + k*i2;
1863
- p3 = q3 + k*i3;
1864
- { (*p3) = ( (*p1) < (*p2) ); }
1865
- }
1866
- }
1867
- } else {
1868
- for (k=0; k<n; k++) {
1869
- p1 = q1 + k*i1;
1870
- p2 = q2 + k*i2;
1871
- p3 = q3 + k*i3;
1872
- { (*p3) = ( (*p1) < (*p2) ); }
1873
- }
1874
- }
1875
- }
1876
-
1877
- static void
1878
- ca_bincmp_lt_uint8_t (ca_size_t n, boolean8_t *m,
1879
- char *ptr1, ca_size_t b1, ca_size_t i1,
1880
- char *ptr2, ca_size_t b2, ca_size_t i2,
1881
- char *ptr3, ca_size_t b3, ca_size_t i3,
1882
- double tol)
1883
- {
1884
- uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
1885
- uint8_t *p1 = q1, *p2 = q2;
1886
- boolean8_t *q3 = (boolean8_t *) ptr3;
1887
- boolean8_t *p3 = q3;
1888
- ca_size_t k;
1889
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1890
- (void) tol;
1891
- if ( m ) {
1892
- boolean8_t *pm;
1893
- for (k=0; k<n; k++) {
1894
- pm = m + k;
1895
- if ( ! *pm ) {
1896
- p1 = q1 + k*i1;
1897
- p2 = q2 + k*i2;
1898
- p3 = q3 + k*i3;
1899
- { (*p3) = ( (*p1) < (*p2) ); }
1900
- }
1901
- }
1902
- } else {
1903
- for (k=0; k<n; k++) {
1904
- p1 = q1 + k*i1;
1905
- p2 = q2 + k*i2;
1906
- p3 = q3 + k*i3;
1907
- { (*p3) = ( (*p1) < (*p2) ); }
1908
- }
1909
- }
1910
- }
1911
-
1912
- static void
1913
- ca_bincmp_lt_int16_t (ca_size_t n, boolean8_t *m,
1914
- char *ptr1, ca_size_t b1, ca_size_t i1,
1915
- char *ptr2, ca_size_t b2, ca_size_t i2,
1916
- char *ptr3, ca_size_t b3, ca_size_t i3,
1917
- double tol)
1918
- {
1919
- int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
1920
- int16_t *p1 = q1, *p2 = q2;
1921
- boolean8_t *q3 = (boolean8_t *) ptr3;
1922
- boolean8_t *p3 = q3;
1923
- ca_size_t k;
1924
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1925
- (void) tol;
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
- p3 = q3 + k*i3;
1934
- { (*p3) = ( (*p1) < (*p2) ); }
1935
- }
1936
- }
1937
- } else {
1938
- for (k=0; k<n; k++) {
1939
- p1 = q1 + k*i1;
1940
- p2 = q2 + k*i2;
1941
- p3 = q3 + k*i3;
1942
- { (*p3) = ( (*p1) < (*p2) ); }
1943
- }
1944
- }
1945
- }
1946
-
1947
- static void
1948
- ca_bincmp_lt_uint16_t (ca_size_t n, boolean8_t *m,
1949
- char *ptr1, ca_size_t b1, ca_size_t i1,
1950
- char *ptr2, ca_size_t b2, ca_size_t i2,
1951
- char *ptr3, ca_size_t b3, ca_size_t i3,
1952
- double tol)
1953
- {
1954
- uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
1955
- uint16_t *p1 = q1, *p2 = q2;
1956
- boolean8_t *q3 = (boolean8_t *) ptr3;
1957
- boolean8_t *p3 = q3;
1958
- ca_size_t k;
1959
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1960
- (void) tol;
1961
- if ( m ) {
1962
- boolean8_t *pm;
1963
- for (k=0; k<n; k++) {
1964
- pm = m + k;
1965
- if ( ! *pm ) {
1966
- p1 = q1 + k*i1;
1967
- p2 = q2 + k*i2;
1968
- p3 = q3 + k*i3;
1969
- { (*p3) = ( (*p1) < (*p2) ); }
1970
- }
1971
- }
1972
- } else {
1973
- for (k=0; k<n; k++) {
1974
- p1 = q1 + k*i1;
1975
- p2 = q2 + k*i2;
1976
- p3 = q3 + k*i3;
1977
- { (*p3) = ( (*p1) < (*p2) ); }
1978
- }
1979
- }
1980
- }
1981
-
1982
- static void
1983
- ca_bincmp_lt_int32_t (ca_size_t n, boolean8_t *m,
1984
- char *ptr1, ca_size_t b1, ca_size_t i1,
1985
- char *ptr2, ca_size_t b2, ca_size_t i2,
1986
- char *ptr3, ca_size_t b3, ca_size_t i3,
1987
- double tol)
1988
- {
1989
- int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
1990
- int32_t *p1 = q1, *p2 = q2;
1991
- boolean8_t *q3 = (boolean8_t *) ptr3;
1992
- boolean8_t *p3 = q3;
1993
- ca_size_t k;
1994
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
1995
- (void) tol;
1996
- if ( m ) {
1997
- boolean8_t *pm;
1998
- for (k=0; k<n; k++) {
1999
- pm = m + k;
2000
- if ( ! *pm ) {
2001
- p1 = q1 + k*i1;
2002
- p2 = q2 + k*i2;
2003
- p3 = q3 + k*i3;
2004
- { (*p3) = ( (*p1) < (*p2) ); }
2005
- }
2006
- }
2007
- } else {
2008
- for (k=0; k<n; k++) {
2009
- p1 = q1 + k*i1;
2010
- p2 = q2 + k*i2;
2011
- p3 = q3 + k*i3;
2012
- { (*p3) = ( (*p1) < (*p2) ); }
2013
- }
2014
- }
2015
- }
2016
-
2017
- static void
2018
- ca_bincmp_lt_uint32_t (ca_size_t n, boolean8_t *m,
2019
- char *ptr1, ca_size_t b1, ca_size_t i1,
2020
- char *ptr2, ca_size_t b2, ca_size_t i2,
2021
- char *ptr3, ca_size_t b3, ca_size_t i3,
2022
- double tol)
2023
- {
2024
- uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
2025
- uint32_t *p1 = q1, *p2 = q2;
2026
- boolean8_t *q3 = (boolean8_t *) ptr3;
2027
- boolean8_t *p3 = q3;
2028
- ca_size_t k;
2029
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2030
- (void) tol;
2031
- if ( m ) {
2032
- boolean8_t *pm;
2033
- for (k=0; k<n; k++) {
2034
- pm = m + k;
2035
- if ( ! *pm ) {
2036
- p1 = q1 + k*i1;
2037
- p2 = q2 + k*i2;
2038
- p3 = q3 + k*i3;
2039
- { (*p3) = ( (*p1) < (*p2) ); }
2040
- }
2041
- }
2042
- } else {
2043
- for (k=0; k<n; k++) {
2044
- p1 = q1 + k*i1;
2045
- p2 = q2 + k*i2;
2046
- p3 = q3 + k*i3;
2047
- { (*p3) = ( (*p1) < (*p2) ); }
2048
- }
2049
- }
2050
- }
2051
-
2052
- static void
2053
- ca_bincmp_lt_int64_t (ca_size_t n, boolean8_t *m,
2054
- char *ptr1, ca_size_t b1, ca_size_t i1,
2055
- char *ptr2, ca_size_t b2, ca_size_t i2,
2056
- char *ptr3, ca_size_t b3, ca_size_t i3,
2057
- double tol)
2058
- {
2059
- int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
2060
- int64_t *p1 = q1, *p2 = q2;
2061
- boolean8_t *q3 = (boolean8_t *) ptr3;
2062
- boolean8_t *p3 = q3;
2063
- ca_size_t k;
2064
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2065
- (void) tol;
2066
- if ( m ) {
2067
- boolean8_t *pm;
2068
- for (k=0; k<n; k++) {
2069
- pm = m + k;
2070
- if ( ! *pm ) {
2071
- p1 = q1 + k*i1;
2072
- p2 = q2 + k*i2;
2073
- p3 = q3 + k*i3;
2074
- { (*p3) = ( (*p1) < (*p2) ); }
2075
- }
2076
- }
2077
- } else {
2078
- for (k=0; k<n; k++) {
2079
- p1 = q1 + k*i1;
2080
- p2 = q2 + k*i2;
2081
- p3 = q3 + k*i3;
2082
- { (*p3) = ( (*p1) < (*p2) ); }
2083
- }
2084
- }
2085
- }
2086
-
2087
- static void
2088
- ca_bincmp_lt_uint64_t (ca_size_t n, boolean8_t *m,
2089
- char *ptr1, ca_size_t b1, ca_size_t i1,
2090
- char *ptr2, ca_size_t b2, ca_size_t i2,
2091
- char *ptr3, ca_size_t b3, ca_size_t i3,
2092
- double tol)
2093
- {
2094
- uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
2095
- uint64_t *p1 = q1, *p2 = q2;
2096
- boolean8_t *q3 = (boolean8_t *) ptr3;
2097
- boolean8_t *p3 = q3;
2098
- ca_size_t k;
2099
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2100
- (void) tol;
2101
- if ( m ) {
2102
- boolean8_t *pm;
2103
- for (k=0; k<n; k++) {
2104
- pm = m + k;
2105
- if ( ! *pm ) {
2106
- p1 = q1 + k*i1;
2107
- p2 = q2 + k*i2;
2108
- p3 = q3 + k*i3;
2109
- { (*p3) = ( (*p1) < (*p2) ); }
2110
- }
2111
- }
2112
- } else {
2113
- for (k=0; k<n; k++) {
2114
- p1 = q1 + k*i1;
2115
- p2 = q2 + k*i2;
2116
- p3 = q3 + k*i3;
2117
- { (*p3) = ( (*p1) < (*p2) ); }
2118
- }
2119
- }
2120
- }
2121
-
2122
- static void
2123
- ca_bincmp_lt_float32_t (ca_size_t n, boolean8_t *m,
2124
- char *ptr1, ca_size_t b1, ca_size_t i1,
2125
- char *ptr2, ca_size_t b2, ca_size_t i2,
2126
- char *ptr3, ca_size_t b3, ca_size_t i3,
2127
- double tol)
2128
- {
2129
- float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
2130
- float *p1 = q1, *p2 = q2;
2131
- boolean8_t *q3 = (boolean8_t *) ptr3;
2132
- boolean8_t *p3 = q3;
2133
- ca_size_t k;
2134
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2135
- (void) tol;
2136
- if ( m ) {
2137
- boolean8_t *pm;
2138
- for (k=0; k<n; k++) {
2139
- pm = m + k;
2140
- if ( ! *pm ) {
2141
- p1 = q1 + k*i1;
2142
- p2 = q2 + k*i2;
2143
- p3 = q3 + k*i3;
2144
- { (*p3) = ( (*p1) < (*p2) ); }
2145
- }
2146
- }
2147
- } else {
2148
- for (k=0; k<n; k++) {
2149
- p1 = q1 + k*i1;
2150
- p2 = q2 + k*i2;
2151
- p3 = q3 + k*i3;
2152
- { (*p3) = ( (*p1) < (*p2) ); }
2153
- }
2154
- }
2155
- }
2156
-
2157
- static void
2158
- ca_bincmp_lt_float64_t (ca_size_t n, boolean8_t *m,
2159
- char *ptr1, ca_size_t b1, ca_size_t i1,
2160
- char *ptr2, ca_size_t b2, ca_size_t i2,
2161
- char *ptr3, ca_size_t b3, ca_size_t i3,
2162
- double tol)
2163
- {
2164
- double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
2165
- double *p1 = q1, *p2 = q2;
2166
- boolean8_t *q3 = (boolean8_t *) ptr3;
2167
- boolean8_t *p3 = q3;
2168
- ca_size_t k;
2169
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2170
- (void) tol;
2171
- if ( m ) {
2172
- boolean8_t *pm;
2173
- for (k=0; k<n; k++) {
2174
- pm = m + k;
2175
- if ( ! *pm ) {
2176
- p1 = q1 + k*i1;
2177
- p2 = q2 + k*i2;
2178
- p3 = q3 + k*i3;
2179
- { (*p3) = ( (*p1) < (*p2) ); }
2180
- }
2181
- }
2182
- } else {
2183
- for (k=0; k<n; k++) {
2184
- p1 = q1 + k*i1;
2185
- p2 = q2 + k*i2;
2186
- p3 = q3 + k*i3;
2187
- { (*p3) = ( (*p1) < (*p2) ); }
2188
- }
2189
- }
2190
- }
2191
-
2192
- static void
2193
- ca_bincmp_lt_VALUE (ca_size_t n, boolean8_t *m,
2194
- char *ptr1, ca_size_t b1, ca_size_t i1,
2195
- char *ptr2, ca_size_t b2, ca_size_t i2,
2196
- char *ptr3, ca_size_t b3, ca_size_t i3,
2197
- double tol)
2198
- {
2199
- VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
2200
- VALUE *p1 = q1, *p2 = q2;
2201
- boolean8_t *q3 = (boolean8_t *) ptr3;
2202
- boolean8_t *p3 = q3;
2203
- ca_size_t k;
2204
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2205
- (void) tol;
2206
- if ( m ) {
2207
- boolean8_t *pm;
2208
- for (k=0; k<n; k++) {
2209
- pm = m + k;
2210
- if ( ! *pm ) {
2211
- p1 = q1 + k*i1;
2212
- p2 = q2 + k*i2;
2213
- p3 = q3 + k*i3;
2214
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern("<"), 1, (*p2))) ? 1 : 0; }
2215
- }
2216
- }
2217
- } else {
2218
- for (k=0; k<n; k++) {
2219
- p1 = q1 + k*i1;
2220
- p2 = q2 + k*i2;
2221
- p3 = q3 + k*i3;
2222
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern("<"), 1, (*p2))) ? 1 : 0; }
2223
- }
2224
- }
2225
- }
2226
-
2227
- ca_bincmp_func_t
2228
- ca_bincmp_lt[CA_NTYPE] = {
2229
- ca_bincmp_lt_fixlen,
2230
- ca_bincmp_lt_boolean8_t,
2231
- ca_bincmp_lt_int8_t,
2232
- ca_bincmp_lt_uint8_t,
2233
- ca_bincmp_lt_int16_t,
2234
- ca_bincmp_lt_uint16_t,
2235
- ca_bincmp_lt_int32_t,
2236
- ca_bincmp_lt_uint32_t,
2237
- ca_bincmp_lt_int64_t,
2238
- ca_bincmp_lt_uint64_t,
2239
- ca_bincmp_lt_float32_t,
2240
- ca_bincmp_lt_float64_t,
2241
- ca_bincmp_not_implement,
2242
- ca_bincmp_not_implement,
2243
- ca_bincmp_not_implement,
2244
- ca_bincmp_not_implement,
2245
- ca_bincmp_lt_VALUE,
2246
- };
2247
-
2248
- VALUE rb_ca_lt (VALUE self, VALUE other)
2249
- {
2250
- if ( ! rb_ca_test_castable(other) ) {
2251
- return rb_ca_binop_pass_to_other(self, other, rb_intern("lt"));
2252
- }
2253
- return rb_ca_call_bincmp(self, other, ca_bincmp_lt, 0.0);
2254
- }
2255
-
2256
- /* ===== bincmp ge ============================================ */
2257
-
2258
- static void
2259
- ca_bincmp_ge_fixlen (ca_size_t n, boolean8_t *m,
2260
- char *ptr1, ca_size_t b1, ca_size_t i1,
2261
- char *ptr2, ca_size_t b2, ca_size_t i2,
2262
- char *ptr3, ca_size_t b3, ca_size_t i3,
2263
- double tol)
2264
- {
2265
- char *q1 = ptr1, *q2 = ptr2;
2266
- char *p1 = q1, *p2 = q2;
2267
- boolean8_t *q3 = (boolean8_t *) ptr3;
2268
- boolean8_t *p3 = q3;
2269
- ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
2270
- ca_size_t k;
2271
- (void) tol;
2272
- if ( m ) {
2273
- boolean8_t *pm;
2274
- for (k=0; k<n; k++) {
2275
- pm = m + k;
2276
- if ( ! *pm ) {
2277
- p1 = q1 + k*s1;
2278
- p2 = q2 + k*s2;
2279
- p3 = q3 + k*s3;
2280
- {
2281
- int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
2282
- (*p3) = ( cmp > 0 || ( cmp == 0 && b1 >= b2 ) );
2283
- }
2284
- }
2285
- }
2286
- } else {
2287
- for (k=0; k<n; k++) {
2288
- p1 = q1 + k*s1;
2289
- p2 = q2 + k*s2;
2290
- p3 = q3 + k*s3;
2291
- {
2292
- int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
2293
- (*p3) = ( cmp > 0 || ( cmp == 0 && b1 >= b2 ) );
2294
- }
2295
- }
2296
- }
2297
- }
2298
-
2299
- static void
2300
- ca_bincmp_ge_boolean8_t (ca_size_t n, boolean8_t *m,
2301
- char *ptr1, ca_size_t b1, ca_size_t i1,
2302
- char *ptr2, ca_size_t b2, ca_size_t i2,
2303
- char *ptr3, ca_size_t b3, ca_size_t i3,
2304
- double tol)
2305
- {
2306
- boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
2307
- boolean8_t *p1 = q1, *p2 = q2;
2308
- boolean8_t *q3 = (boolean8_t *) ptr3;
2309
- boolean8_t *p3 = q3;
2310
- ca_size_t k;
2311
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2312
- (void) tol;
2313
- if ( m ) {
2314
- boolean8_t *pm;
2315
- for (k=0; k<n; k++) {
2316
- pm = m + k;
2317
- if ( ! *pm ) {
2318
- p1 = q1 + k*i1;
2319
- p2 = q2 + k*i2;
2320
- p3 = q3 + k*i3;
2321
- { (*p3) = ( (*p1) >= (*p2) ); }
2322
- }
2323
- }
2324
- } else {
2325
- for (k=0; k<n; k++) {
2326
- p1 = q1 + k*i1;
2327
- p2 = q2 + k*i2;
2328
- p3 = q3 + k*i3;
2329
- { (*p3) = ( (*p1) >= (*p2) ); }
2330
- }
2331
- }
2332
- }
2333
-
2334
- static void
2335
- ca_bincmp_ge_int8_t (ca_size_t n, boolean8_t *m,
2336
- char *ptr1, ca_size_t b1, ca_size_t i1,
2337
- char *ptr2, ca_size_t b2, ca_size_t i2,
2338
- char *ptr3, ca_size_t b3, ca_size_t i3,
2339
- double tol)
2340
- {
2341
- int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
2342
- int8_t *p1 = q1, *p2 = q2;
2343
- boolean8_t *q3 = (boolean8_t *) ptr3;
2344
- boolean8_t *p3 = q3;
2345
- ca_size_t k;
2346
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2347
- (void) tol;
2348
- if ( m ) {
2349
- boolean8_t *pm;
2350
- for (k=0; k<n; k++) {
2351
- pm = m + k;
2352
- if ( ! *pm ) {
2353
- p1 = q1 + k*i1;
2354
- p2 = q2 + k*i2;
2355
- p3 = q3 + k*i3;
2356
- { (*p3) = ( (*p1) >= (*p2) ); }
2357
- }
2358
- }
2359
- } else {
2360
- for (k=0; k<n; k++) {
2361
- p1 = q1 + k*i1;
2362
- p2 = q2 + k*i2;
2363
- p3 = q3 + k*i3;
2364
- { (*p3) = ( (*p1) >= (*p2) ); }
2365
- }
2366
- }
2367
- }
2368
-
2369
- static void
2370
- ca_bincmp_ge_uint8_t (ca_size_t n, boolean8_t *m,
2371
- char *ptr1, ca_size_t b1, ca_size_t i1,
2372
- char *ptr2, ca_size_t b2, ca_size_t i2,
2373
- char *ptr3, ca_size_t b3, ca_size_t i3,
2374
- double tol)
2375
- {
2376
- uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
2377
- uint8_t *p1 = q1, *p2 = q2;
2378
- boolean8_t *q3 = (boolean8_t *) ptr3;
2379
- boolean8_t *p3 = q3;
2380
- ca_size_t k;
2381
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2382
- (void) tol;
2383
- if ( m ) {
2384
- boolean8_t *pm;
2385
- for (k=0; k<n; k++) {
2386
- pm = m + k;
2387
- if ( ! *pm ) {
2388
- p1 = q1 + k*i1;
2389
- p2 = q2 + k*i2;
2390
- p3 = q3 + k*i3;
2391
- { (*p3) = ( (*p1) >= (*p2) ); }
2392
- }
2393
- }
2394
- } else {
2395
- for (k=0; k<n; k++) {
2396
- p1 = q1 + k*i1;
2397
- p2 = q2 + k*i2;
2398
- p3 = q3 + k*i3;
2399
- { (*p3) = ( (*p1) >= (*p2) ); }
2400
- }
2401
- }
2402
- }
2403
-
2404
- static void
2405
- ca_bincmp_ge_int16_t (ca_size_t n, boolean8_t *m,
2406
- char *ptr1, ca_size_t b1, ca_size_t i1,
2407
- char *ptr2, ca_size_t b2, ca_size_t i2,
2408
- char *ptr3, ca_size_t b3, ca_size_t i3,
2409
- double tol)
2410
- {
2411
- int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
2412
- int16_t *p1 = q1, *p2 = q2;
2413
- boolean8_t *q3 = (boolean8_t *) ptr3;
2414
- boolean8_t *p3 = q3;
2415
- ca_size_t k;
2416
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2417
- (void) tol;
2418
- if ( m ) {
2419
- boolean8_t *pm;
2420
- for (k=0; k<n; k++) {
2421
- pm = m + k;
2422
- if ( ! *pm ) {
2423
- p1 = q1 + k*i1;
2424
- p2 = q2 + k*i2;
2425
- p3 = q3 + k*i3;
2426
- { (*p3) = ( (*p1) >= (*p2) ); }
2427
- }
2428
- }
2429
- } else {
2430
- for (k=0; k<n; k++) {
2431
- p1 = q1 + k*i1;
2432
- p2 = q2 + k*i2;
2433
- p3 = q3 + k*i3;
2434
- { (*p3) = ( (*p1) >= (*p2) ); }
2435
- }
2436
- }
2437
- }
2438
-
2439
- static void
2440
- ca_bincmp_ge_uint16_t (ca_size_t n, boolean8_t *m,
2441
- char *ptr1, ca_size_t b1, ca_size_t i1,
2442
- char *ptr2, ca_size_t b2, ca_size_t i2,
2443
- char *ptr3, ca_size_t b3, ca_size_t i3,
2444
- double tol)
2445
- {
2446
- uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
2447
- uint16_t *p1 = q1, *p2 = q2;
2448
- boolean8_t *q3 = (boolean8_t *) ptr3;
2449
- boolean8_t *p3 = q3;
2450
- ca_size_t k;
2451
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2452
- (void) tol;
2453
- if ( m ) {
2454
- boolean8_t *pm;
2455
- for (k=0; k<n; k++) {
2456
- pm = m + k;
2457
- if ( ! *pm ) {
2458
- p1 = q1 + k*i1;
2459
- p2 = q2 + k*i2;
2460
- p3 = q3 + k*i3;
2461
- { (*p3) = ( (*p1) >= (*p2) ); }
2462
- }
2463
- }
2464
- } else {
2465
- for (k=0; k<n; k++) {
2466
- p1 = q1 + k*i1;
2467
- p2 = q2 + k*i2;
2468
- p3 = q3 + k*i3;
2469
- { (*p3) = ( (*p1) >= (*p2) ); }
2470
- }
2471
- }
2472
- }
2473
-
2474
- static void
2475
- ca_bincmp_ge_int32_t (ca_size_t n, boolean8_t *m,
2476
- char *ptr1, ca_size_t b1, ca_size_t i1,
2477
- char *ptr2, ca_size_t b2, ca_size_t i2,
2478
- char *ptr3, ca_size_t b3, ca_size_t i3,
2479
- double tol)
2480
- {
2481
- int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
2482
- int32_t *p1 = q1, *p2 = q2;
2483
- boolean8_t *q3 = (boolean8_t *) ptr3;
2484
- boolean8_t *p3 = q3;
2485
- ca_size_t k;
2486
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2487
- (void) tol;
2488
- if ( m ) {
2489
- boolean8_t *pm;
2490
- for (k=0; k<n; k++) {
2491
- pm = m + k;
2492
- if ( ! *pm ) {
2493
- p1 = q1 + k*i1;
2494
- p2 = q2 + k*i2;
2495
- p3 = q3 + k*i3;
2496
- { (*p3) = ( (*p1) >= (*p2) ); }
2497
- }
2498
- }
2499
- } else {
2500
- for (k=0; k<n; k++) {
2501
- p1 = q1 + k*i1;
2502
- p2 = q2 + k*i2;
2503
- p3 = q3 + k*i3;
2504
- { (*p3) = ( (*p1) >= (*p2) ); }
2505
- }
2506
- }
2507
- }
2508
-
2509
- static void
2510
- ca_bincmp_ge_uint32_t (ca_size_t n, boolean8_t *m,
2511
- char *ptr1, ca_size_t b1, ca_size_t i1,
2512
- char *ptr2, ca_size_t b2, ca_size_t i2,
2513
- char *ptr3, ca_size_t b3, ca_size_t i3,
2514
- double tol)
2515
- {
2516
- uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
2517
- uint32_t *p1 = q1, *p2 = q2;
2518
- boolean8_t *q3 = (boolean8_t *) ptr3;
2519
- boolean8_t *p3 = q3;
2520
- ca_size_t k;
2521
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2522
- (void) tol;
2523
- if ( m ) {
2524
- boolean8_t *pm;
2525
- for (k=0; k<n; k++) {
2526
- pm = m + k;
2527
- if ( ! *pm ) {
2528
- p1 = q1 + k*i1;
2529
- p2 = q2 + k*i2;
2530
- p3 = q3 + k*i3;
2531
- { (*p3) = ( (*p1) >= (*p2) ); }
2532
- }
2533
- }
2534
- } else {
2535
- for (k=0; k<n; k++) {
2536
- p1 = q1 + k*i1;
2537
- p2 = q2 + k*i2;
2538
- p3 = q3 + k*i3;
2539
- { (*p3) = ( (*p1) >= (*p2) ); }
2540
- }
2541
- }
2542
- }
2543
-
2544
- static void
2545
- ca_bincmp_ge_int64_t (ca_size_t n, boolean8_t *m,
2546
- char *ptr1, ca_size_t b1, ca_size_t i1,
2547
- char *ptr2, ca_size_t b2, ca_size_t i2,
2548
- char *ptr3, ca_size_t b3, ca_size_t i3,
2549
- double tol)
2550
- {
2551
- int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
2552
- int64_t *p1 = q1, *p2 = q2;
2553
- boolean8_t *q3 = (boolean8_t *) ptr3;
2554
- boolean8_t *p3 = q3;
2555
- ca_size_t k;
2556
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2557
- (void) tol;
2558
- if ( m ) {
2559
- boolean8_t *pm;
2560
- for (k=0; k<n; k++) {
2561
- pm = m + k;
2562
- if ( ! *pm ) {
2563
- p1 = q1 + k*i1;
2564
- p2 = q2 + k*i2;
2565
- p3 = q3 + k*i3;
2566
- { (*p3) = ( (*p1) >= (*p2) ); }
2567
- }
2568
- }
2569
- } else {
2570
- for (k=0; k<n; k++) {
2571
- p1 = q1 + k*i1;
2572
- p2 = q2 + k*i2;
2573
- p3 = q3 + k*i3;
2574
- { (*p3) = ( (*p1) >= (*p2) ); }
2575
- }
2576
- }
2577
- }
2578
-
2579
- static void
2580
- ca_bincmp_ge_uint64_t (ca_size_t n, boolean8_t *m,
2581
- char *ptr1, ca_size_t b1, ca_size_t i1,
2582
- char *ptr2, ca_size_t b2, ca_size_t i2,
2583
- char *ptr3, ca_size_t b3, ca_size_t i3,
2584
- double tol)
2585
- {
2586
- uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
2587
- uint64_t *p1 = q1, *p2 = q2;
2588
- boolean8_t *q3 = (boolean8_t *) ptr3;
2589
- boolean8_t *p3 = q3;
2590
- ca_size_t k;
2591
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2592
- (void) tol;
2593
- if ( m ) {
2594
- boolean8_t *pm;
2595
- for (k=0; k<n; k++) {
2596
- pm = m + k;
2597
- if ( ! *pm ) {
2598
- p1 = q1 + k*i1;
2599
- p2 = q2 + k*i2;
2600
- p3 = q3 + k*i3;
2601
- { (*p3) = ( (*p1) >= (*p2) ); }
2602
- }
2603
- }
2604
- } else {
2605
- for (k=0; k<n; k++) {
2606
- p1 = q1 + k*i1;
2607
- p2 = q2 + k*i2;
2608
- p3 = q3 + k*i3;
2609
- { (*p3) = ( (*p1) >= (*p2) ); }
2610
- }
2611
- }
2612
- }
2613
-
2614
- static void
2615
- ca_bincmp_ge_float32_t (ca_size_t n, boolean8_t *m,
2616
- char *ptr1, ca_size_t b1, ca_size_t i1,
2617
- char *ptr2, ca_size_t b2, ca_size_t i2,
2618
- char *ptr3, ca_size_t b3, ca_size_t i3,
2619
- double tol)
2620
- {
2621
- float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
2622
- float *p1 = q1, *p2 = q2;
2623
- boolean8_t *q3 = (boolean8_t *) ptr3;
2624
- boolean8_t *p3 = q3;
2625
- ca_size_t k;
2626
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2627
- (void) tol;
2628
- if ( m ) {
2629
- boolean8_t *pm;
2630
- for (k=0; k<n; k++) {
2631
- pm = m + k;
2632
- if ( ! *pm ) {
2633
- p1 = q1 + k*i1;
2634
- p2 = q2 + k*i2;
2635
- p3 = q3 + k*i3;
2636
- { (*p3) = ( (*p1) >= (*p2) ); }
2637
- }
2638
- }
2639
- } else {
2640
- for (k=0; k<n; k++) {
2641
- p1 = q1 + k*i1;
2642
- p2 = q2 + k*i2;
2643
- p3 = q3 + k*i3;
2644
- { (*p3) = ( (*p1) >= (*p2) ); }
2645
- }
2646
- }
2647
- }
2648
-
2649
- static void
2650
- ca_bincmp_ge_float64_t (ca_size_t n, boolean8_t *m,
2651
- char *ptr1, ca_size_t b1, ca_size_t i1,
2652
- char *ptr2, ca_size_t b2, ca_size_t i2,
2653
- char *ptr3, ca_size_t b3, ca_size_t i3,
2654
- double tol)
2655
- {
2656
- double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
2657
- double *p1 = q1, *p2 = q2;
2658
- boolean8_t *q3 = (boolean8_t *) ptr3;
2659
- boolean8_t *p3 = q3;
2660
- ca_size_t k;
2661
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2662
- (void) tol;
2663
- if ( m ) {
2664
- boolean8_t *pm;
2665
- for (k=0; k<n; k++) {
2666
- pm = m + k;
2667
- if ( ! *pm ) {
2668
- p1 = q1 + k*i1;
2669
- p2 = q2 + k*i2;
2670
- p3 = q3 + k*i3;
2671
- { (*p3) = ( (*p1) >= (*p2) ); }
2672
- }
2673
- }
2674
- } else {
2675
- for (k=0; k<n; k++) {
2676
- p1 = q1 + k*i1;
2677
- p2 = q2 + k*i2;
2678
- p3 = q3 + k*i3;
2679
- { (*p3) = ( (*p1) >= (*p2) ); }
2680
- }
2681
- }
2682
- }
2683
-
2684
- static void
2685
- ca_bincmp_ge_VALUE (ca_size_t n, boolean8_t *m,
2686
- char *ptr1, ca_size_t b1, ca_size_t i1,
2687
- char *ptr2, ca_size_t b2, ca_size_t i2,
2688
- char *ptr3, ca_size_t b3, ca_size_t i3,
2689
- double tol)
2690
- {
2691
- VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
2692
- VALUE *p1 = q1, *p2 = q2;
2693
- boolean8_t *q3 = (boolean8_t *) ptr3;
2694
- boolean8_t *p3 = q3;
2695
- ca_size_t k;
2696
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2697
- (void) tol;
2698
- if ( m ) {
2699
- boolean8_t *pm;
2700
- for (k=0; k<n; k++) {
2701
- pm = m + k;
2702
- if ( ! *pm ) {
2703
- p1 = q1 + k*i1;
2704
- p2 = q2 + k*i2;
2705
- p3 = q3 + k*i3;
2706
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern(">="), 1, (*p2))) ? 1 : 0; }
2707
- }
2708
- }
2709
- } else {
2710
- for (k=0; k<n; k++) {
2711
- p1 = q1 + k*i1;
2712
- p2 = q2 + k*i2;
2713
- p3 = q3 + k*i3;
2714
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern(">="), 1, (*p2))) ? 1 : 0; }
2715
- }
2716
- }
2717
- }
2718
-
2719
- ca_bincmp_func_t
2720
- ca_bincmp_ge[CA_NTYPE] = {
2721
- ca_bincmp_ge_fixlen,
2722
- ca_bincmp_ge_boolean8_t,
2723
- ca_bincmp_ge_int8_t,
2724
- ca_bincmp_ge_uint8_t,
2725
- ca_bincmp_ge_int16_t,
2726
- ca_bincmp_ge_uint16_t,
2727
- ca_bincmp_ge_int32_t,
2728
- ca_bincmp_ge_uint32_t,
2729
- ca_bincmp_ge_int64_t,
2730
- ca_bincmp_ge_uint64_t,
2731
- ca_bincmp_ge_float32_t,
2732
- ca_bincmp_ge_float64_t,
2733
- ca_bincmp_not_implement,
2734
- ca_bincmp_not_implement,
2735
- ca_bincmp_not_implement,
2736
- ca_bincmp_not_implement,
2737
- ca_bincmp_ge_VALUE,
2738
- };
2739
-
2740
- VALUE rb_ca_ge (VALUE self, VALUE other)
2741
- {
2742
- if ( ! rb_ca_test_castable(other) ) {
2743
- return rb_ca_binop_pass_to_other(self, other, rb_intern("ge"));
2744
- }
2745
- return rb_ca_call_bincmp(self, other, ca_bincmp_ge, 0.0);
2746
- }
2747
-
2748
- /* ===== bincmp le ============================================ */
2749
-
2750
- static void
2751
- ca_bincmp_le_fixlen (ca_size_t n, boolean8_t *m,
2752
- char *ptr1, ca_size_t b1, ca_size_t i1,
2753
- char *ptr2, ca_size_t b2, ca_size_t i2,
2754
- char *ptr3, ca_size_t b3, ca_size_t i3,
2755
- double tol)
2756
- {
2757
- char *q1 = ptr1, *q2 = ptr2;
2758
- char *p1 = q1, *p2 = q2;
2759
- boolean8_t *q3 = (boolean8_t *) ptr3;
2760
- boolean8_t *p3 = q3;
2761
- ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
2762
- ca_size_t k;
2763
- (void) tol;
2764
- if ( m ) {
2765
- boolean8_t *pm;
2766
- for (k=0; k<n; k++) {
2767
- pm = m + k;
2768
- if ( ! *pm ) {
2769
- p1 = q1 + k*s1;
2770
- p2 = q2 + k*s2;
2771
- p3 = q3 + k*s3;
2772
- {
2773
- int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
2774
- (*p3) = ( cmp < 0 || ( cmp == 0 && b1 <= b2 ) );
2775
- }
2776
- }
2777
- }
2778
- } else {
2779
- for (k=0; k<n; k++) {
2780
- p1 = q1 + k*s1;
2781
- p2 = q2 + k*s2;
2782
- p3 = q3 + k*s3;
2783
- {
2784
- int cmp = memcmp(p1, p2, b1 < b2 ? b1 : b2);
2785
- (*p3) = ( cmp < 0 || ( cmp == 0 && b1 <= b2 ) );
2786
- }
2787
- }
2788
- }
2789
- }
2790
-
2791
- static void
2792
- ca_bincmp_le_boolean8_t (ca_size_t n, boolean8_t *m,
2793
- char *ptr1, ca_size_t b1, ca_size_t i1,
2794
- char *ptr2, ca_size_t b2, ca_size_t i2,
2795
- char *ptr3, ca_size_t b3, ca_size_t i3,
2796
- double tol)
2797
- {
2798
- boolean8_t *q1 = (boolean8_t *) ptr1, *q2 = (boolean8_t *) ptr2;
2799
- boolean8_t *p1 = q1, *p2 = q2;
2800
- boolean8_t *q3 = (boolean8_t *) ptr3;
2801
- boolean8_t *p3 = q3;
2802
- ca_size_t k;
2803
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2804
- (void) tol;
2805
- if ( m ) {
2806
- boolean8_t *pm;
2807
- for (k=0; k<n; k++) {
2808
- pm = m + k;
2809
- if ( ! *pm ) {
2810
- p1 = q1 + k*i1;
2811
- p2 = q2 + k*i2;
2812
- p3 = q3 + k*i3;
2813
- { (*p3) = ( (*p1) <= (*p2) ); }
2814
- }
2815
- }
2816
- } else {
2817
- for (k=0; k<n; k++) {
2818
- p1 = q1 + k*i1;
2819
- p2 = q2 + k*i2;
2820
- p3 = q3 + k*i3;
2821
- { (*p3) = ( (*p1) <= (*p2) ); }
2822
- }
2823
- }
2824
- }
2825
-
2826
- static void
2827
- ca_bincmp_le_int8_t (ca_size_t n, boolean8_t *m,
2828
- char *ptr1, ca_size_t b1, ca_size_t i1,
2829
- char *ptr2, ca_size_t b2, ca_size_t i2,
2830
- char *ptr3, ca_size_t b3, ca_size_t i3,
2831
- double tol)
2832
- {
2833
- int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
2834
- int8_t *p1 = q1, *p2 = q2;
2835
- boolean8_t *q3 = (boolean8_t *) ptr3;
2836
- boolean8_t *p3 = q3;
2837
- ca_size_t k;
2838
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2839
- (void) tol;
2840
- if ( m ) {
2841
- boolean8_t *pm;
2842
- for (k=0; k<n; k++) {
2843
- pm = m + k;
2844
- if ( ! *pm ) {
2845
- p1 = q1 + k*i1;
2846
- p2 = q2 + k*i2;
2847
- p3 = q3 + k*i3;
2848
- { (*p3) = ( (*p1) <= (*p2) ); }
2849
- }
2850
- }
2851
- } else {
2852
- for (k=0; k<n; k++) {
2853
- p1 = q1 + k*i1;
2854
- p2 = q2 + k*i2;
2855
- p3 = q3 + k*i3;
2856
- { (*p3) = ( (*p1) <= (*p2) ); }
2857
- }
2858
- }
2859
- }
2860
-
2861
- static void
2862
- ca_bincmp_le_uint8_t (ca_size_t n, boolean8_t *m,
2863
- char *ptr1, ca_size_t b1, ca_size_t i1,
2864
- char *ptr2, ca_size_t b2, ca_size_t i2,
2865
- char *ptr3, ca_size_t b3, ca_size_t i3,
2866
- double tol)
2867
- {
2868
- uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
2869
- uint8_t *p1 = q1, *p2 = q2;
2870
- boolean8_t *q3 = (boolean8_t *) ptr3;
2871
- boolean8_t *p3 = q3;
2872
- ca_size_t k;
2873
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2874
- (void) tol;
2875
- if ( m ) {
2876
- boolean8_t *pm;
2877
- for (k=0; k<n; k++) {
2878
- pm = m + k;
2879
- if ( ! *pm ) {
2880
- p1 = q1 + k*i1;
2881
- p2 = q2 + k*i2;
2882
- p3 = q3 + k*i3;
2883
- { (*p3) = ( (*p1) <= (*p2) ); }
2884
- }
2885
- }
2886
- } else {
2887
- for (k=0; k<n; k++) {
2888
- p1 = q1 + k*i1;
2889
- p2 = q2 + k*i2;
2890
- p3 = q3 + k*i3;
2891
- { (*p3) = ( (*p1) <= (*p2) ); }
2892
- }
2893
- }
2894
- }
2895
-
2896
- static void
2897
- ca_bincmp_le_int16_t (ca_size_t n, boolean8_t *m,
2898
- char *ptr1, ca_size_t b1, ca_size_t i1,
2899
- char *ptr2, ca_size_t b2, ca_size_t i2,
2900
- char *ptr3, ca_size_t b3, ca_size_t i3,
2901
- double tol)
2902
- {
2903
- int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
2904
- int16_t *p1 = q1, *p2 = q2;
2905
- boolean8_t *q3 = (boolean8_t *) ptr3;
2906
- boolean8_t *p3 = q3;
2907
- ca_size_t k;
2908
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2909
- (void) tol;
2910
- if ( m ) {
2911
- boolean8_t *pm;
2912
- for (k=0; k<n; k++) {
2913
- pm = m + k;
2914
- if ( ! *pm ) {
2915
- p1 = q1 + k*i1;
2916
- p2 = q2 + k*i2;
2917
- p3 = q3 + k*i3;
2918
- { (*p3) = ( (*p1) <= (*p2) ); }
2919
- }
2920
- }
2921
- } else {
2922
- for (k=0; k<n; k++) {
2923
- p1 = q1 + k*i1;
2924
- p2 = q2 + k*i2;
2925
- p3 = q3 + k*i3;
2926
- { (*p3) = ( (*p1) <= (*p2) ); }
2927
- }
2928
- }
2929
- }
2930
-
2931
- static void
2932
- ca_bincmp_le_uint16_t (ca_size_t n, boolean8_t *m,
2933
- char *ptr1, ca_size_t b1, ca_size_t i1,
2934
- char *ptr2, ca_size_t b2, ca_size_t i2,
2935
- char *ptr3, ca_size_t b3, ca_size_t i3,
2936
- double tol)
2937
- {
2938
- uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
2939
- uint16_t *p1 = q1, *p2 = q2;
2940
- boolean8_t *q3 = (boolean8_t *) ptr3;
2941
- boolean8_t *p3 = q3;
2942
- ca_size_t k;
2943
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2944
- (void) tol;
2945
- if ( m ) {
2946
- boolean8_t *pm;
2947
- for (k=0; k<n; k++) {
2948
- pm = m + k;
2949
- if ( ! *pm ) {
2950
- p1 = q1 + k*i1;
2951
- p2 = q2 + k*i2;
2952
- p3 = q3 + k*i3;
2953
- { (*p3) = ( (*p1) <= (*p2) ); }
2954
- }
2955
- }
2956
- } else {
2957
- for (k=0; k<n; k++) {
2958
- p1 = q1 + k*i1;
2959
- p2 = q2 + k*i2;
2960
- p3 = q3 + k*i3;
2961
- { (*p3) = ( (*p1) <= (*p2) ); }
2962
- }
2963
- }
2964
- }
2965
-
2966
- static void
2967
- ca_bincmp_le_int32_t (ca_size_t n, boolean8_t *m,
2968
- char *ptr1, ca_size_t b1, ca_size_t i1,
2969
- char *ptr2, ca_size_t b2, ca_size_t i2,
2970
- char *ptr3, ca_size_t b3, ca_size_t i3,
2971
- double tol)
2972
- {
2973
- int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
2974
- int32_t *p1 = q1, *p2 = q2;
2975
- boolean8_t *q3 = (boolean8_t *) ptr3;
2976
- boolean8_t *p3 = q3;
2977
- ca_size_t k;
2978
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
2979
- (void) tol;
2980
- if ( m ) {
2981
- boolean8_t *pm;
2982
- for (k=0; k<n; k++) {
2983
- pm = m + k;
2984
- if ( ! *pm ) {
2985
- p1 = q1 + k*i1;
2986
- p2 = q2 + k*i2;
2987
- p3 = q3 + k*i3;
2988
- { (*p3) = ( (*p1) <= (*p2) ); }
2989
- }
2990
- }
2991
- } else {
2992
- for (k=0; k<n; k++) {
2993
- p1 = q1 + k*i1;
2994
- p2 = q2 + k*i2;
2995
- p3 = q3 + k*i3;
2996
- { (*p3) = ( (*p1) <= (*p2) ); }
2997
- }
2998
- }
2999
- }
3000
-
3001
- static void
3002
- ca_bincmp_le_uint32_t (ca_size_t n, boolean8_t *m,
3003
- char *ptr1, ca_size_t b1, ca_size_t i1,
3004
- char *ptr2, ca_size_t b2, ca_size_t i2,
3005
- char *ptr3, ca_size_t b3, ca_size_t i3,
3006
- double tol)
3007
- {
3008
- uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
3009
- uint32_t *p1 = q1, *p2 = q2;
3010
- boolean8_t *q3 = (boolean8_t *) ptr3;
3011
- boolean8_t *p3 = q3;
3012
- ca_size_t k;
3013
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3014
- (void) tol;
3015
- if ( m ) {
3016
- boolean8_t *pm;
3017
- for (k=0; k<n; k++) {
3018
- pm = m + k;
3019
- if ( ! *pm ) {
3020
- p1 = q1 + k*i1;
3021
- p2 = q2 + k*i2;
3022
- p3 = q3 + k*i3;
3023
- { (*p3) = ( (*p1) <= (*p2) ); }
3024
- }
3025
- }
3026
- } else {
3027
- for (k=0; k<n; k++) {
3028
- p1 = q1 + k*i1;
3029
- p2 = q2 + k*i2;
3030
- p3 = q3 + k*i3;
3031
- { (*p3) = ( (*p1) <= (*p2) ); }
3032
- }
3033
- }
3034
- }
3035
-
3036
- static void
3037
- ca_bincmp_le_int64_t (ca_size_t n, boolean8_t *m,
3038
- char *ptr1, ca_size_t b1, ca_size_t i1,
3039
- char *ptr2, ca_size_t b2, ca_size_t i2,
3040
- char *ptr3, ca_size_t b3, ca_size_t i3,
3041
- double tol)
3042
- {
3043
- int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
3044
- int64_t *p1 = q1, *p2 = q2;
3045
- boolean8_t *q3 = (boolean8_t *) ptr3;
3046
- boolean8_t *p3 = q3;
3047
- ca_size_t k;
3048
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3049
- (void) tol;
3050
- if ( m ) {
3051
- boolean8_t *pm;
3052
- for (k=0; k<n; k++) {
3053
- pm = m + k;
3054
- if ( ! *pm ) {
3055
- p1 = q1 + k*i1;
3056
- p2 = q2 + k*i2;
3057
- p3 = q3 + k*i3;
3058
- { (*p3) = ( (*p1) <= (*p2) ); }
3059
- }
3060
- }
3061
- } else {
3062
- for (k=0; k<n; k++) {
3063
- p1 = q1 + k*i1;
3064
- p2 = q2 + k*i2;
3065
- p3 = q3 + k*i3;
3066
- { (*p3) = ( (*p1) <= (*p2) ); }
3067
- }
3068
- }
3069
- }
3070
-
3071
- static void
3072
- ca_bincmp_le_uint64_t (ca_size_t n, boolean8_t *m,
3073
- char *ptr1, ca_size_t b1, ca_size_t i1,
3074
- char *ptr2, ca_size_t b2, ca_size_t i2,
3075
- char *ptr3, ca_size_t b3, ca_size_t i3,
3076
- double tol)
3077
- {
3078
- uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
3079
- uint64_t *p1 = q1, *p2 = q2;
3080
- boolean8_t *q3 = (boolean8_t *) ptr3;
3081
- boolean8_t *p3 = q3;
3082
- ca_size_t k;
3083
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3084
- (void) tol;
3085
- if ( m ) {
3086
- boolean8_t *pm;
3087
- for (k=0; k<n; k++) {
3088
- pm = m + k;
3089
- if ( ! *pm ) {
3090
- p1 = q1 + k*i1;
3091
- p2 = q2 + k*i2;
3092
- p3 = q3 + k*i3;
3093
- { (*p3) = ( (*p1) <= (*p2) ); }
3094
- }
3095
- }
3096
- } else {
3097
- for (k=0; k<n; k++) {
3098
- p1 = q1 + k*i1;
3099
- p2 = q2 + k*i2;
3100
- p3 = q3 + k*i3;
3101
- { (*p3) = ( (*p1) <= (*p2) ); }
3102
- }
3103
- }
3104
- }
3105
-
3106
- static void
3107
- ca_bincmp_le_float32_t (ca_size_t n, boolean8_t *m,
3108
- char *ptr1, ca_size_t b1, ca_size_t i1,
3109
- char *ptr2, ca_size_t b2, ca_size_t i2,
3110
- char *ptr3, ca_size_t b3, ca_size_t i3,
3111
- double tol)
3112
- {
3113
- float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
3114
- float *p1 = q1, *p2 = q2;
3115
- boolean8_t *q3 = (boolean8_t *) ptr3;
3116
- boolean8_t *p3 = q3;
3117
- ca_size_t k;
3118
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3119
- (void) tol;
3120
- if ( m ) {
3121
- boolean8_t *pm;
3122
- for (k=0; k<n; k++) {
3123
- pm = m + k;
3124
- if ( ! *pm ) {
3125
- p1 = q1 + k*i1;
3126
- p2 = q2 + k*i2;
3127
- p3 = q3 + k*i3;
3128
- { (*p3) = ( (*p1) <= (*p2) ); }
3129
- }
3130
- }
3131
- } else {
3132
- for (k=0; k<n; k++) {
3133
- p1 = q1 + k*i1;
3134
- p2 = q2 + k*i2;
3135
- p3 = q3 + k*i3;
3136
- { (*p3) = ( (*p1) <= (*p2) ); }
3137
- }
3138
- }
3139
- }
3140
-
3141
- static void
3142
- ca_bincmp_le_float64_t (ca_size_t n, boolean8_t *m,
3143
- char *ptr1, ca_size_t b1, ca_size_t i1,
3144
- char *ptr2, ca_size_t b2, ca_size_t i2,
3145
- char *ptr3, ca_size_t b3, ca_size_t i3,
3146
- double tol)
3147
- {
3148
- double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
3149
- double *p1 = q1, *p2 = q2;
3150
- boolean8_t *q3 = (boolean8_t *) ptr3;
3151
- boolean8_t *p3 = q3;
3152
- ca_size_t k;
3153
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3154
- (void) tol;
3155
- if ( m ) {
3156
- boolean8_t *pm;
3157
- for (k=0; k<n; k++) {
3158
- pm = m + k;
3159
- if ( ! *pm ) {
3160
- p1 = q1 + k*i1;
3161
- p2 = q2 + k*i2;
3162
- p3 = q3 + k*i3;
3163
- { (*p3) = ( (*p1) <= (*p2) ); }
3164
- }
3165
- }
3166
- } else {
3167
- for (k=0; k<n; k++) {
3168
- p1 = q1 + k*i1;
3169
- p2 = q2 + k*i2;
3170
- p3 = q3 + k*i3;
3171
- { (*p3) = ( (*p1) <= (*p2) ); }
3172
- }
3173
- }
3174
- }
3175
-
3176
- static void
3177
- ca_bincmp_le_VALUE (ca_size_t n, boolean8_t *m,
3178
- char *ptr1, ca_size_t b1, ca_size_t i1,
3179
- char *ptr2, ca_size_t b2, ca_size_t i2,
3180
- char *ptr3, ca_size_t b3, ca_size_t i3,
3181
- double tol)
3182
- {
3183
- VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
3184
- VALUE *p1 = q1, *p2 = q2;
3185
- boolean8_t *q3 = (boolean8_t *) ptr3;
3186
- boolean8_t *p3 = q3;
3187
- ca_size_t k;
3188
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3189
- (void) tol;
3190
- if ( m ) {
3191
- boolean8_t *pm;
3192
- for (k=0; k<n; k++) {
3193
- pm = m + k;
3194
- if ( ! *pm ) {
3195
- p1 = q1 + k*i1;
3196
- p2 = q2 + k*i2;
3197
- p3 = q3 + k*i3;
3198
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern("<="), 1, (*p2))) ? 1 : 0; }
3199
- }
3200
- }
3201
- } else {
3202
- for (k=0; k<n; k++) {
3203
- p1 = q1 + k*i1;
3204
- p2 = q2 + k*i2;
3205
- p3 = q3 + k*i3;
3206
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern("<="), 1, (*p2))) ? 1 : 0; }
3207
- }
3208
- }
3209
- }
3210
-
3211
- ca_bincmp_func_t
3212
- ca_bincmp_le[CA_NTYPE] = {
3213
- ca_bincmp_le_fixlen,
3214
- ca_bincmp_le_boolean8_t,
3215
- ca_bincmp_le_int8_t,
3216
- ca_bincmp_le_uint8_t,
3217
- ca_bincmp_le_int16_t,
3218
- ca_bincmp_le_uint16_t,
3219
- ca_bincmp_le_int32_t,
3220
- ca_bincmp_le_uint32_t,
3221
- ca_bincmp_le_int64_t,
3222
- ca_bincmp_le_uint64_t,
3223
- ca_bincmp_le_float32_t,
3224
- ca_bincmp_le_float64_t,
3225
- ca_bincmp_not_implement,
3226
- ca_bincmp_not_implement,
3227
- ca_bincmp_not_implement,
3228
- ca_bincmp_not_implement,
3229
- ca_bincmp_le_VALUE,
3230
- };
3231
-
3232
- VALUE rb_ca_le (VALUE self, VALUE other)
3233
- {
3234
- if ( ! rb_ca_test_castable(other) ) {
3235
- return rb_ca_binop_pass_to_other(self, other, rb_intern("le"));
3236
- }
3237
- return rb_ca_call_bincmp(self, other, ca_bincmp_le, 0.0);
3238
- }
3239
-
3240
- /* ===== bincmp match ============================================ */
3241
-
3242
- static void
3243
- ca_bincmp_match_fixlen (ca_size_t n, boolean8_t *m,
3244
- char *ptr1, ca_size_t b1, ca_size_t i1,
3245
- char *ptr2, ca_size_t b2, ca_size_t i2,
3246
- char *ptr3, ca_size_t b3, ca_size_t i3,
3247
- double tol)
3248
- {
3249
- char *q1 = ptr1, *q2 = ptr2;
3250
- char *p1 = q1, *p2 = q2;
3251
- boolean8_t *q3 = (boolean8_t *) ptr3;
3252
- boolean8_t *p3 = q3;
3253
- ca_size_t s1 = b1*i1, s2 = b2*i2, s3 = b3*i3;
3254
- ca_size_t k;
3255
- (void) tol;
3256
- if ( m ) {
3257
- boolean8_t *pm;
3258
- for (k=0; k<n; k++) {
3259
- pm = m + k;
3260
- if ( ! *pm ) {
3261
- p1 = q1 + k*s1;
3262
- p2 = q2 + k*s2;
3263
- p3 = q3 + k*s3;
3264
- {
3265
- (*p3) = RTEST(rb_funcall(rb_str_new(p1,b1), rb_intern("=~"), 1, (*p2)));
3266
- }
3267
- }
3268
- }
3269
- } else {
3270
- for (k=0; k<n; k++) {
3271
- p1 = q1 + k*s1;
3272
- p2 = q2 + k*s2;
3273
- p3 = q3 + k*s3;
3274
- {
3275
- (*p3) = RTEST(rb_funcall(rb_str_new(p1,b1), rb_intern("=~"), 1, (*p2)));
3276
- }
3277
- }
3278
- }
3279
- }
3280
-
3281
- static void
3282
- ca_bincmp_match_VALUE (ca_size_t n, boolean8_t *m,
3283
- char *ptr1, ca_size_t b1, ca_size_t i1,
3284
- char *ptr2, ca_size_t b2, ca_size_t i2,
3285
- char *ptr3, ca_size_t b3, ca_size_t i3,
3286
- double tol)
3287
- {
3288
- VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
3289
- VALUE *p1 = q1, *p2 = q2;
3290
- boolean8_t *q3 = (boolean8_t *) ptr3;
3291
- boolean8_t *p3 = q3;
3292
- ca_size_t k;
3293
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3294
- (void) tol;
3295
- if ( m ) {
3296
- boolean8_t *pm;
3297
- for (k=0; k<n; k++) {
3298
- pm = m + k;
3299
- if ( ! *pm ) {
3300
- p1 = q1 + k*i1;
3301
- p2 = q2 + k*i2;
3302
- p3 = q3 + k*i3;
3303
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=~"), 1, (*p2))); }
3304
- }
3305
- }
3306
- } else {
3307
- for (k=0; k<n; k++) {
3308
- p1 = q1 + k*i1;
3309
- p2 = q2 + k*i2;
3310
- p3 = q3 + k*i3;
3311
- { (*p3) = RTEST(rb_funcall((*p1), rb_intern("=~"), 1, (*p2))); }
3312
- }
3313
- }
3314
- }
3315
-
3316
- ca_bincmp_func_t
3317
- ca_bincmp_match[CA_NTYPE] = {
3318
- ca_bincmp_match_fixlen,
3319
- ca_bincmp_not_implement,
3320
- ca_bincmp_not_implement,
3321
- ca_bincmp_not_implement,
3322
- ca_bincmp_not_implement,
3323
- ca_bincmp_not_implement,
3324
- ca_bincmp_not_implement,
3325
- ca_bincmp_not_implement,
3326
- ca_bincmp_not_implement,
3327
- ca_bincmp_not_implement,
3328
- ca_bincmp_not_implement,
3329
- ca_bincmp_not_implement,
3330
- ca_bincmp_not_implement,
3331
- ca_bincmp_not_implement,
3332
- ca_bincmp_not_implement,
3333
- ca_bincmp_not_implement,
3334
- ca_bincmp_match_VALUE,
3335
- };
3336
-
3337
- VALUE rb_ca_match (VALUE self, VALUE other)
3338
- {
3339
- if ( ! rb_ca_test_castable(other) ) {
3340
- return rb_ca_binop_pass_to_other(self, other, rb_intern("match"));
3341
- }
3342
- return rb_ca_call_bincmp(self, other, ca_bincmp_match, 0.0);
3343
- }
3344
-
3345
- /* ===== bincmp is_kind_of ============================================ */
3346
-
3347
- static void
3348
- ca_bincmp_is_kind_of_VALUE (ca_size_t n, boolean8_t *m,
3349
- char *ptr1, ca_size_t b1, ca_size_t i1,
3350
- char *ptr2, ca_size_t b2, ca_size_t i2,
3351
- char *ptr3, ca_size_t b3, ca_size_t i3,
3352
- double tol)
3353
- {
3354
- VALUE *q1 = (VALUE *) ptr1, *q2 = (VALUE *) ptr2;
3355
- VALUE *p1 = q1, *p2 = q2;
3356
- boolean8_t *q3 = (boolean8_t *) ptr3;
3357
- boolean8_t *p3 = q3;
3358
- ca_size_t k;
3359
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3360
- (void) tol;
3361
- if ( m ) {
3362
- boolean8_t *pm;
3363
- for (k=0; k<n; k++) {
3364
- pm = m + k;
3365
- if ( ! *pm ) {
3366
- p1 = q1 + k*i1;
3367
- p2 = q2 + k*i2;
3368
- p3 = q3 + k*i3;
3369
- { (*p3) = RTEST(rb_obj_is_kind_of((*p1), (*p2))); }
3370
- }
3371
- }
3372
- } else {
3373
- for (k=0; k<n; k++) {
3374
- p1 = q1 + k*i1;
3375
- p2 = q2 + k*i2;
3376
- p3 = q3 + k*i3;
3377
- { (*p3) = RTEST(rb_obj_is_kind_of((*p1), (*p2))); }
3378
- }
3379
- }
3380
- }
3381
-
3382
- ca_bincmp_func_t
3383
- ca_bincmp_is_kind_of[CA_NTYPE] = {
3384
- ca_bincmp_not_implement,
3385
- ca_bincmp_not_implement,
3386
- ca_bincmp_not_implement,
3387
- ca_bincmp_not_implement,
3388
- ca_bincmp_not_implement,
3389
- ca_bincmp_not_implement,
3390
- ca_bincmp_not_implement,
3391
- ca_bincmp_not_implement,
3392
- ca_bincmp_not_implement,
3393
- ca_bincmp_not_implement,
3394
- ca_bincmp_not_implement,
3395
- ca_bincmp_not_implement,
3396
- ca_bincmp_not_implement,
3397
- ca_bincmp_not_implement,
3398
- ca_bincmp_not_implement,
3399
- ca_bincmp_not_implement,
3400
- ca_bincmp_is_kind_of_VALUE,
3401
- };
3402
-
3403
- VALUE rb_ca_is_kind_of (VALUE self, VALUE other)
3404
- {
3405
- if ( ! rb_ca_test_castable(other) ) {
3406
- return rb_ca_binop_pass_to_other(self, other, rb_intern("is_kind_of"));
3407
- }
3408
- return rb_ca_call_bincmp(self, other, ca_bincmp_is_kind_of, 0.0);
3409
- }
3410
-
3411
- /* ===== bincmp is_close ============================================ */
3412
-
3413
- static void
3414
- ca_bincmp_is_close_int8_t (ca_size_t n, boolean8_t *m,
3415
- char *ptr1, ca_size_t b1, ca_size_t i1,
3416
- char *ptr2, ca_size_t b2, ca_size_t i2,
3417
- char *ptr3, ca_size_t b3, ca_size_t i3,
3418
- double tol)
3419
- {
3420
- int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
3421
- int8_t *p1 = q1, *p2 = q2;
3422
- boolean8_t *q3 = (boolean8_t *) ptr3;
3423
- boolean8_t *p3 = q3;
3424
- ca_size_t k;
3425
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3426
-
3427
- if ( m ) {
3428
- boolean8_t *pm;
3429
- for (k=0; k<n; k++) {
3430
- pm = m + k;
3431
- if ( ! *pm ) {
3432
- p1 = q1 + k*i1;
3433
- p2 = q2 + k*i2;
3434
- p3 = q3 + k*i3;
3435
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3436
- }
3437
- }
3438
- } else {
3439
- for (k=0; k<n; k++) {
3440
- p1 = q1 + k*i1;
3441
- p2 = q2 + k*i2;
3442
- p3 = q3 + k*i3;
3443
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3444
- }
3445
- }
3446
- }
3447
-
3448
- static void
3449
- ca_bincmp_is_close_uint8_t (ca_size_t n, boolean8_t *m,
3450
- char *ptr1, ca_size_t b1, ca_size_t i1,
3451
- char *ptr2, ca_size_t b2, ca_size_t i2,
3452
- char *ptr3, ca_size_t b3, ca_size_t i3,
3453
- double tol)
3454
- {
3455
- uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
3456
- uint8_t *p1 = q1, *p2 = q2;
3457
- boolean8_t *q3 = (boolean8_t *) ptr3;
3458
- boolean8_t *p3 = q3;
3459
- ca_size_t k;
3460
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3461
-
3462
- if ( m ) {
3463
- boolean8_t *pm;
3464
- for (k=0; k<n; k++) {
3465
- pm = m + k;
3466
- if ( ! *pm ) {
3467
- p1 = q1 + k*i1;
3468
- p2 = q2 + k*i2;
3469
- p3 = q3 + k*i3;
3470
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3471
- }
3472
- }
3473
- } else {
3474
- for (k=0; k<n; k++) {
3475
- p1 = q1 + k*i1;
3476
- p2 = q2 + k*i2;
3477
- p3 = q3 + k*i3;
3478
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3479
- }
3480
- }
3481
- }
3482
-
3483
- static void
3484
- ca_bincmp_is_close_int16_t (ca_size_t n, boolean8_t *m,
3485
- char *ptr1, ca_size_t b1, ca_size_t i1,
3486
- char *ptr2, ca_size_t b2, ca_size_t i2,
3487
- char *ptr3, ca_size_t b3, ca_size_t i3,
3488
- double tol)
3489
- {
3490
- int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
3491
- int16_t *p1 = q1, *p2 = q2;
3492
- boolean8_t *q3 = (boolean8_t *) ptr3;
3493
- boolean8_t *p3 = q3;
3494
- ca_size_t k;
3495
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3496
-
3497
- if ( m ) {
3498
- boolean8_t *pm;
3499
- for (k=0; k<n; k++) {
3500
- pm = m + k;
3501
- if ( ! *pm ) {
3502
- p1 = q1 + k*i1;
3503
- p2 = q2 + k*i2;
3504
- p3 = q3 + k*i3;
3505
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3506
- }
3507
- }
3508
- } else {
3509
- for (k=0; k<n; k++) {
3510
- p1 = q1 + k*i1;
3511
- p2 = q2 + k*i2;
3512
- p3 = q3 + k*i3;
3513
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3514
- }
3515
- }
3516
- }
3517
-
3518
- static void
3519
- ca_bincmp_is_close_uint16_t (ca_size_t n, boolean8_t *m,
3520
- char *ptr1, ca_size_t b1, ca_size_t i1,
3521
- char *ptr2, ca_size_t b2, ca_size_t i2,
3522
- char *ptr3, ca_size_t b3, ca_size_t i3,
3523
- double tol)
3524
- {
3525
- uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
3526
- uint16_t *p1 = q1, *p2 = q2;
3527
- boolean8_t *q3 = (boolean8_t *) ptr3;
3528
- boolean8_t *p3 = q3;
3529
- ca_size_t k;
3530
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3531
-
3532
- if ( m ) {
3533
- boolean8_t *pm;
3534
- for (k=0; k<n; k++) {
3535
- pm = m + k;
3536
- if ( ! *pm ) {
3537
- p1 = q1 + k*i1;
3538
- p2 = q2 + k*i2;
3539
- p3 = q3 + k*i3;
3540
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3541
- }
3542
- }
3543
- } else {
3544
- for (k=0; k<n; k++) {
3545
- p1 = q1 + k*i1;
3546
- p2 = q2 + k*i2;
3547
- p3 = q3 + k*i3;
3548
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3549
- }
3550
- }
3551
- }
3552
-
3553
- static void
3554
- ca_bincmp_is_close_int32_t (ca_size_t n, boolean8_t *m,
3555
- char *ptr1, ca_size_t b1, ca_size_t i1,
3556
- char *ptr2, ca_size_t b2, ca_size_t i2,
3557
- char *ptr3, ca_size_t b3, ca_size_t i3,
3558
- double tol)
3559
- {
3560
- int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
3561
- int32_t *p1 = q1, *p2 = q2;
3562
- boolean8_t *q3 = (boolean8_t *) ptr3;
3563
- boolean8_t *p3 = q3;
3564
- ca_size_t k;
3565
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3566
-
3567
- if ( m ) {
3568
- boolean8_t *pm;
3569
- for (k=0; k<n; k++) {
3570
- pm = m + k;
3571
- if ( ! *pm ) {
3572
- p1 = q1 + k*i1;
3573
- p2 = q2 + k*i2;
3574
- p3 = q3 + k*i3;
3575
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3576
- }
3577
- }
3578
- } else {
3579
- for (k=0; k<n; k++) {
3580
- p1 = q1 + k*i1;
3581
- p2 = q2 + k*i2;
3582
- p3 = q3 + k*i3;
3583
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3584
- }
3585
- }
3586
- }
3587
-
3588
- static void
3589
- ca_bincmp_is_close_uint32_t (ca_size_t n, boolean8_t *m,
3590
- char *ptr1, ca_size_t b1, ca_size_t i1,
3591
- char *ptr2, ca_size_t b2, ca_size_t i2,
3592
- char *ptr3, ca_size_t b3, ca_size_t i3,
3593
- double tol)
3594
- {
3595
- uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
3596
- uint32_t *p1 = q1, *p2 = q2;
3597
- boolean8_t *q3 = (boolean8_t *) ptr3;
3598
- boolean8_t *p3 = q3;
3599
- ca_size_t k;
3600
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3601
-
3602
- if ( m ) {
3603
- boolean8_t *pm;
3604
- for (k=0; k<n; k++) {
3605
- pm = m + k;
3606
- if ( ! *pm ) {
3607
- p1 = q1 + k*i1;
3608
- p2 = q2 + k*i2;
3609
- p3 = q3 + k*i3;
3610
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3611
- }
3612
- }
3613
- } else {
3614
- for (k=0; k<n; k++) {
3615
- p1 = q1 + k*i1;
3616
- p2 = q2 + k*i2;
3617
- p3 = q3 + k*i3;
3618
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3619
- }
3620
- }
3621
- }
3622
-
3623
- static void
3624
- ca_bincmp_is_close_int64_t (ca_size_t n, boolean8_t *m,
3625
- char *ptr1, ca_size_t b1, ca_size_t i1,
3626
- char *ptr2, ca_size_t b2, ca_size_t i2,
3627
- char *ptr3, ca_size_t b3, ca_size_t i3,
3628
- double tol)
3629
- {
3630
- int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
3631
- int64_t *p1 = q1, *p2 = q2;
3632
- boolean8_t *q3 = (boolean8_t *) ptr3;
3633
- boolean8_t *p3 = q3;
3634
- ca_size_t k;
3635
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3636
-
3637
- if ( m ) {
3638
- boolean8_t *pm;
3639
- for (k=0; k<n; k++) {
3640
- pm = m + k;
3641
- if ( ! *pm ) {
3642
- p1 = q1 + k*i1;
3643
- p2 = q2 + k*i2;
3644
- p3 = q3 + k*i3;
3645
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3646
- }
3647
- }
3648
- } else {
3649
- for (k=0; k<n; k++) {
3650
- p1 = q1 + k*i1;
3651
- p2 = q2 + k*i2;
3652
- p3 = q3 + k*i3;
3653
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3654
- }
3655
- }
3656
- }
3657
-
3658
- static void
3659
- ca_bincmp_is_close_uint64_t (ca_size_t n, boolean8_t *m,
3660
- char *ptr1, ca_size_t b1, ca_size_t i1,
3661
- char *ptr2, ca_size_t b2, ca_size_t i2,
3662
- char *ptr3, ca_size_t b3, ca_size_t i3,
3663
- double tol)
3664
- {
3665
- uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
3666
- uint64_t *p1 = q1, *p2 = q2;
3667
- boolean8_t *q3 = (boolean8_t *) ptr3;
3668
- boolean8_t *p3 = q3;
3669
- ca_size_t k;
3670
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3671
-
3672
- if ( m ) {
3673
- boolean8_t *pm;
3674
- for (k=0; k<n; k++) {
3675
- pm = m + k;
3676
- if ( ! *pm ) {
3677
- p1 = q1 + k*i1;
3678
- p2 = q2 + k*i2;
3679
- p3 = q3 + k*i3;
3680
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3681
- }
3682
- }
3683
- } else {
3684
- for (k=0; k<n; k++) {
3685
- p1 = q1 + k*i1;
3686
- p2 = q2 + k*i2;
3687
- p3 = q3 + k*i3;
3688
- { (*p3) = (fabs((double)(*p1) - (double)(*p2)) <= tol) ? 1 : 0; }
3689
- }
3690
- }
3691
- }
3692
-
3693
- static void
3694
- ca_bincmp_is_close_float32_t (ca_size_t n, boolean8_t *m,
3695
- char *ptr1, ca_size_t b1, ca_size_t i1,
3696
- char *ptr2, ca_size_t b2, ca_size_t i2,
3697
- char *ptr3, ca_size_t b3, ca_size_t i3,
3698
- double tol)
3699
- {
3700
- float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
3701
- float *p1 = q1, *p2 = q2;
3702
- boolean8_t *q3 = (boolean8_t *) ptr3;
3703
- boolean8_t *p3 = q3;
3704
- ca_size_t k;
3705
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3706
-
3707
- if ( m ) {
3708
- boolean8_t *pm;
3709
- for (k=0; k<n; k++) {
3710
- pm = m + k;
3711
- if ( ! *pm ) {
3712
- p1 = q1 + k*i1;
3713
- p2 = q2 + k*i2;
3714
- p3 = q3 + k*i3;
3715
- { (*p3) = (fabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
3716
- }
3717
- }
3718
- } else {
3719
- for (k=0; k<n; k++) {
3720
- p1 = q1 + k*i1;
3721
- p2 = q2 + k*i2;
3722
- p3 = q3 + k*i3;
3723
- { (*p3) = (fabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
3724
- }
3725
- }
3726
- }
3727
-
3728
- static void
3729
- ca_bincmp_is_close_float64_t (ca_size_t n, boolean8_t *m,
3730
- char *ptr1, ca_size_t b1, ca_size_t i1,
3731
- char *ptr2, ca_size_t b2, ca_size_t i2,
3732
- char *ptr3, ca_size_t b3, ca_size_t i3,
3733
- double tol)
3734
- {
3735
- double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
3736
- double *p1 = q1, *p2 = q2;
3737
- boolean8_t *q3 = (boolean8_t *) ptr3;
3738
- boolean8_t *p3 = q3;
3739
- ca_size_t k;
3740
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3741
-
3742
- if ( m ) {
3743
- boolean8_t *pm;
3744
- for (k=0; k<n; k++) {
3745
- pm = m + k;
3746
- if ( ! *pm ) {
3747
- p1 = q1 + k*i1;
3748
- p2 = q2 + k*i2;
3749
- p3 = q3 + k*i3;
3750
- { (*p3) = (fabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
3751
- }
3752
- }
3753
- } else {
3754
- for (k=0; k<n; k++) {
3755
- p1 = q1 + k*i1;
3756
- p2 = q2 + k*i2;
3757
- p3 = q3 + k*i3;
3758
- { (*p3) = (fabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
3759
- }
3760
- }
3761
- }
3762
-
3763
- static void
3764
- ca_bincmp_is_close_cmplx64_t (ca_size_t n, boolean8_t *m,
3765
- char *ptr1, ca_size_t b1, ca_size_t i1,
3766
- char *ptr2, ca_size_t b2, ca_size_t i2,
3767
- char *ptr3, ca_size_t b3, ca_size_t i3,
3768
- double tol)
3769
- {
3770
- cmplx64_t *q1 = (cmplx64_t *) ptr1, *q2 = (cmplx64_t *) ptr2;
3771
- cmplx64_t *p1 = q1, *p2 = q2;
3772
- boolean8_t *q3 = (boolean8_t *) ptr3;
3773
- boolean8_t *p3 = q3;
3774
- ca_size_t k;
3775
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3776
-
3777
- if ( m ) {
3778
- boolean8_t *pm;
3779
- for (k=0; k<n; k++) {
3780
- pm = m + k;
3781
- if ( ! *pm ) {
3782
- p1 = q1 + k*i1;
3783
- p2 = q2 + k*i2;
3784
- p3 = q3 + k*i3;
3785
- { (*p3) = (cabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
3786
- }
3787
- }
3788
- } else {
3789
- for (k=0; k<n; k++) {
3790
- p1 = q1 + k*i1;
3791
- p2 = q2 + k*i2;
3792
- p3 = q3 + k*i3;
3793
- { (*p3) = (cabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
3794
- }
3795
- }
3796
- }
3797
-
3798
- static void
3799
- ca_bincmp_is_close_cmplx128_t (ca_size_t n, boolean8_t *m,
3800
- char *ptr1, ca_size_t b1, ca_size_t i1,
3801
- char *ptr2, ca_size_t b2, ca_size_t i2,
3802
- char *ptr3, ca_size_t b3, ca_size_t i3,
3803
- double tol)
3804
- {
3805
- cmplx128_t *q1 = (cmplx128_t *) ptr1, *q2 = (cmplx128_t *) ptr2;
3806
- cmplx128_t *p1 = q1, *p2 = q2;
3807
- boolean8_t *q3 = (boolean8_t *) ptr3;
3808
- boolean8_t *p3 = q3;
3809
- ca_size_t k;
3810
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3811
-
3812
- if ( m ) {
3813
- boolean8_t *pm;
3814
- for (k=0; k<n; k++) {
3815
- pm = m + k;
3816
- if ( ! *pm ) {
3817
- p1 = q1 + k*i1;
3818
- p2 = q2 + k*i2;
3819
- p3 = q3 + k*i3;
3820
- { (*p3) = (cabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
3821
- }
3822
- }
3823
- } else {
3824
- for (k=0; k<n; k++) {
3825
- p1 = q1 + k*i1;
3826
- p2 = q2 + k*i2;
3827
- p3 = q3 + k*i3;
3828
- { (*p3) = (cabs((*p1) - (*p2)) <= tol) ? 1 : 0; }
3829
- }
3830
- }
3831
- }
3832
-
3833
- ca_bincmp_func_t
3834
- ca_bincmp_is_close[CA_NTYPE] = {
3835
- ca_bincmp_not_implement,
3836
- ca_bincmp_not_implement,
3837
- ca_bincmp_is_close_int8_t,
3838
- ca_bincmp_is_close_uint8_t,
3839
- ca_bincmp_is_close_int16_t,
3840
- ca_bincmp_is_close_uint16_t,
3841
- ca_bincmp_is_close_int32_t,
3842
- ca_bincmp_is_close_uint32_t,
3843
- ca_bincmp_is_close_int64_t,
3844
- ca_bincmp_is_close_uint64_t,
3845
- ca_bincmp_is_close_float32_t,
3846
- ca_bincmp_is_close_float64_t,
3847
- ca_bincmp_not_implement,
3848
- ca_bincmp_is_close_cmplx64_t,
3849
- ca_bincmp_is_close_cmplx128_t,
3850
- ca_bincmp_not_implement,
3851
- ca_bincmp_not_implement,
3852
- };
3853
-
3854
- VALUE rb_ca_is_close (VALUE self, VALUE other, VALUE tol_val)
3855
- {
3856
- double tol = fabs(NUM2DBL(tol_val));
3857
- if ( ! rb_ca_test_castable(other) ) {
3858
- return rb_funcall(other, rb_intern("is_close"), 2, self, tol_val);
3859
- }
3860
- return rb_ca_call_bincmp(self, other, ca_bincmp_is_close, tol);
3861
- }
3862
-
3863
- /* ===== bincmp is_equiv ============================================ */
3864
-
3865
- static void
3866
- ca_bincmp_is_equiv_int8_t (ca_size_t n, boolean8_t *m,
3867
- char *ptr1, ca_size_t b1, ca_size_t i1,
3868
- char *ptr2, ca_size_t b2, ca_size_t i2,
3869
- char *ptr3, ca_size_t b3, ca_size_t i3,
3870
- double tol)
3871
- {
3872
- int8_t *q1 = (int8_t *) ptr1, *q2 = (int8_t *) ptr2;
3873
- int8_t *p1 = q1, *p2 = q2;
3874
- boolean8_t *q3 = (boolean8_t *) ptr3;
3875
- boolean8_t *p3 = q3;
3876
- ca_size_t k;
3877
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3878
-
3879
- if ( m ) {
3880
- boolean8_t *pm;
3881
- for (k=0; k<n; k++) {
3882
- pm = m + k;
3883
- if ( ! *pm ) {
3884
- p1 = q1 + k*i1;
3885
- p2 = q2 + k*i2;
3886
- p3 = q3 + k*i3;
3887
- {
3888
- double a = (double)(*p1), b = (double)(*p2);
3889
- double aa = fabs(a), ab = fabs(b);
3890
- double m = (aa > ab) ? aa : ab;
3891
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
3892
- }
3893
- }
3894
- }
3895
- } else {
3896
- for (k=0; k<n; k++) {
3897
- p1 = q1 + k*i1;
3898
- p2 = q2 + k*i2;
3899
- p3 = q3 + k*i3;
3900
- {
3901
- double a = (double)(*p1), b = (double)(*p2);
3902
- double aa = fabs(a), ab = fabs(b);
3903
- double m = (aa > ab) ? aa : ab;
3904
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
3905
- }
3906
- }
3907
- }
3908
- }
3909
-
3910
- static void
3911
- ca_bincmp_is_equiv_uint8_t (ca_size_t n, boolean8_t *m,
3912
- char *ptr1, ca_size_t b1, ca_size_t i1,
3913
- char *ptr2, ca_size_t b2, ca_size_t i2,
3914
- char *ptr3, ca_size_t b3, ca_size_t i3,
3915
- double tol)
3916
- {
3917
- uint8_t *q1 = (uint8_t *) ptr1, *q2 = (uint8_t *) ptr2;
3918
- uint8_t *p1 = q1, *p2 = q2;
3919
- boolean8_t *q3 = (boolean8_t *) ptr3;
3920
- boolean8_t *p3 = q3;
3921
- ca_size_t k;
3922
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3923
-
3924
- if ( m ) {
3925
- boolean8_t *pm;
3926
- for (k=0; k<n; k++) {
3927
- pm = m + k;
3928
- if ( ! *pm ) {
3929
- p1 = q1 + k*i1;
3930
- p2 = q2 + k*i2;
3931
- p3 = q3 + k*i3;
3932
- {
3933
- double a = (double)(*p1), b = (double)(*p2);
3934
- double aa = fabs(a), ab = fabs(b);
3935
- double m = (aa > ab) ? aa : ab;
3936
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
3937
- }
3938
- }
3939
- }
3940
- } else {
3941
- for (k=0; k<n; k++) {
3942
- p1 = q1 + k*i1;
3943
- p2 = q2 + k*i2;
3944
- p3 = q3 + k*i3;
3945
- {
3946
- double a = (double)(*p1), b = (double)(*p2);
3947
- double aa = fabs(a), ab = fabs(b);
3948
- double m = (aa > ab) ? aa : ab;
3949
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
3950
- }
3951
- }
3952
- }
3953
- }
3954
-
3955
- static void
3956
- ca_bincmp_is_equiv_int16_t (ca_size_t n, boolean8_t *m,
3957
- char *ptr1, ca_size_t b1, ca_size_t i1,
3958
- char *ptr2, ca_size_t b2, ca_size_t i2,
3959
- char *ptr3, ca_size_t b3, ca_size_t i3,
3960
- double tol)
3961
- {
3962
- int16_t *q1 = (int16_t *) ptr1, *q2 = (int16_t *) ptr2;
3963
- int16_t *p1 = q1, *p2 = q2;
3964
- boolean8_t *q3 = (boolean8_t *) ptr3;
3965
- boolean8_t *p3 = q3;
3966
- ca_size_t k;
3967
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
3968
-
3969
- if ( m ) {
3970
- boolean8_t *pm;
3971
- for (k=0; k<n; k++) {
3972
- pm = m + k;
3973
- if ( ! *pm ) {
3974
- p1 = q1 + k*i1;
3975
- p2 = q2 + k*i2;
3976
- p3 = q3 + k*i3;
3977
- {
3978
- double a = (double)(*p1), b = (double)(*p2);
3979
- double aa = fabs(a), ab = fabs(b);
3980
- double m = (aa > ab) ? aa : ab;
3981
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
3982
- }
3983
- }
3984
- }
3985
- } else {
3986
- for (k=0; k<n; k++) {
3987
- p1 = q1 + k*i1;
3988
- p2 = q2 + k*i2;
3989
- p3 = q3 + k*i3;
3990
- {
3991
- double a = (double)(*p1), b = (double)(*p2);
3992
- double aa = fabs(a), ab = fabs(b);
3993
- double m = (aa > ab) ? aa : ab;
3994
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
3995
- }
3996
- }
3997
- }
3998
- }
3999
-
4000
- static void
4001
- ca_bincmp_is_equiv_uint16_t (ca_size_t n, boolean8_t *m,
4002
- char *ptr1, ca_size_t b1, ca_size_t i1,
4003
- char *ptr2, ca_size_t b2, ca_size_t i2,
4004
- char *ptr3, ca_size_t b3, ca_size_t i3,
4005
- double tol)
4006
- {
4007
- uint16_t *q1 = (uint16_t *) ptr1, *q2 = (uint16_t *) ptr2;
4008
- uint16_t *p1 = q1, *p2 = q2;
4009
- boolean8_t *q3 = (boolean8_t *) ptr3;
4010
- boolean8_t *p3 = q3;
4011
- ca_size_t k;
4012
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
4013
-
4014
- if ( m ) {
4015
- boolean8_t *pm;
4016
- for (k=0; k<n; k++) {
4017
- pm = m + k;
4018
- if ( ! *pm ) {
4019
- p1 = q1 + k*i1;
4020
- p2 = q2 + k*i2;
4021
- p3 = q3 + k*i3;
4022
- {
4023
- double a = (double)(*p1), b = (double)(*p2);
4024
- double aa = fabs(a), ab = fabs(b);
4025
- double m = (aa > ab) ? aa : ab;
4026
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
4027
- }
4028
- }
4029
- }
4030
- } else {
4031
- for (k=0; k<n; k++) {
4032
- p1 = q1 + k*i1;
4033
- p2 = q2 + k*i2;
4034
- p3 = q3 + k*i3;
4035
- {
4036
- double a = (double)(*p1), b = (double)(*p2);
4037
- double aa = fabs(a), ab = fabs(b);
4038
- double m = (aa > ab) ? aa : ab;
4039
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
4040
- }
4041
- }
4042
- }
4043
- }
4044
-
4045
- static void
4046
- ca_bincmp_is_equiv_int32_t (ca_size_t n, boolean8_t *m,
4047
- char *ptr1, ca_size_t b1, ca_size_t i1,
4048
- char *ptr2, ca_size_t b2, ca_size_t i2,
4049
- char *ptr3, ca_size_t b3, ca_size_t i3,
4050
- double tol)
4051
- {
4052
- int32_t *q1 = (int32_t *) ptr1, *q2 = (int32_t *) ptr2;
4053
- int32_t *p1 = q1, *p2 = q2;
4054
- boolean8_t *q3 = (boolean8_t *) ptr3;
4055
- boolean8_t *p3 = q3;
4056
- ca_size_t k;
4057
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
4058
-
4059
- if ( m ) {
4060
- boolean8_t *pm;
4061
- for (k=0; k<n; k++) {
4062
- pm = m + k;
4063
- if ( ! *pm ) {
4064
- p1 = q1 + k*i1;
4065
- p2 = q2 + k*i2;
4066
- p3 = q3 + k*i3;
4067
- {
4068
- double a = (double)(*p1), b = (double)(*p2);
4069
- double aa = fabs(a), ab = fabs(b);
4070
- double m = (aa > ab) ? aa : ab;
4071
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
4072
- }
4073
- }
4074
- }
4075
- } else {
4076
- for (k=0; k<n; k++) {
4077
- p1 = q1 + k*i1;
4078
- p2 = q2 + k*i2;
4079
- p3 = q3 + k*i3;
4080
- {
4081
- double a = (double)(*p1), b = (double)(*p2);
4082
- double aa = fabs(a), ab = fabs(b);
4083
- double m = (aa > ab) ? aa : ab;
4084
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
4085
- }
4086
- }
4087
- }
4088
- }
4089
-
4090
- static void
4091
- ca_bincmp_is_equiv_uint32_t (ca_size_t n, boolean8_t *m,
4092
- char *ptr1, ca_size_t b1, ca_size_t i1,
4093
- char *ptr2, ca_size_t b2, ca_size_t i2,
4094
- char *ptr3, ca_size_t b3, ca_size_t i3,
4095
- double tol)
4096
- {
4097
- uint32_t *q1 = (uint32_t *) ptr1, *q2 = (uint32_t *) ptr2;
4098
- uint32_t *p1 = q1, *p2 = q2;
4099
- boolean8_t *q3 = (boolean8_t *) ptr3;
4100
- boolean8_t *p3 = q3;
4101
- ca_size_t k;
4102
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
4103
-
4104
- if ( m ) {
4105
- boolean8_t *pm;
4106
- for (k=0; k<n; k++) {
4107
- pm = m + k;
4108
- if ( ! *pm ) {
4109
- p1 = q1 + k*i1;
4110
- p2 = q2 + k*i2;
4111
- p3 = q3 + k*i3;
4112
- {
4113
- double a = (double)(*p1), b = (double)(*p2);
4114
- double aa = fabs(a), ab = fabs(b);
4115
- double m = (aa > ab) ? aa : ab;
4116
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
4117
- }
4118
- }
4119
- }
4120
- } else {
4121
- for (k=0; k<n; k++) {
4122
- p1 = q1 + k*i1;
4123
- p2 = q2 + k*i2;
4124
- p3 = q3 + k*i3;
4125
- {
4126
- double a = (double)(*p1), b = (double)(*p2);
4127
- double aa = fabs(a), ab = fabs(b);
4128
- double m = (aa > ab) ? aa : ab;
4129
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
4130
- }
4131
- }
4132
- }
4133
- }
4134
-
4135
- static void
4136
- ca_bincmp_is_equiv_int64_t (ca_size_t n, boolean8_t *m,
4137
- char *ptr1, ca_size_t b1, ca_size_t i1,
4138
- char *ptr2, ca_size_t b2, ca_size_t i2,
4139
- char *ptr3, ca_size_t b3, ca_size_t i3,
4140
- double tol)
4141
- {
4142
- int64_t *q1 = (int64_t *) ptr1, *q2 = (int64_t *) ptr2;
4143
- int64_t *p1 = q1, *p2 = q2;
4144
- boolean8_t *q3 = (boolean8_t *) ptr3;
4145
- boolean8_t *p3 = q3;
4146
- ca_size_t k;
4147
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
4148
-
4149
- if ( m ) {
4150
- boolean8_t *pm;
4151
- for (k=0; k<n; k++) {
4152
- pm = m + k;
4153
- if ( ! *pm ) {
4154
- p1 = q1 + k*i1;
4155
- p2 = q2 + k*i2;
4156
- p3 = q3 + k*i3;
4157
- {
4158
- double a = (double)(*p1), b = (double)(*p2);
4159
- double aa = fabs(a), ab = fabs(b);
4160
- double m = (aa > ab) ? aa : ab;
4161
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
4162
- }
4163
- }
4164
- }
4165
- } else {
4166
- for (k=0; k<n; k++) {
4167
- p1 = q1 + k*i1;
4168
- p2 = q2 + k*i2;
4169
- p3 = q3 + k*i3;
4170
- {
4171
- double a = (double)(*p1), b = (double)(*p2);
4172
- double aa = fabs(a), ab = fabs(b);
4173
- double m = (aa > ab) ? aa : ab;
4174
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
4175
- }
4176
- }
4177
- }
4178
- }
4179
-
4180
- static void
4181
- ca_bincmp_is_equiv_uint64_t (ca_size_t n, boolean8_t *m,
4182
- char *ptr1, ca_size_t b1, ca_size_t i1,
4183
- char *ptr2, ca_size_t b2, ca_size_t i2,
4184
- char *ptr3, ca_size_t b3, ca_size_t i3,
4185
- double tol)
4186
- {
4187
- uint64_t *q1 = (uint64_t *) ptr1, *q2 = (uint64_t *) ptr2;
4188
- uint64_t *p1 = q1, *p2 = q2;
4189
- boolean8_t *q3 = (boolean8_t *) ptr3;
4190
- boolean8_t *p3 = q3;
4191
- ca_size_t k;
4192
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
4193
-
4194
- if ( m ) {
4195
- boolean8_t *pm;
4196
- for (k=0; k<n; k++) {
4197
- pm = m + k;
4198
- if ( ! *pm ) {
4199
- p1 = q1 + k*i1;
4200
- p2 = q2 + k*i2;
4201
- p3 = q3 + k*i3;
4202
- {
4203
- double a = (double)(*p1), b = (double)(*p2);
4204
- double aa = fabs(a), ab = fabs(b);
4205
- double m = (aa > ab) ? aa : ab;
4206
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
4207
- }
4208
- }
4209
- }
4210
- } else {
4211
- for (k=0; k<n; k++) {
4212
- p1 = q1 + k*i1;
4213
- p2 = q2 + k*i2;
4214
- p3 = q3 + k*i3;
4215
- {
4216
- double a = (double)(*p1), b = (double)(*p2);
4217
- double aa = fabs(a), ab = fabs(b);
4218
- double m = (aa > ab) ? aa : ab;
4219
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs(a - b) / m <= tol) ) ? 1 : 0;
4220
- }
4221
- }
4222
- }
4223
- }
4224
-
4225
- static void
4226
- ca_bincmp_is_equiv_float32_t (ca_size_t n, boolean8_t *m,
4227
- char *ptr1, ca_size_t b1, ca_size_t i1,
4228
- char *ptr2, ca_size_t b2, ca_size_t i2,
4229
- char *ptr3, ca_size_t b3, ca_size_t i3,
4230
- double tol)
4231
- {
4232
- float *q1 = (float *) ptr1, *q2 = (float *) ptr2;
4233
- float *p1 = q1, *p2 = q2;
4234
- boolean8_t *q3 = (boolean8_t *) ptr3;
4235
- boolean8_t *p3 = q3;
4236
- ca_size_t k;
4237
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
4238
-
4239
- if ( m ) {
4240
- boolean8_t *pm;
4241
- for (k=0; k<n; k++) {
4242
- pm = m + k;
4243
- if ( ! *pm ) {
4244
- p1 = q1 + k*i1;
4245
- p2 = q2 + k*i2;
4246
- p3 = q3 + k*i3;
4247
- {
4248
- float aa = fabs((*p1)), ab = fabs((*p2));
4249
- float m = (aa > ab) ? aa : ab;
4250
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs((*p1) - (*p2)) / m <= tol) ) ? 1 : 0;
4251
- }
4252
- }
4253
- }
4254
- } else {
4255
- for (k=0; k<n; k++) {
4256
- p1 = q1 + k*i1;
4257
- p2 = q2 + k*i2;
4258
- p3 = q3 + k*i3;
4259
- {
4260
- float aa = fabs((*p1)), ab = fabs((*p2));
4261
- float m = (aa > ab) ? aa : ab;
4262
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs((*p1) - (*p2)) / m <= tol) ) ? 1 : 0;
4263
- }
4264
- }
4265
- }
4266
- }
4267
-
4268
- static void
4269
- ca_bincmp_is_equiv_float64_t (ca_size_t n, boolean8_t *m,
4270
- char *ptr1, ca_size_t b1, ca_size_t i1,
4271
- char *ptr2, ca_size_t b2, ca_size_t i2,
4272
- char *ptr3, ca_size_t b3, ca_size_t i3,
4273
- double tol)
4274
- {
4275
- double *q1 = (double *) ptr1, *q2 = (double *) ptr2;
4276
- double *p1 = q1, *p2 = q2;
4277
- boolean8_t *q3 = (boolean8_t *) ptr3;
4278
- boolean8_t *p3 = q3;
4279
- ca_size_t k;
4280
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
4281
-
4282
- if ( m ) {
4283
- boolean8_t *pm;
4284
- for (k=0; k<n; k++) {
4285
- pm = m + k;
4286
- if ( ! *pm ) {
4287
- p1 = q1 + k*i1;
4288
- p2 = q2 + k*i2;
4289
- p3 = q3 + k*i3;
4290
- {
4291
- double aa = fabs((*p1)), ab = fabs((*p2));
4292
- double m = (aa > ab) ? aa : ab;
4293
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs((*p1) - (*p2)) / m <= tol) ) ? 1 : 0;
4294
- }
4295
- }
4296
- }
4297
- } else {
4298
- for (k=0; k<n; k++) {
4299
- p1 = q1 + k*i1;
4300
- p2 = q2 + k*i2;
4301
- p3 = q3 + k*i3;
4302
- {
4303
- double aa = fabs((*p1)), ab = fabs((*p2));
4304
- double m = (aa > ab) ? aa : ab;
4305
- (*p3) = ( (*p1) == (*p2) || (m > 0 && fabs((*p1) - (*p2)) / m <= tol) ) ? 1 : 0;
4306
- }
4307
- }
4308
- }
4309
- }
4310
-
4311
- static void
4312
- ca_bincmp_is_equiv_cmplx64_t (ca_size_t n, boolean8_t *m,
4313
- char *ptr1, ca_size_t b1, ca_size_t i1,
4314
- char *ptr2, ca_size_t b2, ca_size_t i2,
4315
- char *ptr3, ca_size_t b3, ca_size_t i3,
4316
- double tol)
4317
- {
4318
- cmplx64_t *q1 = (cmplx64_t *) ptr1, *q2 = (cmplx64_t *) ptr2;
4319
- cmplx64_t *p1 = q1, *p2 = q2;
4320
- boolean8_t *q3 = (boolean8_t *) ptr3;
4321
- boolean8_t *p3 = q3;
4322
- ca_size_t k;
4323
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
4324
-
4325
- if ( m ) {
4326
- boolean8_t *pm;
4327
- for (k=0; k<n; k++) {
4328
- pm = m + k;
4329
- if ( ! *pm ) {
4330
- p1 = q1 + k*i1;
4331
- p2 = q2 + k*i2;
4332
- p3 = q3 + k*i3;
4333
- {
4334
- double aa = cabs((*p1)), ab = cabs((*p2));
4335
- double m = (aa > ab) ? aa : ab;
4336
- (*p3) = ( m > 0 && cabs((*p1) - (*p2)) / m <= tol ) ? 1 : 0;
4337
- }
4338
- }
4339
- }
4340
- } else {
4341
- for (k=0; k<n; k++) {
4342
- p1 = q1 + k*i1;
4343
- p2 = q2 + k*i2;
4344
- p3 = q3 + k*i3;
4345
- {
4346
- double aa = cabs((*p1)), ab = cabs((*p2));
4347
- double m = (aa > ab) ? aa : ab;
4348
- (*p3) = ( m > 0 && cabs((*p1) - (*p2)) / m <= tol ) ? 1 : 0;
4349
- }
4350
- }
4351
- }
4352
- }
4353
-
4354
- static void
4355
- ca_bincmp_is_equiv_cmplx128_t (ca_size_t n, boolean8_t *m,
4356
- char *ptr1, ca_size_t b1, ca_size_t i1,
4357
- char *ptr2, ca_size_t b2, ca_size_t i2,
4358
- char *ptr3, ca_size_t b3, ca_size_t i3,
4359
- double tol)
4360
- {
4361
- cmplx128_t *q1 = (cmplx128_t *) ptr1, *q2 = (cmplx128_t *) ptr2;
4362
- cmplx128_t *p1 = q1, *p2 = q2;
4363
- boolean8_t *q3 = (boolean8_t *) ptr3;
4364
- boolean8_t *p3 = q3;
4365
- ca_size_t k;
4366
- (void) b1; (void) b2; (void) b3; /* unused for non-fixlen kernels */
4367
-
4368
- if ( m ) {
4369
- boolean8_t *pm;
4370
- for (k=0; k<n; k++) {
4371
- pm = m + k;
4372
- if ( ! *pm ) {
4373
- p1 = q1 + k*i1;
4374
- p2 = q2 + k*i2;
4375
- p3 = q3 + k*i3;
4376
- {
4377
- double aa = cabs((*p1)), ab = cabs((*p2));
4378
- double m = (aa > ab) ? aa : ab;
4379
- (*p3) = ( m > 0 && cabs((*p1) - (*p2)) / m <= tol ) ? 1 : 0;
4380
- }
4381
- }
4382
- }
4383
- } else {
4384
- for (k=0; k<n; k++) {
4385
- p1 = q1 + k*i1;
4386
- p2 = q2 + k*i2;
4387
- p3 = q3 + k*i3;
4388
- {
4389
- double aa = cabs((*p1)), ab = cabs((*p2));
4390
- double m = (aa > ab) ? aa : ab;
4391
- (*p3) = ( m > 0 && cabs((*p1) - (*p2)) / m <= tol ) ? 1 : 0;
4392
- }
4393
- }
4394
- }
4395
- }
4396
-
4397
- ca_bincmp_func_t
4398
- ca_bincmp_is_equiv[CA_NTYPE] = {
4399
- ca_bincmp_not_implement,
4400
- ca_bincmp_not_implement,
4401
- ca_bincmp_is_equiv_int8_t,
4402
- ca_bincmp_is_equiv_uint8_t,
4403
- ca_bincmp_is_equiv_int16_t,
4404
- ca_bincmp_is_equiv_uint16_t,
4405
- ca_bincmp_is_equiv_int32_t,
4406
- ca_bincmp_is_equiv_uint32_t,
4407
- ca_bincmp_is_equiv_int64_t,
4408
- ca_bincmp_is_equiv_uint64_t,
4409
- ca_bincmp_is_equiv_float32_t,
4410
- ca_bincmp_is_equiv_float64_t,
4411
- ca_bincmp_not_implement,
4412
- ca_bincmp_is_equiv_cmplx64_t,
4413
- ca_bincmp_is_equiv_cmplx128_t,
4414
- ca_bincmp_not_implement,
4415
- ca_bincmp_not_implement,
4416
- };
4417
-
4418
- VALUE rb_ca_is_equiv (VALUE self, VALUE other, VALUE tol_val)
4419
- {
4420
- double tol = fabs(NUM2DBL(tol_val));
4421
- if ( ! rb_ca_test_castable(other) ) {
4422
- return rb_funcall(other, rb_intern("is_equiv"), 2, self, tol_val);
4423
- }
4424
- return rb_ca_call_bincmp(self, other, ca_bincmp_is_equiv, tol);
4425
- }
4426
-
4427
- void
4428
- Init_carray_kernels_bincmp (void)
4429
- {
4430
- rb_define_method(rb_cCArray, "feq", rb_ca_feq, 1);
4431
- rb_define_method(rb_cCArray, "eq", rb_ca_eq, 1);
4432
- rb_define_method(rb_cCArray, "ne", rb_ca_ne, 1);
4433
- rb_define_method(rb_cCArray, "gt", rb_ca_gt, 1);
4434
- rb_define_method(rb_cCArray, "lt", rb_ca_lt, 1);
4435
- rb_define_method(rb_cCArray, "ge", rb_ca_ge, 1);
4436
- rb_define_method(rb_cCArray, "le", rb_ca_le, 1);
4437
- rb_define_method(rb_cCArray, "match", rb_ca_match, 1);
4438
- rb_define_method(rb_cCArray, "is_kind_of", rb_ca_is_kind_of, 1);
4439
- rb_define_alias(rb_cCArray, ">", "gt");
4440
- rb_define_alias(rb_cCArray, "<", "lt");
4441
- rb_define_alias(rb_cCArray, ">=", "ge");
4442
- rb_define_alias(rb_cCArray, "<=", "le");
4443
- rb_define_alias(rb_cCArray, "=~", "match");
4444
- rb_define_method(rb_cCArray, "is_close", rb_ca_is_close, 2);
4445
- rb_define_method(rb_cCArray, "is_equiv", rb_ca_is_equiv, 2);
4446
- }