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