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