1 /*
2 * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 /*
25 * @test
26 * @key randomness
27 *
28 * @library /test/lib
29 * @modules jdk.incubator.vector
30 * @run testng/othervm/timeout=300 -ea -esa -Xbatch -XX:-TieredCompilation DoubleMaxVectorTests
31 */
32
33 // -- This file was mechanically generated: Do not edit! -- //
34
35 import jdk.incubator.vector.VectorShape;
36 import jdk.incubator.vector.VectorSpecies;
37 import jdk.incubator.vector.VectorShuffle;
38 import jdk.incubator.vector.VectorMask;
39 import jdk.incubator.vector.VectorOperators;
40 import jdk.incubator.vector.Vector;
41
42 import jdk.incubator.vector.DoubleVector;
43
44 import org.testng.Assert;
45 import org.testng.annotations.DataProvider;
46 import org.testng.annotations.Test;
47
48 import java.lang.Integer;
49 import java.util.List;
50 import java.util.Arrays;
51 import java.util.function.BiFunction;
52 import java.util.function.IntFunction;
53 import java.util.Objects;
54 import java.util.stream.Collectors;
55 import java.util.stream.Stream;
56
57 @Test
58 public class DoubleMaxVectorTests extends AbstractVectorTest {
59
60 static final VectorSpecies<Double> SPECIES =
61 DoubleVector.SPECIES_MAX;
62
63 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
64
65 static DoubleVector bcast_vec = DoubleVector.broadcast(SPECIES, (double)10);
66
67 static VectorShape getMaxBit() {
68 return VectorShape.S_Max_BIT;
69 }
70
71 private static final int Max = 256; // juts so we can do N/Max
72
73 // for floating point addition reduction ops that may introduce rounding errors
74 private static final double RELATIVE_ROUNDING_ERROR_FACTOR_ADD = (double)10.0;
75
76 // for floating point multiplication reduction ops that may introduce rounding errors
77 private static final double RELATIVE_ROUNDING_ERROR_FACTOR_MUL = (double)50.0;
78
79 static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / Max);
80
81 static void assertArraysStrictlyEquals(double[] r, double[] a) {
82 for (int i = 0; i < a.length; i++) {
83 long ir = Double.doubleToRawLongBits(r[i]);
84 long ia = Double.doubleToRawLongBits(a[i]);
85 if (ir != ia) {
86 Assert.fail(String.format("at index #%d, expected = %016X, actual = %016X", i, ia, ir));
87 }
88 }
89 }
90
91 interface FUnOp {
92 double apply(double a);
93 }
94
95 static void assertArraysEquals(double[] r, double[] a, FUnOp f) {
96 int i = 0;
97 try {
98 for (; i < a.length; i++) {
99 Assert.assertEquals(r[i], f.apply(a[i]));
100 }
101 } catch (AssertionError e) {
102 Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
103 }
104 }
105
106 interface FUnArrayOp {
107 double[] apply(double a);
108 }
109
110 static void assertArraysEquals(double[] r, double[] a, FUnArrayOp f) {
111 int i = 0;
112 try {
113 for (; i < a.length; i += SPECIES.length()) {
114 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
115 f.apply(a[i]));
116 }
117 } catch (AssertionError e) {
118 double[] ref = f.apply(a[i]);
119 double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
120 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
121 + ", res: " + Arrays.toString(res)
122 + "), at index #" + i);
123 }
124 }
125
126 static void assertArraysEquals(double[] r, double[] a, boolean[] mask, FUnOp f) {
127 int i = 0;
128 try {
129 for (; i < a.length; i++) {
130 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
131 }
132 } catch (AssertionError e) {
133 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i], "at index #" + i + ", input = " + a[i] + ", mask = " + mask[i % SPECIES.length()]);
134 }
135 }
136
137 interface FReductionOp {
138 double apply(double[] a, int idx);
139 }
140
141 interface FReductionAllOp {
142 double apply(double[] a);
143 }
144
145 static void assertReductionArraysEquals(double[] r, double rc, double[] a,
146 FReductionOp f, FReductionAllOp fa) {
147 assertReductionArraysEquals(r, rc, a, f, fa, (double)0.0);
148 }
149
150 static void assertReductionArraysEquals(double[] r, double rc, double[] a,
151 FReductionOp f, FReductionAllOp fa,
152 double relativeErrorFactor) {
153 int i = 0;
154 try {
155 Assert.assertEquals(rc, fa.apply(a), Math.ulp(rc) * relativeErrorFactor);
156 for (; i < a.length; i += SPECIES.length()) {
157 Assert.assertEquals(r[i], f.apply(a, i), Math.ulp(r[i]) * relativeErrorFactor);
158 }
159 } catch (AssertionError e) {
160 Assert.assertEquals(rc, fa.apply(a), Math.ulp(rc) * relativeErrorFactor, "Final result is incorrect!");
161 Assert.assertEquals(r[i], f.apply(a, i), Math.ulp(r[i]) * relativeErrorFactor, "at index #" + i);
162 }
163 }
164
165 interface FReductionMaskedOp {
166 double apply(double[] a, int idx, boolean[] mask);
167 }
168
169 interface FReductionAllMaskedOp {
170 double apply(double[] a, boolean[] mask);
171 }
172
173 static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
174 FReductionMaskedOp f, FReductionAllMaskedOp fa) {
175 assertReductionArraysEqualsMasked(r, rc, a, mask, f, fa, (double)0.0);
176 }
177
178 static void assertReductionArraysEqualsMasked(double[] r, double rc, double[] a, boolean[] mask,
179 FReductionMaskedOp f, FReductionAllMaskedOp fa,
180 double relativeError) {
181 int i = 0;
182 try {
183 Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError));
184 for (; i < a.length; i += SPECIES.length()) {
185 Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] *
186 relativeError));
187 }
188 } catch (AssertionError e) {
189 Assert.assertEquals(rc, fa.apply(a, mask), Math.abs(rc * relativeError), "Final result is incorrect!");
190 Assert.assertEquals(r[i], f.apply(a, i, mask), Math.abs(r[i] * relativeError), "at index #" + i);
191 }
192 }
193
194 interface FReductionOpLong {
195 long apply(double[] a, int idx);
196 }
197
198 interface FReductionAllOpLong {
199 long apply(double[] a);
200 }
201
202 static void assertReductionLongArraysEquals(long[] r, long rc, double[] a,
203 FReductionOpLong f, FReductionAllOpLong fa) {
204 int i = 0;
205 try {
206 Assert.assertEquals(rc, fa.apply(a));
207 for (; i < a.length; i += SPECIES.length()) {
208 Assert.assertEquals(r[i], f.apply(a, i));
209 }
210 } catch (AssertionError e) {
211 Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
212 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
213 }
214 }
215
216 interface FReductionMaskedOpLong {
217 long apply(double[] a, int idx, boolean[] mask);
218 }
219
220 interface FReductionAllMaskedOpLong {
221 long apply(double[] a, boolean[] mask);
222 }
223
224 static void assertReductionLongArraysEqualsMasked(long[] r, long rc, double[] a, boolean[] mask,
225 FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) {
226 int i = 0;
227 try {
228 Assert.assertEquals(rc, fa.apply(a, mask));
229 for (; i < a.length; i += SPECIES.length()) {
230 Assert.assertEquals(r[i], f.apply(a, i, mask));
231 }
232 } catch (AssertionError e) {
233 Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
234 Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
235 }
236 }
237
238 interface FBoolReductionOp {
239 boolean apply(boolean[] a, int idx);
240 }
241
242 static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
243 int i = 0;
244 try {
245 for (; i < a.length; i += SPECIES.length()) {
246 Assert.assertEquals(r[i], f.apply(a, i));
247 }
248 } catch (AssertionError e) {
249 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
250 }
251 }
252
253 interface FMaskReductionOp {
254 int apply(boolean[] a, int idx);
255 }
256
257 static void assertMaskReductionArraysEquals(int[] r, boolean[] a, FMaskReductionOp f) {
258 int i = 0;
259 try {
260 for (; i < a.length; i += SPECIES.length()) {
261 Assert.assertEquals(r[i], f.apply(a, i));
262 }
263 } catch (AssertionError e) {
264 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
265 }
266 }
267
268 static void assertRearrangeArraysEquals(double[] r, double[] a, int[] order, int vector_len) {
269 int i = 0, j = 0;
270 try {
271 for (; i < a.length; i += vector_len) {
272 for (j = 0; j < vector_len; j++) {
273 Assert.assertEquals(r[i+j], a[i+order[i+j]]);
274 }
275 }
276 } catch (AssertionError e) {
277 int idx = i + j;
278 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
279 }
280 }
281
282 static void assertcompressArraysEquals(double[] r, double[] a, boolean[] m, int vector_len) {
283 int i = 0, j = 0, k = 0;
284 try {
285 for (; i < a.length; i += vector_len) {
286 k = 0;
287 for (j = 0; j < vector_len; j++) {
288 if (m[(i + j) % SPECIES.length()]) {
289 Assert.assertEquals(r[i + k], a[i + j]);
290 k++;
291 }
292 }
293 for (; k < vector_len; k++) {
294 Assert.assertEquals(r[i + k], (double)0);
295 }
296 }
297 } catch (AssertionError e) {
298 int idx = i + k;
299 if (m[(i + j) % SPECIES.length()]) {
300 Assert.assertEquals(r[idx], a[i + j], "at index #" + idx);
301 } else {
302 Assert.assertEquals(r[idx], (double)0, "at index #" + idx);
303 }
304 }
305 }
306
307 static void assertexpandArraysEquals(double[] r, double[] a, boolean[] m, int vector_len) {
308 int i = 0, j = 0, k = 0;
309 try {
310 for (; i < a.length; i += vector_len) {
311 k = 0;
312 for (j = 0; j < vector_len; j++) {
313 if (m[(i + j) % SPECIES.length()]) {
314 Assert.assertEquals(r[i + j], a[i + k]);
315 k++;
316 } else {
317 Assert.assertEquals(r[i + j], (double)0);
318 }
319 }
320 }
321 } catch (AssertionError e) {
322 int idx = i + j;
323 if (m[idx % SPECIES.length()]) {
324 Assert.assertEquals(r[idx], a[i + k], "at index #" + idx);
325 } else {
326 Assert.assertEquals(r[idx], (double)0, "at index #" + idx);
327 }
328 }
329 }
330
331 static void assertSelectFromTwoVectorEquals(double[] r, double[] order, double[] a, double[] b, int vector_len) {
332 int i = 0, j = 0;
333 boolean is_exceptional_idx = false;
334 int idx = 0, wrapped_index = 0, oidx = 0;
335 try {
336 for (; i < a.length; i += vector_len) {
337 for (j = 0; j < vector_len; j++) {
338 idx = i + j;
339 wrapped_index = Math.floorMod((int)order[idx], 2 * vector_len);
340 is_exceptional_idx = wrapped_index >= vector_len;
341 oidx = is_exceptional_idx ? (wrapped_index - vector_len) : wrapped_index;
342 Assert.assertEquals(r[idx], (is_exceptional_idx ? b[i + oidx] : a[i + oidx]));
343 }
344 }
345 } catch (AssertionError e) {
346 Assert.assertEquals(r[idx], (is_exceptional_idx ? b[i + oidx] : a[i + oidx]), "at index #" + idx + ", order = " + order[idx] + ", a = " + a[i + oidx] + ", b = " + b[i + oidx]);
347 }
348 }
349
350 static void assertSelectFromArraysEquals(double[] r, double[] a, double[] order, int vector_len) {
351 int i = 0, j = 0;
352 try {
353 for (; i < a.length; i += vector_len) {
354 for (j = 0; j < vector_len; j++) {
355 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
356 }
357 }
358 } catch (AssertionError e) {
359 int idx = i + j;
360 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
361 }
362 }
363
364 static void assertRearrangeArraysEquals(double[] r, double[] a, int[] order, boolean[] mask, int vector_len) {
365 int i = 0, j = 0;
366 try {
367 for (; i < a.length; i += vector_len) {
368 for (j = 0; j < vector_len; j++) {
369 if (mask[j % SPECIES.length()])
370 Assert.assertEquals(r[i+j], a[i+order[i+j]]);
371 else
372 Assert.assertEquals(r[i+j], (double)0);
373 }
374 }
375 } catch (AssertionError e) {
376 int idx = i + j;
377 if (mask[j % SPECIES.length()])
378 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
379 else
380 Assert.assertEquals(r[i+j], (double)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
381 }
382 }
383
384 static void assertSelectFromArraysEquals(double[] r, double[] a, double[] order, boolean[] mask, int vector_len) {
385 int i = 0, j = 0;
386 try {
387 for (; i < a.length; i += vector_len) {
388 for (j = 0; j < vector_len; j++) {
389 if (mask[j % SPECIES.length()])
390 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
391 else
392 Assert.assertEquals(r[i+j], (double)0);
393 }
394 }
395 } catch (AssertionError e) {
396 int idx = i + j;
397 if (mask[j % SPECIES.length()])
398 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
399 else
400 Assert.assertEquals(r[i+j], (double)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
401 }
402 }
403
404 static void assertBroadcastArraysEquals(double[] r, double[] a) {
405 int i = 0;
406 for (; i < a.length; i += SPECIES.length()) {
407 int idx = i;
408 for (int j = idx; j < (idx + SPECIES.length()); j++)
409 a[j]=a[idx];
410 }
411
412 try {
413 for (i = 0; i < a.length; i++) {
414 Assert.assertEquals(r[i], a[i]);
415 }
416 } catch (AssertionError e) {
417 Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
418 }
419 }
420
421 interface FBinOp {
422 double apply(double a, double b);
423 }
424
425 interface FBinMaskOp {
426 double apply(double a, double b, boolean m);
427
428 static FBinMaskOp lift(FBinOp f) {
429 return (a, b, m) -> m ? f.apply(a, b) : a;
430 }
431 }
432
433 static void assertArraysEqualsAssociative(double[] rl, double[] rr, double[] a, double[] b, double[] c, FBinOp f) {
434 int i = 0;
435 try {
436 for (; i < a.length; i++) {
437 //Left associative
438 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i]), c[i]));
439
440 //Right associative
441 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i])));
442
443 //Results equal sanity check
444 Assert.assertEquals(rl[i], rr[i]);
445 }
446 } catch (AssertionError e) {
447 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i]), c[i]), "left associative test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
448 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i])), "right associative test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
449 Assert.assertEquals(rl[i], rr[i], "Result checks not equal at index #" + i + "leftRes = " + rl[i] + ", rightRes = " + rr[i]);
450 }
451 }
452
453 static void assertArraysEqualsAssociative(double[] rl, double[] rr, double[] a, double[] b, double[] c, boolean[] mask, FBinOp f) {
454 assertArraysEqualsAssociative(rl, rr, a, b, c, mask, FBinMaskOp.lift(f));
455 }
456
457 static void assertArraysEqualsAssociative(double[] rl, double[] rr, double[] a, double[] b, double[] c, boolean[] mask, FBinMaskOp f) {
458 int i = 0;
459 boolean mask_bit = false;
460 try {
461 for (; i < a.length; i++) {
462 mask_bit = mask[i % SPECIES.length()];
463 //Left associative
464 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i], mask_bit), c[i], mask_bit));
465
466 //Right associative
467 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i], mask_bit), mask_bit));
468
469 //Results equal sanity check
470 Assert.assertEquals(rl[i], rr[i]);
471 }
472 } catch (AssertionError e) {
473 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i], mask_bit), c[i], mask_bit), "left associative masked test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i] + ", mask = " + mask_bit);
474 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i], mask_bit), mask_bit), "right associative masked test at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i] + ", mask = " + mask_bit);
475 Assert.assertEquals(rl[i], rr[i], "Result checks not equal at index #" + i + "leftRes = " + rl[i] + ", rightRes = " + rr[i]);
476 }
477 }
478
479 static void assertArraysEquals(double[] r, double[] a, double[] b, FBinOp f) {
480 int i = 0;
481 try {
482 for (; i < a.length; i++) {
483 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
484 }
485 } catch (AssertionError e) {
486 Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
487 }
488 }
489
490 static void assertArraysEquals(double[] r, double[] a, double b, FBinOp f) {
491 int i = 0;
492 try {
493 for (; i < a.length; i++) {
494 Assert.assertEquals(r[i], f.apply(a[i], b));
495 }
496 } catch (AssertionError e) {
497 Assert.assertEquals(r[i], f.apply(a[i], b), "(" + a[i] + ", " + b + ") at index #" + i);
498 }
499 }
500
501 static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, FBinOp f) {
502 int i = 0;
503 try {
504 for (; i < a.length; i++) {
505 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
506 }
507 } catch (AssertionError e) {
508 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
509 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
510 }
511 }
512
513 static void assertBroadcastLongArraysEquals(double[] r, double[] a, double[] b, FBinOp f) {
514 int i = 0;
515 try {
516 for (; i < a.length; i++) {
517 Assert.assertEquals(r[i], f.apply(a[i], (double)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
518 }
519 } catch (AssertionError e) {
520 Assert.assertEquals(r[i], f.apply(a[i], (double)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
521 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
522 }
523 }
524
525 static void assertArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinOp f) {
526 assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
527 }
528
529 static void assertArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinMaskOp f) {
530 int i = 0;
531 try {
532 for (; i < a.length; i++) {
533 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
534 }
535 } catch (AssertionError err) {
536 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", mask = " + mask[i % SPECIES.length()]);
537 }
538 }
539
540 static void assertArraysEquals(double[] r, double[] a, double b, boolean[] mask, FBinOp f) {
541 assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
542 }
543
544 static void assertArraysEquals(double[] r, double[] a, double b, boolean[] mask, FBinMaskOp f) {
545 int i = 0;
546 try {
547 for (; i < a.length; i++) {
548 Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]));
549 }
550 } catch (AssertionError err) {
551 Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b + ", mask = " + mask[i % SPECIES.length()]);
552 }
553 }
554
555 static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinOp f) {
556 assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
557 }
558
559 static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinMaskOp f) {
560 int i = 0;
561 try {
562 for (; i < a.length; i++) {
563 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
564 }
565 } catch (AssertionError err) {
566 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
567 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
568 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
569 mask[i % SPECIES.length()]);
570 }
571 }
572
573 static void assertBroadcastLongArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinOp f) {
574 assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
575 }
576
577 static void assertBroadcastLongArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinMaskOp f) {
578 int i = 0;
579 try {
580 for (; i < a.length; i++) {
581 Assert.assertEquals(r[i], f.apply(a[i], (double)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
582 }
583 } catch (AssertionError err) {
584 Assert.assertEquals(r[i], f.apply(a[i], (double)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
585 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
586 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
587 mask[i % SPECIES.length()]);
588 }
589 }
590
591 static void assertShiftArraysEquals(double[] r, double[] a, double[] b, FBinOp f) {
592 int i = 0;
593 int j = 0;
594 try {
595 for (; j < a.length; j += SPECIES.length()) {
596 for (i = 0; i < SPECIES.length(); i++) {
597 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
598 }
599 }
600 } catch (AssertionError e) {
601 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
602 }
603 }
604
605 static void assertShiftArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinOp f) {
606 assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
607 }
608
609 static void assertShiftArraysEquals(double[] r, double[] a, double[] b, boolean[] mask, FBinMaskOp f) {
610 int i = 0;
611 int j = 0;
612 try {
613 for (; j < a.length; j += SPECIES.length()) {
614 for (i = 0; i < SPECIES.length(); i++) {
615 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
616 }
617 }
618 } catch (AssertionError err) {
619 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", input2 = " + b[j] + ", mask = " + mask[i]);
620 }
621 }
622
623 interface FBinConstOp {
624 double apply(double a);
625 }
626
627 interface FBinConstMaskOp {
628 double apply(double a, boolean m);
629
630 static FBinConstMaskOp lift(FBinConstOp f) {
631 return (a, m) -> m ? f.apply(a) : a;
632 }
633 }
634
635 static void assertShiftConstEquals(double[] r, double[] a, FBinConstOp f) {
636 int i = 0;
637 int j = 0;
638 try {
639 for (; j < a.length; j += SPECIES.length()) {
640 for (i = 0; i < SPECIES.length(); i++) {
641 Assert.assertEquals(r[i+j], f.apply(a[i+j]));
642 }
643 }
644 } catch (AssertionError e) {
645 Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j);
646 }
647 }
648
649 static void assertShiftConstEquals(double[] r, double[] a, boolean[] mask, FBinConstOp f) {
650 assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
651 }
652
653 static void assertShiftConstEquals(double[] r, double[] a, boolean[] mask, FBinConstMaskOp f) {
654 int i = 0;
655 int j = 0;
656 try {
657 for (; j < a.length; j += SPECIES.length()) {
658 for (i = 0; i < SPECIES.length(); i++) {
659 Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]));
660 }
661 }
662 } catch (AssertionError err) {
663 Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]);
664 }
665 }
666
667 interface FTernOp {
668 double apply(double a, double b, double c);
669 }
670
671 interface FTernMaskOp {
672 double apply(double a, double b, double c, boolean m);
673
674 static FTernMaskOp lift(FTernOp f) {
675 return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
676 }
677 }
678
679 static void assertArraysEquals(double[] r, double[] a, double[] b, double[] c, FTernOp f) {
680 int i = 0;
681 try {
682 for (; i < a.length; i++) {
683 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
684 }
685 } catch (AssertionError e) {
686 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
687 }
688 }
689
690 static void assertArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask, FTernOp f) {
691 assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
692 }
693
694 static void assertArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask, FTernMaskOp f) {
695 int i = 0;
696 try {
697 for (; i < a.length; i++) {
698 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
699 }
700 } catch (AssertionError err) {
701 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
702 + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
703 }
704 }
705
706 static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, FTernOp f) {
707 int i = 0;
708 try {
709 for (; i < a.length; i++) {
710 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
711 }
712 } catch (AssertionError e) {
713 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
714 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
715 c[(i / SPECIES.length()) * SPECIES.length()]);
716 }
717 }
718
719 static void assertAltBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, FTernOp f) {
720 int i = 0;
721 try {
722 for (; i < a.length; i++) {
723 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
724 }
725 } catch (AssertionError e) {
726 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
727 i + ", input1 = " + a[i] + ", input2 = " +
728 b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " + c[i]);
729 }
730 }
731
732 static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
733 FTernOp f) {
734 assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
735 }
736
737 static void assertBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
738 FTernMaskOp f) {
739 int i = 0;
740 try {
741 for (; i < a.length; i++) {
742 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
743 mask[i % SPECIES.length()]));
744 }
745 } catch (AssertionError err) {
746 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
747 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
748 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
749 mask[i % SPECIES.length()]);
750 }
751 }
752
753 static void assertAltBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
754 FTernOp f) {
755 assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
756 }
757
758 static void assertAltBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
759 FTernMaskOp f) {
760 int i = 0;
761 try {
762 for (; i < a.length; i++) {
763 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
764 mask[i % SPECIES.length()]));
765 }
766 } catch (AssertionError err) {
767 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
768 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
769 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
770 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
771 }
772 }
773
774 static void assertDoubleBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, FTernOp f) {
775 int i = 0;
776 try {
777 for (; i < a.length; i++) {
778 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
779 c[(i / SPECIES.length()) * SPECIES.length()]));
780 }
781 } catch (AssertionError e) {
782 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
783 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
784 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
785 c[(i / SPECIES.length()) * SPECIES.length()]);
786 }
787 }
788
789 static void assertDoubleBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
790 FTernOp f) {
791 assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
792 }
793
794 static void assertDoubleBroadcastArraysEquals(double[] r, double[] a, double[] b, double[] c, boolean[] mask,
795 FTernMaskOp f) {
796 int i = 0;
797 try {
798 for (; i < a.length; i++) {
799 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
800 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
801 }
802 } catch (AssertionError err) {
803 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
804 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
805 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
806 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
807 mask[i % SPECIES.length()]);
808 }
809 }
810
811
812 static boolean isWithin1Ulp(double actual, double expected) {
813 if (Double.isNaN(expected) && !Double.isNaN(actual)) {
814 return false;
815 } else if (!Double.isNaN(expected) && Double.isNaN(actual)) {
816 return false;
817 }
818
819 double low = Math.nextDown(expected);
820 double high = Math.nextUp(expected);
821
822 if (Double.compare(low, expected) > 0) {
823 return false;
824 }
825
826 if (Double.compare(high, expected) < 0) {
827 return false;
828 }
829
830 return true;
831 }
832
833 static void assertArraysEqualsWithinOneUlp(double[] r, double[] a, FUnOp mathf, FUnOp strictmathf) {
834 int i = 0;
835 try {
836 // Check that result is within 1 ulp of strict math or equivalent to math implementation.
837 for (; i < a.length; i++) {
838 Assert.assertTrue(Double.compare(r[i], mathf.apply(a[i])) == 0 ||
839 isWithin1Ulp(r[i], strictmathf.apply(a[i])));
840 }
841 } catch (AssertionError e) {
842 Assert.assertTrue(Double.compare(r[i], mathf.apply(a[i])) == 0, "at index #" + i + ", input = " + a[i] + ", actual = " + r[i] + ", expected = " + mathf.apply(a[i]));
843 Assert.assertTrue(isWithin1Ulp(r[i], strictmathf.apply(a[i])), "at index #" + i + ", input = " + a[i] + ", actual = " + r[i] + ", expected (within 1 ulp) = " + strictmathf.apply(a[i]));
844 }
845 }
846
847 static void assertArraysEqualsWithinOneUlp(double[] r, double[] a, double[] b, FBinOp mathf, FBinOp strictmathf) {
848 int i = 0;
849 try {
850 // Check that result is within 1 ulp of strict math or equivalent to math implementation.
851 for (; i < a.length; i++) {
852 Assert.assertTrue(Double.compare(r[i], mathf.apply(a[i], b[i])) == 0 ||
853 isWithin1Ulp(r[i], strictmathf.apply(a[i], b[i])));
854 }
855 } catch (AssertionError e) {
856 Assert.assertTrue(Double.compare(r[i], mathf.apply(a[i], b[i])) == 0, "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", actual = " + r[i] + ", expected = " + mathf.apply(a[i], b[i]));
857 Assert.assertTrue(isWithin1Ulp(r[i], strictmathf.apply(a[i], b[i])), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", actual = " + r[i] + ", expected (within 1 ulp) = " + strictmathf.apply(a[i], b[i]));
858 }
859 }
860
861 static void assertBroadcastArraysEqualsWithinOneUlp(double[] r, double[] a, double[] b,
862 FBinOp mathf, FBinOp strictmathf) {
863 int i = 0;
864 try {
865 // Check that result is within 1 ulp of strict math or equivalent to math implementation.
866 for (; i < a.length; i++) {
867 Assert.assertTrue(Double.compare(r[i],
868 mathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])) == 0 ||
869 isWithin1Ulp(r[i],
870 strictmathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])));
871 }
872 } catch (AssertionError e) {
873 Assert.assertTrue(Double.compare(r[i],
874 mathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])) == 0,
875 "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
876 b[(i / SPECIES.length()) * SPECIES.length()] + ", actual = " + r[i] +
877 ", expected = " + mathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
878 Assert.assertTrue(isWithin1Ulp(r[i],
879 strictmathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])),
880 "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
881 b[(i / SPECIES.length()) * SPECIES.length()] + ", actual = " + r[i] +
882 ", expected (within 1 ulp) = " + strictmathf.apply(a[i],
883 b[(i / SPECIES.length()) * SPECIES.length()]));
884 }
885 }
886
887 interface FGatherScatterOp {
888 double[] apply(double[] a, int ix, int[] b, int iy);
889 }
890
891 static void assertArraysEquals(double[] r, double[] a, int[] b, FGatherScatterOp f) {
892 int i = 0;
893 try {
894 for (; i < a.length; i += SPECIES.length()) {
895 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
896 f.apply(a, i, b, i));
897 }
898 } catch (AssertionError e) {
899 double[] ref = f.apply(a, i, b, i);
900 double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
901 Assert.assertEquals(res, ref,
902 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
903 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
904 + ", b: "
905 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
906 + " at index #" + i);
907 }
908 }
909
910 interface FGatherMaskedOp {
911 double[] apply(double[] a, int ix, boolean[] mask, int[] b, int iy);
912 }
913
914 interface FScatterMaskedOp {
915 double[] apply(double[] r, double[] a, int ix, boolean[] mask, int[] b, int iy);
916 }
917
918 static void assertArraysEquals(double[] r, double[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
919 int i = 0;
920 try {
921 for (; i < a.length; i += SPECIES.length()) {
922 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
923 f.apply(a, i, mask, b, i));
924 }
925 } catch (AssertionError e) {
926 double[] ref = f.apply(a, i, mask, b, i);
927 double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
928 Assert.assertEquals(res, ref,
929 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
930 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
931 + ", b: "
932 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
933 + ", mask: "
934 + Arrays.toString(mask)
935 + " at index #" + i);
936 }
937 }
938
939 static void assertArraysEquals(double[] r, double[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
940 int i = 0;
941 try {
942 for (; i < a.length; i += SPECIES.length()) {
943 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
944 f.apply(r, a, i, mask, b, i));
945 }
946 } catch (AssertionError e) {
947 double[] ref = f.apply(r, a, i, mask, b, i);
948 double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
949 Assert.assertEquals(res, ref,
950 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
951 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
952 + ", b: "
953 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
954 + ", r: "
955 + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
956 + ", mask: "
957 + Arrays.toString(mask)
958 + " at index #" + i);
959 }
960 }
961
962 interface FLaneOp {
963 double[] apply(double[] a, int origin, int idx);
964 }
965
966 static void assertArraysEquals(double[] r, double[] a, int origin, FLaneOp f) {
967 int i = 0;
968 try {
969 for (; i < a.length; i += SPECIES.length()) {
970 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
971 f.apply(a, origin, i));
972 }
973 } catch (AssertionError e) {
974 double[] ref = f.apply(a, origin, i);
975 double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
976 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
977 + ", res: " + Arrays.toString(res)
978 + "), at index #" + i);
979 }
980 }
981
982 interface FLaneBop {
983 double[] apply(double[] a, double[] b, int origin, int idx);
984 }
985
986 static void assertArraysEquals(double[] r, double[] a, double[] b, int origin, FLaneBop f) {
987 int i = 0;
988 try {
989 for (; i < a.length; i += SPECIES.length()) {
990 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
991 f.apply(a, b, origin, i));
992 }
993 } catch (AssertionError e) {
994 double[] ref = f.apply(a, b, origin, i);
995 double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
996 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
997 + ", res: " + Arrays.toString(res)
998 + "), at index #" + i
999 + ", at origin #" + origin);
1000 }
1001 }
1002
1003 interface FLaneMaskedBop {
1004 double[] apply(double[] a, double[] b, int origin, boolean[] mask, int idx);
1005 }
1006
1007 static void assertArraysEquals(double[] r, double[] a, double[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
1008 int i = 0;
1009 try {
1010 for (; i < a.length; i += SPECIES.length()) {
1011 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
1012 f.apply(a, b, origin, mask, i));
1013 }
1014 } catch (AssertionError e) {
1015 double[] ref = f.apply(a, b, origin, mask, i);
1016 double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
1017 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
1018 + ", res: " + Arrays.toString(res)
1019 + "), at index #" + i
1020 + ", at origin #" + origin);
1021 }
1022 }
1023
1024 interface FLanePartBop {
1025 double[] apply(double[] a, double[] b, int origin, int part, int idx);
1026 }
1027
1028 static void assertArraysEquals(double[] r, double[] a, double[] b, int origin, int part, FLanePartBop f) {
1029 int i = 0;
1030 try {
1031 for (; i < a.length; i += SPECIES.length()) {
1032 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
1033 f.apply(a, b, origin, part, i));
1034 }
1035 } catch (AssertionError e) {
1036 double[] ref = f.apply(a, b, origin, part, i);
1037 double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
1038 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
1039 + ", res: " + Arrays.toString(res)
1040 + "), at index #" + i
1041 + ", at origin #" + origin
1042 + ", with part #" + part);
1043 }
1044 }
1045
1046 interface FLanePartMaskedBop {
1047 double[] apply(double[] a, double[] b, int origin, int part, boolean[] mask, int idx);
1048 }
1049
1050 static void assertArraysEquals(double[] r, double[] a, double[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
1051 int i = 0;
1052 try {
1053 for (; i < a.length; i += SPECIES.length()) {
1054 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
1055 f.apply(a, b, origin, part, mask, i));
1056 }
1057 } catch (AssertionError e) {
1058 double[] ref = f.apply(a, b, origin, part, mask, i);
1059 double[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
1060 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
1061 + ", res: " + Arrays.toString(res)
1062 + "), at index #" + i
1063 + ", at origin #" + origin
1064 + ", with part #" + part);
1065 }
1066 }
1067
1068 static int intCornerCaseValue(int i) {
1069 switch(i % 5) {
1070 case 0:
1071 return Integer.MAX_VALUE;
1072 case 1:
1073 return Integer.MIN_VALUE;
1074 case 2:
1075 return Integer.MIN_VALUE;
1076 case 3:
1077 return Integer.MAX_VALUE;
1078 default:
1079 return (int)0;
1080 }
1081 }
1082
1083 static final List<IntFunction<double[]>> INT_DOUBLE_GENERATORS = List.of(
1084 withToString("double[-i * 5]", (int s) -> {
1085 return fill(s * BUFFER_REPS,
1086 i -> (double)(-i * 5));
1087 }),
1088 withToString("double[i * 5]", (int s) -> {
1089 return fill(s * BUFFER_REPS,
1090 i -> (double)(i * 5));
1091 }),
1092 withToString("double[i + 1]", (int s) -> {
1093 return fill(s * BUFFER_REPS,
1094 i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1)));
1095 }),
1096 withToString("double[intCornerCaseValue(i)]", (int s) -> {
1097 return fill(s * BUFFER_REPS,
1098 i -> (double)intCornerCaseValue(i));
1099 })
1100 );
1101
1102 static void assertArraysEquals(int[] r, double[] a, int offs) {
1103 int i = 0;
1104 try {
1105 for (; i < r.length; i++) {
1106 Assert.assertEquals(r[i], (int)(a[i+offs]));
1107 }
1108 } catch (AssertionError e) {
1109 Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
1110 }
1111 }
1112
1113 static long longCornerCaseValue(int i) {
1114 switch(i % 5) {
1115 case 0:
1116 return Long.MAX_VALUE;
1117 case 1:
1118 return Long.MIN_VALUE;
1119 case 2:
1120 return Long.MIN_VALUE;
1121 case 3:
1122 return Long.MAX_VALUE;
1123 default:
1124 return (long)0;
1125 }
1126 }
1127
1128 static final List<IntFunction<double[]>> LONG_DOUBLE_GENERATORS = List.of(
1129 withToString("double[-i * 5]", (int s) -> {
1130 return fill(s * BUFFER_REPS,
1131 i -> (double)(-i * 5));
1132 }),
1133 withToString("double[i * 5]", (int s) -> {
1134 return fill(s * BUFFER_REPS,
1135 i -> (double)(i * 5));
1136 }),
1137 withToString("double[i + 1]", (int s) -> {
1138 return fill(s * BUFFER_REPS,
1139 i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1)));
1140 }),
1141 withToString("double[cornerCaseValue(i)]", (int s) -> {
1142 return fill(s * BUFFER_REPS,
1143 i -> (double)longCornerCaseValue(i));
1144 })
1145 );
1146
1147
1148 static void assertArraysEquals(long[] r, double[] a, int offs) {
1149 int i = 0;
1150 try {
1151 for (; i < r.length; i++) {
1152 Assert.assertEquals(r[i], (long)(a[i+offs]));
1153 }
1154 } catch (AssertionError e) {
1155 Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
1156 }
1157 }
1158
1159 static long bits(double e) {
1160 return Double.doubleToLongBits(e);
1161 }
1162
1163 static final List<IntFunction<double[]>> DOUBLE_GENERATORS = List.of(
1164 withToString("double[-i * 5]", (int s) -> {
1165 return fill(s * BUFFER_REPS,
1166 i -> (double)(-i * 5));
1167 }),
1168 withToString("double[i * 5]", (int s) -> {
1169 return fill(s * BUFFER_REPS,
1170 i -> (double)(i * 5));
1171 }),
1172 withToString("double[i + 1]", (int s) -> {
1173 return fill(s * BUFFER_REPS,
1174 i -> (((double)(i + 1) == 0) ? 1 : (double)(i + 1)));
1175 }),
1176 withToString("double[0.01 + (i / (i + 1))]", (int s) -> {
1177 return fill(s * BUFFER_REPS,
1178 i -> (double)0.01 + ((double)i / (i + 1)));
1179 }),
1180 withToString("double[i -> i % 17 == 0 ? cornerCaseValue(i) : 0.01 + (i / (i + 1))]", (int s) -> {
1181 return fill(s * BUFFER_REPS,
1182 i -> i % 17 == 0 ? cornerCaseValue(i) : (double)0.01 + ((double)i / (i + 1)));
1183 }),
1184 withToString("double[cornerCaseValue(i)]", (int s) -> {
1185 return fill(s * BUFFER_REPS,
1186 i -> cornerCaseValue(i));
1187 })
1188 );
1189
1190 // Create combinations of pairs
1191 // @@@ Might be sensitive to order e.g. div by 0
1192 static final List<List<IntFunction<double[]>>> DOUBLE_GENERATOR_PAIRS =
1193 Stream.of(DOUBLE_GENERATORS.get(0)).
1194 flatMap(fa -> DOUBLE_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
1195 collect(Collectors.toList());
1196
1197 @DataProvider
1198 public Object[][] boolUnaryOpProvider() {
1199 return BOOL_ARRAY_GENERATORS.stream().
1200 map(f -> new Object[]{f}).
1201 toArray(Object[][]::new);
1202 }
1203
1204 static final List<List<IntFunction<double[]>>> DOUBLE_GENERATOR_TRIPLES =
1205 DOUBLE_GENERATOR_PAIRS.stream().
1206 flatMap(pair -> DOUBLE_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1207 collect(Collectors.toList());
1208
1209 static final List<IntFunction<double[]>> SELECT_FROM_INDEX_GENERATORS = List.of(
1210 withToString("double[0..VECLEN*2)", (int s) -> {
1211 return fill(s * BUFFER_REPS,
1212 i -> (double)(RAND.nextInt()));
1213 })
1214 );
1215
1216 static final List<List<IntFunction<double[]>>> DOUBLE_GENERATOR_SELECT_FROM_TRIPLES =
1217 DOUBLE_GENERATOR_PAIRS.stream().
1218 flatMap(pair -> SELECT_FROM_INDEX_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1219 collect(Collectors.toList());
1220
1221 @DataProvider
1222 public Object[][] doubleBinaryOpProvider() {
1223 return DOUBLE_GENERATOR_PAIRS.stream().map(List::toArray).
1224 toArray(Object[][]::new);
1225 }
1226
1227 @DataProvider
1228 public Object[][] doubleIndexedOpProvider() {
1229 return DOUBLE_GENERATOR_PAIRS.stream().map(List::toArray).
1230 toArray(Object[][]::new);
1231 }
1232
1233 @DataProvider
1234 public Object[][] doubleBinaryOpMaskProvider() {
1235 return BOOLEAN_MASK_GENERATORS.stream().
1236 flatMap(fm -> DOUBLE_GENERATOR_PAIRS.stream().map(lfa -> {
1237 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1238 })).
1239 toArray(Object[][]::new);
1240 }
1241
1242 @DataProvider
1243 public Object[][] doubleTernaryOpProvider() {
1244 return DOUBLE_GENERATOR_TRIPLES.stream().map(List::toArray).
1245 toArray(Object[][]::new);
1246 }
1247
1248 @DataProvider
1249 public Object[][] doubleSelectFromTwoVectorOpProvider() {
1250 return DOUBLE_GENERATOR_SELECT_FROM_TRIPLES.stream().map(List::toArray).
1251 toArray(Object[][]::new);
1252 }
1253
1254 @DataProvider
1255 public Object[][] doubleTernaryOpMaskProvider() {
1256 return BOOLEAN_MASK_GENERATORS.stream().
1257 flatMap(fm -> DOUBLE_GENERATOR_TRIPLES.stream().map(lfa -> {
1258 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1259 })).
1260 toArray(Object[][]::new);
1261 }
1262
1263 @DataProvider
1264 public Object[][] doubleUnaryOpProvider() {
1265 return DOUBLE_GENERATORS.stream().
1266 map(f -> new Object[]{f}).
1267 toArray(Object[][]::new);
1268 }
1269
1270 @DataProvider
1271 public Object[][] doubleUnaryOpMaskProvider() {
1272 return BOOLEAN_MASK_GENERATORS.stream().
1273 flatMap(fm -> DOUBLE_GENERATORS.stream().map(fa -> {
1274 return new Object[] {fa, fm};
1275 })).
1276 toArray(Object[][]::new);
1277 }
1278
1279 @DataProvider
1280 public Object[][] doubletoIntUnaryOpProvider() {
1281 return INT_DOUBLE_GENERATORS.stream().
1282 map(f -> new Object[]{f}).
1283 toArray(Object[][]::new);
1284 }
1285
1286 @DataProvider
1287 public Object[][] doubletoLongUnaryOpProvider() {
1288 return LONG_DOUBLE_GENERATORS.stream().
1289 map(f -> new Object[]{f}).
1290 toArray(Object[][]::new);
1291 }
1292
1293 @DataProvider
1294 public Object[][] maskProvider() {
1295 return BOOLEAN_MASK_GENERATORS.stream().
1296 map(f -> new Object[]{f}).
1297 toArray(Object[][]::new);
1298 }
1299
1300 @DataProvider
1301 public Object[][] maskCompareOpProvider() {
1302 return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1303 toArray(Object[][]::new);
1304 }
1305
1306 @DataProvider
1307 public Object[][] shuffleProvider() {
1308 return INT_SHUFFLE_GENERATORS.stream().
1309 map(f -> new Object[]{f}).
1310 toArray(Object[][]::new);
1311 }
1312
1313 @DataProvider
1314 public Object[][] shuffleCompareOpProvider() {
1315 return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1316 toArray(Object[][]::new);
1317 }
1318
1319 @DataProvider
1320 public Object[][] doubleUnaryOpShuffleProvider() {
1321 return INT_SHUFFLE_GENERATORS.stream().
1322 flatMap(fs -> DOUBLE_GENERATORS.stream().map(fa -> {
1323 return new Object[] {fa, fs};
1324 })).
1325 toArray(Object[][]::new);
1326 }
1327
1328 @DataProvider
1329 public Object[][] doubleUnaryOpShuffleMaskProvider() {
1330 return BOOLEAN_MASK_GENERATORS.stream().
1331 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1332 flatMap(fs -> DOUBLE_GENERATORS.stream().map(fa -> {
1333 return new Object[] {fa, fs, fm};
1334 }))).
1335 toArray(Object[][]::new);
1336 }
1337
1338 static final List<BiFunction<Integer,Integer,double[]>> DOUBLE_SHUFFLE_GENERATORS = List.of(
1339 withToStringBi("shuffle[random]", (Integer l, Integer m) -> {
1340 double[] a = new double[l];
1341 int upper = m;
1342 for (int i = 0; i < 1; i++) {
1343 a[i] = (double)RAND.nextInt(upper);
1344 }
1345 return a;
1346 })
1347 );
1348
1349 @DataProvider
1350 public Object[][] doubleUnaryOpSelectFromProvider() {
1351 return DOUBLE_SHUFFLE_GENERATORS.stream().
1352 flatMap(fs -> DOUBLE_GENERATORS.stream().map(fa -> {
1353 return new Object[] {fa, fs};
1354 })).
1355 toArray(Object[][]::new);
1356 }
1357
1358 @DataProvider
1359 public Object[][] doubleUnaryOpSelectFromMaskProvider() {
1360 return BOOLEAN_MASK_GENERATORS.stream().
1361 flatMap(fm -> DOUBLE_SHUFFLE_GENERATORS.stream().
1362 flatMap(fs -> DOUBLE_GENERATORS.stream().map(fa -> {
1363 return new Object[] {fa, fs, fm};
1364 }))).
1365 toArray(Object[][]::new);
1366 }
1367
1368 static final List<IntFunction<double[]>> DOUBLE_COMPARE_GENERATORS = List.of(
1369 withToString("double[i]", (int s) -> {
1370 return fill(s * BUFFER_REPS,
1371 i -> (double)i);
1372 }),
1373 withToString("double[i - length / 2]", (int s) -> {
1374 return fill(s * BUFFER_REPS,
1375 i -> (double)(i - (s * BUFFER_REPS / 2)));
1376 }),
1377 withToString("double[i + 1]", (int s) -> {
1378 return fill(s * BUFFER_REPS,
1379 i -> (double)(i + 1));
1380 }),
1381 withToString("double[i - 2]", (int s) -> {
1382 return fill(s * BUFFER_REPS,
1383 i -> (double)(i - 2));
1384 }),
1385 withToString("double[zigZag(i)]", (int s) -> {
1386 return fill(s * BUFFER_REPS,
1387 i -> i%3 == 0 ? (double)i : (i%3 == 1 ? (double)(i + 1) : (double)(i - 2)));
1388 }),
1389 withToString("double[cornerCaseValue(i)]", (int s) -> {
1390 return fill(s * BUFFER_REPS,
1391 i -> cornerCaseValue(i));
1392 })
1393 );
1394
1395 static final List<List<IntFunction<double[]>>> DOUBLE_TEST_GENERATOR_ARGS =
1396 DOUBLE_COMPARE_GENERATORS.stream().
1397 map(fa -> List.of(fa)).
1398 collect(Collectors.toList());
1399
1400 @DataProvider
1401 public Object[][] doubleTestOpProvider() {
1402 return DOUBLE_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1403 toArray(Object[][]::new);
1404 }
1405
1406 @DataProvider
1407 public Object[][] doubleTestOpMaskProvider() {
1408 return BOOLEAN_MASK_GENERATORS.stream().
1409 flatMap(fm -> DOUBLE_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1410 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1411 })).
1412 toArray(Object[][]::new);
1413 }
1414
1415 static final List<List<IntFunction<double[]>>> DOUBLE_COMPARE_GENERATOR_PAIRS =
1416 DOUBLE_COMPARE_GENERATORS.stream().
1417 flatMap(fa -> DOUBLE_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1418 collect(Collectors.toList());
1419
1420 @DataProvider
1421 public Object[][] doubleCompareOpProvider() {
1422 return DOUBLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1423 toArray(Object[][]::new);
1424 }
1425
1426 @DataProvider
1427 public Object[][] doubleCompareOpMaskProvider() {
1428 return BOOLEAN_MASK_GENERATORS.stream().
1429 flatMap(fm -> DOUBLE_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1430 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1431 })).
1432 toArray(Object[][]::new);
1433 }
1434
1435 interface ToDoubleF {
1436 double apply(int i);
1437 }
1438
1439 static double[] fill(int s , ToDoubleF f) {
1440 return fill(new double[s], f);
1441 }
1442
1443 static double[] fill(double[] a, ToDoubleF f) {
1444 for (int i = 0; i < a.length; i++) {
1445 a[i] = f.apply(i);
1446 }
1447 return a;
1448 }
1449
1450 static double cornerCaseValue(int i) {
1451 return switch(i % 8) {
1452 case 0 -> Double.MAX_VALUE;
1453 case 1 -> Double.MIN_VALUE;
1454 case 2 -> Double.NEGATIVE_INFINITY;
1455 case 3 -> Double.POSITIVE_INFINITY;
1456 case 4 -> Double.NaN;
1457 case 5 -> Double.longBitsToDouble(0x7FF123456789ABCDL);
1458 case 6 -> (double)0.0;
1459 default -> (double)-0.0;
1460 };
1461 }
1462
1463 static final IntFunction<double[]> fr = (vl) -> {
1464 int length = BUFFER_REPS * vl;
1465 return new double[length];
1466 };
1467
1468 static final IntFunction<boolean[]> fmr = (vl) -> {
1469 int length = BUFFER_REPS * vl;
1470 return new boolean[length];
1471 };
1472
1473 static final IntFunction<long[]> lfr = (vl) -> {
1474 int length = BUFFER_REPS * vl;
1475 return new long[length];
1476 };
1477
1478 static boolean eq(double a, double b) {
1479 return a == b;
1480 }
1481
1482 static boolean neq(double a, double b) {
1483 return a != b;
1484 }
1485
1486 static boolean lt(double a, double b) {
1487 return a < b;
1488 }
1489
1490 static boolean le(double a, double b) {
1491 return a <= b;
1492 }
1493
1494 static boolean gt(double a, double b) {
1495 return a > b;
1496 }
1497
1498 static boolean ge(double a, double b) {
1499 return a >= b;
1500 }
1501
1502 static double firstNonZero(double a, double b) {
1503 return Double.compare(a, (double) 0) != 0 ? a : b;
1504 }
1505
1506 @Test
1507 static void smokeTest1() {
1508 DoubleVector three = DoubleVector.broadcast(SPECIES, (byte)-3);
1509 DoubleVector three2 = (DoubleVector) SPECIES.broadcast(-3);
1510 assert(three.eq(three2).allTrue());
1511 DoubleVector three3 = three2.broadcast(1).broadcast(-3);
1512 assert(three.eq(three3).allTrue());
1513 int scale = 2;
1514 Class<?> ETYPE = double.class;
1515 if (ETYPE == double.class || ETYPE == long.class)
1516 scale = 1000000;
1517 else if (ETYPE == byte.class && SPECIES.length() >= 64)
1518 scale = 1;
1519 DoubleVector higher = three.addIndex(scale);
1520 VectorMask<Double> m = three.compare(VectorOperators.LE, higher);
1521 assert(m.allTrue());
1522 m = higher.min((double)-1).test(VectorOperators.IS_NEGATIVE);
1523 assert(m.allTrue());
1524 m = higher.test(VectorOperators.IS_FINITE);
1525 assert(m.allTrue());
1526 double max = higher.reduceLanes(VectorOperators.MAX);
1527 assert(max == -3 + scale * (SPECIES.length()-1));
1528 }
1529
1530 private static double[]
1531 bothToArray(DoubleVector a, DoubleVector b) {
1532 double[] r = new double[a.length() + b.length()];
1533 a.intoArray(r, 0);
1534 b.intoArray(r, a.length());
1535 return r;
1536 }
1537
1538 @Test
1539 static void smokeTest2() {
1540 // Do some zipping and shuffling.
1541 DoubleVector io = (DoubleVector) SPECIES.broadcast(0).addIndex(1);
1542 DoubleVector io2 = (DoubleVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1543 Assert.assertEquals(io, io2);
1544 DoubleVector a = io.add((double)1); //[1,2]
1545 DoubleVector b = a.neg(); //[-1,-2]
1546 double[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1547 VectorShuffle<Double> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1548 VectorShuffle<Double> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1549 DoubleVector zab0 = a.rearrange(zip0,b); //[1,-1]
1550 DoubleVector zab1 = a.rearrange(zip1,b); //[2,-2]
1551 double[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1552 // manually zip
1553 double[] manual = new double[zabValues.length];
1554 for (int i = 0; i < manual.length; i += 2) {
1555 manual[i+0] = abValues[i/2];
1556 manual[i+1] = abValues[a.length() + i/2];
1557 }
1558 Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1559 VectorShuffle<Double> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1560 VectorShuffle<Double> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1561 DoubleVector uab0 = zab0.rearrange(unz0,zab1);
1562 DoubleVector uab1 = zab0.rearrange(unz1,zab1);
1563 double[] abValues1 = bothToArray(uab0, uab1);
1564 Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1565 }
1566
1567 static void iotaShuffle() {
1568 DoubleVector io = (DoubleVector) SPECIES.broadcast(0).addIndex(1);
1569 DoubleVector io2 = (DoubleVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1570 Assert.assertEquals(io, io2);
1571 }
1572
1573 @Test
1574 // Test all shuffle related operations.
1575 static void shuffleTest() {
1576 // To test backend instructions, make sure that C2 is used.
1577 for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1578 iotaShuffle();
1579 }
1580 }
1581
1582 @Test
1583 void viewAsIntegeralLanesTest() {
1584 Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1585 VectorSpecies<?> asIntegralSpecies = asIntegral.species();
1586 Assert.assertNotEquals(asIntegralSpecies.elementType(), SPECIES.elementType());
1587 Assert.assertEquals(asIntegralSpecies.vectorShape(), SPECIES.vectorShape());
1588 Assert.assertEquals(asIntegralSpecies.length(), SPECIES.length());
1589 Assert.assertEquals(asIntegral.viewAsFloatingLanes().species(), SPECIES);
1590 }
1591
1592 @Test
1593 void viewAsFloatingLanesTest() {
1594 Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
1595 Assert.assertEquals(asFloating.species(), SPECIES);
1596 }
1597
1598 static double ADD(double a, double b) {
1599 return (double)(a + b);
1600 }
1601
1602 @Test(dataProvider = "doubleBinaryOpProvider")
1603 static void ADDDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1604 double[] a = fa.apply(SPECIES.length());
1605 double[] b = fb.apply(SPECIES.length());
1606 double[] r = fr.apply(SPECIES.length());
1607
1608 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1609 for (int i = 0; i < a.length; i += SPECIES.length()) {
1610 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1611 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1612 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1613 }
1614 }
1615
1616 assertArraysEquals(r, a, b, DoubleMaxVectorTests::ADD);
1617 }
1618
1619 static double add(double a, double b) {
1620 return (double)(a + b);
1621 }
1622
1623 @Test(dataProvider = "doubleBinaryOpProvider")
1624 static void addDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1625 double[] a = fa.apply(SPECIES.length());
1626 double[] b = fb.apply(SPECIES.length());
1627 double[] r = fr.apply(SPECIES.length());
1628
1629 for (int i = 0; i < a.length; i += SPECIES.length()) {
1630 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1631 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1632 av.add(bv).intoArray(r, i);
1633 }
1634
1635 assertArraysEquals(r, a, b, DoubleMaxVectorTests::add);
1636 }
1637
1638 @Test(dataProvider = "doubleBinaryOpMaskProvider")
1639 static void ADDDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1640 IntFunction<boolean[]> fm) {
1641 double[] a = fa.apply(SPECIES.length());
1642 double[] b = fb.apply(SPECIES.length());
1643 double[] r = fr.apply(SPECIES.length());
1644 boolean[] mask = fm.apply(SPECIES.length());
1645 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1646
1647 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1648 for (int i = 0; i < a.length; i += SPECIES.length()) {
1649 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1650 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1651 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1652 }
1653 }
1654
1655 assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::ADD);
1656 }
1657
1658 @Test(dataProvider = "doubleBinaryOpMaskProvider")
1659 static void addDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1660 IntFunction<boolean[]> fm) {
1661 double[] a = fa.apply(SPECIES.length());
1662 double[] b = fb.apply(SPECIES.length());
1663 double[] r = fr.apply(SPECIES.length());
1664 boolean[] mask = fm.apply(SPECIES.length());
1665 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1666
1667 for (int i = 0; i < a.length; i += SPECIES.length()) {
1668 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1669 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1670 av.add(bv, vmask).intoArray(r, i);
1671 }
1672
1673 assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::add);
1674 }
1675
1676 static double SUB(double a, double b) {
1677 return (double)(a - b);
1678 }
1679
1680 @Test(dataProvider = "doubleBinaryOpProvider")
1681 static void SUBDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1682 double[] a = fa.apply(SPECIES.length());
1683 double[] b = fb.apply(SPECIES.length());
1684 double[] r = fr.apply(SPECIES.length());
1685
1686 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1687 for (int i = 0; i < a.length; i += SPECIES.length()) {
1688 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1689 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1690 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1691 }
1692 }
1693
1694 assertArraysEquals(r, a, b, DoubleMaxVectorTests::SUB);
1695 }
1696
1697 static double sub(double a, double b) {
1698 return (double)(a - b);
1699 }
1700
1701 @Test(dataProvider = "doubleBinaryOpProvider")
1702 static void subDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1703 double[] a = fa.apply(SPECIES.length());
1704 double[] b = fb.apply(SPECIES.length());
1705 double[] r = fr.apply(SPECIES.length());
1706
1707 for (int i = 0; i < a.length; i += SPECIES.length()) {
1708 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1709 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1710 av.sub(bv).intoArray(r, i);
1711 }
1712
1713 assertArraysEquals(r, a, b, DoubleMaxVectorTests::sub);
1714 }
1715
1716 @Test(dataProvider = "doubleBinaryOpMaskProvider")
1717 static void SUBDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1718 IntFunction<boolean[]> fm) {
1719 double[] a = fa.apply(SPECIES.length());
1720 double[] b = fb.apply(SPECIES.length());
1721 double[] r = fr.apply(SPECIES.length());
1722 boolean[] mask = fm.apply(SPECIES.length());
1723 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1724
1725 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1726 for (int i = 0; i < a.length; i += SPECIES.length()) {
1727 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1728 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1729 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1730 }
1731 }
1732
1733 assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::SUB);
1734 }
1735
1736 @Test(dataProvider = "doubleBinaryOpMaskProvider")
1737 static void subDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1738 IntFunction<boolean[]> fm) {
1739 double[] a = fa.apply(SPECIES.length());
1740 double[] b = fb.apply(SPECIES.length());
1741 double[] r = fr.apply(SPECIES.length());
1742 boolean[] mask = fm.apply(SPECIES.length());
1743 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1744
1745 for (int i = 0; i < a.length; i += SPECIES.length()) {
1746 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1747 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1748 av.sub(bv, vmask).intoArray(r, i);
1749 }
1750
1751 assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::sub);
1752 }
1753
1754 static double MUL(double a, double b) {
1755 return (double)(a * b);
1756 }
1757
1758 @Test(dataProvider = "doubleBinaryOpProvider")
1759 static void MULDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1760 double[] a = fa.apply(SPECIES.length());
1761 double[] b = fb.apply(SPECIES.length());
1762 double[] r = fr.apply(SPECIES.length());
1763
1764 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1765 for (int i = 0; i < a.length; i += SPECIES.length()) {
1766 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1767 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1768 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1769 }
1770 }
1771
1772 assertArraysEquals(r, a, b, DoubleMaxVectorTests::MUL);
1773 }
1774
1775 static double mul(double a, double b) {
1776 return (double)(a * b);
1777 }
1778
1779 @Test(dataProvider = "doubleBinaryOpProvider")
1780 static void mulDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1781 double[] a = fa.apply(SPECIES.length());
1782 double[] b = fb.apply(SPECIES.length());
1783 double[] r = fr.apply(SPECIES.length());
1784
1785 for (int i = 0; i < a.length; i += SPECIES.length()) {
1786 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1787 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1788 av.mul(bv).intoArray(r, i);
1789 }
1790
1791 assertArraysEquals(r, a, b, DoubleMaxVectorTests::mul);
1792 }
1793
1794 @Test(dataProvider = "doubleBinaryOpMaskProvider")
1795 static void MULDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1796 IntFunction<boolean[]> fm) {
1797 double[] a = fa.apply(SPECIES.length());
1798 double[] b = fb.apply(SPECIES.length());
1799 double[] r = fr.apply(SPECIES.length());
1800 boolean[] mask = fm.apply(SPECIES.length());
1801 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1802
1803 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1804 for (int i = 0; i < a.length; i += SPECIES.length()) {
1805 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1806 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1807 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1808 }
1809 }
1810
1811 assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::MUL);
1812 }
1813
1814 @Test(dataProvider = "doubleBinaryOpMaskProvider")
1815 static void mulDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1816 IntFunction<boolean[]> fm) {
1817 double[] a = fa.apply(SPECIES.length());
1818 double[] b = fb.apply(SPECIES.length());
1819 double[] r = fr.apply(SPECIES.length());
1820 boolean[] mask = fm.apply(SPECIES.length());
1821 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1822
1823 for (int i = 0; i < a.length; i += SPECIES.length()) {
1824 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1825 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1826 av.mul(bv, vmask).intoArray(r, i);
1827 }
1828
1829 assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::mul);
1830 }
1831
1832 static double DIV(double a, double b) {
1833 return (double)(a / b);
1834 }
1835
1836 @Test(dataProvider = "doubleBinaryOpProvider")
1837 static void DIVDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1838 double[] a = fa.apply(SPECIES.length());
1839 double[] b = fb.apply(SPECIES.length());
1840 double[] r = fr.apply(SPECIES.length());
1841
1842 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1843 for (int i = 0; i < a.length; i += SPECIES.length()) {
1844 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1845 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1846 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1847 }
1848 }
1849
1850 assertArraysEquals(r, a, b, DoubleMaxVectorTests::DIV);
1851 }
1852
1853 static double div(double a, double b) {
1854 return (double)(a / b);
1855 }
1856
1857 @Test(dataProvider = "doubleBinaryOpProvider")
1858 static void divDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1859 double[] a = fa.apply(SPECIES.length());
1860 double[] b = fb.apply(SPECIES.length());
1861 double[] r = fr.apply(SPECIES.length());
1862
1863 for (int i = 0; i < a.length; i += SPECIES.length()) {
1864 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1865 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1866 av.div(bv).intoArray(r, i);
1867 }
1868
1869 assertArraysEquals(r, a, b, DoubleMaxVectorTests::div);
1870 }
1871
1872 @Test(dataProvider = "doubleBinaryOpMaskProvider")
1873 static void DIVDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1874 IntFunction<boolean[]> fm) {
1875 double[] a = fa.apply(SPECIES.length());
1876 double[] b = fb.apply(SPECIES.length());
1877 double[] r = fr.apply(SPECIES.length());
1878 boolean[] mask = fm.apply(SPECIES.length());
1879 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1880
1881 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1882 for (int i = 0; i < a.length; i += SPECIES.length()) {
1883 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1884 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1885 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1886 }
1887 }
1888
1889 assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::DIV);
1890 }
1891
1892 @Test(dataProvider = "doubleBinaryOpMaskProvider")
1893 static void divDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1894 IntFunction<boolean[]> fm) {
1895 double[] a = fa.apply(SPECIES.length());
1896 double[] b = fb.apply(SPECIES.length());
1897 double[] r = fr.apply(SPECIES.length());
1898 boolean[] mask = fm.apply(SPECIES.length());
1899 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1900
1901 for (int i = 0; i < a.length; i += SPECIES.length()) {
1902 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1903 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1904 av.div(bv, vmask).intoArray(r, i);
1905 }
1906
1907 assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::div);
1908 }
1909
1910 static double FIRST_NONZERO(double a, double b) {
1911 return (double)(Double.doubleToLongBits(a)!=0?a:b);
1912 }
1913
1914 @Test(dataProvider = "doubleBinaryOpProvider")
1915 static void FIRST_NONZERODoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1916 double[] a = fa.apply(SPECIES.length());
1917 double[] b = fb.apply(SPECIES.length());
1918 double[] r = fr.apply(SPECIES.length());
1919
1920 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1921 for (int i = 0; i < a.length; i += SPECIES.length()) {
1922 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1923 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1924 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1925 }
1926 }
1927
1928 assertArraysEquals(r, a, b, DoubleMaxVectorTests::FIRST_NONZERO);
1929 }
1930
1931 @Test(dataProvider = "doubleBinaryOpMaskProvider")
1932 static void FIRST_NONZERODoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
1933 IntFunction<boolean[]> fm) {
1934 double[] a = fa.apply(SPECIES.length());
1935 double[] b = fb.apply(SPECIES.length());
1936 double[] r = fr.apply(SPECIES.length());
1937 boolean[] mask = fm.apply(SPECIES.length());
1938 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1939
1940 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1941 for (int i = 0; i < a.length; i += SPECIES.length()) {
1942 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1943 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
1944 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1945 }
1946 }
1947
1948 assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::FIRST_NONZERO);
1949 }
1950
1951 @Test(dataProvider = "doubleBinaryOpProvider")
1952 static void addDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1953 double[] a = fa.apply(SPECIES.length());
1954 double[] b = fb.apply(SPECIES.length());
1955 double[] r = fr.apply(SPECIES.length());
1956
1957 for (int i = 0; i < a.length; i += SPECIES.length()) {
1958 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1959 av.add(b[i]).intoArray(r, i);
1960 }
1961
1962 assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::add);
1963 }
1964
1965 @Test(dataProvider = "doubleBinaryOpMaskProvider")
1966 static void addDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
1967 IntFunction<boolean[]> fm) {
1968 double[] a = fa.apply(SPECIES.length());
1969 double[] b = fb.apply(SPECIES.length());
1970 double[] r = fr.apply(SPECIES.length());
1971 boolean[] mask = fm.apply(SPECIES.length());
1972 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1973
1974 for (int i = 0; i < a.length; i += SPECIES.length()) {
1975 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1976 av.add(b[i], vmask).intoArray(r, i);
1977 }
1978
1979 assertBroadcastArraysEquals(r, a, b, mask, DoubleMaxVectorTests::add);
1980 }
1981
1982 @Test(dataProvider = "doubleBinaryOpProvider")
1983 static void subDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
1984 double[] a = fa.apply(SPECIES.length());
1985 double[] b = fb.apply(SPECIES.length());
1986 double[] r = fr.apply(SPECIES.length());
1987
1988 for (int i = 0; i < a.length; i += SPECIES.length()) {
1989 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
1990 av.sub(b[i]).intoArray(r, i);
1991 }
1992
1993 assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::sub);
1994 }
1995
1996 @Test(dataProvider = "doubleBinaryOpMaskProvider")
1997 static void subDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
1998 IntFunction<boolean[]> fm) {
1999 double[] a = fa.apply(SPECIES.length());
2000 double[] b = fb.apply(SPECIES.length());
2001 double[] r = fr.apply(SPECIES.length());
2002 boolean[] mask = fm.apply(SPECIES.length());
2003 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2004
2005 for (int i = 0; i < a.length; i += SPECIES.length()) {
2006 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2007 av.sub(b[i], vmask).intoArray(r, i);
2008 }
2009
2010 assertBroadcastArraysEquals(r, a, b, mask, DoubleMaxVectorTests::sub);
2011 }
2012
2013 @Test(dataProvider = "doubleBinaryOpProvider")
2014 static void mulDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2015 double[] a = fa.apply(SPECIES.length());
2016 double[] b = fb.apply(SPECIES.length());
2017 double[] r = fr.apply(SPECIES.length());
2018
2019 for (int i = 0; i < a.length; i += SPECIES.length()) {
2020 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2021 av.mul(b[i]).intoArray(r, i);
2022 }
2023
2024 assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::mul);
2025 }
2026
2027 @Test(dataProvider = "doubleBinaryOpMaskProvider")
2028 static void mulDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
2029 IntFunction<boolean[]> fm) {
2030 double[] a = fa.apply(SPECIES.length());
2031 double[] b = fb.apply(SPECIES.length());
2032 double[] r = fr.apply(SPECIES.length());
2033 boolean[] mask = fm.apply(SPECIES.length());
2034 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2035
2036 for (int i = 0; i < a.length; i += SPECIES.length()) {
2037 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2038 av.mul(b[i], vmask).intoArray(r, i);
2039 }
2040
2041 assertBroadcastArraysEquals(r, a, b, mask, DoubleMaxVectorTests::mul);
2042 }
2043
2044 @Test(dataProvider = "doubleBinaryOpProvider")
2045 static void divDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2046 double[] a = fa.apply(SPECIES.length());
2047 double[] b = fb.apply(SPECIES.length());
2048 double[] r = fr.apply(SPECIES.length());
2049
2050 for (int i = 0; i < a.length; i += SPECIES.length()) {
2051 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2052 av.div(b[i]).intoArray(r, i);
2053 }
2054
2055 assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::div);
2056 }
2057
2058 @Test(dataProvider = "doubleBinaryOpMaskProvider")
2059 static void divDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
2060 IntFunction<boolean[]> fm) {
2061 double[] a = fa.apply(SPECIES.length());
2062 double[] b = fb.apply(SPECIES.length());
2063 double[] r = fr.apply(SPECIES.length());
2064 boolean[] mask = fm.apply(SPECIES.length());
2065 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2066
2067 for (int i = 0; i < a.length; i += SPECIES.length()) {
2068 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2069 av.div(b[i], vmask).intoArray(r, i);
2070 }
2071
2072 assertBroadcastArraysEquals(r, a, b, mask, DoubleMaxVectorTests::div);
2073 }
2074
2075 @Test(dataProvider = "doubleBinaryOpProvider")
2076 static void ADDDoubleMaxVectorTestsBroadcastLongSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2077 double[] a = fa.apply(SPECIES.length());
2078 double[] b = fb.apply(SPECIES.length());
2079 double[] r = fr.apply(SPECIES.length());
2080
2081 for (int i = 0; i < a.length; i += SPECIES.length()) {
2082 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2083 av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2084 }
2085
2086 assertBroadcastLongArraysEquals(r, a, b, DoubleMaxVectorTests::ADD);
2087 }
2088
2089 @Test(dataProvider = "doubleBinaryOpMaskProvider")
2090 static void ADDDoubleMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
2091 IntFunction<boolean[]> fm) {
2092 double[] a = fa.apply(SPECIES.length());
2093 double[] b = fb.apply(SPECIES.length());
2094 double[] r = fr.apply(SPECIES.length());
2095 boolean[] mask = fm.apply(SPECIES.length());
2096 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2097
2098 for (int i = 0; i < a.length; i += SPECIES.length()) {
2099 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2100 av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2101 }
2102
2103 assertBroadcastLongArraysEquals(r, a, b, mask, DoubleMaxVectorTests::ADD);
2104 }
2105
2106 @Test(dataProvider = "doubleUnaryOpProvider")
2107 static void MINDoubleMaxVectorTestsWithMemOp(IntFunction<double[]> fa) {
2108 double[] a = fa.apply(SPECIES.length());
2109 double[] r = fr.apply(SPECIES.length());
2110
2111 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2112 for (int i = 0; i < a.length; i += SPECIES.length()) {
2113 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2114 av.lanewise(VectorOperators.MIN, bcast_vec).intoArray(r, i);
2115 }
2116 }
2117
2118 assertArraysEquals(r, a, (double)10, DoubleMaxVectorTests::MIN);
2119 }
2120
2121 @Test(dataProvider = "doubleUnaryOpProvider")
2122 static void minDoubleMaxVectorTestsWithMemOp(IntFunction<double[]> fa) {
2123 double[] a = fa.apply(SPECIES.length());
2124 double[] r = fr.apply(SPECIES.length());
2125
2126 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2127 for (int i = 0; i < a.length; i += SPECIES.length()) {
2128 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2129 av.min(bcast_vec).intoArray(r, i);
2130 }
2131 }
2132
2133 assertArraysEquals(r, a, (double)10, DoubleMaxVectorTests::min);
2134 }
2135
2136 @Test(dataProvider = "doubleUnaryOpMaskProvider")
2137 static void MINDoubleMaxVectorTestsMaskedWithMemOp(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2138 double[] a = fa.apply(SPECIES.length());
2139 double[] r = fr.apply(SPECIES.length());
2140 boolean[] mask = fm.apply(SPECIES.length());
2141 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2142
2143 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2144 for (int i = 0; i < a.length; i += SPECIES.length()) {
2145 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2146 av.lanewise(VectorOperators.MIN, bcast_vec, vmask).intoArray(r, i);
2147 }
2148 }
2149
2150 assertArraysEquals(r, a, (double)10, mask, DoubleMaxVectorTests::MIN);
2151 }
2152
2153 @Test(dataProvider = "doubleUnaryOpProvider")
2154 static void MAXDoubleMaxVectorTestsWithMemOp(IntFunction<double[]> fa) {
2155 double[] a = fa.apply(SPECIES.length());
2156 double[] r = fr.apply(SPECIES.length());
2157
2158 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2159 for (int i = 0; i < a.length; i += SPECIES.length()) {
2160 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2161 av.lanewise(VectorOperators.MAX, bcast_vec).intoArray(r, i);
2162 }
2163 }
2164
2165 assertArraysEquals(r, a, (double)10, DoubleMaxVectorTests::MAX);
2166 }
2167
2168 @Test(dataProvider = "doubleUnaryOpProvider")
2169 static void maxDoubleMaxVectorTestsWithMemOp(IntFunction<double[]> fa) {
2170 double[] a = fa.apply(SPECIES.length());
2171 double[] r = fr.apply(SPECIES.length());
2172
2173 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2174 for (int i = 0; i < a.length; i += SPECIES.length()) {
2175 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2176 av.max(bcast_vec).intoArray(r, i);
2177 }
2178 }
2179
2180 assertArraysEquals(r, a, (double)10, DoubleMaxVectorTests::max);
2181 }
2182
2183 @Test(dataProvider = "doubleUnaryOpMaskProvider")
2184 static void MAXDoubleMaxVectorTestsMaskedWithMemOp(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2185 double[] a = fa.apply(SPECIES.length());
2186 double[] r = fr.apply(SPECIES.length());
2187 boolean[] mask = fm.apply(SPECIES.length());
2188 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2189
2190 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2191 for (int i = 0; i < a.length; i += SPECIES.length()) {
2192 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2193 av.lanewise(VectorOperators.MAX, bcast_vec, vmask).intoArray(r, i);
2194 }
2195 }
2196
2197 assertArraysEquals(r, a, (double)10, mask, DoubleMaxVectorTests::MAX);
2198 }
2199
2200 static double MIN(double a, double b) {
2201 return (double)(Math.min(a, b));
2202 }
2203
2204 @Test(dataProvider = "doubleBinaryOpProvider")
2205 static void MINDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2206 double[] a = fa.apply(SPECIES.length());
2207 double[] b = fb.apply(SPECIES.length());
2208 double[] r = fr.apply(SPECIES.length());
2209
2210 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2211 for (int i = 0; i < a.length; i += SPECIES.length()) {
2212 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2213 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
2214 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
2215 }
2216 }
2217
2218 assertArraysEquals(r, a, b, DoubleMaxVectorTests::MIN);
2219 }
2220
2221 static double min(double a, double b) {
2222 return (double)(Math.min(a, b));
2223 }
2224
2225 @Test(dataProvider = "doubleBinaryOpProvider")
2226 static void minDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2227 double[] a = fa.apply(SPECIES.length());
2228 double[] b = fb.apply(SPECIES.length());
2229 double[] r = fr.apply(SPECIES.length());
2230
2231 for (int i = 0; i < a.length; i += SPECIES.length()) {
2232 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2233 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
2234 av.min(bv).intoArray(r, i);
2235 }
2236
2237 assertArraysEquals(r, a, b, DoubleMaxVectorTests::min);
2238 }
2239
2240 static double MAX(double a, double b) {
2241 return (double)(Math.max(a, b));
2242 }
2243
2244 @Test(dataProvider = "doubleBinaryOpProvider")
2245 static void MAXDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2246 double[] a = fa.apply(SPECIES.length());
2247 double[] b = fb.apply(SPECIES.length());
2248 double[] r = fr.apply(SPECIES.length());
2249
2250 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2251 for (int i = 0; i < a.length; i += SPECIES.length()) {
2252 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2253 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
2254 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
2255 }
2256 }
2257
2258 assertArraysEquals(r, a, b, DoubleMaxVectorTests::MAX);
2259 }
2260
2261 static double max(double a, double b) {
2262 return (double)(Math.max(a, b));
2263 }
2264
2265 @Test(dataProvider = "doubleBinaryOpProvider")
2266 static void maxDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2267 double[] a = fa.apply(SPECIES.length());
2268 double[] b = fb.apply(SPECIES.length());
2269 double[] r = fr.apply(SPECIES.length());
2270
2271 for (int i = 0; i < a.length; i += SPECIES.length()) {
2272 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2273 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
2274 av.max(bv).intoArray(r, i);
2275 }
2276
2277 assertArraysEquals(r, a, b, DoubleMaxVectorTests::max);
2278 }
2279
2280 @Test(dataProvider = "doubleBinaryOpProvider")
2281 static void MINDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2282 double[] a = fa.apply(SPECIES.length());
2283 double[] b = fb.apply(SPECIES.length());
2284 double[] r = fr.apply(SPECIES.length());
2285
2286 for (int i = 0; i < a.length; i += SPECIES.length()) {
2287 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2288 av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
2289 }
2290
2291 assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::MIN);
2292 }
2293
2294 @Test(dataProvider = "doubleBinaryOpProvider")
2295 static void minDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2296 double[] a = fa.apply(SPECIES.length());
2297 double[] b = fb.apply(SPECIES.length());
2298 double[] r = fr.apply(SPECIES.length());
2299
2300 for (int i = 0; i < a.length; i += SPECIES.length()) {
2301 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2302 av.min(b[i]).intoArray(r, i);
2303 }
2304
2305 assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::min);
2306 }
2307
2308 @Test(dataProvider = "doubleBinaryOpProvider")
2309 static void MAXDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2310 double[] a = fa.apply(SPECIES.length());
2311 double[] b = fb.apply(SPECIES.length());
2312 double[] r = fr.apply(SPECIES.length());
2313
2314 for (int i = 0; i < a.length; i += SPECIES.length()) {
2315 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2316 av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
2317 }
2318
2319 assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::MAX);
2320 }
2321
2322 @Test(dataProvider = "doubleBinaryOpProvider")
2323 static void maxDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
2324 double[] a = fa.apply(SPECIES.length());
2325 double[] b = fb.apply(SPECIES.length());
2326 double[] r = fr.apply(SPECIES.length());
2327
2328 for (int i = 0; i < a.length; i += SPECIES.length()) {
2329 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2330 av.max(b[i]).intoArray(r, i);
2331 }
2332
2333 assertBroadcastArraysEquals(r, a, b, DoubleMaxVectorTests::max);
2334 }
2335
2336 static double ADDReduce(double[] a, int idx) {
2337 double res = 0;
2338 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2339 res += a[i];
2340 }
2341
2342 return res;
2343 }
2344
2345 static double ADDReduceAll(double[] a) {
2346 double res = 0;
2347 for (int i = 0; i < a.length; i += SPECIES.length()) {
2348 res += ADDReduce(a, i);
2349 }
2350
2351 return res;
2352 }
2353
2354 @Test(dataProvider = "doubleUnaryOpProvider")
2355 static void ADDReduceDoubleMaxVectorTests(IntFunction<double[]> fa) {
2356 double[] a = fa.apply(SPECIES.length());
2357 double[] r = fr.apply(SPECIES.length());
2358 double ra = 0;
2359
2360 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2361 for (int i = 0; i < a.length; i += SPECIES.length()) {
2362 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2363 r[i] = av.reduceLanes(VectorOperators.ADD);
2364 }
2365 }
2366
2367 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2368 ra = 0;
2369 for (int i = 0; i < a.length; i += SPECIES.length()) {
2370 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2371 ra += av.reduceLanes(VectorOperators.ADD);
2372 }
2373 }
2374
2375 assertReductionArraysEquals(r, ra, a,
2376 DoubleMaxVectorTests::ADDReduce, DoubleMaxVectorTests::ADDReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_ADD);
2377 }
2378
2379 static double ADDReduceMasked(double[] a, int idx, boolean[] mask) {
2380 double res = 0;
2381 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2382 if (mask[i % SPECIES.length()])
2383 res += a[i];
2384 }
2385
2386 return res;
2387 }
2388
2389 static double ADDReduceAllMasked(double[] a, boolean[] mask) {
2390 double res = 0;
2391 for (int i = 0; i < a.length; i += SPECIES.length()) {
2392 res += ADDReduceMasked(a, i, mask);
2393 }
2394
2395 return res;
2396 }
2397
2398 @Test(dataProvider = "doubleUnaryOpMaskProvider")
2399 static void ADDReduceDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2400 double[] a = fa.apply(SPECIES.length());
2401 double[] r = fr.apply(SPECIES.length());
2402 boolean[] mask = fm.apply(SPECIES.length());
2403 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2404 double ra = 0;
2405
2406 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2407 for (int i = 0; i < a.length; i += SPECIES.length()) {
2408 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2409 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
2410 }
2411 }
2412
2413 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2414 ra = 0;
2415 for (int i = 0; i < a.length; i += SPECIES.length()) {
2416 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2417 ra += av.reduceLanes(VectorOperators.ADD, vmask);
2418 }
2419 }
2420
2421 assertReductionArraysEqualsMasked(r, ra, a, mask,
2422 DoubleMaxVectorTests::ADDReduceMasked, DoubleMaxVectorTests::ADDReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_ADD);
2423 }
2424
2425 static double MULReduce(double[] a, int idx) {
2426 double res = 1;
2427 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2428 res *= a[i];
2429 }
2430
2431 return res;
2432 }
2433
2434 static double MULReduceAll(double[] a) {
2435 double res = 1;
2436 for (int i = 0; i < a.length; i += SPECIES.length()) {
2437 res *= MULReduce(a, i);
2438 }
2439
2440 return res;
2441 }
2442
2443 @Test(dataProvider = "doubleUnaryOpProvider")
2444 static void MULReduceDoubleMaxVectorTests(IntFunction<double[]> fa) {
2445 double[] a = fa.apply(SPECIES.length());
2446 double[] r = fr.apply(SPECIES.length());
2447 double ra = 1;
2448
2449 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2450 for (int i = 0; i < a.length; i += SPECIES.length()) {
2451 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2452 r[i] = av.reduceLanes(VectorOperators.MUL);
2453 }
2454 }
2455
2456 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2457 ra = 1;
2458 for (int i = 0; i < a.length; i += SPECIES.length()) {
2459 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2460 ra *= av.reduceLanes(VectorOperators.MUL);
2461 }
2462 }
2463
2464 assertReductionArraysEquals(r, ra, a,
2465 DoubleMaxVectorTests::MULReduce, DoubleMaxVectorTests::MULReduceAll, RELATIVE_ROUNDING_ERROR_FACTOR_MUL);
2466 }
2467
2468 static double MULReduceMasked(double[] a, int idx, boolean[] mask) {
2469 double res = 1;
2470 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2471 if (mask[i % SPECIES.length()])
2472 res *= a[i];
2473 }
2474
2475 return res;
2476 }
2477
2478 static double MULReduceAllMasked(double[] a, boolean[] mask) {
2479 double res = 1;
2480 for (int i = 0; i < a.length; i += SPECIES.length()) {
2481 res *= MULReduceMasked(a, i, mask);
2482 }
2483
2484 return res;
2485 }
2486
2487 @Test(dataProvider = "doubleUnaryOpMaskProvider")
2488 static void MULReduceDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2489 double[] a = fa.apply(SPECIES.length());
2490 double[] r = fr.apply(SPECIES.length());
2491 boolean[] mask = fm.apply(SPECIES.length());
2492 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2493 double ra = 1;
2494
2495 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2496 for (int i = 0; i < a.length; i += SPECIES.length()) {
2497 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2498 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
2499 }
2500 }
2501
2502 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2503 ra = 1;
2504 for (int i = 0; i < a.length; i += SPECIES.length()) {
2505 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2506 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
2507 }
2508 }
2509
2510 assertReductionArraysEqualsMasked(r, ra, a, mask,
2511 DoubleMaxVectorTests::MULReduceMasked, DoubleMaxVectorTests::MULReduceAllMasked, RELATIVE_ROUNDING_ERROR_FACTOR_MUL);
2512 }
2513
2514 static double MINReduce(double[] a, int idx) {
2515 double res = Double.POSITIVE_INFINITY;
2516 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2517 res = (double) Math.min(res, a[i]);
2518 }
2519
2520 return res;
2521 }
2522
2523 static double MINReduceAll(double[] a) {
2524 double res = Double.POSITIVE_INFINITY;
2525 for (int i = 0; i < a.length; i += SPECIES.length()) {
2526 res = (double) Math.min(res, MINReduce(a, i));
2527 }
2528
2529 return res;
2530 }
2531
2532 @Test(dataProvider = "doubleUnaryOpProvider")
2533 static void MINReduceDoubleMaxVectorTests(IntFunction<double[]> fa) {
2534 double[] a = fa.apply(SPECIES.length());
2535 double[] r = fr.apply(SPECIES.length());
2536 double ra = Double.POSITIVE_INFINITY;
2537
2538 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2539 for (int i = 0; i < a.length; i += SPECIES.length()) {
2540 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2541 r[i] = av.reduceLanes(VectorOperators.MIN);
2542 }
2543 }
2544
2545 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2546 ra = Double.POSITIVE_INFINITY;
2547 for (int i = 0; i < a.length; i += SPECIES.length()) {
2548 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2549 ra = (double) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
2550 }
2551 }
2552
2553 assertReductionArraysEquals(r, ra, a,
2554 DoubleMaxVectorTests::MINReduce, DoubleMaxVectorTests::MINReduceAll);
2555 }
2556
2557 static double MINReduceMasked(double[] a, int idx, boolean[] mask) {
2558 double res = Double.POSITIVE_INFINITY;
2559 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2560 if (mask[i % SPECIES.length()])
2561 res = (double) Math.min(res, a[i]);
2562 }
2563
2564 return res;
2565 }
2566
2567 static double MINReduceAllMasked(double[] a, boolean[] mask) {
2568 double res = Double.POSITIVE_INFINITY;
2569 for (int i = 0; i < a.length; i += SPECIES.length()) {
2570 res = (double) Math.min(res, MINReduceMasked(a, i, mask));
2571 }
2572
2573 return res;
2574 }
2575
2576 @Test(dataProvider = "doubleUnaryOpMaskProvider")
2577 static void MINReduceDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2578 double[] a = fa.apply(SPECIES.length());
2579 double[] r = fr.apply(SPECIES.length());
2580 boolean[] mask = fm.apply(SPECIES.length());
2581 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2582 double ra = Double.POSITIVE_INFINITY;
2583
2584 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2585 for (int i = 0; i < a.length; i += SPECIES.length()) {
2586 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2587 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
2588 }
2589 }
2590
2591 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2592 ra = Double.POSITIVE_INFINITY;
2593 for (int i = 0; i < a.length; i += SPECIES.length()) {
2594 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2595 ra = (double) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
2596 }
2597 }
2598
2599 assertReductionArraysEqualsMasked(r, ra, a, mask,
2600 DoubleMaxVectorTests::MINReduceMasked, DoubleMaxVectorTests::MINReduceAllMasked);
2601 }
2602
2603 static double MAXReduce(double[] a, int idx) {
2604 double res = Double.NEGATIVE_INFINITY;
2605 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2606 res = (double) Math.max(res, a[i]);
2607 }
2608
2609 return res;
2610 }
2611
2612 static double MAXReduceAll(double[] a) {
2613 double res = Double.NEGATIVE_INFINITY;
2614 for (int i = 0; i < a.length; i += SPECIES.length()) {
2615 res = (double) Math.max(res, MAXReduce(a, i));
2616 }
2617
2618 return res;
2619 }
2620
2621 @Test(dataProvider = "doubleUnaryOpProvider")
2622 static void MAXReduceDoubleMaxVectorTests(IntFunction<double[]> fa) {
2623 double[] a = fa.apply(SPECIES.length());
2624 double[] r = fr.apply(SPECIES.length());
2625 double ra = Double.NEGATIVE_INFINITY;
2626
2627 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2628 for (int i = 0; i < a.length; i += SPECIES.length()) {
2629 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2630 r[i] = av.reduceLanes(VectorOperators.MAX);
2631 }
2632 }
2633
2634 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2635 ra = Double.NEGATIVE_INFINITY;
2636 for (int i = 0; i < a.length; i += SPECIES.length()) {
2637 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2638 ra = (double) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
2639 }
2640 }
2641
2642 assertReductionArraysEquals(r, ra, a,
2643 DoubleMaxVectorTests::MAXReduce, DoubleMaxVectorTests::MAXReduceAll);
2644 }
2645
2646 static double MAXReduceMasked(double[] a, int idx, boolean[] mask) {
2647 double res = Double.NEGATIVE_INFINITY;
2648 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2649 if (mask[i % SPECIES.length()])
2650 res = (double) Math.max(res, a[i]);
2651 }
2652
2653 return res;
2654 }
2655
2656 static double MAXReduceAllMasked(double[] a, boolean[] mask) {
2657 double res = Double.NEGATIVE_INFINITY;
2658 for (int i = 0; i < a.length; i += SPECIES.length()) {
2659 res = (double) Math.max(res, MAXReduceMasked(a, i, mask));
2660 }
2661
2662 return res;
2663 }
2664
2665 @Test(dataProvider = "doubleUnaryOpMaskProvider")
2666 static void MAXReduceDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2667 double[] a = fa.apply(SPECIES.length());
2668 double[] r = fr.apply(SPECIES.length());
2669 boolean[] mask = fm.apply(SPECIES.length());
2670 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2671 double ra = Double.NEGATIVE_INFINITY;
2672
2673 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2674 for (int i = 0; i < a.length; i += SPECIES.length()) {
2675 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2676 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
2677 }
2678 }
2679
2680 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2681 ra = Double.NEGATIVE_INFINITY;
2682 for (int i = 0; i < a.length; i += SPECIES.length()) {
2683 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2684 ra = (double) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
2685 }
2686 }
2687
2688 assertReductionArraysEqualsMasked(r, ra, a, mask,
2689 DoubleMaxVectorTests::MAXReduceMasked, DoubleMaxVectorTests::MAXReduceAllMasked);
2690 }
2691
2692 static double FIRST_NONZEROReduce(double[] a, int idx) {
2693 double res = (double) 0;
2694 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2695 res = firstNonZero(res, a[i]);
2696 }
2697
2698 return res;
2699 }
2700
2701 static double FIRST_NONZEROReduceAll(double[] a) {
2702 double res = (double) 0;
2703 for (int i = 0; i < a.length; i += SPECIES.length()) {
2704 res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
2705 }
2706
2707 return res;
2708 }
2709
2710 @Test(dataProvider = "doubleUnaryOpProvider")
2711 static void FIRST_NONZEROReduceDoubleMaxVectorTests(IntFunction<double[]> fa) {
2712 double[] a = fa.apply(SPECIES.length());
2713 double[] r = fr.apply(SPECIES.length());
2714 double ra = (double) 0;
2715
2716 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2717 for (int i = 0; i < a.length; i += SPECIES.length()) {
2718 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2719 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO);
2720 }
2721 }
2722
2723 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2724 ra = (double) 0;
2725 for (int i = 0; i < a.length; i += SPECIES.length()) {
2726 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2727 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
2728 }
2729 }
2730
2731 assertReductionArraysEquals(r, ra, a,
2732 DoubleMaxVectorTests::FIRST_NONZEROReduce, DoubleMaxVectorTests::FIRST_NONZEROReduceAll);
2733 }
2734
2735 static double FIRST_NONZEROReduceMasked(double[] a, int idx, boolean[] mask) {
2736 double res = (double) 0;
2737 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2738 if (mask[i % SPECIES.length()])
2739 res = firstNonZero(res, a[i]);
2740 }
2741
2742 return res;
2743 }
2744
2745 static double FIRST_NONZEROReduceAllMasked(double[] a, boolean[] mask) {
2746 double res = (double) 0;
2747 for (int i = 0; i < a.length; i += SPECIES.length()) {
2748 res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
2749 }
2750
2751 return res;
2752 }
2753
2754 @Test(dataProvider = "doubleUnaryOpMaskProvider")
2755 static void FIRST_NONZEROReduceDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
2756 double[] a = fa.apply(SPECIES.length());
2757 double[] r = fr.apply(SPECIES.length());
2758 boolean[] mask = fm.apply(SPECIES.length());
2759 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2760 double ra = (double) 0;
2761
2762 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2763 for (int i = 0; i < a.length; i += SPECIES.length()) {
2764 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2765 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask);
2766 }
2767 }
2768
2769 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2770 ra = (double) 0;
2771 for (int i = 0; i < a.length; i += SPECIES.length()) {
2772 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2773 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
2774 }
2775 }
2776
2777 assertReductionArraysEqualsMasked(r, ra, a, mask,
2778 DoubleMaxVectorTests::FIRST_NONZEROReduceMasked, DoubleMaxVectorTests::FIRST_NONZEROReduceAllMasked);
2779 }
2780
2781 @Test(dataProvider = "doubleBinaryOpProvider")
2782 static void withDoubleMaxVectorTests(IntFunction<double []> fa, IntFunction<double []> fb) {
2783 double[] a = fa.apply(SPECIES.length());
2784 double[] b = fb.apply(SPECIES.length());
2785 double[] r = fr.apply(SPECIES.length());
2786
2787 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2788 for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
2789 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2790 av.withLane(j, b[i + j]).intoArray(r, i);
2791 a[i + j] = b[i + j];
2792 j = (j + 1) & (SPECIES.length() - 1);
2793 }
2794 }
2795
2796
2797 assertArraysStrictlyEquals(r, a);
2798 }
2799
2800 static boolean testIS_DEFAULT(double a) {
2801 return bits(a)==0;
2802 }
2803
2804 @Test(dataProvider = "doubleTestOpProvider")
2805 static void IS_DEFAULTDoubleMaxVectorTests(IntFunction<double[]> fa) {
2806 double[] a = fa.apply(SPECIES.length());
2807
2808 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2809 for (int i = 0; i < a.length; i += SPECIES.length()) {
2810 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2811 VectorMask<Double> mv = av.test(VectorOperators.IS_DEFAULT);
2812
2813 // Check results as part of computation.
2814 for (int j = 0; j < SPECIES.length(); j++) {
2815 Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
2816 }
2817 }
2818 }
2819 }
2820
2821 @Test(dataProvider = "doubleTestOpMaskProvider")
2822 static void IS_DEFAULTMaskedDoubleMaxVectorTests(IntFunction<double[]> fa,
2823 IntFunction<boolean[]> fm) {
2824 double[] a = fa.apply(SPECIES.length());
2825 boolean[] mask = fm.apply(SPECIES.length());
2826 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2827
2828 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2829 for (int i = 0; i < a.length; i += SPECIES.length()) {
2830 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2831 VectorMask<Double> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
2832
2833 // Check results as part of computation.
2834 for (int j = 0; j < SPECIES.length(); j++) {
2835 Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
2836 }
2837 }
2838 }
2839 }
2840
2841 static boolean testIS_NEGATIVE(double a) {
2842 return bits(a)<0;
2843 }
2844
2845 @Test(dataProvider = "doubleTestOpProvider")
2846 static void IS_NEGATIVEDoubleMaxVectorTests(IntFunction<double[]> fa) {
2847 double[] a = fa.apply(SPECIES.length());
2848
2849 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2850 for (int i = 0; i < a.length; i += SPECIES.length()) {
2851 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2852 VectorMask<Double> mv = av.test(VectorOperators.IS_NEGATIVE);
2853
2854 // Check results as part of computation.
2855 for (int j = 0; j < SPECIES.length(); j++) {
2856 Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
2857 }
2858 }
2859 }
2860 }
2861
2862 @Test(dataProvider = "doubleTestOpMaskProvider")
2863 static void IS_NEGATIVEMaskedDoubleMaxVectorTests(IntFunction<double[]> fa,
2864 IntFunction<boolean[]> fm) {
2865 double[] a = fa.apply(SPECIES.length());
2866 boolean[] mask = fm.apply(SPECIES.length());
2867 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2868
2869 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2870 for (int i = 0; i < a.length; i += SPECIES.length()) {
2871 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2872 VectorMask<Double> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
2873
2874 // Check results as part of computation.
2875 for (int j = 0; j < SPECIES.length(); j++) {
2876 Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
2877 }
2878 }
2879 }
2880 }
2881
2882 static boolean testIS_FINITE(double a) {
2883 return Double.isFinite(a);
2884 }
2885
2886 @Test(dataProvider = "doubleTestOpProvider")
2887 static void IS_FINITEDoubleMaxVectorTests(IntFunction<double[]> fa) {
2888 double[] a = fa.apply(SPECIES.length());
2889
2890 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2891 for (int i = 0; i < a.length; i += SPECIES.length()) {
2892 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2893 VectorMask<Double> mv = av.test(VectorOperators.IS_FINITE);
2894
2895 // Check results as part of computation.
2896 for (int j = 0; j < SPECIES.length(); j++) {
2897 Assert.assertEquals(mv.laneIsSet(j), testIS_FINITE(a[i + j]));
2898 }
2899 }
2900 }
2901 }
2902
2903 @Test(dataProvider = "doubleTestOpMaskProvider")
2904 static void IS_FINITEMaskedDoubleMaxVectorTests(IntFunction<double[]> fa,
2905 IntFunction<boolean[]> fm) {
2906 double[] a = fa.apply(SPECIES.length());
2907 boolean[] mask = fm.apply(SPECIES.length());
2908 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2909
2910 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2911 for (int i = 0; i < a.length; i += SPECIES.length()) {
2912 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2913 VectorMask<Double> mv = av.test(VectorOperators.IS_FINITE, vmask);
2914
2915 // Check results as part of computation.
2916 for (int j = 0; j < SPECIES.length(); j++) {
2917 Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_FINITE(a[i + j]));
2918 }
2919 }
2920 }
2921 }
2922
2923 static boolean testIS_NAN(double a) {
2924 return Double.isNaN(a);
2925 }
2926
2927 @Test(dataProvider = "doubleTestOpProvider")
2928 static void IS_NANDoubleMaxVectorTests(IntFunction<double[]> fa) {
2929 double[] a = fa.apply(SPECIES.length());
2930
2931 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2932 for (int i = 0; i < a.length; i += SPECIES.length()) {
2933 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2934 VectorMask<Double> mv = av.test(VectorOperators.IS_NAN);
2935
2936 // Check results as part of computation.
2937 for (int j = 0; j < SPECIES.length(); j++) {
2938 Assert.assertEquals(mv.laneIsSet(j), testIS_NAN(a[i + j]));
2939 }
2940 }
2941 }
2942 }
2943
2944 @Test(dataProvider = "doubleTestOpMaskProvider")
2945 static void IS_NANMaskedDoubleMaxVectorTests(IntFunction<double[]> fa,
2946 IntFunction<boolean[]> fm) {
2947 double[] a = fa.apply(SPECIES.length());
2948 boolean[] mask = fm.apply(SPECIES.length());
2949 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2950
2951 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2952 for (int i = 0; i < a.length; i += SPECIES.length()) {
2953 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2954 VectorMask<Double> mv = av.test(VectorOperators.IS_NAN, vmask);
2955
2956 // Check results as part of computation.
2957 for (int j = 0; j < SPECIES.length(); j++) {
2958 Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_NAN(a[i + j]));
2959 }
2960 }
2961 }
2962 }
2963
2964 static boolean testIS_INFINITE(double a) {
2965 return Double.isInfinite(a);
2966 }
2967
2968 @Test(dataProvider = "doubleTestOpProvider")
2969 static void IS_INFINITEDoubleMaxVectorTests(IntFunction<double[]> fa) {
2970 double[] a = fa.apply(SPECIES.length());
2971
2972 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2973 for (int i = 0; i < a.length; i += SPECIES.length()) {
2974 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2975 VectorMask<Double> mv = av.test(VectorOperators.IS_INFINITE);
2976
2977 // Check results as part of computation.
2978 for (int j = 0; j < SPECIES.length(); j++) {
2979 Assert.assertEquals(mv.laneIsSet(j), testIS_INFINITE(a[i + j]));
2980 }
2981 }
2982 }
2983 }
2984
2985 @Test(dataProvider = "doubleTestOpMaskProvider")
2986 static void IS_INFINITEMaskedDoubleMaxVectorTests(IntFunction<double[]> fa,
2987 IntFunction<boolean[]> fm) {
2988 double[] a = fa.apply(SPECIES.length());
2989 boolean[] mask = fm.apply(SPECIES.length());
2990 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2991
2992 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2993 for (int i = 0; i < a.length; i += SPECIES.length()) {
2994 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
2995 VectorMask<Double> mv = av.test(VectorOperators.IS_INFINITE, vmask);
2996
2997 // Check results as part of computation.
2998 for (int j = 0; j < SPECIES.length(); j++) {
2999 Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_INFINITE(a[i + j]));
3000 }
3001 }
3002 }
3003 }
3004
3005 @Test(dataProvider = "doubleCompareOpProvider")
3006 static void LTDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3007 double[] a = fa.apply(SPECIES.length());
3008 double[] b = fb.apply(SPECIES.length());
3009
3010 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3011 for (int i = 0; i < a.length; i += SPECIES.length()) {
3012 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3013 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3014 VectorMask<Double> mv = av.compare(VectorOperators.LT, bv);
3015
3016 // Check results as part of computation.
3017 for (int j = 0; j < SPECIES.length(); j++) {
3018 Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3019 }
3020 }
3021 }
3022 }
3023
3024 @Test(dataProvider = "doubleCompareOpProvider")
3025 static void ltDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3026 double[] a = fa.apply(SPECIES.length());
3027 double[] b = fb.apply(SPECIES.length());
3028
3029 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3030 for (int i = 0; i < a.length; i += SPECIES.length()) {
3031 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3032 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3033 VectorMask<Double> mv = av.lt(bv);
3034
3035 // Check results as part of computation.
3036 for (int j = 0; j < SPECIES.length(); j++) {
3037 Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3038 }
3039 }
3040 }
3041 }
3042
3043 @Test(dataProvider = "doubleCompareOpMaskProvider")
3044 static void LTDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3045 IntFunction<boolean[]> fm) {
3046 double[] a = fa.apply(SPECIES.length());
3047 double[] b = fb.apply(SPECIES.length());
3048 boolean[] mask = fm.apply(SPECIES.length());
3049
3050 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3051
3052 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3053 for (int i = 0; i < a.length; i += SPECIES.length()) {
3054 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3055 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3056 VectorMask<Double> mv = av.compare(VectorOperators.LT, bv, vmask);
3057
3058 // Check results as part of computation.
3059 for (int j = 0; j < SPECIES.length(); j++) {
3060 Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
3061 }
3062 }
3063 }
3064 }
3065
3066 @Test(dataProvider = "doubleCompareOpProvider")
3067 static void GTDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3068 double[] a = fa.apply(SPECIES.length());
3069 double[] b = fb.apply(SPECIES.length());
3070
3071 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3072 for (int i = 0; i < a.length; i += SPECIES.length()) {
3073 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3074 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3075 VectorMask<Double> mv = av.compare(VectorOperators.GT, bv);
3076
3077 // Check results as part of computation.
3078 for (int j = 0; j < SPECIES.length(); j++) {
3079 Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
3080 }
3081 }
3082 }
3083 }
3084
3085 @Test(dataProvider = "doubleCompareOpMaskProvider")
3086 static void GTDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3087 IntFunction<boolean[]> fm) {
3088 double[] a = fa.apply(SPECIES.length());
3089 double[] b = fb.apply(SPECIES.length());
3090 boolean[] mask = fm.apply(SPECIES.length());
3091
3092 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3093
3094 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3095 for (int i = 0; i < a.length; i += SPECIES.length()) {
3096 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3097 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3098 VectorMask<Double> mv = av.compare(VectorOperators.GT, bv, vmask);
3099
3100 // Check results as part of computation.
3101 for (int j = 0; j < SPECIES.length(); j++) {
3102 Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
3103 }
3104 }
3105 }
3106 }
3107
3108 @Test(dataProvider = "doubleCompareOpProvider")
3109 static void EQDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3110 double[] a = fa.apply(SPECIES.length());
3111 double[] b = fb.apply(SPECIES.length());
3112
3113 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3114 for (int i = 0; i < a.length; i += SPECIES.length()) {
3115 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3116 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3117 VectorMask<Double> mv = av.compare(VectorOperators.EQ, bv);
3118
3119 // Check results as part of computation.
3120 for (int j = 0; j < SPECIES.length(); j++) {
3121 Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3122 }
3123 }
3124 }
3125 }
3126
3127 @Test(dataProvider = "doubleCompareOpProvider")
3128 static void eqDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3129 double[] a = fa.apply(SPECIES.length());
3130 double[] b = fb.apply(SPECIES.length());
3131
3132 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3133 for (int i = 0; i < a.length; i += SPECIES.length()) {
3134 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3135 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3136 VectorMask<Double> mv = av.eq(bv);
3137
3138 // Check results as part of computation.
3139 for (int j = 0; j < SPECIES.length(); j++) {
3140 Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3141 }
3142 }
3143 }
3144 }
3145
3146 @Test(dataProvider = "doubleCompareOpMaskProvider")
3147 static void EQDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3148 IntFunction<boolean[]> fm) {
3149 double[] a = fa.apply(SPECIES.length());
3150 double[] b = fb.apply(SPECIES.length());
3151 boolean[] mask = fm.apply(SPECIES.length());
3152
3153 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3154
3155 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3156 for (int i = 0; i < a.length; i += SPECIES.length()) {
3157 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3158 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3159 VectorMask<Double> mv = av.compare(VectorOperators.EQ, bv, vmask);
3160
3161 // Check results as part of computation.
3162 for (int j = 0; j < SPECIES.length(); j++) {
3163 Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
3164 }
3165 }
3166 }
3167 }
3168
3169 @Test(dataProvider = "doubleCompareOpProvider")
3170 static void NEDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3171 double[] a = fa.apply(SPECIES.length());
3172 double[] b = fb.apply(SPECIES.length());
3173
3174 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3175 for (int i = 0; i < a.length; i += SPECIES.length()) {
3176 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3177 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3178 VectorMask<Double> mv = av.compare(VectorOperators.NE, bv);
3179
3180 // Check results as part of computation.
3181 for (int j = 0; j < SPECIES.length(); j++) {
3182 Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
3183 }
3184 }
3185 }
3186 }
3187
3188 @Test(dataProvider = "doubleCompareOpMaskProvider")
3189 static void NEDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3190 IntFunction<boolean[]> fm) {
3191 double[] a = fa.apply(SPECIES.length());
3192 double[] b = fb.apply(SPECIES.length());
3193 boolean[] mask = fm.apply(SPECIES.length());
3194
3195 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3196
3197 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3198 for (int i = 0; i < a.length; i += SPECIES.length()) {
3199 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3200 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3201 VectorMask<Double> mv = av.compare(VectorOperators.NE, bv, vmask);
3202
3203 // Check results as part of computation.
3204 for (int j = 0; j < SPECIES.length(); j++) {
3205 Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
3206 }
3207 }
3208 }
3209 }
3210
3211 @Test(dataProvider = "doubleCompareOpProvider")
3212 static void LEDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3213 double[] a = fa.apply(SPECIES.length());
3214 double[] b = fb.apply(SPECIES.length());
3215
3216 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3217 for (int i = 0; i < a.length; i += SPECIES.length()) {
3218 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3219 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3220 VectorMask<Double> mv = av.compare(VectorOperators.LE, bv);
3221
3222 // Check results as part of computation.
3223 for (int j = 0; j < SPECIES.length(); j++) {
3224 Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
3225 }
3226 }
3227 }
3228 }
3229
3230 @Test(dataProvider = "doubleCompareOpMaskProvider")
3231 static void LEDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3232 IntFunction<boolean[]> fm) {
3233 double[] a = fa.apply(SPECIES.length());
3234 double[] b = fb.apply(SPECIES.length());
3235 boolean[] mask = fm.apply(SPECIES.length());
3236
3237 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3238
3239 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3240 for (int i = 0; i < a.length; i += SPECIES.length()) {
3241 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3242 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3243 VectorMask<Double> mv = av.compare(VectorOperators.LE, bv, vmask);
3244
3245 // Check results as part of computation.
3246 for (int j = 0; j < SPECIES.length(); j++) {
3247 Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
3248 }
3249 }
3250 }
3251 }
3252
3253 @Test(dataProvider = "doubleCompareOpProvider")
3254 static void GEDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3255 double[] a = fa.apply(SPECIES.length());
3256 double[] b = fb.apply(SPECIES.length());
3257
3258 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3259 for (int i = 0; i < a.length; i += SPECIES.length()) {
3260 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3261 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3262 VectorMask<Double> mv = av.compare(VectorOperators.GE, bv);
3263
3264 // Check results as part of computation.
3265 for (int j = 0; j < SPECIES.length(); j++) {
3266 Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
3267 }
3268 }
3269 }
3270 }
3271
3272 @Test(dataProvider = "doubleCompareOpMaskProvider")
3273 static void GEDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3274 IntFunction<boolean[]> fm) {
3275 double[] a = fa.apply(SPECIES.length());
3276 double[] b = fb.apply(SPECIES.length());
3277 boolean[] mask = fm.apply(SPECIES.length());
3278
3279 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3280
3281 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3282 for (int i = 0; i < a.length; i += SPECIES.length()) {
3283 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3284 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3285 VectorMask<Double> mv = av.compare(VectorOperators.GE, bv, vmask);
3286
3287 // Check results as part of computation.
3288 for (int j = 0; j < SPECIES.length(); j++) {
3289 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
3290 }
3291 }
3292 }
3293 }
3294
3295 @Test(dataProvider = "doubleCompareOpProvider")
3296 static void LTDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3297 double[] a = fa.apply(SPECIES.length());
3298 double[] b = fb.apply(SPECIES.length());
3299
3300 for (int i = 0; i < a.length; i += SPECIES.length()) {
3301 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3302 VectorMask<Double> mv = av.compare(VectorOperators.LT, b[i]);
3303
3304 // Check results as part of computation.
3305 for (int j = 0; j < SPECIES.length(); j++) {
3306 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
3307 }
3308 }
3309 }
3310
3311 @Test(dataProvider = "doubleCompareOpMaskProvider")
3312 static void LTDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa,
3313 IntFunction<double[]> fb, IntFunction<boolean[]> fm) {
3314 double[] a = fa.apply(SPECIES.length());
3315 double[] b = fb.apply(SPECIES.length());
3316 boolean[] mask = fm.apply(SPECIES.length());
3317
3318 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3319
3320 for (int i = 0; i < a.length; i += SPECIES.length()) {
3321 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3322 VectorMask<Double> mv = av.compare(VectorOperators.LT, b[i], vmask);
3323
3324 // Check results as part of computation.
3325 for (int j = 0; j < SPECIES.length(); j++) {
3326 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
3327 }
3328 }
3329 }
3330
3331 @Test(dataProvider = "doubleCompareOpProvider")
3332 static void LTDoubleMaxVectorTestsBroadcastLongSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3333 double[] a = fa.apply(SPECIES.length());
3334 double[] b = fb.apply(SPECIES.length());
3335
3336 for (int i = 0; i < a.length; i += SPECIES.length()) {
3337 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3338 VectorMask<Double> mv = av.compare(VectorOperators.LT, (long)b[i]);
3339
3340 // Check results as part of computation.
3341 for (int j = 0; j < SPECIES.length(); j++) {
3342 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (double)((long)b[i]));
3343 }
3344 }
3345 }
3346
3347 @Test(dataProvider = "doubleCompareOpMaskProvider")
3348 static void LTDoubleMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<double[]> fa,
3349 IntFunction<double[]> fb, IntFunction<boolean[]> fm) {
3350 double[] a = fa.apply(SPECIES.length());
3351 double[] b = fb.apply(SPECIES.length());
3352 boolean[] mask = fm.apply(SPECIES.length());
3353
3354 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3355
3356 for (int i = 0; i < a.length; i += SPECIES.length()) {
3357 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3358 VectorMask<Double> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
3359
3360 // Check results as part of computation.
3361 for (int j = 0; j < SPECIES.length(); j++) {
3362 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (double)((long)b[i])));
3363 }
3364 }
3365 }
3366
3367 @Test(dataProvider = "doubleCompareOpProvider")
3368 static void EQDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3369 double[] a = fa.apply(SPECIES.length());
3370 double[] b = fb.apply(SPECIES.length());
3371
3372 for (int i = 0; i < a.length; i += SPECIES.length()) {
3373 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3374 VectorMask<Double> mv = av.compare(VectorOperators.EQ, b[i]);
3375
3376 // Check results as part of computation.
3377 for (int j = 0; j < SPECIES.length(); j++) {
3378 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
3379 }
3380 }
3381 }
3382
3383 @Test(dataProvider = "doubleCompareOpMaskProvider")
3384 static void EQDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa,
3385 IntFunction<double[]> fb, IntFunction<boolean[]> fm) {
3386 double[] a = fa.apply(SPECIES.length());
3387 double[] b = fb.apply(SPECIES.length());
3388 boolean[] mask = fm.apply(SPECIES.length());
3389
3390 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3391
3392 for (int i = 0; i < a.length; i += SPECIES.length()) {
3393 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3394 VectorMask<Double> mv = av.compare(VectorOperators.EQ, b[i], vmask);
3395
3396 // Check results as part of computation.
3397 for (int j = 0; j < SPECIES.length(); j++) {
3398 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
3399 }
3400 }
3401 }
3402
3403 @Test(dataProvider = "doubleCompareOpProvider")
3404 static void EQDoubleMaxVectorTestsBroadcastLongSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3405 double[] a = fa.apply(SPECIES.length());
3406 double[] b = fb.apply(SPECIES.length());
3407
3408 for (int i = 0; i < a.length; i += SPECIES.length()) {
3409 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3410 VectorMask<Double> mv = av.compare(VectorOperators.EQ, (long)b[i]);
3411
3412 // Check results as part of computation.
3413 for (int j = 0; j < SPECIES.length(); j++) {
3414 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (double)((long)b[i]));
3415 }
3416 }
3417 }
3418
3419 @Test(dataProvider = "doubleCompareOpMaskProvider")
3420 static void EQDoubleMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<double[]> fa,
3421 IntFunction<double[]> fb, IntFunction<boolean[]> fm) {
3422 double[] a = fa.apply(SPECIES.length());
3423 double[] b = fb.apply(SPECIES.length());
3424 boolean[] mask = fm.apply(SPECIES.length());
3425
3426 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3427
3428 for (int i = 0; i < a.length; i += SPECIES.length()) {
3429 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3430 VectorMask<Double> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
3431
3432 // Check results as part of computation.
3433 for (int j = 0; j < SPECIES.length(); j++) {
3434 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (double)((long)b[i])));
3435 }
3436 }
3437 }
3438
3439 static double blend(double a, double b, boolean mask) {
3440 return mask ? b : a;
3441 }
3442
3443 @Test(dataProvider = "doubleBinaryOpMaskProvider")
3444 static void blendDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb,
3445 IntFunction<boolean[]> fm) {
3446 double[] a = fa.apply(SPECIES.length());
3447 double[] b = fb.apply(SPECIES.length());
3448 double[] r = fr.apply(SPECIES.length());
3449 boolean[] mask = fm.apply(SPECIES.length());
3450 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3451
3452 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3453 for (int i = 0; i < a.length; i += SPECIES.length()) {
3454 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3455 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3456 av.blend(bv, vmask).intoArray(r, i);
3457 }
3458 }
3459
3460 assertArraysEquals(r, a, b, mask, DoubleMaxVectorTests::blend);
3461 }
3462
3463 @Test(dataProvider = "doubleUnaryOpShuffleProvider")
3464 static void RearrangeDoubleMaxVectorTests(IntFunction<double[]> fa,
3465 BiFunction<Integer,Integer,int[]> fs) {
3466 double[] a = fa.apply(SPECIES.length());
3467 int[] order = fs.apply(a.length, SPECIES.length());
3468 double[] r = fr.apply(SPECIES.length());
3469
3470 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3471 for (int i = 0; i < a.length; i += SPECIES.length()) {
3472 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3473 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
3474 }
3475 }
3476
3477 assertRearrangeArraysEquals(r, a, order, SPECIES.length());
3478 }
3479
3480 @Test(dataProvider = "doubleUnaryOpShuffleMaskProvider")
3481 static void RearrangeDoubleMaxVectorTestsMaskedSmokeTest(IntFunction<double[]> fa,
3482 BiFunction<Integer,Integer,int[]> fs,
3483 IntFunction<boolean[]> fm) {
3484 double[] a = fa.apply(SPECIES.length());
3485 int[] order = fs.apply(a.length, SPECIES.length());
3486 double[] r = fr.apply(SPECIES.length());
3487 boolean[] mask = fm.apply(SPECIES.length());
3488 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3489
3490 for (int i = 0; i < a.length; i += SPECIES.length()) {
3491 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3492 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
3493 }
3494
3495 assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
3496 }
3497
3498 @Test(dataProvider = "doubleUnaryOpMaskProvider")
3499 static void compressDoubleMaxVectorTests(IntFunction<double[]> fa,
3500 IntFunction<boolean[]> fm) {
3501 double[] a = fa.apply(SPECIES.length());
3502 double[] r = fr.apply(SPECIES.length());
3503 boolean[] mask = fm.apply(SPECIES.length());
3504 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3505
3506 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3507 for (int i = 0; i < a.length; i += SPECIES.length()) {
3508 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3509 av.compress(vmask).intoArray(r, i);
3510 }
3511 }
3512
3513 assertcompressArraysEquals(r, a, mask, SPECIES.length());
3514 }
3515
3516 @Test(dataProvider = "doubleUnaryOpMaskProvider")
3517 static void expandDoubleMaxVectorTests(IntFunction<double[]> fa,
3518 IntFunction<boolean[]> fm) {
3519 double[] a = fa.apply(SPECIES.length());
3520 double[] r = fr.apply(SPECIES.length());
3521 boolean[] mask = fm.apply(SPECIES.length());
3522 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3523
3524 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3525 for (int i = 0; i < a.length; i += SPECIES.length()) {
3526 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3527 av.expand(vmask).intoArray(r, i);
3528 }
3529 }
3530
3531 assertexpandArraysEquals(r, a, mask, SPECIES.length());
3532 }
3533
3534 @Test(dataProvider = "doubleUnaryOpProvider")
3535 static void getDoubleMaxVectorTests(IntFunction<double[]> fa) {
3536 double[] a = fa.apply(SPECIES.length());
3537 double[] r = fr.apply(SPECIES.length());
3538
3539 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3540 for (int i = 0; i < a.length; i += SPECIES.length()) {
3541 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3542 int num_lanes = SPECIES.length();
3543 // Manually unroll because full unroll happens after intrinsification.
3544 // Unroll is needed because get intrinsic requires for index to be a known constant.
3545 if (num_lanes == 1) {
3546 r[i]=av.lane(0);
3547 } else if (num_lanes == 2) {
3548 r[i]=av.lane(0);
3549 r[i+1]=av.lane(1);
3550 } else if (num_lanes == 4) {
3551 r[i]=av.lane(0);
3552 r[i+1]=av.lane(1);
3553 r[i+2]=av.lane(2);
3554 r[i+3]=av.lane(3);
3555 } else if (num_lanes == 8) {
3556 r[i]=av.lane(0);
3557 r[i+1]=av.lane(1);
3558 r[i+2]=av.lane(2);
3559 r[i+3]=av.lane(3);
3560 r[i+4]=av.lane(4);
3561 r[i+5]=av.lane(5);
3562 r[i+6]=av.lane(6);
3563 r[i+7]=av.lane(7);
3564 } else if (num_lanes == 16) {
3565 r[i]=av.lane(0);
3566 r[i+1]=av.lane(1);
3567 r[i+2]=av.lane(2);
3568 r[i+3]=av.lane(3);
3569 r[i+4]=av.lane(4);
3570 r[i+5]=av.lane(5);
3571 r[i+6]=av.lane(6);
3572 r[i+7]=av.lane(7);
3573 r[i+8]=av.lane(8);
3574 r[i+9]=av.lane(9);
3575 r[i+10]=av.lane(10);
3576 r[i+11]=av.lane(11);
3577 r[i+12]=av.lane(12);
3578 r[i+13]=av.lane(13);
3579 r[i+14]=av.lane(14);
3580 r[i+15]=av.lane(15);
3581 } else if (num_lanes == 32) {
3582 r[i]=av.lane(0);
3583 r[i+1]=av.lane(1);
3584 r[i+2]=av.lane(2);
3585 r[i+3]=av.lane(3);
3586 r[i+4]=av.lane(4);
3587 r[i+5]=av.lane(5);
3588 r[i+6]=av.lane(6);
3589 r[i+7]=av.lane(7);
3590 r[i+8]=av.lane(8);
3591 r[i+9]=av.lane(9);
3592 r[i+10]=av.lane(10);
3593 r[i+11]=av.lane(11);
3594 r[i+12]=av.lane(12);
3595 r[i+13]=av.lane(13);
3596 r[i+14]=av.lane(14);
3597 r[i+15]=av.lane(15);
3598 r[i+16]=av.lane(16);
3599 r[i+17]=av.lane(17);
3600 r[i+18]=av.lane(18);
3601 r[i+19]=av.lane(19);
3602 r[i+20]=av.lane(20);
3603 r[i+21]=av.lane(21);
3604 r[i+22]=av.lane(22);
3605 r[i+23]=av.lane(23);
3606 r[i+24]=av.lane(24);
3607 r[i+25]=av.lane(25);
3608 r[i+26]=av.lane(26);
3609 r[i+27]=av.lane(27);
3610 r[i+28]=av.lane(28);
3611 r[i+29]=av.lane(29);
3612 r[i+30]=av.lane(30);
3613 r[i+31]=av.lane(31);
3614 } else if (num_lanes == 64) {
3615 r[i]=av.lane(0);
3616 r[i+1]=av.lane(1);
3617 r[i+2]=av.lane(2);
3618 r[i+3]=av.lane(3);
3619 r[i+4]=av.lane(4);
3620 r[i+5]=av.lane(5);
3621 r[i+6]=av.lane(6);
3622 r[i+7]=av.lane(7);
3623 r[i+8]=av.lane(8);
3624 r[i+9]=av.lane(9);
3625 r[i+10]=av.lane(10);
3626 r[i+11]=av.lane(11);
3627 r[i+12]=av.lane(12);
3628 r[i+13]=av.lane(13);
3629 r[i+14]=av.lane(14);
3630 r[i+15]=av.lane(15);
3631 r[i+16]=av.lane(16);
3632 r[i+17]=av.lane(17);
3633 r[i+18]=av.lane(18);
3634 r[i+19]=av.lane(19);
3635 r[i+20]=av.lane(20);
3636 r[i+21]=av.lane(21);
3637 r[i+22]=av.lane(22);
3638 r[i+23]=av.lane(23);
3639 r[i+24]=av.lane(24);
3640 r[i+25]=av.lane(25);
3641 r[i+26]=av.lane(26);
3642 r[i+27]=av.lane(27);
3643 r[i+28]=av.lane(28);
3644 r[i+29]=av.lane(29);
3645 r[i+30]=av.lane(30);
3646 r[i+31]=av.lane(31);
3647 r[i+32]=av.lane(32);
3648 r[i+33]=av.lane(33);
3649 r[i+34]=av.lane(34);
3650 r[i+35]=av.lane(35);
3651 r[i+36]=av.lane(36);
3652 r[i+37]=av.lane(37);
3653 r[i+38]=av.lane(38);
3654 r[i+39]=av.lane(39);
3655 r[i+40]=av.lane(40);
3656 r[i+41]=av.lane(41);
3657 r[i+42]=av.lane(42);
3658 r[i+43]=av.lane(43);
3659 r[i+44]=av.lane(44);
3660 r[i+45]=av.lane(45);
3661 r[i+46]=av.lane(46);
3662 r[i+47]=av.lane(47);
3663 r[i+48]=av.lane(48);
3664 r[i+49]=av.lane(49);
3665 r[i+50]=av.lane(50);
3666 r[i+51]=av.lane(51);
3667 r[i+52]=av.lane(52);
3668 r[i+53]=av.lane(53);
3669 r[i+54]=av.lane(54);
3670 r[i+55]=av.lane(55);
3671 r[i+56]=av.lane(56);
3672 r[i+57]=av.lane(57);
3673 r[i+58]=av.lane(58);
3674 r[i+59]=av.lane(59);
3675 r[i+60]=av.lane(60);
3676 r[i+61]=av.lane(61);
3677 r[i+62]=av.lane(62);
3678 r[i+63]=av.lane(63);
3679 } else {
3680 for (int j = 0; j < SPECIES.length(); j++) {
3681 r[i+j]=av.lane(j);
3682 }
3683 }
3684 }
3685 }
3686
3687 assertArraysStrictlyEquals(r, a);
3688 }
3689
3690 @Test(dataProvider = "doubleUnaryOpProvider")
3691 static void BroadcastDoubleMaxVectorTests(IntFunction<double[]> fa) {
3692 double[] a = fa.apply(SPECIES.length());
3693 double[] r = new double[a.length];
3694
3695 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3696 for (int i = 0; i < a.length; i += SPECIES.length()) {
3697 DoubleVector.broadcast(SPECIES, a[i]).intoArray(r, i);
3698 }
3699 }
3700
3701 assertBroadcastArraysEquals(r, a);
3702 }
3703
3704 @Test(dataProvider = "doubleUnaryOpProvider")
3705 static void ZeroDoubleMaxVectorTests(IntFunction<double[]> fa) {
3706 double[] a = fa.apply(SPECIES.length());
3707 double[] r = new double[a.length];
3708
3709 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3710 for (int i = 0; i < a.length; i += SPECIES.length()) {
3711 DoubleVector.zero(SPECIES).intoArray(a, i);
3712 }
3713 }
3714
3715 Assert.assertEquals(a, r);
3716 }
3717
3718 static double[] sliceUnary(double[] a, int origin, int idx) {
3719 double[] res = new double[SPECIES.length()];
3720 for (int i = 0; i < SPECIES.length(); i++){
3721 if(i+origin < SPECIES.length())
3722 res[i] = a[idx+i+origin];
3723 else
3724 res[i] = (double)0;
3725 }
3726 return res;
3727 }
3728
3729 @Test(dataProvider = "doubleUnaryOpProvider")
3730 static void sliceUnaryDoubleMaxVectorTests(IntFunction<double[]> fa) {
3731 double[] a = fa.apply(SPECIES.length());
3732 double[] r = new double[a.length];
3733 int origin = RAND.nextInt(SPECIES.length());
3734 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3735 for (int i = 0; i < a.length; i += SPECIES.length()) {
3736 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3737 av.slice(origin).intoArray(r, i);
3738 }
3739 }
3740
3741 assertArraysEquals(r, a, origin, DoubleMaxVectorTests::sliceUnary);
3742 }
3743
3744 static double[] sliceBinary(double[] a, double[] b, int origin, int idx) {
3745 double[] res = new double[SPECIES.length()];
3746 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3747 if(i+origin < SPECIES.length())
3748 res[i] = a[idx+i+origin];
3749 else {
3750 res[i] = b[idx+j];
3751 j++;
3752 }
3753 }
3754 return res;
3755 }
3756
3757 @Test(dataProvider = "doubleBinaryOpProvider")
3758 static void sliceBinaryDoubleMaxVectorTestsBinary(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3759 double[] a = fa.apply(SPECIES.length());
3760 double[] b = fb.apply(SPECIES.length());
3761 double[] r = new double[a.length];
3762 int origin = RAND.nextInt(SPECIES.length());
3763 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3764 for (int i = 0; i < a.length; i += SPECIES.length()) {
3765 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3766 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3767 av.slice(origin, bv).intoArray(r, i);
3768 }
3769 }
3770
3771 assertArraysEquals(r, a, b, origin, DoubleMaxVectorTests::sliceBinary);
3772 }
3773
3774 static double[] slice(double[] a, double[] b, int origin, boolean[] mask, int idx) {
3775 double[] res = new double[SPECIES.length()];
3776 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3777 if(i+origin < SPECIES.length())
3778 res[i] = mask[i] ? a[idx+i+origin] : (double)0;
3779 else {
3780 res[i] = mask[i] ? b[idx+j] : (double)0;
3781 j++;
3782 }
3783 }
3784 return res;
3785 }
3786
3787 @Test(dataProvider = "doubleBinaryOpMaskProvider")
3788 static void sliceDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3789 IntFunction<boolean[]> fm) {
3790 double[] a = fa.apply(SPECIES.length());
3791 double[] b = fb.apply(SPECIES.length());
3792 boolean[] mask = fm.apply(SPECIES.length());
3793 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3794
3795 double[] r = new double[a.length];
3796 int origin = RAND.nextInt(SPECIES.length());
3797 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3798 for (int i = 0; i < a.length; i += SPECIES.length()) {
3799 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3800 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3801 av.slice(origin, bv, vmask).intoArray(r, i);
3802 }
3803 }
3804
3805 assertArraysEquals(r, a, b, origin, mask, DoubleMaxVectorTests::slice);
3806 }
3807
3808 static double[] unsliceUnary(double[] a, int origin, int idx) {
3809 double[] res = new double[SPECIES.length()];
3810 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3811 if(i < origin)
3812 res[i] = (double)0;
3813 else {
3814 res[i] = a[idx+j];
3815 j++;
3816 }
3817 }
3818 return res;
3819 }
3820
3821 @Test(dataProvider = "doubleUnaryOpProvider")
3822 static void unsliceUnaryDoubleMaxVectorTests(IntFunction<double[]> fa) {
3823 double[] a = fa.apply(SPECIES.length());
3824 double[] r = new double[a.length];
3825 int origin = RAND.nextInt(SPECIES.length());
3826 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3827 for (int i = 0; i < a.length; i += SPECIES.length()) {
3828 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3829 av.unslice(origin).intoArray(r, i);
3830 }
3831 }
3832
3833 assertArraysEquals(r, a, origin, DoubleMaxVectorTests::unsliceUnary);
3834 }
3835
3836 static double[] unsliceBinary(double[] a, double[] b, int origin, int part, int idx) {
3837 double[] res = new double[SPECIES.length()];
3838 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3839 if (part == 0) {
3840 if (i < origin)
3841 res[i] = b[idx+i];
3842 else {
3843 res[i] = a[idx+j];
3844 j++;
3845 }
3846 } else if (part == 1) {
3847 if (i < origin)
3848 res[i] = a[idx+SPECIES.length()-origin+i];
3849 else {
3850 res[i] = b[idx+origin+j];
3851 j++;
3852 }
3853 }
3854 }
3855 return res;
3856 }
3857
3858 @Test(dataProvider = "doubleBinaryOpProvider")
3859 static void unsliceBinaryDoubleMaxVectorTestsBinary(IntFunction<double[]> fa, IntFunction<double[]> fb) {
3860 double[] a = fa.apply(SPECIES.length());
3861 double[] b = fb.apply(SPECIES.length());
3862 double[] r = new double[a.length];
3863 int origin = RAND.nextInt(SPECIES.length());
3864 int part = RAND.nextInt(2);
3865 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3866 for (int i = 0; i < a.length; i += SPECIES.length()) {
3867 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3868 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3869 av.unslice(origin, bv, part).intoArray(r, i);
3870 }
3871 }
3872
3873 assertArraysEquals(r, a, b, origin, part, DoubleMaxVectorTests::unsliceBinary);
3874 }
3875
3876 static double[] unslice(double[] a, double[] b, int origin, int part, boolean[] mask, int idx) {
3877 double[] res = new double[SPECIES.length()];
3878 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3879 if(i+origin < SPECIES.length())
3880 res[i] = b[idx+i+origin];
3881 else {
3882 res[i] = b[idx+j];
3883 j++;
3884 }
3885 }
3886 for (int i = 0; i < SPECIES.length(); i++){
3887 res[i] = mask[i] ? a[idx+i] : res[i];
3888 }
3889 double[] res1 = new double[SPECIES.length()];
3890 if (part == 0) {
3891 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3892 if (i < origin)
3893 res1[i] = b[idx+i];
3894 else {
3895 res1[i] = res[j];
3896 j++;
3897 }
3898 }
3899 } else if (part == 1) {
3900 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3901 if (i < origin)
3902 res1[i] = res[SPECIES.length()-origin+i];
3903 else {
3904 res1[i] = b[idx+origin+j];
3905 j++;
3906 }
3907 }
3908 }
3909 return res1;
3910 }
3911
3912 @Test(dataProvider = "doubleBinaryOpMaskProvider")
3913 static void unsliceDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
3914 IntFunction<boolean[]> fm) {
3915 double[] a = fa.apply(SPECIES.length());
3916 double[] b = fb.apply(SPECIES.length());
3917 boolean[] mask = fm.apply(SPECIES.length());
3918 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3919 double[] r = new double[a.length];
3920 int origin = RAND.nextInt(SPECIES.length());
3921 int part = RAND.nextInt(2);
3922 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3923 for (int i = 0; i < a.length; i += SPECIES.length()) {
3924 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3925 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
3926 av.unslice(origin, bv, part, vmask).intoArray(r, i);
3927 }
3928 }
3929
3930 assertArraysEquals(r, a, b, origin, part, mask, DoubleMaxVectorTests::unslice);
3931 }
3932
3933 static double SIN(double a) {
3934 return (double)(Math.sin((double)a));
3935 }
3936
3937 static double strictSIN(double a) {
3938 return (double)(StrictMath.sin((double)a));
3939 }
3940
3941 @Test(dataProvider = "doubleUnaryOpProvider")
3942 static void SINDoubleMaxVectorTests(IntFunction<double[]> fa) {
3943 double[] a = fa.apply(SPECIES.length());
3944 double[] r = fr.apply(SPECIES.length());
3945
3946 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3947 for (int i = 0; i < a.length; i += SPECIES.length()) {
3948 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3949 av.lanewise(VectorOperators.SIN).intoArray(r, i);
3950 }
3951 }
3952
3953 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::SIN, DoubleMaxVectorTests::strictSIN);
3954 }
3955
3956 static double EXP(double a) {
3957 return (double)(Math.exp((double)a));
3958 }
3959
3960 static double strictEXP(double a) {
3961 return (double)(StrictMath.exp((double)a));
3962 }
3963
3964 @Test(dataProvider = "doubleUnaryOpProvider")
3965 static void EXPDoubleMaxVectorTests(IntFunction<double[]> fa) {
3966 double[] a = fa.apply(SPECIES.length());
3967 double[] r = fr.apply(SPECIES.length());
3968
3969 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3970 for (int i = 0; i < a.length; i += SPECIES.length()) {
3971 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3972 av.lanewise(VectorOperators.EXP).intoArray(r, i);
3973 }
3974 }
3975
3976 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::EXP, DoubleMaxVectorTests::strictEXP);
3977 }
3978
3979 static double LOG1P(double a) {
3980 return (double)(Math.log1p((double)a));
3981 }
3982
3983 static double strictLOG1P(double a) {
3984 return (double)(StrictMath.log1p((double)a));
3985 }
3986
3987 @Test(dataProvider = "doubleUnaryOpProvider")
3988 static void LOG1PDoubleMaxVectorTests(IntFunction<double[]> fa) {
3989 double[] a = fa.apply(SPECIES.length());
3990 double[] r = fr.apply(SPECIES.length());
3991
3992 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3993 for (int i = 0; i < a.length; i += SPECIES.length()) {
3994 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
3995 av.lanewise(VectorOperators.LOG1P).intoArray(r, i);
3996 }
3997 }
3998
3999 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::LOG1P, DoubleMaxVectorTests::strictLOG1P);
4000 }
4001
4002 static double LOG(double a) {
4003 return (double)(Math.log((double)a));
4004 }
4005
4006 static double strictLOG(double a) {
4007 return (double)(StrictMath.log((double)a));
4008 }
4009
4010 @Test(dataProvider = "doubleUnaryOpProvider")
4011 static void LOGDoubleMaxVectorTests(IntFunction<double[]> fa) {
4012 double[] a = fa.apply(SPECIES.length());
4013 double[] r = fr.apply(SPECIES.length());
4014
4015 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4016 for (int i = 0; i < a.length; i += SPECIES.length()) {
4017 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4018 av.lanewise(VectorOperators.LOG).intoArray(r, i);
4019 }
4020 }
4021
4022 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::LOG, DoubleMaxVectorTests::strictLOG);
4023 }
4024
4025 static double LOG10(double a) {
4026 return (double)(Math.log10((double)a));
4027 }
4028
4029 static double strictLOG10(double a) {
4030 return (double)(StrictMath.log10((double)a));
4031 }
4032
4033 @Test(dataProvider = "doubleUnaryOpProvider")
4034 static void LOG10DoubleMaxVectorTests(IntFunction<double[]> fa) {
4035 double[] a = fa.apply(SPECIES.length());
4036 double[] r = fr.apply(SPECIES.length());
4037
4038 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4039 for (int i = 0; i < a.length; i += SPECIES.length()) {
4040 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4041 av.lanewise(VectorOperators.LOG10).intoArray(r, i);
4042 }
4043 }
4044
4045 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::LOG10, DoubleMaxVectorTests::strictLOG10);
4046 }
4047
4048 static double EXPM1(double a) {
4049 return (double)(Math.expm1((double)a));
4050 }
4051
4052 static double strictEXPM1(double a) {
4053 return (double)(StrictMath.expm1((double)a));
4054 }
4055
4056 @Test(dataProvider = "doubleUnaryOpProvider")
4057 static void EXPM1DoubleMaxVectorTests(IntFunction<double[]> fa) {
4058 double[] a = fa.apply(SPECIES.length());
4059 double[] r = fr.apply(SPECIES.length());
4060
4061 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4062 for (int i = 0; i < a.length; i += SPECIES.length()) {
4063 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4064 av.lanewise(VectorOperators.EXPM1).intoArray(r, i);
4065 }
4066 }
4067
4068 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::EXPM1, DoubleMaxVectorTests::strictEXPM1);
4069 }
4070
4071 static double COS(double a) {
4072 return (double)(Math.cos((double)a));
4073 }
4074
4075 static double strictCOS(double a) {
4076 return (double)(StrictMath.cos((double)a));
4077 }
4078
4079 @Test(dataProvider = "doubleUnaryOpProvider")
4080 static void COSDoubleMaxVectorTests(IntFunction<double[]> fa) {
4081 double[] a = fa.apply(SPECIES.length());
4082 double[] r = fr.apply(SPECIES.length());
4083
4084 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4085 for (int i = 0; i < a.length; i += SPECIES.length()) {
4086 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4087 av.lanewise(VectorOperators.COS).intoArray(r, i);
4088 }
4089 }
4090
4091 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::COS, DoubleMaxVectorTests::strictCOS);
4092 }
4093
4094 static double TAN(double a) {
4095 return (double)(Math.tan((double)a));
4096 }
4097
4098 static double strictTAN(double a) {
4099 return (double)(StrictMath.tan((double)a));
4100 }
4101
4102 @Test(dataProvider = "doubleUnaryOpProvider")
4103 static void TANDoubleMaxVectorTests(IntFunction<double[]> fa) {
4104 double[] a = fa.apply(SPECIES.length());
4105 double[] r = fr.apply(SPECIES.length());
4106
4107 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4108 for (int i = 0; i < a.length; i += SPECIES.length()) {
4109 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4110 av.lanewise(VectorOperators.TAN).intoArray(r, i);
4111 }
4112 }
4113
4114 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::TAN, DoubleMaxVectorTests::strictTAN);
4115 }
4116
4117 static double SINH(double a) {
4118 return (double)(Math.sinh((double)a));
4119 }
4120
4121 static double strictSINH(double a) {
4122 return (double)(StrictMath.sinh((double)a));
4123 }
4124
4125 @Test(dataProvider = "doubleUnaryOpProvider")
4126 static void SINHDoubleMaxVectorTests(IntFunction<double[]> fa) {
4127 double[] a = fa.apply(SPECIES.length());
4128 double[] r = fr.apply(SPECIES.length());
4129
4130 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4131 for (int i = 0; i < a.length; i += SPECIES.length()) {
4132 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4133 av.lanewise(VectorOperators.SINH).intoArray(r, i);
4134 }
4135 }
4136
4137 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::SINH, DoubleMaxVectorTests::strictSINH);
4138 }
4139
4140 static double COSH(double a) {
4141 return (double)(Math.cosh((double)a));
4142 }
4143
4144 static double strictCOSH(double a) {
4145 return (double)(StrictMath.cosh((double)a));
4146 }
4147
4148 @Test(dataProvider = "doubleUnaryOpProvider")
4149 static void COSHDoubleMaxVectorTests(IntFunction<double[]> fa) {
4150 double[] a = fa.apply(SPECIES.length());
4151 double[] r = fr.apply(SPECIES.length());
4152
4153 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4154 for (int i = 0; i < a.length; i += SPECIES.length()) {
4155 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4156 av.lanewise(VectorOperators.COSH).intoArray(r, i);
4157 }
4158 }
4159
4160 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::COSH, DoubleMaxVectorTests::strictCOSH);
4161 }
4162
4163 static double TANH(double a) {
4164 return (double)(Math.tanh((double)a));
4165 }
4166
4167 static double strictTANH(double a) {
4168 return (double)(StrictMath.tanh((double)a));
4169 }
4170
4171 @Test(dataProvider = "doubleUnaryOpProvider")
4172 static void TANHDoubleMaxVectorTests(IntFunction<double[]> fa) {
4173 double[] a = fa.apply(SPECIES.length());
4174 double[] r = fr.apply(SPECIES.length());
4175
4176 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4177 for (int i = 0; i < a.length; i += SPECIES.length()) {
4178 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4179 av.lanewise(VectorOperators.TANH).intoArray(r, i);
4180 }
4181 }
4182
4183 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::TANH, DoubleMaxVectorTests::strictTANH);
4184 }
4185
4186 static double ASIN(double a) {
4187 return (double)(Math.asin((double)a));
4188 }
4189
4190 static double strictASIN(double a) {
4191 return (double)(StrictMath.asin((double)a));
4192 }
4193
4194 @Test(dataProvider = "doubleUnaryOpProvider")
4195 static void ASINDoubleMaxVectorTests(IntFunction<double[]> fa) {
4196 double[] a = fa.apply(SPECIES.length());
4197 double[] r = fr.apply(SPECIES.length());
4198
4199 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4200 for (int i = 0; i < a.length; i += SPECIES.length()) {
4201 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4202 av.lanewise(VectorOperators.ASIN).intoArray(r, i);
4203 }
4204 }
4205
4206 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::ASIN, DoubleMaxVectorTests::strictASIN);
4207 }
4208
4209 static double ACOS(double a) {
4210 return (double)(Math.acos((double)a));
4211 }
4212
4213 static double strictACOS(double a) {
4214 return (double)(StrictMath.acos((double)a));
4215 }
4216
4217 @Test(dataProvider = "doubleUnaryOpProvider")
4218 static void ACOSDoubleMaxVectorTests(IntFunction<double[]> fa) {
4219 double[] a = fa.apply(SPECIES.length());
4220 double[] r = fr.apply(SPECIES.length());
4221
4222 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4223 for (int i = 0; i < a.length; i += SPECIES.length()) {
4224 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4225 av.lanewise(VectorOperators.ACOS).intoArray(r, i);
4226 }
4227 }
4228
4229 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::ACOS, DoubleMaxVectorTests::strictACOS);
4230 }
4231
4232 static double ATAN(double a) {
4233 return (double)(Math.atan((double)a));
4234 }
4235
4236 static double strictATAN(double a) {
4237 return (double)(StrictMath.atan((double)a));
4238 }
4239
4240 @Test(dataProvider = "doubleUnaryOpProvider")
4241 static void ATANDoubleMaxVectorTests(IntFunction<double[]> fa) {
4242 double[] a = fa.apply(SPECIES.length());
4243 double[] r = fr.apply(SPECIES.length());
4244
4245 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4246 for (int i = 0; i < a.length; i += SPECIES.length()) {
4247 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4248 av.lanewise(VectorOperators.ATAN).intoArray(r, i);
4249 }
4250 }
4251
4252 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::ATAN, DoubleMaxVectorTests::strictATAN);
4253 }
4254
4255 static double CBRT(double a) {
4256 return (double)(Math.cbrt((double)a));
4257 }
4258
4259 static double strictCBRT(double a) {
4260 return (double)(StrictMath.cbrt((double)a));
4261 }
4262
4263 @Test(dataProvider = "doubleUnaryOpProvider")
4264 static void CBRTDoubleMaxVectorTests(IntFunction<double[]> fa) {
4265 double[] a = fa.apply(SPECIES.length());
4266 double[] r = fr.apply(SPECIES.length());
4267
4268 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4269 for (int i = 0; i < a.length; i += SPECIES.length()) {
4270 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4271 av.lanewise(VectorOperators.CBRT).intoArray(r, i);
4272 }
4273 }
4274
4275 assertArraysEqualsWithinOneUlp(r, a, DoubleMaxVectorTests::CBRT, DoubleMaxVectorTests::strictCBRT);
4276 }
4277
4278 static double HYPOT(double a, double b) {
4279 return (double)(Math.hypot((double)a, (double)b));
4280 }
4281
4282 static double strictHYPOT(double a, double b) {
4283 return (double)(StrictMath.hypot((double)a, (double)b));
4284 }
4285
4286 @Test(dataProvider = "doubleBinaryOpProvider")
4287 static void HYPOTDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4288 double[] a = fa.apply(SPECIES.length());
4289 double[] b = fb.apply(SPECIES.length());
4290 double[] r = fr.apply(SPECIES.length());
4291
4292 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4293 for (int i = 0; i < a.length; i += SPECIES.length()) {
4294 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4295 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4296 av.lanewise(VectorOperators.HYPOT, bv).intoArray(r, i);
4297 }
4298 }
4299
4300 assertArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::HYPOT, DoubleMaxVectorTests::strictHYPOT);
4301 }
4302
4303
4304 static double POW(double a, double b) {
4305 return (double)(Math.pow((double)a, (double)b));
4306 }
4307
4308 static double strictPOW(double a, double b) {
4309 return (double)(StrictMath.pow((double)a, (double)b));
4310 }
4311
4312 @Test(dataProvider = "doubleBinaryOpProvider")
4313 static void POWDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4314 double[] a = fa.apply(SPECIES.length());
4315 double[] b = fb.apply(SPECIES.length());
4316 double[] r = fr.apply(SPECIES.length());
4317
4318 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4319 for (int i = 0; i < a.length; i += SPECIES.length()) {
4320 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4321 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4322 av.lanewise(VectorOperators.POW, bv).intoArray(r, i);
4323 }
4324 }
4325
4326 assertArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::POW, DoubleMaxVectorTests::strictPOW);
4327 }
4328
4329
4330 static double pow(double a, double b) {
4331 return (double)(Math.pow((double)a, (double)b));
4332 }
4333
4334 static double strictpow(double a, double b) {
4335 return (double)(StrictMath.pow((double)a, (double)b));
4336 }
4337
4338 @Test(dataProvider = "doubleBinaryOpProvider")
4339 static void powDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4340 double[] a = fa.apply(SPECIES.length());
4341 double[] b = fb.apply(SPECIES.length());
4342 double[] r = fr.apply(SPECIES.length());
4343
4344 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4345 for (int i = 0; i < a.length; i += SPECIES.length()) {
4346 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4347 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4348 av.pow(bv).intoArray(r, i);
4349 }
4350 }
4351
4352 assertArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::pow, DoubleMaxVectorTests::strictpow);
4353 }
4354
4355
4356 static double ATAN2(double a, double b) {
4357 return (double)(Math.atan2((double)a, (double)b));
4358 }
4359
4360 static double strictATAN2(double a, double b) {
4361 return (double)(StrictMath.atan2((double)a, (double)b));
4362 }
4363
4364 @Test(dataProvider = "doubleBinaryOpProvider")
4365 static void ATAN2DoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4366 double[] a = fa.apply(SPECIES.length());
4367 double[] b = fb.apply(SPECIES.length());
4368 double[] r = fr.apply(SPECIES.length());
4369
4370 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4371 for (int i = 0; i < a.length; i += SPECIES.length()) {
4372 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4373 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4374 av.lanewise(VectorOperators.ATAN2, bv).intoArray(r, i);
4375 }
4376 }
4377
4378 assertArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::ATAN2, DoubleMaxVectorTests::strictATAN2);
4379 }
4380
4381
4382 @Test(dataProvider = "doubleBinaryOpProvider")
4383 static void POWDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4384 double[] a = fa.apply(SPECIES.length());
4385 double[] b = fb.apply(SPECIES.length());
4386 double[] r = fr.apply(SPECIES.length());
4387
4388 for (int i = 0; i < a.length; i += SPECIES.length()) {
4389 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4390 av.lanewise(VectorOperators.POW, b[i]).intoArray(r, i);
4391 }
4392
4393 assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::POW, DoubleMaxVectorTests::strictPOW);
4394 }
4395
4396
4397 @Test(dataProvider = "doubleBinaryOpProvider")
4398 static void powDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4399 double[] a = fa.apply(SPECIES.length());
4400 double[] b = fb.apply(SPECIES.length());
4401 double[] r = fr.apply(SPECIES.length());
4402
4403 for (int i = 0; i < a.length; i += SPECIES.length()) {
4404 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4405 av.pow(b[i]).intoArray(r, i);
4406 }
4407
4408 assertBroadcastArraysEqualsWithinOneUlp(r, a, b, DoubleMaxVectorTests::pow, DoubleMaxVectorTests::strictpow);
4409 }
4410
4411
4412 static double FMA(double a, double b, double c) {
4413 return (double)(Math.fma(a, b, c));
4414 }
4415
4416 static double fma(double a, double b, double c) {
4417 return (double)(Math.fma(a, b, c));
4418 }
4419
4420 @Test(dataProvider = "doubleTernaryOpProvider")
4421 static void FMADoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4422 int count = INVOC_COUNT;
4423 switch ("FMA") {
4424 case "fma": case "lanewise_FMA":
4425 // Math.fma uses BigDecimal
4426 count = Math.max(5, count/20); break;
4427 }
4428 final int INVOC_COUNT = count;
4429 double[] a = fa.apply(SPECIES.length());
4430 double[] b = fb.apply(SPECIES.length());
4431 double[] c = fc.apply(SPECIES.length());
4432 double[] r = fr.apply(SPECIES.length());
4433
4434 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4435 for (int i = 0; i < a.length; i += SPECIES.length()) {
4436 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4437 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4438 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
4439 av.lanewise(VectorOperators.FMA, bv, cv).intoArray(r, i);
4440 }
4441 }
4442
4443 assertArraysEquals(r, a, b, c, DoubleMaxVectorTests::FMA);
4444 }
4445
4446 @Test(dataProvider = "doubleTernaryOpProvider")
4447 static void fmaDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4448 int count = INVOC_COUNT;
4449 switch ("fma") {
4450 case "fma": case "lanewise_FMA":
4451 // Math.fma uses BigDecimal
4452 count = Math.max(5, count/20); break;
4453 }
4454 final int INVOC_COUNT = count;
4455 double[] a = fa.apply(SPECIES.length());
4456 double[] b = fb.apply(SPECIES.length());
4457 double[] c = fc.apply(SPECIES.length());
4458 double[] r = fr.apply(SPECIES.length());
4459
4460 for (int i = 0; i < a.length; i += SPECIES.length()) {
4461 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4462 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4463 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
4464 av.fma(bv, cv).intoArray(r, i);
4465 }
4466
4467 assertArraysEquals(r, a, b, c, DoubleMaxVectorTests::fma);
4468 }
4469
4470 @Test(dataProvider = "doubleTernaryOpMaskProvider")
4471 static void FMADoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<double[]> fb,
4472 IntFunction<double[]> fc, IntFunction<boolean[]> fm) {
4473 int count = INVOC_COUNT;
4474 switch ("FMA") {
4475 case "fma": case "lanewise_FMA":
4476 // Math.fma uses BigDecimal
4477 count = Math.max(5, count/20); break;
4478 }
4479 final int INVOC_COUNT = count;
4480 double[] a = fa.apply(SPECIES.length());
4481 double[] b = fb.apply(SPECIES.length());
4482 double[] c = fc.apply(SPECIES.length());
4483 double[] r = fr.apply(SPECIES.length());
4484 boolean[] mask = fm.apply(SPECIES.length());
4485 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4486
4487 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4488 for (int i = 0; i < a.length; i += SPECIES.length()) {
4489 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4490 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4491 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
4492 av.lanewise(VectorOperators.FMA, bv, cv, vmask).intoArray(r, i);
4493 }
4494 }
4495
4496 assertArraysEquals(r, a, b, c, mask, DoubleMaxVectorTests::FMA);
4497 }
4498
4499 @Test(dataProvider = "doubleTernaryOpProvider")
4500 static void FMADoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4501 double[] a = fa.apply(SPECIES.length());
4502 double[] b = fb.apply(SPECIES.length());
4503 double[] c = fc.apply(SPECIES.length());
4504 double[] r = fr.apply(SPECIES.length());
4505
4506 for (int i = 0; i < a.length; i += SPECIES.length()) {
4507 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4508 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4509 av.lanewise(VectorOperators.FMA, bv, c[i]).intoArray(r, i);
4510 }
4511 assertBroadcastArraysEquals(r, a, b, c, DoubleMaxVectorTests::FMA);
4512 }
4513
4514 @Test(dataProvider = "doubleTernaryOpProvider")
4515 static void FMADoubleMaxVectorTestsAltBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4516 double[] a = fa.apply(SPECIES.length());
4517 double[] b = fb.apply(SPECIES.length());
4518 double[] c = fc.apply(SPECIES.length());
4519 double[] r = fr.apply(SPECIES.length());
4520
4521 for (int i = 0; i < a.length; i += SPECIES.length()) {
4522 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4523 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
4524 av.lanewise(VectorOperators.FMA, b[i], cv).intoArray(r, i);
4525 }
4526 assertAltBroadcastArraysEquals(r, a, b, c, DoubleMaxVectorTests::FMA);
4527 }
4528
4529 @Test(dataProvider = "doubleTernaryOpMaskProvider")
4530 static void FMADoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
4531 IntFunction<double[]> fc, IntFunction<boolean[]> fm) {
4532 double[] a = fa.apply(SPECIES.length());
4533 double[] b = fb.apply(SPECIES.length());
4534 double[] c = fc.apply(SPECIES.length());
4535 double[] r = fr.apply(SPECIES.length());
4536 boolean[] mask = fm.apply(SPECIES.length());
4537 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4538
4539 for (int i = 0; i < a.length; i += SPECIES.length()) {
4540 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4541 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
4542 av.lanewise(VectorOperators.FMA, bv, c[i], vmask).intoArray(r, i);
4543 }
4544
4545 assertBroadcastArraysEquals(r, a, b, c, mask, DoubleMaxVectorTests::FMA);
4546 }
4547
4548 @Test(dataProvider = "doubleTernaryOpMaskProvider")
4549 static void FMADoubleMaxVectorTestsAltBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
4550 IntFunction<double[]> fc, IntFunction<boolean[]> fm) {
4551 double[] a = fa.apply(SPECIES.length());
4552 double[] b = fb.apply(SPECIES.length());
4553 double[] c = fc.apply(SPECIES.length());
4554 double[] r = fr.apply(SPECIES.length());
4555 boolean[] mask = fm.apply(SPECIES.length());
4556 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4557
4558 for (int i = 0; i < a.length; i += SPECIES.length()) {
4559 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4560 DoubleVector cv = DoubleVector.fromArray(SPECIES, c, i);
4561 av.lanewise(VectorOperators.FMA, b[i], cv, vmask).intoArray(r, i);
4562 }
4563
4564 assertAltBroadcastArraysEquals(r, a, b, c, mask, DoubleMaxVectorTests::FMA);
4565 }
4566
4567 @Test(dataProvider = "doubleTernaryOpProvider")
4568 static void FMADoubleMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4569 int count = INVOC_COUNT;
4570 switch ("FMA") {
4571 case "fma": case "lanewise_FMA":
4572 // Math.fma uses BigDecimal
4573 count = Math.max(5, count/20); break;
4574 }
4575 final int INVOC_COUNT = count;
4576 double[] a = fa.apply(SPECIES.length());
4577 double[] b = fb.apply(SPECIES.length());
4578 double[] c = fc.apply(SPECIES.length());
4579 double[] r = fr.apply(SPECIES.length());
4580
4581 for (int i = 0; i < a.length; i += SPECIES.length()) {
4582 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4583 av.lanewise(VectorOperators.FMA, b[i], c[i]).intoArray(r, i);
4584 }
4585
4586 assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleMaxVectorTests::FMA);
4587 }
4588
4589 @Test(dataProvider = "doubleTernaryOpProvider")
4590 static void fmaDoubleMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
4591 int count = INVOC_COUNT;
4592 switch ("fma") {
4593 case "fma": case "lanewise_FMA":
4594 // Math.fma uses BigDecimal
4595 count = Math.max(5, count/20); break;
4596 }
4597 final int INVOC_COUNT = count;
4598 double[] a = fa.apply(SPECIES.length());
4599 double[] b = fb.apply(SPECIES.length());
4600 double[] c = fc.apply(SPECIES.length());
4601 double[] r = fr.apply(SPECIES.length());
4602
4603 for (int i = 0; i < a.length; i += SPECIES.length()) {
4604 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4605 av.fma(b[i], c[i]).intoArray(r, i);
4606 }
4607
4608 assertDoubleBroadcastArraysEquals(r, a, b, c, DoubleMaxVectorTests::fma);
4609 }
4610
4611 @Test(dataProvider = "doubleTernaryOpMaskProvider")
4612 static void FMADoubleMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
4613 IntFunction<double[]> fc, IntFunction<boolean[]> fm) {
4614 int count = INVOC_COUNT;
4615 switch ("FMA") {
4616 case "fma": case "lanewise_FMA":
4617 // Math.fma uses BigDecimal
4618 count = Math.max(5, count/20); break;
4619 }
4620 final int INVOC_COUNT = count;
4621 double[] a = fa.apply(SPECIES.length());
4622 double[] b = fb.apply(SPECIES.length());
4623 double[] c = fc.apply(SPECIES.length());
4624 double[] r = fr.apply(SPECIES.length());
4625 boolean[] mask = fm.apply(SPECIES.length());
4626 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4627
4628 for (int i = 0; i < a.length; i += SPECIES.length()) {
4629 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4630 av.lanewise(VectorOperators.FMA, b[i], c[i], vmask).intoArray(r, i);
4631 }
4632
4633 assertDoubleBroadcastArraysEquals(r, a, b, c, mask, DoubleMaxVectorTests::FMA);
4634 }
4635
4636 static double NEG(double a) {
4637 return (double)(-((double)a));
4638 }
4639
4640 static double neg(double a) {
4641 return (double)(-((double)a));
4642 }
4643
4644 @Test(dataProvider = "doubleUnaryOpProvider")
4645 static void NEGDoubleMaxVectorTests(IntFunction<double[]> fa) {
4646 double[] a = fa.apply(SPECIES.length());
4647 double[] r = fr.apply(SPECIES.length());
4648
4649 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4650 for (int i = 0; i < a.length; i += SPECIES.length()) {
4651 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4652 av.lanewise(VectorOperators.NEG).intoArray(r, i);
4653 }
4654 }
4655
4656 assertArraysEquals(r, a, DoubleMaxVectorTests::NEG);
4657 }
4658
4659 @Test(dataProvider = "doubleUnaryOpProvider")
4660 static void negDoubleMaxVectorTests(IntFunction<double[]> fa) {
4661 double[] a = fa.apply(SPECIES.length());
4662 double[] r = fr.apply(SPECIES.length());
4663
4664 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4665 for (int i = 0; i < a.length; i += SPECIES.length()) {
4666 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4667 av.neg().intoArray(r, i);
4668 }
4669 }
4670
4671 assertArraysEquals(r, a, DoubleMaxVectorTests::neg);
4672 }
4673
4674 @Test(dataProvider = "doubleUnaryOpMaskProvider")
4675 static void NEGMaskedDoubleMaxVectorTests(IntFunction<double[]> fa,
4676 IntFunction<boolean[]> fm) {
4677 double[] a = fa.apply(SPECIES.length());
4678 double[] r = fr.apply(SPECIES.length());
4679 boolean[] mask = fm.apply(SPECIES.length());
4680 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4681
4682 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4683 for (int i = 0; i < a.length; i += SPECIES.length()) {
4684 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4685 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
4686 }
4687 }
4688
4689 assertArraysEquals(r, a, mask, DoubleMaxVectorTests::NEG);
4690 }
4691
4692 static double ABS(double a) {
4693 return (double)(Math.abs((double)a));
4694 }
4695
4696 static double abs(double a) {
4697 return (double)(Math.abs((double)a));
4698 }
4699
4700 @Test(dataProvider = "doubleUnaryOpProvider")
4701 static void ABSDoubleMaxVectorTests(IntFunction<double[]> fa) {
4702 double[] a = fa.apply(SPECIES.length());
4703 double[] r = fr.apply(SPECIES.length());
4704
4705 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4706 for (int i = 0; i < a.length; i += SPECIES.length()) {
4707 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4708 av.lanewise(VectorOperators.ABS).intoArray(r, i);
4709 }
4710 }
4711
4712 assertArraysEquals(r, a, DoubleMaxVectorTests::ABS);
4713 }
4714
4715 @Test(dataProvider = "doubleUnaryOpProvider")
4716 static void absDoubleMaxVectorTests(IntFunction<double[]> fa) {
4717 double[] a = fa.apply(SPECIES.length());
4718 double[] r = fr.apply(SPECIES.length());
4719
4720 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4721 for (int i = 0; i < a.length; i += SPECIES.length()) {
4722 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4723 av.abs().intoArray(r, i);
4724 }
4725 }
4726
4727 assertArraysEquals(r, a, DoubleMaxVectorTests::abs);
4728 }
4729
4730 @Test(dataProvider = "doubleUnaryOpMaskProvider")
4731 static void ABSMaskedDoubleMaxVectorTests(IntFunction<double[]> fa,
4732 IntFunction<boolean[]> fm) {
4733 double[] a = fa.apply(SPECIES.length());
4734 double[] r = fr.apply(SPECIES.length());
4735 boolean[] mask = fm.apply(SPECIES.length());
4736 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4737
4738 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4739 for (int i = 0; i < a.length; i += SPECIES.length()) {
4740 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4741 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
4742 }
4743 }
4744
4745 assertArraysEquals(r, a, mask, DoubleMaxVectorTests::ABS);
4746 }
4747
4748 static double SQRT(double a) {
4749 return (double)(Math.sqrt((double)a));
4750 }
4751
4752 static double sqrt(double a) {
4753 return (double)(Math.sqrt((double)a));
4754 }
4755
4756 @Test(dataProvider = "doubleUnaryOpProvider")
4757 static void SQRTDoubleMaxVectorTests(IntFunction<double[]> fa) {
4758 double[] a = fa.apply(SPECIES.length());
4759 double[] r = fr.apply(SPECIES.length());
4760
4761 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4762 for (int i = 0; i < a.length; i += SPECIES.length()) {
4763 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4764 av.lanewise(VectorOperators.SQRT).intoArray(r, i);
4765 }
4766 }
4767
4768 assertArraysEquals(r, a, DoubleMaxVectorTests::SQRT);
4769 }
4770
4771 @Test(dataProvider = "doubleUnaryOpProvider")
4772 static void sqrtDoubleMaxVectorTests(IntFunction<double[]> fa) {
4773 double[] a = fa.apply(SPECIES.length());
4774 double[] r = fr.apply(SPECIES.length());
4775
4776 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4777 for (int i = 0; i < a.length; i += SPECIES.length()) {
4778 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4779 av.sqrt().intoArray(r, i);
4780 }
4781 }
4782
4783 assertArraysEquals(r, a, DoubleMaxVectorTests::sqrt);
4784 }
4785
4786 @Test(dataProvider = "doubleUnaryOpMaskProvider")
4787 static void SQRTMaskedDoubleMaxVectorTests(IntFunction<double[]> fa,
4788 IntFunction<boolean[]> fm) {
4789 double[] a = fa.apply(SPECIES.length());
4790 double[] r = fr.apply(SPECIES.length());
4791 boolean[] mask = fm.apply(SPECIES.length());
4792 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4793
4794 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4795 for (int i = 0; i < a.length; i += SPECIES.length()) {
4796 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4797 av.lanewise(VectorOperators.SQRT, vmask).intoArray(r, i);
4798 }
4799 }
4800
4801 assertArraysEquals(r, a, mask, DoubleMaxVectorTests::SQRT);
4802 }
4803
4804 @Test(dataProvider = "doubleCompareOpProvider")
4805 static void ltDoubleMaxVectorTestsBroadcastSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4806 double[] a = fa.apply(SPECIES.length());
4807 double[] b = fb.apply(SPECIES.length());
4808
4809 for (int i = 0; i < a.length; i += SPECIES.length()) {
4810 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4811 VectorMask<Double> mv = av.lt(b[i]);
4812
4813 // Check results as part of computation.
4814 for (int j = 0; j < SPECIES.length(); j++) {
4815 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
4816 }
4817 }
4818 }
4819
4820 @Test(dataProvider = "doubleCompareOpProvider")
4821 static void eqDoubleMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb) {
4822 double[] a = fa.apply(SPECIES.length());
4823 double[] b = fb.apply(SPECIES.length());
4824
4825 for (int i = 0; i < a.length; i += SPECIES.length()) {
4826 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4827 VectorMask<Double> mv = av.eq(b[i]);
4828
4829 // Check results as part of computation.
4830 for (int j = 0; j < SPECIES.length(); j++) {
4831 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
4832 }
4833 }
4834 }
4835
4836 @Test(dataProvider = "doubletoIntUnaryOpProvider")
4837 static void toIntArrayDoubleMaxVectorTestsSmokeTest(IntFunction<double[]> fa) {
4838 double[] a = fa.apply(SPECIES.length());
4839
4840 for (int i = 0; i < a.length; i += SPECIES.length()) {
4841 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4842 int[] r = av.toIntArray();
4843 assertArraysEquals(r, a, i);
4844 }
4845 }
4846
4847 @Test(dataProvider = "doubletoLongUnaryOpProvider")
4848 static void toLongArrayDoubleMaxVectorTestsSmokeTest(IntFunction<double[]> fa) {
4849 double[] a = fa.apply(SPECIES.length());
4850
4851 for (int i = 0; i < a.length; i += SPECIES.length()) {
4852 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4853 long[] r = av.toLongArray();
4854 assertArraysEquals(r, a, i);
4855 }
4856 }
4857
4858
4859 @Test(dataProvider = "doubleUnaryOpProvider")
4860 static void toStringDoubleMaxVectorTestsSmokeTest(IntFunction<double[]> fa) {
4861 double[] a = fa.apply(SPECIES.length());
4862
4863 for (int i = 0; i < a.length; i += SPECIES.length()) {
4864 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4865 String str = av.toString();
4866
4867 double subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
4868 Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
4869 }
4870 }
4871
4872 @Test(dataProvider = "doubleUnaryOpProvider")
4873 static void hashCodeDoubleMaxVectorTestsSmokeTest(IntFunction<double[]> fa) {
4874 double[] a = fa.apply(SPECIES.length());
4875
4876 for (int i = 0; i < a.length; i += SPECIES.length()) {
4877 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4878 int hash = av.hashCode();
4879
4880 double subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
4881 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
4882 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
4883 }
4884 }
4885
4886
4887 static long ADDReduceLong(double[] a, int idx) {
4888 double res = 0;
4889 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4890 res += a[i];
4891 }
4892
4893 return (long)res;
4894 }
4895
4896 static long ADDReduceAllLong(double[] a) {
4897 long res = 0;
4898 for (int i = 0; i < a.length; i += SPECIES.length()) {
4899 res += ADDReduceLong(a, i);
4900 }
4901
4902 return res;
4903 }
4904
4905 @Test(dataProvider = "doubleUnaryOpProvider")
4906 static void ADDReduceLongDoubleMaxVectorTests(IntFunction<double[]> fa) {
4907 double[] a = fa.apply(SPECIES.length());
4908 long[] r = lfr.apply(SPECIES.length());
4909 long ra = 0;
4910
4911 for (int i = 0; i < a.length; i += SPECIES.length()) {
4912 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4913 r[i] = av.reduceLanesToLong(VectorOperators.ADD);
4914 }
4915
4916 ra = 0;
4917 for (int i = 0; i < a.length; i ++) {
4918 ra += r[i];
4919 }
4920
4921 assertReductionLongArraysEquals(r, ra, a,
4922 DoubleMaxVectorTests::ADDReduceLong, DoubleMaxVectorTests::ADDReduceAllLong);
4923 }
4924
4925 static long ADDReduceLongMasked(double[] a, int idx, boolean[] mask) {
4926 double res = 0;
4927 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4928 if(mask[i % SPECIES.length()])
4929 res += a[i];
4930 }
4931
4932 return (long)res;
4933 }
4934
4935 static long ADDReduceAllLongMasked(double[] a, boolean[] mask) {
4936 long res = 0;
4937 for (int i = 0; i < a.length; i += SPECIES.length()) {
4938 res += ADDReduceLongMasked(a, i, mask);
4939 }
4940
4941 return res;
4942 }
4943
4944 @Test(dataProvider = "doubleUnaryOpMaskProvider")
4945 static void ADDReduceLongDoubleMaxVectorTestsMasked(IntFunction<double[]> fa, IntFunction<boolean[]> fm) {
4946 double[] a = fa.apply(SPECIES.length());
4947 long[] r = lfr.apply(SPECIES.length());
4948 boolean[] mask = fm.apply(SPECIES.length());
4949 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4950 long ra = 0;
4951
4952 for (int i = 0; i < a.length; i += SPECIES.length()) {
4953 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4954 r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
4955 }
4956
4957 ra = 0;
4958 for (int i = 0; i < a.length; i ++) {
4959 ra += r[i];
4960 }
4961
4962 assertReductionLongArraysEqualsMasked(r, ra, a, mask,
4963 DoubleMaxVectorTests::ADDReduceLongMasked, DoubleMaxVectorTests::ADDReduceAllLongMasked);
4964 }
4965
4966 @Test(dataProvider = "doubletoLongUnaryOpProvider")
4967 static void BroadcastLongDoubleMaxVectorTestsSmokeTest(IntFunction<double[]> fa) {
4968 double[] a = fa.apply(SPECIES.length());
4969 double[] r = new double[a.length];
4970
4971 for (int i = 0; i < a.length; i += SPECIES.length()) {
4972 DoubleVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
4973 }
4974 assertBroadcastArraysEquals(r, a);
4975 }
4976
4977 @Test(dataProvider = "doubleBinaryOpMaskProvider")
4978 static void blendDoubleMaxVectorTestsBroadcastLongSmokeTest(IntFunction<double[]> fa, IntFunction<double[]> fb,
4979 IntFunction<boolean[]> fm) {
4980 double[] a = fa.apply(SPECIES.length());
4981 double[] b = fb.apply(SPECIES.length());
4982 double[] r = fr.apply(SPECIES.length());
4983 boolean[] mask = fm.apply(SPECIES.length());
4984 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4985
4986 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4987 for (int i = 0; i < a.length; i += SPECIES.length()) {
4988 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
4989 av.blend((long)b[i], vmask).intoArray(r, i);
4990 }
4991 }
4992 assertBroadcastLongArraysEquals(r, a, b, mask, DoubleMaxVectorTests::blend);
4993 }
4994
4995
4996 @Test(dataProvider = "doubleUnaryOpSelectFromProvider")
4997 static void SelectFromDoubleMaxVectorTests(IntFunction<double[]> fa,
4998 BiFunction<Integer,Integer,double[]> fs) {
4999 double[] a = fa.apply(SPECIES.length());
5000 double[] order = fs.apply(a.length, SPECIES.length());
5001 double[] r = fr.apply(SPECIES.length());
5002
5003 for (int i = 0; i < a.length; i += SPECIES.length()) {
5004 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
5005 DoubleVector bv = DoubleVector.fromArray(SPECIES, order, i);
5006 bv.selectFrom(av).intoArray(r, i);
5007 }
5008
5009 assertSelectFromArraysEquals(r, a, order, SPECIES.length());
5010 }
5011
5012 @Test(dataProvider = "doubleSelectFromTwoVectorOpProvider")
5013 static void SelectFromTwoVectorDoubleMaxVectorTests(IntFunction<double[]> fa, IntFunction<double[]> fb, IntFunction<double[]> fc) {
5014 double[] a = fa.apply(SPECIES.length());
5015 double[] b = fb.apply(SPECIES.length());
5016 double[] idx = fc.apply(SPECIES.length());
5017 double[] r = fr.apply(SPECIES.length());
5018
5019 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5020 for (int i = 0; i < idx.length; i += SPECIES.length()) {
5021 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
5022 DoubleVector bv = DoubleVector.fromArray(SPECIES, b, i);
5023 DoubleVector idxv = DoubleVector.fromArray(SPECIES, idx, i);
5024 idxv.selectFrom(av, bv).intoArray(r, i);
5025 }
5026 }
5027 assertSelectFromTwoVectorEquals(r, idx, a, b, SPECIES.length());
5028 }
5029
5030 @Test(dataProvider = "doubleUnaryOpSelectFromMaskProvider")
5031 static void SelectFromDoubleMaxVectorTestsMaskedSmokeTest(IntFunction<double[]> fa,
5032 BiFunction<Integer,Integer,double[]> fs,
5033 IntFunction<boolean[]> fm) {
5034 double[] a = fa.apply(SPECIES.length());
5035 double[] order = fs.apply(a.length, SPECIES.length());
5036 double[] r = fr.apply(SPECIES.length());
5037 boolean[] mask = fm.apply(SPECIES.length());
5038 VectorMask<Double> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5039
5040 for (int i = 0; i < a.length; i += SPECIES.length()) {
5041 DoubleVector av = DoubleVector.fromArray(SPECIES, a, i);
5042 DoubleVector bv = DoubleVector.fromArray(SPECIES, order, i);
5043 bv.selectFrom(av, vmask).intoArray(r, i);
5044 }
5045
5046 assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
5047 }
5048
5049 @Test(dataProvider = "shuffleProvider")
5050 static void shuffleMiscellaneousDoubleMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5051 int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5052
5053 for (int i = 0; i < a.length; i += SPECIES.length()) {
5054 var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5055 int hash = shuffle.hashCode();
5056 int length = shuffle.length();
5057
5058 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5059 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5060 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5061 Assert.assertEquals(length, SPECIES.length());
5062 }
5063 }
5064
5065 @Test(dataProvider = "shuffleProvider")
5066 static void shuffleToStringDoubleMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5067 int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5068
5069 for (int i = 0; i < a.length; i += SPECIES.length()) {
5070 var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5071 String str = shuffle.toString();
5072
5073 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5074 Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
5075 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5076 }
5077 }
5078
5079 @Test(dataProvider = "shuffleCompareOpProvider")
5080 static void shuffleEqualsDoubleMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
5081 int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5082 int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5083
5084 for (int i = 0; i < a.length; i += SPECIES.length()) {
5085 var av = VectorShuffle.fromArray(SPECIES, a, i);
5086 var bv = VectorShuffle.fromArray(SPECIES, b, i);
5087 boolean eq = av.equals(bv);
5088 int to = i + SPECIES.length();
5089 Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
5090 }
5091 }
5092
5093 @Test(dataProvider = "maskCompareOpProvider")
5094 static void maskEqualsDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5095 boolean[] a = fa.apply(SPECIES.length());
5096 boolean[] b = fb.apply(SPECIES.length());
5097
5098 for (int i = 0; i < a.length; i += SPECIES.length()) {
5099 var av = SPECIES.loadMask(a, i);
5100 var bv = SPECIES.loadMask(b, i);
5101 boolean equals = av.equals(bv);
5102 int to = i + SPECIES.length();
5103 Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
5104 }
5105 }
5106
5107 static boolean band(boolean a, boolean b) {
5108 return a & b;
5109 }
5110
5111 @Test(dataProvider = "maskCompareOpProvider")
5112 static void maskAndDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5113 boolean[] a = fa.apply(SPECIES.length());
5114 boolean[] b = fb.apply(SPECIES.length());
5115 boolean[] r = new boolean[a.length];
5116
5117 for (int i = 0; i < a.length; i += SPECIES.length()) {
5118 var av = SPECIES.loadMask(a, i);
5119 var bv = SPECIES.loadMask(b, i);
5120 var cv = av.and(bv);
5121 cv.intoArray(r, i);
5122 }
5123 assertArraysEquals(r, a, b, DoubleMaxVectorTests::band);
5124 }
5125
5126 static boolean bor(boolean a, boolean b) {
5127 return a | b;
5128 }
5129
5130 @Test(dataProvider = "maskCompareOpProvider")
5131 static void maskOrDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5132 boolean[] a = fa.apply(SPECIES.length());
5133 boolean[] b = fb.apply(SPECIES.length());
5134 boolean[] r = new boolean[a.length];
5135
5136 for (int i = 0; i < a.length; i += SPECIES.length()) {
5137 var av = SPECIES.loadMask(a, i);
5138 var bv = SPECIES.loadMask(b, i);
5139 var cv = av.or(bv);
5140 cv.intoArray(r, i);
5141 }
5142 assertArraysEquals(r, a, b, DoubleMaxVectorTests::bor);
5143 }
5144
5145 static boolean bxor(boolean a, boolean b) {
5146 return a != b;
5147 }
5148
5149 @Test(dataProvider = "maskCompareOpProvider")
5150 static void maskXorDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5151 boolean[] a = fa.apply(SPECIES.length());
5152 boolean[] b = fb.apply(SPECIES.length());
5153 boolean[] r = new boolean[a.length];
5154
5155 for (int i = 0; i < a.length; i += SPECIES.length()) {
5156 var av = SPECIES.loadMask(a, i);
5157 var bv = SPECIES.loadMask(b, i);
5158 var cv = av.xor(bv);
5159 cv.intoArray(r, i);
5160 }
5161 assertArraysEquals(r, a, b, DoubleMaxVectorTests::bxor);
5162 }
5163
5164 static boolean bandNot(boolean a, boolean b) {
5165 return a & !b;
5166 }
5167
5168 @Test(dataProvider = "maskCompareOpProvider")
5169 static void maskAndNotDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5170 boolean[] a = fa.apply(SPECIES.length());
5171 boolean[] b = fb.apply(SPECIES.length());
5172 boolean[] r = new boolean[a.length];
5173
5174 for (int i = 0; i < a.length; i += SPECIES.length()) {
5175 var av = SPECIES.loadMask(a, i);
5176 var bv = SPECIES.loadMask(b, i);
5177 var cv = av.andNot(bv);
5178 cv.intoArray(r, i);
5179 }
5180 assertArraysEquals(r, a, b, DoubleMaxVectorTests::bandNot);
5181 }
5182
5183 static boolean beq(boolean a, boolean b) {
5184 return (a == b);
5185 }
5186
5187 @Test(dataProvider = "maskCompareOpProvider")
5188 static void maskEqDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5189 boolean[] a = fa.apply(SPECIES.length());
5190 boolean[] b = fb.apply(SPECIES.length());
5191 boolean[] r = new boolean[a.length];
5192
5193 for (int i = 0; i < a.length; i += SPECIES.length()) {
5194 var av = SPECIES.loadMask(a, i);
5195 var bv = SPECIES.loadMask(b, i);
5196 var cv = av.eq(bv);
5197 cv.intoArray(r, i);
5198 }
5199 assertArraysEquals(r, a, b, DoubleMaxVectorTests::beq);
5200 }
5201
5202 @Test(dataProvider = "maskProvider")
5203 static void maskHashCodeDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5204 boolean[] a = fa.apply(SPECIES.length());
5205
5206 for (int i = 0; i < a.length; i += SPECIES.length()) {
5207 var vmask = SPECIES.loadMask(a, i);
5208 int hash = vmask.hashCode();
5209
5210 boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5211 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5212 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5213 }
5214 }
5215
5216 static int maskTrueCount(boolean[] a, int idx) {
5217 int trueCount = 0;
5218 for (int i = idx; i < idx + SPECIES.length(); i++) {
5219 trueCount += a[i] ? 1 : 0;
5220 }
5221 return trueCount;
5222 }
5223
5224 @Test(dataProvider = "maskProvider")
5225 static void maskTrueCountDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5226 boolean[] a = fa.apply(SPECIES.length());
5227 int[] r = new int[a.length];
5228
5229 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5230 for (int i = 0; i < a.length; i += SPECIES.length()) {
5231 var vmask = SPECIES.loadMask(a, i);
5232 r[i] = vmask.trueCount();
5233 }
5234 }
5235
5236 assertMaskReductionArraysEquals(r, a, DoubleMaxVectorTests::maskTrueCount);
5237 }
5238
5239 static int maskLastTrue(boolean[] a, int idx) {
5240 int i = idx + SPECIES.length() - 1;
5241 for (; i >= idx; i--) {
5242 if (a[i]) {
5243 break;
5244 }
5245 }
5246 return i - idx;
5247 }
5248
5249 @Test(dataProvider = "maskProvider")
5250 static void maskLastTrueDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5251 boolean[] a = fa.apply(SPECIES.length());
5252 int[] r = new int[a.length];
5253
5254 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5255 for (int i = 0; i < a.length; i += SPECIES.length()) {
5256 var vmask = SPECIES.loadMask(a, i);
5257 r[i] = vmask.lastTrue();
5258 }
5259 }
5260
5261 assertMaskReductionArraysEquals(r, a, DoubleMaxVectorTests::maskLastTrue);
5262 }
5263
5264 static int maskFirstTrue(boolean[] a, int idx) {
5265 int i = idx;
5266 for (; i < idx + SPECIES.length(); i++) {
5267 if (a[i]) {
5268 break;
5269 }
5270 }
5271 return i - idx;
5272 }
5273
5274 @Test(dataProvider = "maskProvider")
5275 static void maskFirstTrueDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5276 boolean[] a = fa.apply(SPECIES.length());
5277 int[] r = new int[a.length];
5278
5279 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5280 for (int i = 0; i < a.length; i += SPECIES.length()) {
5281 var vmask = SPECIES.loadMask(a, i);
5282 r[i] = vmask.firstTrue();
5283 }
5284 }
5285
5286 assertMaskReductionArraysEquals(r, a, DoubleMaxVectorTests::maskFirstTrue);
5287 }
5288
5289 @Test(dataProvider = "maskProvider")
5290 static void maskCompressDoubleMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5291 int trueCount = 0;
5292 boolean[] a = fa.apply(SPECIES.length());
5293
5294 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5295 for (int i = 0; i < a.length; i += SPECIES.length()) {
5296 var vmask = SPECIES.loadMask(a, i);
5297 trueCount = vmask.trueCount();
5298 var rmask = vmask.compress();
5299 for (int j = 0; j < SPECIES.length(); j++) {
5300 Assert.assertEquals(rmask.laneIsSet(j), j < trueCount);
5301 }
5302 }
5303 }
5304 }
5305
5306
5307 @DataProvider
5308 public static Object[][] offsetProvider() {
5309 return new Object[][]{
5310 {0},
5311 {-1},
5312 {+1},
5313 {+2},
5314 {-2},
5315 };
5316 }
5317
5318 @Test(dataProvider = "offsetProvider")
5319 static void indexInRangeDoubleMaxVectorTestsSmokeTest(int offset) {
5320 int limit = SPECIES.length() * BUFFER_REPS;
5321 for (int i = 0; i < limit; i += SPECIES.length()) {
5322 var actualMask = SPECIES.indexInRange(i + offset, limit);
5323 var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5324 assert(actualMask.equals(expectedMask));
5325 for (int j = 0; j < SPECIES.length(); j++) {
5326 int index = i + j + offset;
5327 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
5328 }
5329 }
5330 }
5331
5332 @Test(dataProvider = "offsetProvider")
5333 static void indexInRangeLongDoubleMaxVectorTestsSmokeTest(int offset) {
5334 long limit = SPECIES.length() * BUFFER_REPS;
5335 for (long i = 0; i < limit; i += SPECIES.length()) {
5336 var actualMask = SPECIES.indexInRange(i + offset, limit);
5337 var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5338 assert(actualMask.equals(expectedMask));
5339 for (int j = 0; j < SPECIES.length(); j++) {
5340 long index = i + j + offset;
5341 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
5342 }
5343 }
5344 }
5345
5346 @DataProvider
5347 public static Object[][] lengthProvider() {
5348 return new Object[][]{
5349 {0},
5350 {1},
5351 {32},
5352 {37},
5353 {1024},
5354 {1024+1},
5355 {1024+5},
5356 };
5357 }
5358
5359 @Test(dataProvider = "lengthProvider")
5360 static void loopBoundDoubleMaxVectorTestsSmokeTest(int length) {
5361 int actualLoopBound = SPECIES.loopBound(length);
5362 int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
5363 Assert.assertEquals(actualLoopBound, expectedLoopBound);
5364 }
5365
5366 @Test(dataProvider = "lengthProvider")
5367 static void loopBoundLongDoubleMaxVectorTestsSmokeTest(int _length) {
5368 long length = _length;
5369 long actualLoopBound = SPECIES.loopBound(length);
5370 long expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
5371 Assert.assertEquals(actualLoopBound, expectedLoopBound);
5372 }
5373
5374 @Test
5375 static void ElementSizeDoubleMaxVectorTestsSmokeTest() {
5376 DoubleVector av = DoubleVector.zero(SPECIES);
5377 int elsize = av.elementSize();
5378 Assert.assertEquals(elsize, Double.SIZE);
5379 }
5380
5381 @Test
5382 static void VectorShapeDoubleMaxVectorTestsSmokeTest() {
5383 DoubleVector av = DoubleVector.zero(SPECIES);
5384 VectorShape vsh = av.shape();
5385 assert(vsh.equals(VectorShape.S_Max_BIT));
5386 }
5387
5388 @Test
5389 static void ShapeWithLanesDoubleMaxVectorTestsSmokeTest() {
5390 DoubleVector av = DoubleVector.zero(SPECIES);
5391 VectorShape vsh = av.shape();
5392 VectorSpecies species = vsh.withLanes(double.class);
5393 assert(species.equals(SPECIES));
5394 }
5395
5396 @Test
5397 static void ElementTypeDoubleMaxVectorTestsSmokeTest() {
5398 DoubleVector av = DoubleVector.zero(SPECIES);
5399 assert(av.species().elementType() == double.class);
5400 }
5401
5402 @Test
5403 static void SpeciesElementSizeDoubleMaxVectorTestsSmokeTest() {
5404 DoubleVector av = DoubleVector.zero(SPECIES);
5405 assert(av.species().elementSize() == Double.SIZE);
5406 }
5407
5408 @Test
5409 static void VectorTypeDoubleMaxVectorTestsSmokeTest() {
5410 DoubleVector av = DoubleVector.zero(SPECIES);
5411 assert(av.species().vectorType() == av.getClass());
5412 }
5413
5414 @Test
5415 static void WithLanesDoubleMaxVectorTestsSmokeTest() {
5416 DoubleVector av = DoubleVector.zero(SPECIES);
5417 VectorSpecies species = av.species().withLanes(double.class);
5418 assert(species.equals(SPECIES));
5419 }
5420
5421 @Test
5422 static void WithShapeDoubleMaxVectorTestsSmokeTest() {
5423 DoubleVector av = DoubleVector.zero(SPECIES);
5424 VectorShape vsh = av.shape();
5425 VectorSpecies species = av.species().withShape(vsh);
5426 assert(species.equals(SPECIES));
5427 }
5428
5429 @Test
5430 static void MaskAllTrueDoubleMaxVectorTestsSmokeTest() {
5431 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5432 Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
5433 }
5434 }
5435 }