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