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