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