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