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