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