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 IntMaxVectorTests
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 import jdk.incubator.vector.VectorMath;
42
43 import jdk.incubator.vector.IntVector;
44
45 import org.testng.Assert;
46 import org.testng.annotations.DataProvider;
47 import org.testng.annotations.Test;
48
49 import java.lang.Integer;
50 import java.util.List;
51 import java.util.Arrays;
52 import java.util.function.BiFunction;
53 import java.util.function.IntFunction;
54 import java.util.Objects;
55 import java.util.stream.Collectors;
56 import java.util.stream.Stream;
57
58 @Test
59 public class IntMaxVectorTests extends AbstractVectorTest {
60
61 static final VectorSpecies<Integer> SPECIES =
62 IntVector.SPECIES_MAX;
63
64 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
65
66 static VectorShape getMaxBit() {
67 return VectorShape.S_Max_BIT;
68 }
69
70 private static final int Max = 256; // juts so we can do N/Max
71
72 private static final int CONST_SHIFT = Integer.SIZE / 2;
73
74 static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / Max);
75
76 static void assertArraysStrictlyEquals(int[] r, int[] a) {
77 for (int i = 0; i < a.length; i++) {
78 if (r[i] != a[i]) {
79 Assert.fail("at index #" + i + ", expected = " + a[i] + ", actual = " + r[i]);
80 }
81 }
82 }
83
84 interface FUnOp {
85 int apply(int a);
86 }
87
88 static void assertArraysEquals(int[] r, int[] 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 int[] apply(int a);
101 }
102
103 static void assertArraysEquals(int[] r, int[] 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 int[] ref = f.apply(a[i]);
112 int[] 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(int[] r, int[] 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 int apply(int[] a, int idx);
132 }
133
134 interface FReductionAllOp {
135 int apply(int[] a);
136 }
137
138 static void assertReductionArraysEquals(int[] r, int rc, int[] a,
139 FReductionOp f, FReductionAllOp fa) {
140 int i = 0;
141 try {
142 Assert.assertEquals(rc, fa.apply(a));
143 for (; i < a.length; i += SPECIES.length()) {
144 Assert.assertEquals(r[i], f.apply(a, i));
145 }
146 } catch (AssertionError e) {
147 Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
148 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
149 }
150 }
151
152 interface FReductionMaskedOp {
153 int apply(int[] a, int idx, boolean[] mask);
154 }
155
156 interface FReductionAllMaskedOp {
157 int apply(int[] a, boolean[] mask);
158 }
159
160 static void assertReductionArraysEqualsMasked(int[] r, int rc, int[] a, boolean[] mask,
161 FReductionMaskedOp f, FReductionAllMaskedOp fa) {
162 int i = 0;
163 try {
164 Assert.assertEquals(rc, fa.apply(a, mask));
165 for (; i < a.length; i += SPECIES.length()) {
166 Assert.assertEquals(r[i], f.apply(a, i, mask));
167 }
168 } catch (AssertionError e) {
169 Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
170 Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
171 }
172 }
173
174 interface FReductionOpLong {
175 long apply(int[] a, int idx);
176 }
177
178 interface FReductionAllOpLong {
179 long apply(int[] a);
180 }
181
182 static void assertReductionLongArraysEquals(long[] r, long rc, int[] a,
183 FReductionOpLong f, FReductionAllOpLong fa) {
184 int i = 0;
185 try {
186 Assert.assertEquals(rc, fa.apply(a));
187 for (; i < a.length; i += SPECIES.length()) {
188 Assert.assertEquals(r[i], f.apply(a, i));
189 }
190 } catch (AssertionError e) {
191 Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
192 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
193 }
194 }
195
196 interface FReductionMaskedOpLong {
197 long apply(int[] a, int idx, boolean[] mask);
198 }
199
200 interface FReductionAllMaskedOpLong {
201 long apply(int[] a, boolean[] mask);
202 }
203
204 static void assertReductionLongArraysEqualsMasked(long[] r, long rc, int[] a, boolean[] mask,
205 FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) {
206 int i = 0;
207 try {
208 Assert.assertEquals(rc, fa.apply(a, mask));
209 for (; i < a.length; i += SPECIES.length()) {
210 Assert.assertEquals(r[i], f.apply(a, i, mask));
211 }
212 } catch (AssertionError e) {
213 Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
214 Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
215 }
216 }
217
218 interface FBoolReductionOp {
219 boolean apply(boolean[] a, int idx);
220 }
221
222 static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
223 int i = 0;
224 try {
225 for (; i < a.length; i += SPECIES.length()) {
226 Assert.assertEquals(r[i], f.apply(a, i));
227 }
228 } catch (AssertionError e) {
229 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
230 }
231 }
232
233 interface FMaskReductionOp {
234 int apply(boolean[] a, int idx);
235 }
236
237 static void assertMaskReductionArraysEquals(int[] r, boolean[] a, FMaskReductionOp f) {
238 int i = 0;
239 try {
240 for (; i < a.length; i += SPECIES.length()) {
241 Assert.assertEquals(r[i], f.apply(a, i));
242 }
243 } catch (AssertionError e) {
244 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
245 }
246 }
247
248 static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, int vector_len) {
249 int i = 0, j = 0;
250 try {
251 for (; i < a.length; i += vector_len) {
252 for (j = 0; j < vector_len; j++) {
253 Assert.assertEquals(r[i+j], a[i+order[i+j]]);
254 }
255 }
256 } catch (AssertionError e) {
257 int idx = i + j;
258 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
259 }
260 }
261
262 static void assertcompressArraysEquals(int[] r, int[] a, boolean[] m, int vector_len) {
263 int i = 0, j = 0, k = 0;
264 try {
265 for (; i < a.length; i += vector_len) {
266 k = 0;
267 for (j = 0; j < vector_len; j++) {
268 if (m[(i + j) % SPECIES.length()]) {
269 Assert.assertEquals(r[i + k], a[i + j]);
270 k++;
271 }
272 }
273 for (; k < vector_len; k++) {
274 Assert.assertEquals(r[i + k], (int)0);
275 }
276 }
277 } catch (AssertionError e) {
278 int idx = i + k;
279 if (m[(i + j) % SPECIES.length()]) {
280 Assert.assertEquals(r[idx], a[i + j], "at index #" + idx);
281 } else {
282 Assert.assertEquals(r[idx], (int)0, "at index #" + idx);
283 }
284 }
285 }
286
287 static void assertexpandArraysEquals(int[] r, int[] a, boolean[] m, int vector_len) {
288 int i = 0, j = 0, k = 0;
289 try {
290 for (; i < a.length; i += vector_len) {
291 k = 0;
292 for (j = 0; j < vector_len; j++) {
293 if (m[(i + j) % SPECIES.length()]) {
294 Assert.assertEquals(r[i + j], a[i + k]);
295 k++;
296 } else {
297 Assert.assertEquals(r[i + j], (int)0);
298 }
299 }
300 }
301 } catch (AssertionError e) {
302 int idx = i + j;
303 if (m[idx % SPECIES.length()]) {
304 Assert.assertEquals(r[idx], a[i + k], "at index #" + idx);
305 } else {
306 Assert.assertEquals(r[idx], (int)0, "at index #" + idx);
307 }
308 }
309 }
310
311 static void assertSelectFromTwoVectorEquals(int[] r, int[] order, int[] a, int[] b, int vector_len) {
312 int i = 0, j = 0;
313 boolean is_exceptional_idx = false;
314 int idx = 0, wrapped_index = 0, oidx = 0;
315 try {
316 for (; i < a.length; i += vector_len) {
317 for (j = 0; j < vector_len; j++) {
318 idx = i + j;
319 wrapped_index = Math.floorMod((int)order[idx], 2 * vector_len);
320 is_exceptional_idx = wrapped_index >= vector_len;
321 oidx = is_exceptional_idx ? (wrapped_index - vector_len) : wrapped_index;
322 Assert.assertEquals(r[idx], (is_exceptional_idx ? b[i + oidx] : a[i + oidx]));
323 }
324 }
325 } catch (AssertionError e) {
326 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]);
327 }
328 }
329
330 static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, int vector_len) {
331 int i = 0, j = 0;
332 try {
333 for (; i < a.length; i += vector_len) {
334 for (j = 0; j < vector_len; j++) {
335 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
336 }
337 }
338 } catch (AssertionError e) {
339 int idx = i + j;
340 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
341 }
342 }
343
344 static void assertRearrangeArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) {
345 int i = 0, j = 0;
346 try {
347 for (; i < a.length; i += vector_len) {
348 for (j = 0; j < vector_len; j++) {
349 if (mask[j % SPECIES.length()])
350 Assert.assertEquals(r[i+j], a[i+order[i+j]]);
351 else
352 Assert.assertEquals(r[i+j], (int)0);
353 }
354 }
355 } catch (AssertionError e) {
356 int idx = i + j;
357 if (mask[j % SPECIES.length()])
358 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
359 else
360 Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
361 }
362 }
363
364 static void assertSelectFromArraysEquals(int[] r, int[] a, int[] order, boolean[] mask, int vector_len) {
365 int i = 0, j = 0;
366 try {
367 for (; i < a.length; i += vector_len) {
368 for (j = 0; j < vector_len; j++) {
369 if (mask[j % SPECIES.length()])
370 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
371 else
372 Assert.assertEquals(r[i+j], (int)0);
373 }
374 }
375 } catch (AssertionError e) {
376 int idx = i + j;
377 if (mask[j % SPECIES.length()])
378 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()]);
379 else
380 Assert.assertEquals(r[i+j], (int)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
381 }
382 }
383
384 static void assertBroadcastArraysEquals(int[] r, int[] a) {
385 int i = 0;
386 for (; i < a.length; i += SPECIES.length()) {
387 int idx = i;
388 for (int j = idx; j < (idx + SPECIES.length()); j++)
389 a[j]=a[idx];
390 }
391
392 try {
393 for (i = 0; i < a.length; i++) {
394 Assert.assertEquals(r[i], a[i]);
395 }
396 } catch (AssertionError e) {
397 Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
398 }
399 }
400
401 interface FBinOp {
402 int apply(int a, int b);
403 }
404
405 interface FBinMaskOp {
406 int apply(int a, int b, boolean m);
407
408 static FBinMaskOp lift(FBinOp f) {
409 return (a, b, m) -> m ? f.apply(a, b) : a;
410 }
411 }
412
413 static void assertArraysEqualsAssociative(int[] rl, int[] rr, int[] a, int[] b, int[] c, FBinOp f) {
414 int i = 0;
415 try {
416 for (; i < a.length; i++) {
417 //Left associative
418 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i]), c[i]));
419
420 //Right associative
421 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i])));
422
423 //Results equal sanity check
424 Assert.assertEquals(rl[i], rr[i]);
425 }
426 } catch (AssertionError e) {
427 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]);
428 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]);
429 Assert.assertEquals(rl[i], rr[i], "Result checks not equal at index #" + i + "leftRes = " + rl[i] + ", rightRes = " + rr[i]);
430 }
431 }
432
433 static void assertArraysEqualsAssociative(int[] rl, int[] rr, int[] a, int[] b, int[] c, boolean[] mask, FBinOp f) {
434 assertArraysEqualsAssociative(rl, rr, a, b, c, mask, FBinMaskOp.lift(f));
435 }
436
437 static void assertArraysEqualsAssociative(int[] rl, int[] rr, int[] a, int[] b, int[] c, boolean[] mask, FBinMaskOp f) {
438 int i = 0;
439 boolean mask_bit = false;
440 try {
441 for (; i < a.length; i++) {
442 mask_bit = mask[i % SPECIES.length()];
443 //Left associative
444 Assert.assertEquals(rl[i], f.apply(f.apply(a[i], b[i], mask_bit), c[i], mask_bit));
445
446 //Right associative
447 Assert.assertEquals(rr[i], f.apply(a[i], f.apply(b[i], c[i], mask_bit), mask_bit));
448
449 //Results equal sanity check
450 Assert.assertEquals(rl[i], rr[i]);
451 }
452 } catch (AssertionError e) {
453 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);
454 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);
455 Assert.assertEquals(rl[i], rr[i], "Result checks not equal at index #" + i + "leftRes = " + rl[i] + ", rightRes = " + rr[i]);
456 }
457 }
458
459 static void assertArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
460 int i = 0;
461 try {
462 for (; i < a.length; i++) {
463 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
464 }
465 } catch (AssertionError e) {
466 Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
467 }
468 }
469
470 static void assertArraysEquals(int[] r, int[] a, int b, FBinOp f) {
471 int i = 0;
472 try {
473 for (; i < a.length; i++) {
474 Assert.assertEquals(r[i], f.apply(a[i], b));
475 }
476 } catch (AssertionError e) {
477 Assert.assertEquals(r[i], f.apply(a[i], b), "(" + a[i] + ", " + b + ") at index #" + i);
478 }
479 }
480
481 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
482 int i = 0;
483 try {
484 for (; i < a.length; i++) {
485 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
486 }
487 } catch (AssertionError e) {
488 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
489 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
490 }
491 }
492
493 static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
494 int i = 0;
495 try {
496 for (; i < a.length; i++) {
497 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
498 }
499 } catch (AssertionError e) {
500 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
501 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
502 }
503 }
504
505 static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
506 assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
507 }
508
509 static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
510 int i = 0;
511 try {
512 for (; i < a.length; i++) {
513 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
514 }
515 } catch (AssertionError err) {
516 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()]);
517 }
518 }
519
520 static void assertArraysEquals(int[] r, int[] a, int b, boolean[] mask, FBinOp f) {
521 assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
522 }
523
524 static void assertArraysEquals(int[] r, int[] a, int b, boolean[] mask, FBinMaskOp f) {
525 int i = 0;
526 try {
527 for (; i < a.length; i++) {
528 Assert.assertEquals(r[i], f.apply(a[i], b, mask[i % SPECIES.length()]));
529 }
530 } catch (AssertionError err) {
531 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()]);
532 }
533 }
534
535 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
536 assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
537 }
538
539 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
540 int i = 0;
541 try {
542 for (; i < a.length; i++) {
543 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
544 }
545 } catch (AssertionError err) {
546 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
547 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
548 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
549 mask[i % SPECIES.length()]);
550 }
551 }
552
553 static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
554 assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
555 }
556
557 static void assertBroadcastLongArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
558 int i = 0;
559 try {
560 for (; i < a.length; i++) {
561 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
562 }
563 } catch (AssertionError err) {
564 Assert.assertEquals(r[i], f.apply(a[i], (int)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
565 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
566 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
567 mask[i % SPECIES.length()]);
568 }
569 }
570
571 static void assertShiftArraysEquals(int[] r, int[] a, int[] b, FBinOp f) {
572 int i = 0;
573 int j = 0;
574 try {
575 for (; j < a.length; j += SPECIES.length()) {
576 for (i = 0; i < SPECIES.length(); i++) {
577 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
578 }
579 }
580 } catch (AssertionError e) {
581 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
582 }
583 }
584
585 static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinOp f) {
586 assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
587 }
588
589 static void assertShiftArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FBinMaskOp f) {
590 int i = 0;
591 int j = 0;
592 try {
593 for (; j < a.length; j += SPECIES.length()) {
594 for (i = 0; i < SPECIES.length(); i++) {
595 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
596 }
597 }
598 } catch (AssertionError err) {
599 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]);
600 }
601 }
602
603 interface FBinConstOp {
604 int apply(int a);
605 }
606
607 interface FBinConstMaskOp {
608 int apply(int a, boolean m);
609
610 static FBinConstMaskOp lift(FBinConstOp f) {
611 return (a, m) -> m ? f.apply(a) : a;
612 }
613 }
614
615 static void assertShiftConstEquals(int[] r, int[] a, FBinConstOp f) {
616 int i = 0;
617 int j = 0;
618 try {
619 for (; j < a.length; j += SPECIES.length()) {
620 for (i = 0; i < SPECIES.length(); i++) {
621 Assert.assertEquals(r[i+j], f.apply(a[i+j]));
622 }
623 }
624 } catch (AssertionError e) {
625 Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j);
626 }
627 }
628
629 static void assertShiftConstEquals(int[] r, int[] a, boolean[] mask, FBinConstOp f) {
630 assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
631 }
632
633 static void assertShiftConstEquals(int[] r, int[] a, boolean[] mask, FBinConstMaskOp f) {
634 int i = 0;
635 int j = 0;
636 try {
637 for (; j < a.length; j += SPECIES.length()) {
638 for (i = 0; i < SPECIES.length(); i++) {
639 Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]));
640 }
641 }
642 } catch (AssertionError err) {
643 Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]);
644 }
645 }
646
647 interface FTernOp {
648 int apply(int a, int b, int c);
649 }
650
651 interface FTernMaskOp {
652 int apply(int a, int b, int c, boolean m);
653
654 static FTernMaskOp lift(FTernOp f) {
655 return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
656 }
657 }
658
659 static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
660 int i = 0;
661 try {
662 for (; i < a.length; i++) {
663 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
664 }
665 } catch (AssertionError e) {
666 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
667 }
668 }
669
670 static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernOp f) {
671 assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
672 }
673
674 static void assertArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask, FTernMaskOp f) {
675 int i = 0;
676 try {
677 for (; i < a.length; i++) {
678 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
679 }
680 } catch (AssertionError err) {
681 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
682 + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
683 }
684 }
685
686 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
687 int i = 0;
688 try {
689 for (; i < a.length; i++) {
690 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
691 }
692 } catch (AssertionError e) {
693 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
694 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
695 c[(i / SPECIES.length()) * SPECIES.length()]);
696 }
697 }
698
699 static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] 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 / SPECIES.length()) * SPECIES.length()], c[i]));
704 }
705 } catch (AssertionError e) {
706 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
707 i + ", input1 = " + a[i] + ", input2 = " +
708 b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " + c[i]);
709 }
710 }
711
712 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
713 FTernOp f) {
714 assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
715 }
716
717 static void assertBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
718 FTernMaskOp f) {
719 int i = 0;
720 try {
721 for (; i < a.length; i++) {
722 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
723 mask[i % SPECIES.length()]));
724 }
725 } catch (AssertionError err) {
726 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
727 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
728 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
729 mask[i % SPECIES.length()]);
730 }
731 }
732
733 static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
734 FTernOp f) {
735 assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
736 }
737
738 static void assertAltBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
739 FTernMaskOp f) {
740 int i = 0;
741 try {
742 for (; i < a.length; i++) {
743 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
744 mask[i % SPECIES.length()]));
745 }
746 } catch (AssertionError err) {
747 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
748 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
749 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
750 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
751 }
752 }
753
754 static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, FTernOp f) {
755 int i = 0;
756 try {
757 for (; i < a.length; i++) {
758 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
759 c[(i / SPECIES.length()) * SPECIES.length()]));
760 }
761 } catch (AssertionError e) {
762 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
763 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
764 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
765 c[(i / SPECIES.length()) * SPECIES.length()]);
766 }
767 }
768
769 static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
770 FTernOp f) {
771 assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
772 }
773
774 static void assertDoubleBroadcastArraysEquals(int[] r, int[] a, int[] b, int[] c, boolean[] mask,
775 FTernMaskOp f) {
776 int i = 0;
777 try {
778 for (; i < a.length; i++) {
779 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
780 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
781 }
782 } catch (AssertionError err) {
783 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
784 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
785 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
786 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
787 mask[i % SPECIES.length()]);
788 }
789 }
790
791
792
793 interface FGatherScatterOp {
794 int[] apply(int[] a, int ix, int[] b, int iy);
795 }
796
797 static void assertArraysEquals(int[] r, int[] a, int[] b, FGatherScatterOp f) {
798 int i = 0;
799 try {
800 for (; i < a.length; i += SPECIES.length()) {
801 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
802 f.apply(a, i, b, i));
803 }
804 } catch (AssertionError e) {
805 int[] ref = f.apply(a, i, b, i);
806 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
807 Assert.assertEquals(res, ref,
808 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
809 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
810 + ", b: "
811 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
812 + " at index #" + i);
813 }
814 }
815
816 interface FGatherMaskedOp {
817 int[] apply(int[] a, int ix, boolean[] mask, int[] b, int iy);
818 }
819
820 interface FScatterMaskedOp {
821 int[] apply(int[] r, int[] a, int ix, boolean[] mask, int[] b, int iy);
822 }
823
824 static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
825 int i = 0;
826 try {
827 for (; i < a.length; i += SPECIES.length()) {
828 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
829 f.apply(a, i, mask, b, i));
830 }
831 } catch (AssertionError e) {
832 int[] ref = f.apply(a, i, mask, b, i);
833 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
834 Assert.assertEquals(res, ref,
835 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
836 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
837 + ", b: "
838 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
839 + ", mask: "
840 + Arrays.toString(mask)
841 + " at index #" + i);
842 }
843 }
844
845 static void assertArraysEquals(int[] r, int[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
846 int i = 0;
847 try {
848 for (; i < a.length; i += SPECIES.length()) {
849 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
850 f.apply(r, a, i, mask, b, i));
851 }
852 } catch (AssertionError e) {
853 int[] ref = f.apply(r, a, i, mask, b, i);
854 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
855 Assert.assertEquals(res, ref,
856 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
857 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
858 + ", b: "
859 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
860 + ", r: "
861 + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
862 + ", mask: "
863 + Arrays.toString(mask)
864 + " at index #" + i);
865 }
866 }
867
868 interface FLaneOp {
869 int[] apply(int[] a, int origin, int idx);
870 }
871
872 static void assertArraysEquals(int[] r, int[] a, int origin, FLaneOp f) {
873 int i = 0;
874 try {
875 for (; i < a.length; i += SPECIES.length()) {
876 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
877 f.apply(a, origin, i));
878 }
879 } catch (AssertionError e) {
880 int[] ref = f.apply(a, origin, i);
881 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
882 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
883 + ", res: " + Arrays.toString(res)
884 + "), at index #" + i);
885 }
886 }
887
888 interface FLaneBop {
889 int[] apply(int[] a, int[] b, int origin, int idx);
890 }
891
892 static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, FLaneBop f) {
893 int i = 0;
894 try {
895 for (; i < a.length; i += SPECIES.length()) {
896 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
897 f.apply(a, b, origin, i));
898 }
899 } catch (AssertionError e) {
900 int[] ref = f.apply(a, b, origin, i);
901 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
902 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
903 + ", res: " + Arrays.toString(res)
904 + "), at index #" + i
905 + ", at origin #" + origin);
906 }
907 }
908
909 interface FLaneMaskedBop {
910 int[] apply(int[] a, int[] b, int origin, boolean[] mask, int idx);
911 }
912
913 static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
914 int i = 0;
915 try {
916 for (; i < a.length; i += SPECIES.length()) {
917 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
918 f.apply(a, b, origin, mask, i));
919 }
920 } catch (AssertionError e) {
921 int[] ref = f.apply(a, b, origin, mask, i);
922 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
923 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
924 + ", res: " + Arrays.toString(res)
925 + "), at index #" + i
926 + ", at origin #" + origin);
927 }
928 }
929
930 interface FLanePartBop {
931 int[] apply(int[] a, int[] b, int origin, int part, int idx);
932 }
933
934 static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, FLanePartBop f) {
935 int i = 0;
936 try {
937 for (; i < a.length; i += SPECIES.length()) {
938 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
939 f.apply(a, b, origin, part, i));
940 }
941 } catch (AssertionError e) {
942 int[] ref = f.apply(a, b, origin, part, i);
943 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
944 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
945 + ", res: " + Arrays.toString(res)
946 + "), at index #" + i
947 + ", at origin #" + origin
948 + ", with part #" + part);
949 }
950 }
951
952 interface FLanePartMaskedBop {
953 int[] apply(int[] a, int[] b, int origin, int part, boolean[] mask, int idx);
954 }
955
956 static void assertArraysEquals(int[] r, int[] a, int[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
957 int i = 0;
958 try {
959 for (; i < a.length; i += SPECIES.length()) {
960 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
961 f.apply(a, b, origin, part, mask, i));
962 }
963 } catch (AssertionError e) {
964 int[] ref = f.apply(a, b, origin, part, mask, i);
965 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
966 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
967 + ", res: " + Arrays.toString(res)
968 + "), at index #" + i
969 + ", at origin #" + origin
970 + ", with part #" + part);
971 }
972 }
973
974
975 static void assertArraysEquals(int[] r, int[] a, int offs) {
976 int i = 0;
977 try {
978 for (; i < r.length; i++) {
979 Assert.assertEquals(r[i], (int)(a[i+offs]));
980 }
981 } catch (AssertionError e) {
982 Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
983 }
984 }
985
986
987
988 static void assertArraysEquals(long[] r, int[] a, int offs) {
989 int i = 0;
990 try {
991 for (; i < r.length; i++) {
992 Assert.assertEquals(r[i], (long)(a[i+offs]));
993 }
994 } catch (AssertionError e) {
995 Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
996 }
997 }
998
999 static void assertArraysEquals(double[] r, int[] a, int offs) {
1000 int i = 0;
1001 try {
1002 for (; i < r.length; i++) {
1003 Assert.assertEquals(r[i], (double)(a[i+offs]));
1004 }
1005 } catch (AssertionError e) {
1006 Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
1007 }
1008 }
1009
1010 static int bits(int e) {
1011 return e;
1012 }
1013
1014 static final List<IntFunction<int[]>> INT_GENERATORS = List.of(
1015 withToString("int[-i * 5]", (int s) -> {
1016 return fill(s * BUFFER_REPS,
1017 i -> (int)(-i * 5));
1018 }),
1019 withToString("int[i * 5]", (int s) -> {
1020 return fill(s * BUFFER_REPS,
1021 i -> (int)(i * 5));
1022 }),
1023 withToString("int[i + 1]", (int s) -> {
1024 return fill(s * BUFFER_REPS,
1025 i -> (((int)(i + 1) == 0) ? 1 : (int)(i + 1)));
1026 }),
1027 withToString("int[cornerCaseValue(i)]", (int s) -> {
1028 return fill(s * BUFFER_REPS,
1029 i -> cornerCaseValue(i));
1030 })
1031 );
1032
1033 static final List<IntFunction<int[]>> INT_SATURATING_GENERATORS = List.of(
1034 withToString("int[Integer.MIN_VALUE]", (int s) -> {
1035 return fill(s * BUFFER_REPS,
1036 i -> (int)(Integer.MIN_VALUE));
1037 }),
1038 withToString("int[Integer.MAX_VALUE]", (int s) -> {
1039 return fill(s * BUFFER_REPS,
1040 i -> (int)(Integer.MAX_VALUE));
1041 }),
1042 withToString("int[Integer.MAX_VALUE - 100]", (int s) -> {
1043 return fill(s * BUFFER_REPS,
1044 i -> (int)(Integer.MAX_VALUE - 100));
1045 }),
1046 withToString("int[Integer.MIN_VALUE + 100]", (int s) -> {
1047 return fill(s * BUFFER_REPS,
1048 i -> (int)(Integer.MIN_VALUE + 100));
1049 }),
1050 withToString("int[-i * 5]", (int s) -> {
1051 return fill(s * BUFFER_REPS,
1052 i -> (int)(-i * 5));
1053 }),
1054 withToString("int[i * 5]", (int s) -> {
1055 return fill(s * BUFFER_REPS,
1056 i -> (int)(i * 5));
1057 })
1058 );
1059
1060 static final List<IntFunction<int[]>> INT_SATURATING_GENERATORS_ASSOC = List.of(
1061 withToString("int[Integer.MAX_VALUE]", (int s) -> {
1062 return fill(s * BUFFER_REPS,
1063 i -> (int)(Integer.MAX_VALUE));
1064 }),
1065 withToString("int[Integer.MAX_VALUE - 100]", (int s) -> {
1066 return fill(s * BUFFER_REPS,
1067 i -> (int)(Integer.MAX_VALUE - 100));
1068 }),
1069 withToString("int[-1]", (int s) -> {
1070 return fill(s * BUFFER_REPS,
1071 i -> (int)(-1));
1072 })
1073 );
1074
1075 // Create combinations of pairs
1076 // @@@ Might be sensitive to order e.g. div by 0
1077 static final List<List<IntFunction<int[]>>> INT_GENERATOR_PAIRS =
1078 Stream.of(INT_GENERATORS.get(0)).
1079 flatMap(fa -> INT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
1080 collect(Collectors.toList());
1081
1082 static final List<List<IntFunction<int[]>>> INT_SATURATING_GENERATOR_PAIRS =
1083 Stream.of(INT_GENERATORS.get(0)).
1084 flatMap(fa -> INT_SATURATING_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
1085 collect(Collectors.toList());
1086
1087 static final List<List<IntFunction<int[]>>> INT_SATURATING_GENERATOR_TRIPLETS =
1088 Stream.of(INT_GENERATORS.get(1))
1089 .flatMap(fa -> INT_SATURATING_GENERATORS_ASSOC.stream().map(fb -> List.of(fa, fb)))
1090 .flatMap(pair -> INT_SATURATING_GENERATORS_ASSOC.stream().map(f -> List.of(pair.get(0), pair.get(1), f)))
1091 .collect(Collectors.toList());
1092
1093 @DataProvider
1094 public Object[][] boolUnaryOpProvider() {
1095 return BOOL_ARRAY_GENERATORS.stream().
1096 map(f -> new Object[]{f}).
1097 toArray(Object[][]::new);
1098 }
1099
1100 static final List<List<IntFunction<int[]>>> INT_GENERATOR_TRIPLES =
1101 INT_GENERATOR_PAIRS.stream().
1102 flatMap(pair -> INT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1103 collect(Collectors.toList());
1104
1105 static final List<IntFunction<int[]>> SELECT_FROM_INDEX_GENERATORS = List.of(
1106 withToString("int[0..VECLEN*2)", (int s) -> {
1107 return fill(s * BUFFER_REPS,
1108 i -> (int)(RAND.nextInt()));
1109 })
1110 );
1111
1112 static final List<List<IntFunction<int[]>>> INT_GENERATOR_SELECT_FROM_TRIPLES =
1113 INT_GENERATOR_PAIRS.stream().
1114 flatMap(pair -> SELECT_FROM_INDEX_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1115 collect(Collectors.toList());
1116
1117 @DataProvider
1118 public Object[][] intBinaryOpProvider() {
1119 return INT_GENERATOR_PAIRS.stream().map(List::toArray).
1120 toArray(Object[][]::new);
1121 }
1122
1123 @DataProvider
1124 public Object[][] intSaturatingBinaryOpProvider() {
1125 return INT_SATURATING_GENERATOR_PAIRS.stream().map(List::toArray).
1126 toArray(Object[][]::new);
1127 }
1128
1129 @DataProvider
1130 public Object[][] intSaturatingBinaryOpAssocProvider() {
1131 return INT_SATURATING_GENERATOR_TRIPLETS.stream().map(List::toArray).
1132 toArray(Object[][]::new);
1133 }
1134
1135 @DataProvider
1136 public Object[][] intSaturatingBinaryOpAssocMaskProvider() {
1137 return BOOLEAN_MASK_GENERATORS.stream().
1138 flatMap(fm -> INT_SATURATING_GENERATOR_TRIPLETS.stream().map(lfa -> {
1139 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1140 })).
1141 toArray(Object[][]::new);
1142 }
1143
1144
1145 @DataProvider
1146 public Object[][] intIndexedOpProvider() {
1147 return INT_GENERATOR_PAIRS.stream().map(List::toArray).
1148 toArray(Object[][]::new);
1149 }
1150
1151 @DataProvider
1152 public Object[][] intSaturatingBinaryOpMaskProvider() {
1153 return BOOLEAN_MASK_GENERATORS.stream().
1154 flatMap(fm -> INT_SATURATING_GENERATOR_PAIRS.stream().map(lfa -> {
1155 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1156 })).
1157 toArray(Object[][]::new);
1158 }
1159
1160 @DataProvider
1161 public Object[][] intSaturatingUnaryOpProvider() {
1162 return INT_SATURATING_GENERATORS.stream().
1163 map(f -> new Object[]{f}).
1164 toArray(Object[][]::new);
1165 }
1166
1167 @DataProvider
1168 public Object[][] intSaturatingUnaryOpMaskProvider() {
1169 return BOOLEAN_MASK_GENERATORS.stream().
1170 flatMap(fm -> INT_SATURATING_GENERATORS.stream().map(fa -> {
1171 return new Object[] {fa, fm};
1172 })).
1173 toArray(Object[][]::new);
1174 }
1175
1176 @DataProvider
1177 public Object[][] intBinaryOpMaskProvider() {
1178 return BOOLEAN_MASK_GENERATORS.stream().
1179 flatMap(fm -> INT_GENERATOR_PAIRS.stream().map(lfa -> {
1180 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1181 })).
1182 toArray(Object[][]::new);
1183 }
1184
1185 @DataProvider
1186 public Object[][] intTernaryOpProvider() {
1187 return INT_GENERATOR_TRIPLES.stream().map(List::toArray).
1188 toArray(Object[][]::new);
1189 }
1190
1191 @DataProvider
1192 public Object[][] intSelectFromTwoVectorOpProvider() {
1193 return INT_GENERATOR_SELECT_FROM_TRIPLES.stream().map(List::toArray).
1194 toArray(Object[][]::new);
1195 }
1196
1197 @DataProvider
1198 public Object[][] intTernaryOpMaskProvider() {
1199 return BOOLEAN_MASK_GENERATORS.stream().
1200 flatMap(fm -> INT_GENERATOR_TRIPLES.stream().map(lfa -> {
1201 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1202 })).
1203 toArray(Object[][]::new);
1204 }
1205
1206 @DataProvider
1207 public Object[][] intUnaryOpProvider() {
1208 return INT_GENERATORS.stream().
1209 map(f -> new Object[]{f}).
1210 toArray(Object[][]::new);
1211 }
1212
1213 @DataProvider
1214 public Object[][] intUnaryOpMaskProvider() {
1215 return BOOLEAN_MASK_GENERATORS.stream().
1216 flatMap(fm -> INT_GENERATORS.stream().map(fa -> {
1217 return new Object[] {fa, fm};
1218 })).
1219 toArray(Object[][]::new);
1220 }
1221
1222 @DataProvider
1223 public Object[][] maskProvider() {
1224 return BOOLEAN_MASK_GENERATORS.stream().
1225 map(f -> new Object[]{f}).
1226 toArray(Object[][]::new);
1227 }
1228
1229 @DataProvider
1230 public Object[][] maskCompareOpProvider() {
1231 return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1232 toArray(Object[][]::new);
1233 }
1234
1235 @DataProvider
1236 public Object[][] shuffleProvider() {
1237 return INT_SHUFFLE_GENERATORS.stream().
1238 map(f -> new Object[]{f}).
1239 toArray(Object[][]::new);
1240 }
1241
1242 @DataProvider
1243 public Object[][] shuffleCompareOpProvider() {
1244 return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1245 toArray(Object[][]::new);
1246 }
1247
1248 @DataProvider
1249 public Object[][] intUnaryOpShuffleProvider() {
1250 return INT_SHUFFLE_GENERATORS.stream().
1251 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
1252 return new Object[] {fa, fs};
1253 })).
1254 toArray(Object[][]::new);
1255 }
1256
1257 @DataProvider
1258 public Object[][] intUnaryOpShuffleMaskProvider() {
1259 return BOOLEAN_MASK_GENERATORS.stream().
1260 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1261 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
1262 return new Object[] {fa, fs, fm};
1263 }))).
1264 toArray(Object[][]::new);
1265 }
1266
1267 static final List<IntFunction<int[]>> INT_COMPARE_GENERATORS = List.of(
1268 withToString("int[i]", (int s) -> {
1269 return fill(s * BUFFER_REPS,
1270 i -> (int)i);
1271 }),
1272 withToString("int[i - length / 2]", (int s) -> {
1273 return fill(s * BUFFER_REPS,
1274 i -> (int)(i - (s * BUFFER_REPS / 2)));
1275 }),
1276 withToString("int[i + 1]", (int s) -> {
1277 return fill(s * BUFFER_REPS,
1278 i -> (int)(i + 1));
1279 }),
1280 withToString("int[i - 2]", (int s) -> {
1281 return fill(s * BUFFER_REPS,
1282 i -> (int)(i - 2));
1283 }),
1284 withToString("int[zigZag(i)]", (int s) -> {
1285 return fill(s * BUFFER_REPS,
1286 i -> i%3 == 0 ? (int)i : (i%3 == 1 ? (int)(i + 1) : (int)(i - 2)));
1287 }),
1288 withToString("int[cornerCaseValue(i)]", (int s) -> {
1289 return fill(s * BUFFER_REPS,
1290 i -> cornerCaseValue(i));
1291 })
1292 );
1293
1294 static final List<List<IntFunction<int[]>>> INT_TEST_GENERATOR_ARGS =
1295 INT_COMPARE_GENERATORS.stream().
1296 map(fa -> List.of(fa)).
1297 collect(Collectors.toList());
1298
1299 @DataProvider
1300 public Object[][] intTestOpProvider() {
1301 return INT_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1302 toArray(Object[][]::new);
1303 }
1304
1305 @DataProvider
1306 public Object[][] intTestOpMaskProvider() {
1307 return BOOLEAN_MASK_GENERATORS.stream().
1308 flatMap(fm -> INT_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1309 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1310 })).
1311 toArray(Object[][]::new);
1312 }
1313
1314 static final List<List<IntFunction<int[]>>> INT_COMPARE_GENERATOR_PAIRS =
1315 INT_COMPARE_GENERATORS.stream().
1316 flatMap(fa -> INT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1317 collect(Collectors.toList());
1318
1319 @DataProvider
1320 public Object[][] intCompareOpProvider() {
1321 return INT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1322 toArray(Object[][]::new);
1323 }
1324
1325 @DataProvider
1326 public Object[][] intCompareOpMaskProvider() {
1327 return BOOLEAN_MASK_GENERATORS.stream().
1328 flatMap(fm -> INT_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1329 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1330 })).
1331 toArray(Object[][]::new);
1332 }
1333
1334 interface ToIntF {
1335 int apply(int i);
1336 }
1337
1338 static int[] fill(int s , ToIntF f) {
1339 return fill(new int[s], f);
1340 }
1341
1342 static int[] fill(int[] a, ToIntF f) {
1343 for (int i = 0; i < a.length; i++) {
1344 a[i] = f.apply(i);
1345 }
1346 return a;
1347 }
1348
1349 static int cornerCaseValue(int i) {
1350 switch(i % 5) {
1351 case 0:
1352 return Integer.MAX_VALUE;
1353 case 1:
1354 return Integer.MIN_VALUE;
1355 case 2:
1356 return Integer.MIN_VALUE;
1357 case 3:
1358 return Integer.MAX_VALUE;
1359 default:
1360 return (int)0;
1361 }
1362 }
1363
1364 static final IntFunction<int[]> fr = (vl) -> {
1365 int length = BUFFER_REPS * vl;
1366 return new int[length];
1367 };
1368
1369 static final IntFunction<boolean[]> fmr = (vl) -> {
1370 int length = BUFFER_REPS * vl;
1371 return new boolean[length];
1372 };
1373
1374 static final IntFunction<long[]> lfr = (vl) -> {
1375 int length = BUFFER_REPS * vl;
1376 return new long[length];
1377 };
1378
1379 static void replaceZero(int[] a, int v) {
1380 for (int i = 0; i < a.length; i++) {
1381 if (a[i] == 0) {
1382 a[i] = v;
1383 }
1384 }
1385 }
1386
1387 static void replaceZero(int[] a, boolean[] mask, int v) {
1388 for (int i = 0; i < a.length; i++) {
1389 if (mask[i % mask.length] && a[i] == 0) {
1390 a[i] = v;
1391 }
1392 }
1393 }
1394
1395 static int ROL_scalar(int a, int b) {
1396 return Integer.rotateLeft(a, ((int)b));
1397 }
1398
1399 static int ROR_scalar(int a, int b) {
1400 return Integer.rotateRight(a, ((int)b));
1401 }
1402
1403 static int TRAILING_ZEROS_COUNT_scalar(int a) {
1404 return Integer.numberOfTrailingZeros(a);
1405 }
1406
1407 static int LEADING_ZEROS_COUNT_scalar(int a) {
1408 return Integer.numberOfLeadingZeros(a);
1409 }
1410
1411 static int REVERSE_scalar(int a) {
1412 return Integer.reverse(a);
1413 }
1414
1415 static boolean eq(int a, int b) {
1416 return a == b;
1417 }
1418
1419 static boolean neq(int a, int b) {
1420 return a != b;
1421 }
1422
1423 static boolean lt(int a, int b) {
1424 return a < b;
1425 }
1426
1427 static boolean le(int a, int b) {
1428 return a <= b;
1429 }
1430
1431 static boolean gt(int a, int b) {
1432 return a > b;
1433 }
1434
1435 static boolean ge(int a, int b) {
1436 return a >= b;
1437 }
1438
1439 static boolean ult(int a, int b) {
1440 return Integer.compareUnsigned(a, b) < 0;
1441 }
1442
1443 static boolean ule(int a, int b) {
1444 return Integer.compareUnsigned(a, b) <= 0;
1445 }
1446
1447 static boolean ugt(int a, int b) {
1448 return Integer.compareUnsigned(a, b) > 0;
1449 }
1450
1451 static boolean uge(int a, int b) {
1452 return Integer.compareUnsigned(a, b) >= 0;
1453 }
1454
1455 static int firstNonZero(int a, int b) {
1456 return Integer.compare(a, (int) 0) != 0 ? a : b;
1457 }
1458
1459 @Test
1460 static void smokeTest1() {
1461 IntVector three = IntVector.broadcast(SPECIES, (byte)-3);
1462 IntVector three2 = (IntVector) SPECIES.broadcast(-3);
1463 assert(three.eq(three2).allTrue());
1464 IntVector three3 = three2.broadcast(1).broadcast(-3);
1465 assert(three.eq(three3).allTrue());
1466 int scale = 2;
1467 Class<?> ETYPE = int.class;
1468 if (ETYPE == double.class || ETYPE == long.class)
1469 scale = 1000000;
1470 else if (ETYPE == byte.class && SPECIES.length() >= 64)
1471 scale = 1;
1472 IntVector higher = three.addIndex(scale);
1473 VectorMask<Integer> m = three.compare(VectorOperators.LE, higher);
1474 assert(m.allTrue());
1475 m = higher.min((int)-1).test(VectorOperators.IS_NEGATIVE);
1476 assert(m.allTrue());
1477 int max = higher.reduceLanes(VectorOperators.MAX);
1478 assert(max == -3 + scale * (SPECIES.length()-1));
1479 }
1480
1481 private static int[]
1482 bothToArray(IntVector a, IntVector b) {
1483 int[] r = new int[a.length() + b.length()];
1484 a.intoArray(r, 0);
1485 b.intoArray(r, a.length());
1486 return r;
1487 }
1488
1489 @Test
1490 static void smokeTest2() {
1491 // Do some zipping and shuffling.
1492 IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
1493 IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1494 Assert.assertEquals(io, io2);
1495 IntVector a = io.add((int)1); //[1,2]
1496 IntVector b = a.neg(); //[-1,-2]
1497 int[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1498 VectorShuffle<Integer> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1499 VectorShuffle<Integer> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1500 IntVector zab0 = a.rearrange(zip0,b); //[1,-1]
1501 IntVector zab1 = a.rearrange(zip1,b); //[2,-2]
1502 int[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1503 // manually zip
1504 int[] manual = new int[zabValues.length];
1505 for (int i = 0; i < manual.length; i += 2) {
1506 manual[i+0] = abValues[i/2];
1507 manual[i+1] = abValues[a.length() + i/2];
1508 }
1509 Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1510 VectorShuffle<Integer> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1511 VectorShuffle<Integer> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1512 IntVector uab0 = zab0.rearrange(unz0,zab1);
1513 IntVector uab1 = zab0.rearrange(unz1,zab1);
1514 int[] abValues1 = bothToArray(uab0, uab1);
1515 Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1516 }
1517
1518 static void iotaShuffle() {
1519 IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
1520 IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1521 Assert.assertEquals(io, io2);
1522 }
1523
1524 @Test
1525 // Test all shuffle related operations.
1526 static void shuffleTest() {
1527 // To test backend instructions, make sure that C2 is used.
1528 for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1529 iotaShuffle();
1530 }
1531 }
1532
1533 @Test
1534 void viewAsIntegeralLanesTest() {
1535 Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1536 Assert.assertEquals(asIntegral.species(), SPECIES);
1537 }
1538
1539 @Test
1540 void viewAsFloatingLanesTest() {
1541 Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
1542 VectorSpecies<?> asFloatingSpecies = asFloating.species();
1543 Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType());
1544 Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape());
1545 Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length());
1546 Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES);
1547 }
1548
1549 @Test
1550 // Test div by 0.
1551 static void bitwiseDivByZeroSmokeTest() {
1552 try {
1553 IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
1554 IntVector b = (IntVector) SPECIES.broadcast(0);
1555 a.div(b);
1556 Assert.fail();
1557 } catch (ArithmeticException e) {
1558 }
1559
1560 try {
1561 IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
1562 IntVector b = (IntVector) SPECIES.broadcast(0);
1563 VectorMask<Integer> m = a.lt((int) 1);
1564 a.div(b, m);
1565 Assert.fail();
1566 } catch (ArithmeticException e) {
1567 }
1568 }
1569
1570 static int ADD(int a, int b) {
1571 return (int)(a + b);
1572 }
1573
1574 @Test(dataProvider = "intBinaryOpProvider")
1575 static void ADDIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1576 int[] a = fa.apply(SPECIES.length());
1577 int[] b = fb.apply(SPECIES.length());
1578 int[] r = fr.apply(SPECIES.length());
1579
1580 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1581 for (int i = 0; i < a.length; i += SPECIES.length()) {
1582 IntVector av = IntVector.fromArray(SPECIES, a, i);
1583 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1584 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1585 }
1586 }
1587
1588 assertArraysEquals(r, a, b, IntMaxVectorTests::ADD);
1589 }
1590
1591 static int add(int a, int b) {
1592 return (int)(a + b);
1593 }
1594
1595 @Test(dataProvider = "intBinaryOpProvider")
1596 static void addIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1597 int[] a = fa.apply(SPECIES.length());
1598 int[] b = fb.apply(SPECIES.length());
1599 int[] r = fr.apply(SPECIES.length());
1600
1601 for (int i = 0; i < a.length; i += SPECIES.length()) {
1602 IntVector av = IntVector.fromArray(SPECIES, a, i);
1603 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1604 av.add(bv).intoArray(r, i);
1605 }
1606
1607 assertArraysEquals(r, a, b, IntMaxVectorTests::add);
1608 }
1609
1610 @Test(dataProvider = "intBinaryOpMaskProvider")
1611 static void ADDIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1612 IntFunction<boolean[]> fm) {
1613 int[] a = fa.apply(SPECIES.length());
1614 int[] b = fb.apply(SPECIES.length());
1615 int[] r = fr.apply(SPECIES.length());
1616 boolean[] mask = fm.apply(SPECIES.length());
1617 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1618
1619 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1620 for (int i = 0; i < a.length; i += SPECIES.length()) {
1621 IntVector av = IntVector.fromArray(SPECIES, a, i);
1622 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1623 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1624 }
1625 }
1626
1627 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::ADD);
1628 }
1629
1630 @Test(dataProvider = "intBinaryOpMaskProvider")
1631 static void addIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1632 IntFunction<boolean[]> fm) {
1633 int[] a = fa.apply(SPECIES.length());
1634 int[] b = fb.apply(SPECIES.length());
1635 int[] r = fr.apply(SPECIES.length());
1636 boolean[] mask = fm.apply(SPECIES.length());
1637 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1638
1639 for (int i = 0; i < a.length; i += SPECIES.length()) {
1640 IntVector av = IntVector.fromArray(SPECIES, a, i);
1641 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1642 av.add(bv, vmask).intoArray(r, i);
1643 }
1644
1645 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::add);
1646 }
1647
1648 static int SUB(int a, int b) {
1649 return (int)(a - b);
1650 }
1651
1652 @Test(dataProvider = "intBinaryOpProvider")
1653 static void SUBIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1654 int[] a = fa.apply(SPECIES.length());
1655 int[] b = fb.apply(SPECIES.length());
1656 int[] r = fr.apply(SPECIES.length());
1657
1658 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1659 for (int i = 0; i < a.length; i += SPECIES.length()) {
1660 IntVector av = IntVector.fromArray(SPECIES, a, i);
1661 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1662 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1663 }
1664 }
1665
1666 assertArraysEquals(r, a, b, IntMaxVectorTests::SUB);
1667 }
1668
1669 static int sub(int a, int b) {
1670 return (int)(a - b);
1671 }
1672
1673 @Test(dataProvider = "intBinaryOpProvider")
1674 static void subIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1675 int[] a = fa.apply(SPECIES.length());
1676 int[] b = fb.apply(SPECIES.length());
1677 int[] r = fr.apply(SPECIES.length());
1678
1679 for (int i = 0; i < a.length; i += SPECIES.length()) {
1680 IntVector av = IntVector.fromArray(SPECIES, a, i);
1681 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1682 av.sub(bv).intoArray(r, i);
1683 }
1684
1685 assertArraysEquals(r, a, b, IntMaxVectorTests::sub);
1686 }
1687
1688 @Test(dataProvider = "intBinaryOpMaskProvider")
1689 static void SUBIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1690 IntFunction<boolean[]> fm) {
1691 int[] a = fa.apply(SPECIES.length());
1692 int[] b = fb.apply(SPECIES.length());
1693 int[] r = fr.apply(SPECIES.length());
1694 boolean[] mask = fm.apply(SPECIES.length());
1695 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1696
1697 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1698 for (int i = 0; i < a.length; i += SPECIES.length()) {
1699 IntVector av = IntVector.fromArray(SPECIES, a, i);
1700 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1701 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1702 }
1703 }
1704
1705 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::SUB);
1706 }
1707
1708 @Test(dataProvider = "intBinaryOpMaskProvider")
1709 static void subIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1710 IntFunction<boolean[]> fm) {
1711 int[] a = fa.apply(SPECIES.length());
1712 int[] b = fb.apply(SPECIES.length());
1713 int[] r = fr.apply(SPECIES.length());
1714 boolean[] mask = fm.apply(SPECIES.length());
1715 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1716
1717 for (int i = 0; i < a.length; i += SPECIES.length()) {
1718 IntVector av = IntVector.fromArray(SPECIES, a, i);
1719 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1720 av.sub(bv, vmask).intoArray(r, i);
1721 }
1722
1723 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::sub);
1724 }
1725
1726 static int MUL(int a, int b) {
1727 return (int)(a * b);
1728 }
1729
1730 @Test(dataProvider = "intBinaryOpProvider")
1731 static void MULIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1732 int[] a = fa.apply(SPECIES.length());
1733 int[] b = fb.apply(SPECIES.length());
1734 int[] r = fr.apply(SPECIES.length());
1735
1736 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1737 for (int i = 0; i < a.length; i += SPECIES.length()) {
1738 IntVector av = IntVector.fromArray(SPECIES, a, i);
1739 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1740 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1741 }
1742 }
1743
1744 assertArraysEquals(r, a, b, IntMaxVectorTests::MUL);
1745 }
1746
1747 static int mul(int a, int b) {
1748 return (int)(a * b);
1749 }
1750
1751 @Test(dataProvider = "intBinaryOpProvider")
1752 static void mulIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1753 int[] a = fa.apply(SPECIES.length());
1754 int[] b = fb.apply(SPECIES.length());
1755 int[] r = fr.apply(SPECIES.length());
1756
1757 for (int i = 0; i < a.length; i += SPECIES.length()) {
1758 IntVector av = IntVector.fromArray(SPECIES, a, i);
1759 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1760 av.mul(bv).intoArray(r, i);
1761 }
1762
1763 assertArraysEquals(r, a, b, IntMaxVectorTests::mul);
1764 }
1765
1766 @Test(dataProvider = "intBinaryOpMaskProvider")
1767 static void MULIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1768 IntFunction<boolean[]> fm) {
1769 int[] a = fa.apply(SPECIES.length());
1770 int[] b = fb.apply(SPECIES.length());
1771 int[] r = fr.apply(SPECIES.length());
1772 boolean[] mask = fm.apply(SPECIES.length());
1773 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1774
1775 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1776 for (int i = 0; i < a.length; i += SPECIES.length()) {
1777 IntVector av = IntVector.fromArray(SPECIES, a, i);
1778 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1779 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1780 }
1781 }
1782
1783 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::MUL);
1784 }
1785
1786 @Test(dataProvider = "intBinaryOpMaskProvider")
1787 static void mulIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1788 IntFunction<boolean[]> fm) {
1789 int[] a = fa.apply(SPECIES.length());
1790 int[] b = fb.apply(SPECIES.length());
1791 int[] r = fr.apply(SPECIES.length());
1792 boolean[] mask = fm.apply(SPECIES.length());
1793 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1794
1795 for (int i = 0; i < a.length; i += SPECIES.length()) {
1796 IntVector av = IntVector.fromArray(SPECIES, a, i);
1797 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1798 av.mul(bv, vmask).intoArray(r, i);
1799 }
1800
1801 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::mul);
1802 }
1803
1804 static int DIV(int a, int b) {
1805 return (int)(a / b);
1806 }
1807
1808 @Test(dataProvider = "intBinaryOpProvider")
1809 static void DIVIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1810 int[] a = fa.apply(SPECIES.length());
1811 int[] b = fb.apply(SPECIES.length());
1812 int[] r = fr.apply(SPECIES.length());
1813
1814 replaceZero(b, (int) 1);
1815
1816 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1817 for (int i = 0; i < a.length; i += SPECIES.length()) {
1818 IntVector av = IntVector.fromArray(SPECIES, a, i);
1819 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1820 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1821 }
1822 }
1823
1824 assertArraysEquals(r, a, b, IntMaxVectorTests::DIV);
1825 }
1826
1827 static int div(int a, int b) {
1828 return (int)(a / b);
1829 }
1830
1831 @Test(dataProvider = "intBinaryOpProvider")
1832 static void divIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1833 int[] a = fa.apply(SPECIES.length());
1834 int[] b = fb.apply(SPECIES.length());
1835 int[] r = fr.apply(SPECIES.length());
1836
1837 replaceZero(b, (int) 1);
1838
1839 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1840 for (int i = 0; i < a.length; i += SPECIES.length()) {
1841 IntVector av = IntVector.fromArray(SPECIES, a, i);
1842 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1843 av.div(bv).intoArray(r, i);
1844 }
1845 }
1846
1847 assertArraysEquals(r, a, b, IntMaxVectorTests::div);
1848 }
1849
1850 @Test(dataProvider = "intBinaryOpMaskProvider")
1851 static void DIVIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1852 IntFunction<boolean[]> fm) {
1853 int[] a = fa.apply(SPECIES.length());
1854 int[] b = fb.apply(SPECIES.length());
1855 int[] r = fr.apply(SPECIES.length());
1856 boolean[] mask = fm.apply(SPECIES.length());
1857 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1858
1859 replaceZero(b, mask, (int) 1);
1860
1861 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1862 for (int i = 0; i < a.length; i += SPECIES.length()) {
1863 IntVector av = IntVector.fromArray(SPECIES, a, i);
1864 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1865 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1866 }
1867 }
1868
1869 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::DIV);
1870 }
1871
1872 @Test(dataProvider = "intBinaryOpMaskProvider")
1873 static void divIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1874 IntFunction<boolean[]> fm) {
1875 int[] a = fa.apply(SPECIES.length());
1876 int[] b = fb.apply(SPECIES.length());
1877 int[] r = fr.apply(SPECIES.length());
1878 boolean[] mask = fm.apply(SPECIES.length());
1879 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1880
1881 replaceZero(b, mask, (int) 1);
1882
1883 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1884 for (int i = 0; i < a.length; i += SPECIES.length()) {
1885 IntVector av = IntVector.fromArray(SPECIES, a, i);
1886 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1887 av.div(bv, vmask).intoArray(r, i);
1888 }
1889 }
1890
1891 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::div);
1892 }
1893
1894 static int FIRST_NONZERO(int a, int b) {
1895 return (int)((a)!=0?a:b);
1896 }
1897
1898 @Test(dataProvider = "intBinaryOpProvider")
1899 static void FIRST_NONZEROIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1900 int[] a = fa.apply(SPECIES.length());
1901 int[] b = fb.apply(SPECIES.length());
1902 int[] r = fr.apply(SPECIES.length());
1903
1904 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1905 for (int i = 0; i < a.length; i += SPECIES.length()) {
1906 IntVector av = IntVector.fromArray(SPECIES, a, i);
1907 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1908 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1909 }
1910 }
1911
1912 assertArraysEquals(r, a, b, IntMaxVectorTests::FIRST_NONZERO);
1913 }
1914
1915 @Test(dataProvider = "intBinaryOpMaskProvider")
1916 static void FIRST_NONZEROIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1917 IntFunction<boolean[]> fm) {
1918 int[] a = fa.apply(SPECIES.length());
1919 int[] b = fb.apply(SPECIES.length());
1920 int[] r = fr.apply(SPECIES.length());
1921 boolean[] mask = fm.apply(SPECIES.length());
1922 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1923
1924 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1925 for (int i = 0; i < a.length; i += SPECIES.length()) {
1926 IntVector av = IntVector.fromArray(SPECIES, a, i);
1927 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1928 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1929 }
1930 }
1931
1932 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::FIRST_NONZERO);
1933 }
1934
1935 static int AND(int a, int b) {
1936 return (int)(a & b);
1937 }
1938
1939 @Test(dataProvider = "intBinaryOpProvider")
1940 static void ANDIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1941 int[] a = fa.apply(SPECIES.length());
1942 int[] b = fb.apply(SPECIES.length());
1943 int[] r = fr.apply(SPECIES.length());
1944
1945 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1946 for (int i = 0; i < a.length; i += SPECIES.length()) {
1947 IntVector av = IntVector.fromArray(SPECIES, a, i);
1948 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1949 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1950 }
1951 }
1952
1953 assertArraysEquals(r, a, b, IntMaxVectorTests::AND);
1954 }
1955
1956 static int and(int a, int b) {
1957 return (int)(a & b);
1958 }
1959
1960 @Test(dataProvider = "intBinaryOpProvider")
1961 static void andIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1962 int[] a = fa.apply(SPECIES.length());
1963 int[] b = fb.apply(SPECIES.length());
1964 int[] r = fr.apply(SPECIES.length());
1965
1966 for (int i = 0; i < a.length; i += SPECIES.length()) {
1967 IntVector av = IntVector.fromArray(SPECIES, a, i);
1968 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1969 av.and(bv).intoArray(r, i);
1970 }
1971
1972 assertArraysEquals(r, a, b, IntMaxVectorTests::and);
1973 }
1974
1975 @Test(dataProvider = "intBinaryOpMaskProvider")
1976 static void ANDIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1977 IntFunction<boolean[]> fm) {
1978 int[] a = fa.apply(SPECIES.length());
1979 int[] b = fb.apply(SPECIES.length());
1980 int[] r = fr.apply(SPECIES.length());
1981 boolean[] mask = fm.apply(SPECIES.length());
1982 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1983
1984 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1985 for (int i = 0; i < a.length; i += SPECIES.length()) {
1986 IntVector av = IntVector.fromArray(SPECIES, a, i);
1987 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1988 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1989 }
1990 }
1991
1992 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::AND);
1993 }
1994
1995 static int AND_NOT(int a, int b) {
1996 return (int)(a & ~b);
1997 }
1998
1999 @Test(dataProvider = "intBinaryOpProvider")
2000 static void AND_NOTIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2001 int[] a = fa.apply(SPECIES.length());
2002 int[] b = fb.apply(SPECIES.length());
2003 int[] r = fr.apply(SPECIES.length());
2004
2005 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2006 for (int i = 0; i < a.length; i += SPECIES.length()) {
2007 IntVector av = IntVector.fromArray(SPECIES, a, i);
2008 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2009 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
2010 }
2011 }
2012
2013 assertArraysEquals(r, a, b, IntMaxVectorTests::AND_NOT);
2014 }
2015
2016 @Test(dataProvider = "intBinaryOpMaskProvider")
2017 static void AND_NOTIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2018 IntFunction<boolean[]> fm) {
2019 int[] a = fa.apply(SPECIES.length());
2020 int[] b = fb.apply(SPECIES.length());
2021 int[] r = fr.apply(SPECIES.length());
2022 boolean[] mask = fm.apply(SPECIES.length());
2023 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2024
2025 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2026 for (int i = 0; i < a.length; i += SPECIES.length()) {
2027 IntVector av = IntVector.fromArray(SPECIES, a, i);
2028 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2029 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
2030 }
2031 }
2032
2033 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::AND_NOT);
2034 }
2035
2036 static int OR(int a, int b) {
2037 return (int)(a | b);
2038 }
2039
2040 @Test(dataProvider = "intBinaryOpProvider")
2041 static void ORIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2042 int[] a = fa.apply(SPECIES.length());
2043 int[] b = fb.apply(SPECIES.length());
2044 int[] r = fr.apply(SPECIES.length());
2045
2046 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2047 for (int i = 0; i < a.length; i += SPECIES.length()) {
2048 IntVector av = IntVector.fromArray(SPECIES, a, i);
2049 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2050 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
2051 }
2052 }
2053
2054 assertArraysEquals(r, a, b, IntMaxVectorTests::OR);
2055 }
2056
2057 static int or(int a, int b) {
2058 return (int)(a | b);
2059 }
2060
2061 @Test(dataProvider = "intBinaryOpProvider")
2062 static void orIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2063 int[] a = fa.apply(SPECIES.length());
2064 int[] b = fb.apply(SPECIES.length());
2065 int[] r = fr.apply(SPECIES.length());
2066
2067 for (int i = 0; i < a.length; i += SPECIES.length()) {
2068 IntVector av = IntVector.fromArray(SPECIES, a, i);
2069 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2070 av.or(bv).intoArray(r, i);
2071 }
2072
2073 assertArraysEquals(r, a, b, IntMaxVectorTests::or);
2074 }
2075
2076 @Test(dataProvider = "intBinaryOpMaskProvider")
2077 static void ORIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2078 IntFunction<boolean[]> fm) {
2079 int[] a = fa.apply(SPECIES.length());
2080 int[] b = fb.apply(SPECIES.length());
2081 int[] r = fr.apply(SPECIES.length());
2082 boolean[] mask = fm.apply(SPECIES.length());
2083 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2084
2085 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2086 for (int i = 0; i < a.length; i += SPECIES.length()) {
2087 IntVector av = IntVector.fromArray(SPECIES, a, i);
2088 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2089 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
2090 }
2091 }
2092
2093 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::OR);
2094 }
2095
2096 static int XOR(int a, int b) {
2097 return (int)(a ^ b);
2098 }
2099
2100 @Test(dataProvider = "intBinaryOpProvider")
2101 static void XORIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2102 int[] a = fa.apply(SPECIES.length());
2103 int[] b = fb.apply(SPECIES.length());
2104 int[] r = fr.apply(SPECIES.length());
2105
2106 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2107 for (int i = 0; i < a.length; i += SPECIES.length()) {
2108 IntVector av = IntVector.fromArray(SPECIES, a, i);
2109 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2110 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
2111 }
2112 }
2113
2114 assertArraysEquals(r, a, b, IntMaxVectorTests::XOR);
2115 }
2116
2117 @Test(dataProvider = "intBinaryOpMaskProvider")
2118 static void XORIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2119 IntFunction<boolean[]> fm) {
2120 int[] a = fa.apply(SPECIES.length());
2121 int[] b = fb.apply(SPECIES.length());
2122 int[] r = fr.apply(SPECIES.length());
2123 boolean[] mask = fm.apply(SPECIES.length());
2124 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2125
2126 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2127 for (int i = 0; i < a.length; i += SPECIES.length()) {
2128 IntVector av = IntVector.fromArray(SPECIES, a, i);
2129 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2130 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
2131 }
2132 }
2133
2134 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::XOR);
2135 }
2136
2137 static int COMPRESS_BITS(int a, int b) {
2138 return (int)(Integer.compress(a, b));
2139 }
2140
2141 @Test(dataProvider = "intBinaryOpProvider")
2142 static void COMPRESS_BITSIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2143 int[] a = fa.apply(SPECIES.length());
2144 int[] b = fb.apply(SPECIES.length());
2145 int[] r = fr.apply(SPECIES.length());
2146
2147 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2148 for (int i = 0; i < a.length; i += SPECIES.length()) {
2149 IntVector av = IntVector.fromArray(SPECIES, a, i);
2150 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2151 av.lanewise(VectorOperators.COMPRESS_BITS, bv).intoArray(r, i);
2152 }
2153 }
2154
2155 assertArraysEquals(r, a, b, IntMaxVectorTests::COMPRESS_BITS);
2156 }
2157
2158 @Test(dataProvider = "intBinaryOpMaskProvider")
2159 static void COMPRESS_BITSIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2160 IntFunction<boolean[]> fm) {
2161 int[] a = fa.apply(SPECIES.length());
2162 int[] b = fb.apply(SPECIES.length());
2163 int[] r = fr.apply(SPECIES.length());
2164 boolean[] mask = fm.apply(SPECIES.length());
2165 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2166
2167 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2168 for (int i = 0; i < a.length; i += SPECIES.length()) {
2169 IntVector av = IntVector.fromArray(SPECIES, a, i);
2170 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2171 av.lanewise(VectorOperators.COMPRESS_BITS, bv, vmask).intoArray(r, i);
2172 }
2173 }
2174
2175 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::COMPRESS_BITS);
2176 }
2177
2178 static int EXPAND_BITS(int a, int b) {
2179 return (int)(Integer.expand(a, b));
2180 }
2181
2182 @Test(dataProvider = "intBinaryOpProvider")
2183 static void EXPAND_BITSIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2184 int[] a = fa.apply(SPECIES.length());
2185 int[] b = fb.apply(SPECIES.length());
2186 int[] r = fr.apply(SPECIES.length());
2187
2188 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2189 for (int i = 0; i < a.length; i += SPECIES.length()) {
2190 IntVector av = IntVector.fromArray(SPECIES, a, i);
2191 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2192 av.lanewise(VectorOperators.EXPAND_BITS, bv).intoArray(r, i);
2193 }
2194 }
2195
2196 assertArraysEquals(r, a, b, IntMaxVectorTests::EXPAND_BITS);
2197 }
2198
2199 @Test(dataProvider = "intBinaryOpMaskProvider")
2200 static void EXPAND_BITSIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2201 IntFunction<boolean[]> fm) {
2202 int[] a = fa.apply(SPECIES.length());
2203 int[] b = fb.apply(SPECIES.length());
2204 int[] r = fr.apply(SPECIES.length());
2205 boolean[] mask = fm.apply(SPECIES.length());
2206 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2207
2208 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2209 for (int i = 0; i < a.length; i += SPECIES.length()) {
2210 IntVector av = IntVector.fromArray(SPECIES, a, i);
2211 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2212 av.lanewise(VectorOperators.EXPAND_BITS, bv, vmask).intoArray(r, i);
2213 }
2214 }
2215
2216 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::EXPAND_BITS);
2217 }
2218
2219 @Test(dataProvider = "intBinaryOpProvider")
2220 static void addIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2221 int[] a = fa.apply(SPECIES.length());
2222 int[] b = fb.apply(SPECIES.length());
2223 int[] r = fr.apply(SPECIES.length());
2224
2225 for (int i = 0; i < a.length; i += SPECIES.length()) {
2226 IntVector av = IntVector.fromArray(SPECIES, a, i);
2227 av.add(b[i]).intoArray(r, i);
2228 }
2229
2230 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::add);
2231 }
2232
2233 @Test(dataProvider = "intBinaryOpMaskProvider")
2234 static void addIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2235 IntFunction<boolean[]> fm) {
2236 int[] a = fa.apply(SPECIES.length());
2237 int[] b = fb.apply(SPECIES.length());
2238 int[] r = fr.apply(SPECIES.length());
2239 boolean[] mask = fm.apply(SPECIES.length());
2240 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2241
2242 for (int i = 0; i < a.length; i += SPECIES.length()) {
2243 IntVector av = IntVector.fromArray(SPECIES, a, i);
2244 av.add(b[i], vmask).intoArray(r, i);
2245 }
2246
2247 assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::add);
2248 }
2249
2250 @Test(dataProvider = "intBinaryOpProvider")
2251 static void subIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2252 int[] a = fa.apply(SPECIES.length());
2253 int[] b = fb.apply(SPECIES.length());
2254 int[] r = fr.apply(SPECIES.length());
2255
2256 for (int i = 0; i < a.length; i += SPECIES.length()) {
2257 IntVector av = IntVector.fromArray(SPECIES, a, i);
2258 av.sub(b[i]).intoArray(r, i);
2259 }
2260
2261 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::sub);
2262 }
2263
2264 @Test(dataProvider = "intBinaryOpMaskProvider")
2265 static void subIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2266 IntFunction<boolean[]> fm) {
2267 int[] a = fa.apply(SPECIES.length());
2268 int[] b = fb.apply(SPECIES.length());
2269 int[] r = fr.apply(SPECIES.length());
2270 boolean[] mask = fm.apply(SPECIES.length());
2271 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2272
2273 for (int i = 0; i < a.length; i += SPECIES.length()) {
2274 IntVector av = IntVector.fromArray(SPECIES, a, i);
2275 av.sub(b[i], vmask).intoArray(r, i);
2276 }
2277
2278 assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::sub);
2279 }
2280
2281 @Test(dataProvider = "intBinaryOpProvider")
2282 static void mulIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2283 int[] a = fa.apply(SPECIES.length());
2284 int[] b = fb.apply(SPECIES.length());
2285 int[] r = fr.apply(SPECIES.length());
2286
2287 for (int i = 0; i < a.length; i += SPECIES.length()) {
2288 IntVector av = IntVector.fromArray(SPECIES, a, i);
2289 av.mul(b[i]).intoArray(r, i);
2290 }
2291
2292 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::mul);
2293 }
2294
2295 @Test(dataProvider = "intBinaryOpMaskProvider")
2296 static void mulIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2297 IntFunction<boolean[]> fm) {
2298 int[] a = fa.apply(SPECIES.length());
2299 int[] b = fb.apply(SPECIES.length());
2300 int[] r = fr.apply(SPECIES.length());
2301 boolean[] mask = fm.apply(SPECIES.length());
2302 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2303
2304 for (int i = 0; i < a.length; i += SPECIES.length()) {
2305 IntVector av = IntVector.fromArray(SPECIES, a, i);
2306 av.mul(b[i], vmask).intoArray(r, i);
2307 }
2308
2309 assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::mul);
2310 }
2311
2312 @Test(dataProvider = "intBinaryOpProvider")
2313 static void divIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2314 int[] a = fa.apply(SPECIES.length());
2315 int[] b = fb.apply(SPECIES.length());
2316 int[] r = fr.apply(SPECIES.length());
2317
2318 replaceZero(b, (int) 1);
2319
2320 for (int i = 0; i < a.length; i += SPECIES.length()) {
2321 IntVector av = IntVector.fromArray(SPECIES, a, i);
2322 av.div(b[i]).intoArray(r, i);
2323 }
2324
2325 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::div);
2326 }
2327
2328 @Test(dataProvider = "intBinaryOpMaskProvider")
2329 static void divIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2330 IntFunction<boolean[]> fm) {
2331 int[] a = fa.apply(SPECIES.length());
2332 int[] b = fb.apply(SPECIES.length());
2333 int[] r = fr.apply(SPECIES.length());
2334 boolean[] mask = fm.apply(SPECIES.length());
2335 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2336
2337 replaceZero(b, (int) 1);
2338
2339 for (int i = 0; i < a.length; i += SPECIES.length()) {
2340 IntVector av = IntVector.fromArray(SPECIES, a, i);
2341 av.div(b[i], vmask).intoArray(r, i);
2342 }
2343
2344 assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::div);
2345 }
2346
2347 @Test(dataProvider = "intBinaryOpProvider")
2348 static void ORIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2349 int[] a = fa.apply(SPECIES.length());
2350 int[] b = fb.apply(SPECIES.length());
2351 int[] r = fr.apply(SPECIES.length());
2352
2353 for (int i = 0; i < a.length; i += SPECIES.length()) {
2354 IntVector av = IntVector.fromArray(SPECIES, a, i);
2355 av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
2356 }
2357
2358 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::OR);
2359 }
2360
2361 @Test(dataProvider = "intBinaryOpProvider")
2362 static void orIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2363 int[] a = fa.apply(SPECIES.length());
2364 int[] b = fb.apply(SPECIES.length());
2365 int[] r = fr.apply(SPECIES.length());
2366
2367 for (int i = 0; i < a.length; i += SPECIES.length()) {
2368 IntVector av = IntVector.fromArray(SPECIES, a, i);
2369 av.or(b[i]).intoArray(r, i);
2370 }
2371
2372 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::or);
2373 }
2374
2375 @Test(dataProvider = "intBinaryOpMaskProvider")
2376 static void ORIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2377 IntFunction<boolean[]> fm) {
2378 int[] a = fa.apply(SPECIES.length());
2379 int[] b = fb.apply(SPECIES.length());
2380 int[] r = fr.apply(SPECIES.length());
2381 boolean[] mask = fm.apply(SPECIES.length());
2382 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2383
2384 for (int i = 0; i < a.length; i += SPECIES.length()) {
2385 IntVector av = IntVector.fromArray(SPECIES, a, i);
2386 av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
2387 }
2388
2389 assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::OR);
2390 }
2391
2392 @Test(dataProvider = "intBinaryOpProvider")
2393 static void ANDIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2394 int[] a = fa.apply(SPECIES.length());
2395 int[] b = fb.apply(SPECIES.length());
2396 int[] r = fr.apply(SPECIES.length());
2397
2398 for (int i = 0; i < a.length; i += SPECIES.length()) {
2399 IntVector av = IntVector.fromArray(SPECIES, a, i);
2400 av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
2401 }
2402
2403 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::AND);
2404 }
2405
2406 @Test(dataProvider = "intBinaryOpProvider")
2407 static void andIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2408 int[] a = fa.apply(SPECIES.length());
2409 int[] b = fb.apply(SPECIES.length());
2410 int[] r = fr.apply(SPECIES.length());
2411
2412 for (int i = 0; i < a.length; i += SPECIES.length()) {
2413 IntVector av = IntVector.fromArray(SPECIES, a, i);
2414 av.and(b[i]).intoArray(r, i);
2415 }
2416
2417 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::and);
2418 }
2419
2420 @Test(dataProvider = "intBinaryOpMaskProvider")
2421 static void ANDIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2422 IntFunction<boolean[]> fm) {
2423 int[] a = fa.apply(SPECIES.length());
2424 int[] b = fb.apply(SPECIES.length());
2425 int[] r = fr.apply(SPECIES.length());
2426 boolean[] mask = fm.apply(SPECIES.length());
2427 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2428
2429 for (int i = 0; i < a.length; i += SPECIES.length()) {
2430 IntVector av = IntVector.fromArray(SPECIES, a, i);
2431 av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
2432 }
2433
2434 assertBroadcastArraysEquals(r, a, b, mask, IntMaxVectorTests::AND);
2435 }
2436
2437 @Test(dataProvider = "intBinaryOpProvider")
2438 static void ORIntMaxVectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2439 int[] a = fa.apply(SPECIES.length());
2440 int[] b = fb.apply(SPECIES.length());
2441 int[] r = fr.apply(SPECIES.length());
2442
2443 for (int i = 0; i < a.length; i += SPECIES.length()) {
2444 IntVector av = IntVector.fromArray(SPECIES, a, i);
2445 av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
2446 }
2447
2448 assertBroadcastLongArraysEquals(r, a, b, IntMaxVectorTests::OR);
2449 }
2450
2451 @Test(dataProvider = "intBinaryOpMaskProvider")
2452 static void ORIntMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2453 IntFunction<boolean[]> fm) {
2454 int[] a = fa.apply(SPECIES.length());
2455 int[] b = fb.apply(SPECIES.length());
2456 int[] r = fr.apply(SPECIES.length());
2457 boolean[] mask = fm.apply(SPECIES.length());
2458 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2459
2460 for (int i = 0; i < a.length; i += SPECIES.length()) {
2461 IntVector av = IntVector.fromArray(SPECIES, a, i);
2462 av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
2463 }
2464
2465 assertBroadcastLongArraysEquals(r, a, b, mask, IntMaxVectorTests::OR);
2466 }
2467
2468 @Test(dataProvider = "intBinaryOpProvider")
2469 static void ADDIntMaxVectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2470 int[] a = fa.apply(SPECIES.length());
2471 int[] b = fb.apply(SPECIES.length());
2472 int[] r = fr.apply(SPECIES.length());
2473
2474 for (int i = 0; i < a.length; i += SPECIES.length()) {
2475 IntVector av = IntVector.fromArray(SPECIES, a, i);
2476 av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2477 }
2478
2479 assertBroadcastLongArraysEquals(r, a, b, IntMaxVectorTests::ADD);
2480 }
2481
2482 @Test(dataProvider = "intBinaryOpMaskProvider")
2483 static void ADDIntMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
2484 IntFunction<boolean[]> fm) {
2485 int[] a = fa.apply(SPECIES.length());
2486 int[] b = fb.apply(SPECIES.length());
2487 int[] r = fr.apply(SPECIES.length());
2488 boolean[] mask = fm.apply(SPECIES.length());
2489 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2490
2491 for (int i = 0; i < a.length; i += SPECIES.length()) {
2492 IntVector av = IntVector.fromArray(SPECIES, a, i);
2493 av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2494 }
2495
2496 assertBroadcastLongArraysEquals(r, a, b, mask, IntMaxVectorTests::ADD);
2497 }
2498
2499 static int LSHL(int a, int b) {
2500 return (int)((a << b));
2501 }
2502
2503 @Test(dataProvider = "intBinaryOpProvider")
2504 static void LSHLIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2505 int[] a = fa.apply(SPECIES.length());
2506 int[] b = fb.apply(SPECIES.length());
2507 int[] r = fr.apply(SPECIES.length());
2508
2509 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2510 for (int i = 0; i < a.length; i += SPECIES.length()) {
2511 IntVector av = IntVector.fromArray(SPECIES, a, i);
2512 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2513 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
2514 }
2515 }
2516
2517 assertArraysEquals(r, a, b, IntMaxVectorTests::LSHL);
2518 }
2519
2520 @Test(dataProvider = "intBinaryOpMaskProvider")
2521 static void LSHLIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2522 IntFunction<boolean[]> fm) {
2523 int[] a = fa.apply(SPECIES.length());
2524 int[] b = fb.apply(SPECIES.length());
2525 int[] r = fr.apply(SPECIES.length());
2526 boolean[] mask = fm.apply(SPECIES.length());
2527 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2528
2529 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2530 for (int i = 0; i < a.length; i += SPECIES.length()) {
2531 IntVector av = IntVector.fromArray(SPECIES, a, i);
2532 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2533 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
2534 }
2535 }
2536
2537 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::LSHL);
2538 }
2539
2540 static int ASHR(int a, int b) {
2541 return (int)((a >> b));
2542 }
2543
2544 @Test(dataProvider = "intBinaryOpProvider")
2545 static void ASHRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2546 int[] a = fa.apply(SPECIES.length());
2547 int[] b = fb.apply(SPECIES.length());
2548 int[] r = fr.apply(SPECIES.length());
2549
2550 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2551 for (int i = 0; i < a.length; i += SPECIES.length()) {
2552 IntVector av = IntVector.fromArray(SPECIES, a, i);
2553 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2554 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
2555 }
2556 }
2557
2558 assertArraysEquals(r, a, b, IntMaxVectorTests::ASHR);
2559 }
2560
2561 @Test(dataProvider = "intBinaryOpMaskProvider")
2562 static void ASHRIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2563 IntFunction<boolean[]> fm) {
2564 int[] a = fa.apply(SPECIES.length());
2565 int[] b = fb.apply(SPECIES.length());
2566 int[] r = fr.apply(SPECIES.length());
2567 boolean[] mask = fm.apply(SPECIES.length());
2568 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2569
2570 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2571 for (int i = 0; i < a.length; i += SPECIES.length()) {
2572 IntVector av = IntVector.fromArray(SPECIES, a, i);
2573 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2574 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
2575 }
2576 }
2577
2578 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::ASHR);
2579 }
2580
2581 static int LSHR(int a, int b) {
2582 return (int)((a >>> b));
2583 }
2584
2585 @Test(dataProvider = "intBinaryOpProvider")
2586 static void LSHRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2587 int[] a = fa.apply(SPECIES.length());
2588 int[] b = fb.apply(SPECIES.length());
2589 int[] r = fr.apply(SPECIES.length());
2590
2591 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2592 for (int i = 0; i < a.length; i += SPECIES.length()) {
2593 IntVector av = IntVector.fromArray(SPECIES, a, i);
2594 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2595 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
2596 }
2597 }
2598
2599 assertArraysEquals(r, a, b, IntMaxVectorTests::LSHR);
2600 }
2601
2602 @Test(dataProvider = "intBinaryOpMaskProvider")
2603 static void LSHRIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2604 IntFunction<boolean[]> fm) {
2605 int[] a = fa.apply(SPECIES.length());
2606 int[] b = fb.apply(SPECIES.length());
2607 int[] r = fr.apply(SPECIES.length());
2608 boolean[] mask = fm.apply(SPECIES.length());
2609 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2610
2611 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2612 for (int i = 0; i < a.length; i += SPECIES.length()) {
2613 IntVector av = IntVector.fromArray(SPECIES, a, i);
2614 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2615 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
2616 }
2617 }
2618
2619 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::LSHR);
2620 }
2621
2622 static int LSHL_unary(int a, int b) {
2623 return (int)((a << b));
2624 }
2625
2626 @Test(dataProvider = "intBinaryOpProvider")
2627 static void LSHLIntMaxVectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2628 int[] a = fa.apply(SPECIES.length());
2629 int[] b = fb.apply(SPECIES.length());
2630 int[] r = fr.apply(SPECIES.length());
2631
2632 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2633 for (int i = 0; i < a.length; i += SPECIES.length()) {
2634 IntVector av = IntVector.fromArray(SPECIES, a, i);
2635 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
2636 }
2637 }
2638
2639 assertShiftArraysEquals(r, a, b, IntMaxVectorTests::LSHL_unary);
2640 }
2641
2642 @Test(dataProvider = "intBinaryOpMaskProvider")
2643 static void LSHLIntMaxVectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2644 IntFunction<boolean[]> fm) {
2645 int[] a = fa.apply(SPECIES.length());
2646 int[] b = fb.apply(SPECIES.length());
2647 int[] r = fr.apply(SPECIES.length());
2648 boolean[] mask = fm.apply(SPECIES.length());
2649 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2650
2651 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2652 for (int i = 0; i < a.length; i += SPECIES.length()) {
2653 IntVector av = IntVector.fromArray(SPECIES, a, i);
2654 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
2655 }
2656 }
2657
2658 assertShiftArraysEquals(r, a, b, mask, IntMaxVectorTests::LSHL_unary);
2659 }
2660
2661 static int LSHR_unary(int a, int b) {
2662 return (int)((a >>> b));
2663 }
2664
2665 @Test(dataProvider = "intBinaryOpProvider")
2666 static void LSHRIntMaxVectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2667 int[] a = fa.apply(SPECIES.length());
2668 int[] b = fb.apply(SPECIES.length());
2669 int[] r = fr.apply(SPECIES.length());
2670
2671 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2672 for (int i = 0; i < a.length; i += SPECIES.length()) {
2673 IntVector av = IntVector.fromArray(SPECIES, a, i);
2674 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
2675 }
2676 }
2677
2678 assertShiftArraysEquals(r, a, b, IntMaxVectorTests::LSHR_unary);
2679 }
2680
2681 @Test(dataProvider = "intBinaryOpMaskProvider")
2682 static void LSHRIntMaxVectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2683 IntFunction<boolean[]> fm) {
2684 int[] a = fa.apply(SPECIES.length());
2685 int[] b = fb.apply(SPECIES.length());
2686 int[] r = fr.apply(SPECIES.length());
2687 boolean[] mask = fm.apply(SPECIES.length());
2688 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2689
2690 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2691 for (int i = 0; i < a.length; i += SPECIES.length()) {
2692 IntVector av = IntVector.fromArray(SPECIES, a, i);
2693 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
2694 }
2695 }
2696
2697 assertShiftArraysEquals(r, a, b, mask, IntMaxVectorTests::LSHR_unary);
2698 }
2699
2700 static int ASHR_unary(int a, int b) {
2701 return (int)((a >> b));
2702 }
2703
2704 @Test(dataProvider = "intBinaryOpProvider")
2705 static void ASHRIntMaxVectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2706 int[] a = fa.apply(SPECIES.length());
2707 int[] b = fb.apply(SPECIES.length());
2708 int[] r = fr.apply(SPECIES.length());
2709
2710 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2711 for (int i = 0; i < a.length; i += SPECIES.length()) {
2712 IntVector av = IntVector.fromArray(SPECIES, a, i);
2713 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
2714 }
2715 }
2716
2717 assertShiftArraysEquals(r, a, b, IntMaxVectorTests::ASHR_unary);
2718 }
2719
2720 @Test(dataProvider = "intBinaryOpMaskProvider")
2721 static void ASHRIntMaxVectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2722 IntFunction<boolean[]> fm) {
2723 int[] a = fa.apply(SPECIES.length());
2724 int[] b = fb.apply(SPECIES.length());
2725 int[] r = fr.apply(SPECIES.length());
2726 boolean[] mask = fm.apply(SPECIES.length());
2727 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2728
2729 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2730 for (int i = 0; i < a.length; i += SPECIES.length()) {
2731 IntVector av = IntVector.fromArray(SPECIES, a, i);
2732 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
2733 }
2734 }
2735
2736 assertShiftArraysEquals(r, a, b, mask, IntMaxVectorTests::ASHR_unary);
2737 }
2738
2739 static int ROR(int a, int b) {
2740 return (int)(ROR_scalar(a,b));
2741 }
2742
2743 @Test(dataProvider = "intBinaryOpProvider")
2744 static void RORIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2745 int[] a = fa.apply(SPECIES.length());
2746 int[] b = fb.apply(SPECIES.length());
2747 int[] r = fr.apply(SPECIES.length());
2748
2749 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2750 for (int i = 0; i < a.length; i += SPECIES.length()) {
2751 IntVector av = IntVector.fromArray(SPECIES, a, i);
2752 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2753 av.lanewise(VectorOperators.ROR, bv).intoArray(r, i);
2754 }
2755 }
2756
2757 assertArraysEquals(r, a, b, IntMaxVectorTests::ROR);
2758 }
2759
2760 @Test(dataProvider = "intBinaryOpMaskProvider")
2761 static void RORIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2762 IntFunction<boolean[]> fm) {
2763 int[] a = fa.apply(SPECIES.length());
2764 int[] b = fb.apply(SPECIES.length());
2765 int[] r = fr.apply(SPECIES.length());
2766 boolean[] mask = fm.apply(SPECIES.length());
2767 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2768
2769 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2770 for (int i = 0; i < a.length; i += SPECIES.length()) {
2771 IntVector av = IntVector.fromArray(SPECIES, a, i);
2772 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2773 av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i);
2774 }
2775 }
2776
2777 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::ROR);
2778 }
2779
2780 static int ROL(int a, int b) {
2781 return (int)(ROL_scalar(a,b));
2782 }
2783
2784 @Test(dataProvider = "intBinaryOpProvider")
2785 static void ROLIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2786 int[] a = fa.apply(SPECIES.length());
2787 int[] b = fb.apply(SPECIES.length());
2788 int[] r = fr.apply(SPECIES.length());
2789
2790 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2791 for (int i = 0; i < a.length; i += SPECIES.length()) {
2792 IntVector av = IntVector.fromArray(SPECIES, a, i);
2793 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2794 av.lanewise(VectorOperators.ROL, bv).intoArray(r, i);
2795 }
2796 }
2797
2798 assertArraysEquals(r, a, b, IntMaxVectorTests::ROL);
2799 }
2800
2801 @Test(dataProvider = "intBinaryOpMaskProvider")
2802 static void ROLIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2803 IntFunction<boolean[]> fm) {
2804 int[] a = fa.apply(SPECIES.length());
2805 int[] b = fb.apply(SPECIES.length());
2806 int[] r = fr.apply(SPECIES.length());
2807 boolean[] mask = fm.apply(SPECIES.length());
2808 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2809
2810 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2811 for (int i = 0; i < a.length; i += SPECIES.length()) {
2812 IntVector av = IntVector.fromArray(SPECIES, a, i);
2813 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2814 av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i);
2815 }
2816 }
2817
2818 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::ROL);
2819 }
2820
2821 static int ROR_unary(int a, int b) {
2822 return (int)(ROR_scalar(a, b));
2823 }
2824
2825 @Test(dataProvider = "intBinaryOpProvider")
2826 static void RORIntMaxVectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2827 int[] a = fa.apply(SPECIES.length());
2828 int[] b = fb.apply(SPECIES.length());
2829 int[] r = fr.apply(SPECIES.length());
2830
2831 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2832 for (int i = 0; i < a.length; i += SPECIES.length()) {
2833 IntVector av = IntVector.fromArray(SPECIES, a, i);
2834 av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i);
2835 }
2836 }
2837
2838 assertShiftArraysEquals(r, a, b, IntMaxVectorTests::ROR_unary);
2839 }
2840
2841 @Test(dataProvider = "intBinaryOpMaskProvider")
2842 static void RORIntMaxVectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2843 IntFunction<boolean[]> fm) {
2844 int[] a = fa.apply(SPECIES.length());
2845 int[] b = fb.apply(SPECIES.length());
2846 int[] r = fr.apply(SPECIES.length());
2847 boolean[] mask = fm.apply(SPECIES.length());
2848 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2849
2850 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2851 for (int i = 0; i < a.length; i += SPECIES.length()) {
2852 IntVector av = IntVector.fromArray(SPECIES, a, i);
2853 av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i);
2854 }
2855 }
2856
2857 assertShiftArraysEquals(r, a, b, mask, IntMaxVectorTests::ROR_unary);
2858 }
2859
2860 static int ROL_unary(int a, int b) {
2861 return (int)(ROL_scalar(a, b));
2862 }
2863
2864 @Test(dataProvider = "intBinaryOpProvider")
2865 static void ROLIntMaxVectorTestsScalarShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2866 int[] a = fa.apply(SPECIES.length());
2867 int[] b = fb.apply(SPECIES.length());
2868 int[] r = fr.apply(SPECIES.length());
2869
2870 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2871 for (int i = 0; i < a.length; i += SPECIES.length()) {
2872 IntVector av = IntVector.fromArray(SPECIES, a, i);
2873 av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i);
2874 }
2875 }
2876
2877 assertShiftArraysEquals(r, a, b, IntMaxVectorTests::ROL_unary);
2878 }
2879
2880 @Test(dataProvider = "intBinaryOpMaskProvider")
2881 static void ROLIntMaxVectorTestsScalarShiftMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
2882 IntFunction<boolean[]> fm) {
2883 int[] a = fa.apply(SPECIES.length());
2884 int[] b = fb.apply(SPECIES.length());
2885 int[] r = fr.apply(SPECIES.length());
2886 boolean[] mask = fm.apply(SPECIES.length());
2887 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2888
2889 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2890 for (int i = 0; i < a.length; i += SPECIES.length()) {
2891 IntVector av = IntVector.fromArray(SPECIES, a, i);
2892 av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i);
2893 }
2894 }
2895
2896 assertShiftArraysEquals(r, a, b, mask, IntMaxVectorTests::ROL_unary);
2897 }
2898 static int LSHR_binary_const(int a) {
2899 return (int)((a >>> CONST_SHIFT));
2900 }
2901
2902 @Test(dataProvider = "intUnaryOpProvider")
2903 static void LSHRIntMaxVectorTestsScalarShiftConst(IntFunction<int[]> fa) {
2904 int[] a = fa.apply(SPECIES.length());
2905 int[] r = fr.apply(SPECIES.length());
2906
2907 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2908 for (int i = 0; i < a.length; i += SPECIES.length()) {
2909 IntVector av = IntVector.fromArray(SPECIES, a, i);
2910 av.lanewise(VectorOperators.LSHR, CONST_SHIFT).intoArray(r, i);
2911 }
2912 }
2913
2914 assertShiftConstEquals(r, a, IntMaxVectorTests::LSHR_binary_const);
2915 }
2916
2917 @Test(dataProvider = "intUnaryOpMaskProvider")
2918 static void LSHRIntMaxVectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
2919 IntFunction<boolean[]> fm) {
2920 int[] a = fa.apply(SPECIES.length());
2921 int[] r = fr.apply(SPECIES.length());
2922 boolean[] mask = fm.apply(SPECIES.length());
2923 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2924
2925 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2926 for (int i = 0; i < a.length; i += SPECIES.length()) {
2927 IntVector av = IntVector.fromArray(SPECIES, a, i);
2928 av.lanewise(VectorOperators.LSHR, CONST_SHIFT, vmask).intoArray(r, i);
2929 }
2930 }
2931
2932 assertShiftConstEquals(r, a, mask, IntMaxVectorTests::LSHR_binary_const);
2933 }
2934
2935 static int LSHL_binary_const(int a) {
2936 return (int)((a << CONST_SHIFT));
2937 }
2938
2939 @Test(dataProvider = "intUnaryOpProvider")
2940 static void LSHLIntMaxVectorTestsScalarShiftConst(IntFunction<int[]> fa) {
2941 int[] a = fa.apply(SPECIES.length());
2942 int[] r = fr.apply(SPECIES.length());
2943
2944 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2945 for (int i = 0; i < a.length; i += SPECIES.length()) {
2946 IntVector av = IntVector.fromArray(SPECIES, a, i);
2947 av.lanewise(VectorOperators.LSHL, CONST_SHIFT).intoArray(r, i);
2948 }
2949 }
2950
2951 assertShiftConstEquals(r, a, IntMaxVectorTests::LSHL_binary_const);
2952 }
2953
2954 @Test(dataProvider = "intUnaryOpMaskProvider")
2955 static void LSHLIntMaxVectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
2956 IntFunction<boolean[]> fm) {
2957 int[] a = fa.apply(SPECIES.length());
2958 int[] r = fr.apply(SPECIES.length());
2959 boolean[] mask = fm.apply(SPECIES.length());
2960 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2961
2962 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2963 for (int i = 0; i < a.length; i += SPECIES.length()) {
2964 IntVector av = IntVector.fromArray(SPECIES, a, i);
2965 av.lanewise(VectorOperators.LSHL, CONST_SHIFT, vmask).intoArray(r, i);
2966 }
2967 }
2968
2969 assertShiftConstEquals(r, a, mask, IntMaxVectorTests::LSHL_binary_const);
2970 }
2971
2972 static int ASHR_binary_const(int a) {
2973 return (int)((a >> CONST_SHIFT));
2974 }
2975
2976 @Test(dataProvider = "intUnaryOpProvider")
2977 static void ASHRIntMaxVectorTestsScalarShiftConst(IntFunction<int[]> fa) {
2978 int[] a = fa.apply(SPECIES.length());
2979 int[] r = fr.apply(SPECIES.length());
2980
2981 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2982 for (int i = 0; i < a.length; i += SPECIES.length()) {
2983 IntVector av = IntVector.fromArray(SPECIES, a, i);
2984 av.lanewise(VectorOperators.ASHR, CONST_SHIFT).intoArray(r, i);
2985 }
2986 }
2987
2988 assertShiftConstEquals(r, a, IntMaxVectorTests::ASHR_binary_const);
2989 }
2990
2991 @Test(dataProvider = "intUnaryOpMaskProvider")
2992 static void ASHRIntMaxVectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
2993 IntFunction<boolean[]> fm) {
2994 int[] a = fa.apply(SPECIES.length());
2995 int[] r = fr.apply(SPECIES.length());
2996 boolean[] mask = fm.apply(SPECIES.length());
2997 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2998
2999 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3000 for (int i = 0; i < a.length; i += SPECIES.length()) {
3001 IntVector av = IntVector.fromArray(SPECIES, a, i);
3002 av.lanewise(VectorOperators.ASHR, CONST_SHIFT, vmask).intoArray(r, i);
3003 }
3004 }
3005
3006 assertShiftConstEquals(r, a, mask, IntMaxVectorTests::ASHR_binary_const);
3007 }
3008
3009 static int ROR_binary_const(int a) {
3010 return (int)(ROR_scalar(a, CONST_SHIFT));
3011 }
3012
3013 @Test(dataProvider = "intUnaryOpProvider")
3014 static void RORIntMaxVectorTestsScalarShiftConst(IntFunction<int[]> fa) {
3015 int[] a = fa.apply(SPECIES.length());
3016 int[] r = fr.apply(SPECIES.length());
3017
3018 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3019 for (int i = 0; i < a.length; i += SPECIES.length()) {
3020 IntVector av = IntVector.fromArray(SPECIES, a, i);
3021 av.lanewise(VectorOperators.ROR, CONST_SHIFT).intoArray(r, i);
3022 }
3023 }
3024
3025 assertShiftConstEquals(r, a, IntMaxVectorTests::ROR_binary_const);
3026 }
3027
3028 @Test(dataProvider = "intUnaryOpMaskProvider")
3029 static void RORIntMaxVectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
3030 IntFunction<boolean[]> fm) {
3031 int[] a = fa.apply(SPECIES.length());
3032 int[] r = fr.apply(SPECIES.length());
3033 boolean[] mask = fm.apply(SPECIES.length());
3034 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3035
3036 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3037 for (int i = 0; i < a.length; i += SPECIES.length()) {
3038 IntVector av = IntVector.fromArray(SPECIES, a, i);
3039 av.lanewise(VectorOperators.ROR, CONST_SHIFT, vmask).intoArray(r, i);
3040 }
3041 }
3042
3043 assertShiftConstEquals(r, a, mask, IntMaxVectorTests::ROR_binary_const);
3044 }
3045
3046 static int ROL_binary_const(int a) {
3047 return (int)(ROL_scalar(a, CONST_SHIFT));
3048 }
3049
3050 @Test(dataProvider = "intUnaryOpProvider")
3051 static void ROLIntMaxVectorTestsScalarShiftConst(IntFunction<int[]> fa) {
3052 int[] a = fa.apply(SPECIES.length());
3053 int[] r = fr.apply(SPECIES.length());
3054
3055 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3056 for (int i = 0; i < a.length; i += SPECIES.length()) {
3057 IntVector av = IntVector.fromArray(SPECIES, a, i);
3058 av.lanewise(VectorOperators.ROL, CONST_SHIFT).intoArray(r, i);
3059 }
3060 }
3061
3062 assertShiftConstEquals(r, a, IntMaxVectorTests::ROL_binary_const);
3063 }
3064
3065 @Test(dataProvider = "intUnaryOpMaskProvider")
3066 static void ROLIntMaxVectorTestsScalarShiftMaskedConst(IntFunction<int[]> fa,
3067 IntFunction<boolean[]> fm) {
3068 int[] a = fa.apply(SPECIES.length());
3069 int[] r = fr.apply(SPECIES.length());
3070 boolean[] mask = fm.apply(SPECIES.length());
3071 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3072
3073 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3074 for (int i = 0; i < a.length; i += SPECIES.length()) {
3075 IntVector av = IntVector.fromArray(SPECIES, a, i);
3076 av.lanewise(VectorOperators.ROL, CONST_SHIFT, vmask).intoArray(r, i);
3077 }
3078 }
3079
3080 assertShiftConstEquals(r, a, mask, IntMaxVectorTests::ROL_binary_const);
3081 }
3082
3083
3084 static IntVector bv_MIN = IntVector.broadcast(SPECIES, (int)10);
3085
3086 @Test(dataProvider = "intUnaryOpProvider")
3087 static void MINIntMaxVectorTestsWithMemOp(IntFunction<int[]> fa) {
3088 int[] a = fa.apply(SPECIES.length());
3089 int[] r = fr.apply(SPECIES.length());
3090
3091 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3092 for (int i = 0; i < a.length; i += SPECIES.length()) {
3093 IntVector av = IntVector.fromArray(SPECIES, a, i);
3094 av.lanewise(VectorOperators.MIN, bv_MIN).intoArray(r, i);
3095 }
3096 }
3097
3098 assertArraysEquals(r, a, (int)10, IntMaxVectorTests::MIN);
3099 }
3100
3101 static IntVector bv_min = IntVector.broadcast(SPECIES, (int)10);
3102
3103 @Test(dataProvider = "intUnaryOpProvider")
3104 static void minIntMaxVectorTestsWithMemOp(IntFunction<int[]> fa) {
3105 int[] a = fa.apply(SPECIES.length());
3106 int[] r = fr.apply(SPECIES.length());
3107
3108 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3109 for (int i = 0; i < a.length; i += SPECIES.length()) {
3110 IntVector av = IntVector.fromArray(SPECIES, a, i);
3111 av.min(bv_min).intoArray(r, i);
3112 }
3113 }
3114
3115 assertArraysEquals(r, a, (int)10, IntMaxVectorTests::min);
3116 }
3117
3118 static IntVector bv_MIN_M = IntVector.broadcast(SPECIES, (int)10);
3119
3120 @Test(dataProvider = "intUnaryOpMaskProvider")
3121 static void MINIntMaxVectorTestsMaskedWithMemOp(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3122 int[] a = fa.apply(SPECIES.length());
3123 int[] r = fr.apply(SPECIES.length());
3124 boolean[] mask = fm.apply(SPECIES.length());
3125 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3126
3127 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3128 for (int i = 0; i < a.length; i += SPECIES.length()) {
3129 IntVector av = IntVector.fromArray(SPECIES, a, i);
3130 av.lanewise(VectorOperators.MIN, bv_MIN_M, vmask).intoArray(r, i);
3131 }
3132 }
3133
3134 assertArraysEquals(r, a, (int)10, mask, IntMaxVectorTests::MIN);
3135 }
3136
3137 static IntVector bv_MAX = IntVector.broadcast(SPECIES, (int)10);
3138
3139 @Test(dataProvider = "intUnaryOpProvider")
3140 static void MAXIntMaxVectorTestsWithMemOp(IntFunction<int[]> fa) {
3141 int[] a = fa.apply(SPECIES.length());
3142 int[] r = fr.apply(SPECIES.length());
3143
3144 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3145 for (int i = 0; i < a.length; i += SPECIES.length()) {
3146 IntVector av = IntVector.fromArray(SPECIES, a, i);
3147 av.lanewise(VectorOperators.MAX, bv_MAX).intoArray(r, i);
3148 }
3149 }
3150
3151 assertArraysEquals(r, a, (int)10, IntMaxVectorTests::MAX);
3152 }
3153
3154 static IntVector bv_max = IntVector.broadcast(SPECIES, (int)10);
3155
3156 @Test(dataProvider = "intUnaryOpProvider")
3157 static void maxIntMaxVectorTestsWithMemOp(IntFunction<int[]> fa) {
3158 int[] a = fa.apply(SPECIES.length());
3159 int[] r = fr.apply(SPECIES.length());
3160
3161 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3162 for (int i = 0; i < a.length; i += SPECIES.length()) {
3163 IntVector av = IntVector.fromArray(SPECIES, a, i);
3164 av.max(bv_max).intoArray(r, i);
3165 }
3166 }
3167
3168 assertArraysEquals(r, a, (int)10, IntMaxVectorTests::max);
3169 }
3170
3171 static IntVector bv_MAX_M = IntVector.broadcast(SPECIES, (int)10);
3172
3173 @Test(dataProvider = "intUnaryOpMaskProvider")
3174 static void MAXIntMaxVectorTestsMaskedWithMemOp(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3175 int[] a = fa.apply(SPECIES.length());
3176 int[] r = fr.apply(SPECIES.length());
3177 boolean[] mask = fm.apply(SPECIES.length());
3178 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3179
3180 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3181 for (int i = 0; i < a.length; i += SPECIES.length()) {
3182 IntVector av = IntVector.fromArray(SPECIES, a, i);
3183 av.lanewise(VectorOperators.MAX, bv_MAX_M, vmask).intoArray(r, i);
3184 }
3185 }
3186
3187 assertArraysEquals(r, a, (int)10, mask, IntMaxVectorTests::MAX);
3188 }
3189
3190 static int MIN(int a, int b) {
3191 return (int)(Math.min(a, b));
3192 }
3193
3194 @Test(dataProvider = "intBinaryOpProvider")
3195 static void MINIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3196 int[] a = fa.apply(SPECIES.length());
3197 int[] b = fb.apply(SPECIES.length());
3198 int[] r = fr.apply(SPECIES.length());
3199
3200 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3201 for (int i = 0; i < a.length; i += SPECIES.length()) {
3202 IntVector av = IntVector.fromArray(SPECIES, a, i);
3203 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3204 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
3205 }
3206 }
3207
3208 assertArraysEquals(r, a, b, IntMaxVectorTests::MIN);
3209 }
3210
3211 static int min(int a, int b) {
3212 return (int)(Math.min(a, b));
3213 }
3214
3215 @Test(dataProvider = "intBinaryOpProvider")
3216 static void minIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3217 int[] a = fa.apply(SPECIES.length());
3218 int[] b = fb.apply(SPECIES.length());
3219 int[] r = fr.apply(SPECIES.length());
3220
3221 for (int i = 0; i < a.length; i += SPECIES.length()) {
3222 IntVector av = IntVector.fromArray(SPECIES, a, i);
3223 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3224 av.min(bv).intoArray(r, i);
3225 }
3226
3227 assertArraysEquals(r, a, b, IntMaxVectorTests::min);
3228 }
3229
3230 static int MAX(int a, int b) {
3231 return (int)(Math.max(a, b));
3232 }
3233
3234 @Test(dataProvider = "intBinaryOpProvider")
3235 static void MAXIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3236 int[] a = fa.apply(SPECIES.length());
3237 int[] b = fb.apply(SPECIES.length());
3238 int[] r = fr.apply(SPECIES.length());
3239
3240 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3241 for (int i = 0; i < a.length; i += SPECIES.length()) {
3242 IntVector av = IntVector.fromArray(SPECIES, a, i);
3243 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3244 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
3245 }
3246 }
3247
3248 assertArraysEquals(r, a, b, IntMaxVectorTests::MAX);
3249 }
3250
3251 static int max(int a, int b) {
3252 return (int)(Math.max(a, b));
3253 }
3254
3255 @Test(dataProvider = "intBinaryOpProvider")
3256 static void maxIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3257 int[] a = fa.apply(SPECIES.length());
3258 int[] b = fb.apply(SPECIES.length());
3259 int[] r = fr.apply(SPECIES.length());
3260
3261 for (int i = 0; i < a.length; i += SPECIES.length()) {
3262 IntVector av = IntVector.fromArray(SPECIES, a, i);
3263 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3264 av.max(bv).intoArray(r, i);
3265 }
3266
3267 assertArraysEquals(r, a, b, IntMaxVectorTests::max);
3268 }
3269
3270 static int UMIN(int a, int b) {
3271 return (int)(VectorMath.minUnsigned(a, b));
3272 }
3273
3274 @Test(dataProvider = "intBinaryOpProvider")
3275 static void UMINIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3276 int[] a = fa.apply(SPECIES.length());
3277 int[] b = fb.apply(SPECIES.length());
3278 int[] r = fr.apply(SPECIES.length());
3279
3280 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3281 for (int i = 0; i < a.length; i += SPECIES.length()) {
3282 IntVector av = IntVector.fromArray(SPECIES, a, i);
3283 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3284 av.lanewise(VectorOperators.UMIN, bv).intoArray(r, i);
3285 }
3286 }
3287
3288 assertArraysEquals(r, a, b, IntMaxVectorTests::UMIN);
3289 }
3290
3291 @Test(dataProvider = "intBinaryOpMaskProvider")
3292 static void UMINIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3293 IntFunction<boolean[]> fm) {
3294 int[] a = fa.apply(SPECIES.length());
3295 int[] b = fb.apply(SPECIES.length());
3296 int[] r = fr.apply(SPECIES.length());
3297 boolean[] mask = fm.apply(SPECIES.length());
3298 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3299
3300 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3301 for (int i = 0; i < a.length; i += SPECIES.length()) {
3302 IntVector av = IntVector.fromArray(SPECIES, a, i);
3303 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3304 av.lanewise(VectorOperators.UMIN, bv, vmask).intoArray(r, i);
3305 }
3306 }
3307
3308 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::UMIN);
3309 }
3310
3311 static int UMAX(int a, int b) {
3312 return (int)(VectorMath.maxUnsigned(a, b));
3313 }
3314
3315 @Test(dataProvider = "intBinaryOpProvider")
3316 static void UMAXIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3317 int[] a = fa.apply(SPECIES.length());
3318 int[] b = fb.apply(SPECIES.length());
3319 int[] r = fr.apply(SPECIES.length());
3320
3321 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3322 for (int i = 0; i < a.length; i += SPECIES.length()) {
3323 IntVector av = IntVector.fromArray(SPECIES, a, i);
3324 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3325 av.lanewise(VectorOperators.UMAX, bv).intoArray(r, i);
3326 }
3327 }
3328
3329 assertArraysEquals(r, a, b, IntMaxVectorTests::UMAX);
3330 }
3331
3332 @Test(dataProvider = "intBinaryOpMaskProvider")
3333 static void UMAXIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3334 IntFunction<boolean[]> fm) {
3335 int[] a = fa.apply(SPECIES.length());
3336 int[] b = fb.apply(SPECIES.length());
3337 int[] r = fr.apply(SPECIES.length());
3338 boolean[] mask = fm.apply(SPECIES.length());
3339 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3340
3341 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3342 for (int i = 0; i < a.length; i += SPECIES.length()) {
3343 IntVector av = IntVector.fromArray(SPECIES, a, i);
3344 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3345 av.lanewise(VectorOperators.UMAX, bv, vmask).intoArray(r, i);
3346 }
3347 }
3348
3349 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::UMAX);
3350 }
3351
3352 static int SADD(int a, int b) {
3353 return (int)(VectorMath.addSaturating(a, b));
3354 }
3355
3356 @Test(dataProvider = "intSaturatingBinaryOpProvider")
3357 static void SADDIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3358 int[] a = fa.apply(SPECIES.length());
3359 int[] b = fb.apply(SPECIES.length());
3360 int[] r = fr.apply(SPECIES.length());
3361
3362 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3363 for (int i = 0; i < a.length; i += SPECIES.length()) {
3364 IntVector av = IntVector.fromArray(SPECIES, a, i);
3365 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3366 av.lanewise(VectorOperators.SADD, bv).intoArray(r, i);
3367 }
3368 }
3369
3370 assertArraysEquals(r, a, b, IntMaxVectorTests::SADD);
3371 }
3372
3373 @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3374 static void SADDIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3375 IntFunction<boolean[]> fm) {
3376 int[] a = fa.apply(SPECIES.length());
3377 int[] b = fb.apply(SPECIES.length());
3378 int[] r = fr.apply(SPECIES.length());
3379 boolean[] mask = fm.apply(SPECIES.length());
3380 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3381
3382 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3383 for (int i = 0; i < a.length; i += SPECIES.length()) {
3384 IntVector av = IntVector.fromArray(SPECIES, a, i);
3385 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3386 av.lanewise(VectorOperators.SADD, bv, vmask).intoArray(r, i);
3387 }
3388 }
3389
3390 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::SADD);
3391 }
3392
3393 static int SSUB(int a, int b) {
3394 return (int)(VectorMath.subSaturating(a, b));
3395 }
3396
3397 @Test(dataProvider = "intSaturatingBinaryOpProvider")
3398 static void SSUBIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3399 int[] a = fa.apply(SPECIES.length());
3400 int[] b = fb.apply(SPECIES.length());
3401 int[] r = fr.apply(SPECIES.length());
3402
3403 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3404 for (int i = 0; i < a.length; i += SPECIES.length()) {
3405 IntVector av = IntVector.fromArray(SPECIES, a, i);
3406 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3407 av.lanewise(VectorOperators.SSUB, bv).intoArray(r, i);
3408 }
3409 }
3410
3411 assertArraysEquals(r, a, b, IntMaxVectorTests::SSUB);
3412 }
3413
3414 @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3415 static void SSUBIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3416 IntFunction<boolean[]> fm) {
3417 int[] a = fa.apply(SPECIES.length());
3418 int[] b = fb.apply(SPECIES.length());
3419 int[] r = fr.apply(SPECIES.length());
3420 boolean[] mask = fm.apply(SPECIES.length());
3421 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3422
3423 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3424 for (int i = 0; i < a.length; i += SPECIES.length()) {
3425 IntVector av = IntVector.fromArray(SPECIES, a, i);
3426 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3427 av.lanewise(VectorOperators.SSUB, bv, vmask).intoArray(r, i);
3428 }
3429 }
3430
3431 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::SSUB);
3432 }
3433
3434 static int SUADD(int a, int b) {
3435 return (int)(VectorMath.addSaturatingUnsigned(a, b));
3436 }
3437
3438 @Test(dataProvider = "intSaturatingBinaryOpProvider")
3439 static void SUADDIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3440 int[] a = fa.apply(SPECIES.length());
3441 int[] b = fb.apply(SPECIES.length());
3442 int[] r = fr.apply(SPECIES.length());
3443
3444 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3445 for (int i = 0; i < a.length; i += SPECIES.length()) {
3446 IntVector av = IntVector.fromArray(SPECIES, a, i);
3447 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3448 av.lanewise(VectorOperators.SUADD, bv).intoArray(r, i);
3449 }
3450 }
3451
3452 assertArraysEquals(r, a, b, IntMaxVectorTests::SUADD);
3453 }
3454
3455 @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3456 static void SUADDIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3457 IntFunction<boolean[]> fm) {
3458 int[] a = fa.apply(SPECIES.length());
3459 int[] b = fb.apply(SPECIES.length());
3460 int[] r = fr.apply(SPECIES.length());
3461 boolean[] mask = fm.apply(SPECIES.length());
3462 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3463
3464 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3465 for (int i = 0; i < a.length; i += SPECIES.length()) {
3466 IntVector av = IntVector.fromArray(SPECIES, a, i);
3467 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3468 av.lanewise(VectorOperators.SUADD, bv, vmask).intoArray(r, i);
3469 }
3470 }
3471
3472 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::SUADD);
3473 }
3474
3475 static int SUSUB(int a, int b) {
3476 return (int)(VectorMath.subSaturatingUnsigned(a, b));
3477 }
3478
3479 @Test(dataProvider = "intSaturatingBinaryOpProvider")
3480 static void SUSUBIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3481 int[] a = fa.apply(SPECIES.length());
3482 int[] b = fb.apply(SPECIES.length());
3483 int[] r = fr.apply(SPECIES.length());
3484
3485 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3486 for (int i = 0; i < a.length; i += SPECIES.length()) {
3487 IntVector av = IntVector.fromArray(SPECIES, a, i);
3488 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3489 av.lanewise(VectorOperators.SUSUB, bv).intoArray(r, i);
3490 }
3491 }
3492
3493 assertArraysEquals(r, a, b, IntMaxVectorTests::SUSUB);
3494 }
3495
3496 @Test(dataProvider = "intSaturatingBinaryOpMaskProvider")
3497 static void SUSUBIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3498 IntFunction<boolean[]> fm) {
3499 int[] a = fa.apply(SPECIES.length());
3500 int[] b = fb.apply(SPECIES.length());
3501 int[] r = fr.apply(SPECIES.length());
3502 boolean[] mask = fm.apply(SPECIES.length());
3503 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3504
3505 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3506 for (int i = 0; i < a.length; i += SPECIES.length()) {
3507 IntVector av = IntVector.fromArray(SPECIES, a, i);
3508 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3509 av.lanewise(VectorOperators.SUSUB, bv, vmask).intoArray(r, i);
3510 }
3511 }
3512
3513 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::SUSUB);
3514 }
3515
3516 @Test(dataProvider = "intBinaryOpProvider")
3517 static void MINIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3518 int[] a = fa.apply(SPECIES.length());
3519 int[] b = fb.apply(SPECIES.length());
3520 int[] r = fr.apply(SPECIES.length());
3521
3522 for (int i = 0; i < a.length; i += SPECIES.length()) {
3523 IntVector av = IntVector.fromArray(SPECIES, a, i);
3524 av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
3525 }
3526
3527 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::MIN);
3528 }
3529
3530 @Test(dataProvider = "intBinaryOpProvider")
3531 static void minIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3532 int[] a = fa.apply(SPECIES.length());
3533 int[] b = fb.apply(SPECIES.length());
3534 int[] r = fr.apply(SPECIES.length());
3535
3536 for (int i = 0; i < a.length; i += SPECIES.length()) {
3537 IntVector av = IntVector.fromArray(SPECIES, a, i);
3538 av.min(b[i]).intoArray(r, i);
3539 }
3540
3541 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::min);
3542 }
3543
3544 @Test(dataProvider = "intBinaryOpProvider")
3545 static void MAXIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3546 int[] a = fa.apply(SPECIES.length());
3547 int[] b = fb.apply(SPECIES.length());
3548 int[] r = fr.apply(SPECIES.length());
3549
3550 for (int i = 0; i < a.length; i += SPECIES.length()) {
3551 IntVector av = IntVector.fromArray(SPECIES, a, i);
3552 av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
3553 }
3554
3555 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::MAX);
3556 }
3557
3558 @Test(dataProvider = "intBinaryOpProvider")
3559 static void maxIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3560 int[] a = fa.apply(SPECIES.length());
3561 int[] b = fb.apply(SPECIES.length());
3562 int[] r = fr.apply(SPECIES.length());
3563
3564 for (int i = 0; i < a.length; i += SPECIES.length()) {
3565 IntVector av = IntVector.fromArray(SPECIES, a, i);
3566 av.max(b[i]).intoArray(r, i);
3567 }
3568
3569 assertBroadcastArraysEquals(r, a, b, IntMaxVectorTests::max);
3570 }
3571 @Test(dataProvider = "intSaturatingBinaryOpAssocProvider")
3572 static void SUADDAssocIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
3573 int[] a = fa.apply(SPECIES.length());
3574 int[] b = fb.apply(SPECIES.length());
3575 int[] c = fc.apply(SPECIES.length());
3576 int[] rl = fr.apply(SPECIES.length());
3577 int[] rr = fr.apply(SPECIES.length());
3578
3579 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3580 for (int i = 0; i < a.length; i += SPECIES.length()) {
3581 IntVector av = IntVector.fromArray(SPECIES, a, i);
3582 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3583 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3584 av.lanewise(VectorOperators.SUADD, bv).lanewise(VectorOperators.SUADD, cv).intoArray(rl, i);
3585 av.lanewise(VectorOperators.SUADD, bv.lanewise(VectorOperators.SUADD, cv)).intoArray(rr, i);
3586 }
3587 }
3588
3589 assertArraysEqualsAssociative(rl, rr, a, b, c, IntMaxVectorTests::SUADD);
3590 }
3591
3592 @Test(dataProvider = "intSaturatingBinaryOpAssocMaskProvider")
3593 static void SUADDAssocIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3594 IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
3595 int[] a = fa.apply(SPECIES.length());
3596 int[] b = fb.apply(SPECIES.length());
3597 int[] c = fc.apply(SPECIES.length());
3598 boolean[] mask = fm.apply(SPECIES.length());
3599 int[] rl = fr.apply(SPECIES.length());
3600 int[] rr = fr.apply(SPECIES.length());
3601
3602 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3603
3604 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3605 for (int i = 0; i < a.length; i += SPECIES.length()) {
3606 IntVector av = IntVector.fromArray(SPECIES, a, i);
3607 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3608 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3609 av.lanewise(VectorOperators.SUADD, bv, vmask).lanewise(VectorOperators.SUADD, cv, vmask).intoArray(rl, i);
3610 av.lanewise(VectorOperators.SUADD, bv.lanewise(VectorOperators.SUADD, cv, vmask), vmask).intoArray(rr, i);
3611 }
3612 }
3613
3614 assertArraysEqualsAssociative(rl, rr, a, b, c, mask, IntMaxVectorTests::SUADD);
3615 }
3616
3617 static int ANDReduce(int[] a, int idx) {
3618 int res = -1;
3619 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3620 res &= a[i];
3621 }
3622
3623 return res;
3624 }
3625
3626 static int ANDReduceAll(int[] a) {
3627 int res = -1;
3628 for (int i = 0; i < a.length; i += SPECIES.length()) {
3629 res &= ANDReduce(a, i);
3630 }
3631
3632 return res;
3633 }
3634
3635 @Test(dataProvider = "intUnaryOpProvider")
3636 static void ANDReduceIntMaxVectorTests(IntFunction<int[]> fa) {
3637 int[] a = fa.apply(SPECIES.length());
3638 int[] r = fr.apply(SPECIES.length());
3639 int ra = -1;
3640
3641 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3642 for (int i = 0; i < a.length; i += SPECIES.length()) {
3643 IntVector av = IntVector.fromArray(SPECIES, a, i);
3644 r[i] = av.reduceLanes(VectorOperators.AND);
3645 }
3646 }
3647
3648 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3649 ra = -1;
3650 for (int i = 0; i < a.length; i += SPECIES.length()) {
3651 IntVector av = IntVector.fromArray(SPECIES, a, i);
3652 ra &= av.reduceLanes(VectorOperators.AND);
3653 }
3654 }
3655
3656 assertReductionArraysEquals(r, ra, a,
3657 IntMaxVectorTests::ANDReduce, IntMaxVectorTests::ANDReduceAll);
3658 }
3659
3660 static int ANDReduceMasked(int[] a, int idx, boolean[] mask) {
3661 int res = -1;
3662 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3663 if (mask[i % SPECIES.length()])
3664 res &= a[i];
3665 }
3666
3667 return res;
3668 }
3669
3670 static int ANDReduceAllMasked(int[] a, boolean[] mask) {
3671 int res = -1;
3672 for (int i = 0; i < a.length; i += SPECIES.length()) {
3673 res &= ANDReduceMasked(a, i, mask);
3674 }
3675
3676 return res;
3677 }
3678
3679 @Test(dataProvider = "intUnaryOpMaskProvider")
3680 static void ANDReduceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3681 int[] a = fa.apply(SPECIES.length());
3682 int[] r = fr.apply(SPECIES.length());
3683 boolean[] mask = fm.apply(SPECIES.length());
3684 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3685 int ra = -1;
3686
3687 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3688 for (int i = 0; i < a.length; i += SPECIES.length()) {
3689 IntVector av = IntVector.fromArray(SPECIES, a, i);
3690 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
3691 }
3692 }
3693
3694 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3695 ra = -1;
3696 for (int i = 0; i < a.length; i += SPECIES.length()) {
3697 IntVector av = IntVector.fromArray(SPECIES, a, i);
3698 ra &= av.reduceLanes(VectorOperators.AND, vmask);
3699 }
3700 }
3701
3702 assertReductionArraysEqualsMasked(r, ra, a, mask,
3703 IntMaxVectorTests::ANDReduceMasked, IntMaxVectorTests::ANDReduceAllMasked);
3704 }
3705
3706 static int ORReduce(int[] a, int idx) {
3707 int res = 0;
3708 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3709 res |= a[i];
3710 }
3711
3712 return res;
3713 }
3714
3715 static int ORReduceAll(int[] a) {
3716 int res = 0;
3717 for (int i = 0; i < a.length; i += SPECIES.length()) {
3718 res |= ORReduce(a, i);
3719 }
3720
3721 return res;
3722 }
3723
3724 @Test(dataProvider = "intUnaryOpProvider")
3725 static void ORReduceIntMaxVectorTests(IntFunction<int[]> fa) {
3726 int[] a = fa.apply(SPECIES.length());
3727 int[] r = fr.apply(SPECIES.length());
3728 int ra = 0;
3729
3730 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3731 for (int i = 0; i < a.length; i += SPECIES.length()) {
3732 IntVector av = IntVector.fromArray(SPECIES, a, i);
3733 r[i] = av.reduceLanes(VectorOperators.OR);
3734 }
3735 }
3736
3737 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3738 ra = 0;
3739 for (int i = 0; i < a.length; i += SPECIES.length()) {
3740 IntVector av = IntVector.fromArray(SPECIES, a, i);
3741 ra |= av.reduceLanes(VectorOperators.OR);
3742 }
3743 }
3744
3745 assertReductionArraysEquals(r, ra, a,
3746 IntMaxVectorTests::ORReduce, IntMaxVectorTests::ORReduceAll);
3747 }
3748
3749 static int ORReduceMasked(int[] a, int idx, boolean[] mask) {
3750 int res = 0;
3751 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3752 if (mask[i % SPECIES.length()])
3753 res |= a[i];
3754 }
3755
3756 return res;
3757 }
3758
3759 static int ORReduceAllMasked(int[] a, boolean[] mask) {
3760 int res = 0;
3761 for (int i = 0; i < a.length; i += SPECIES.length()) {
3762 res |= ORReduceMasked(a, i, mask);
3763 }
3764
3765 return res;
3766 }
3767
3768 @Test(dataProvider = "intUnaryOpMaskProvider")
3769 static void ORReduceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3770 int[] a = fa.apply(SPECIES.length());
3771 int[] r = fr.apply(SPECIES.length());
3772 boolean[] mask = fm.apply(SPECIES.length());
3773 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3774 int ra = 0;
3775
3776 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3777 for (int i = 0; i < a.length; i += SPECIES.length()) {
3778 IntVector av = IntVector.fromArray(SPECIES, a, i);
3779 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
3780 }
3781 }
3782
3783 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3784 ra = 0;
3785 for (int i = 0; i < a.length; i += SPECIES.length()) {
3786 IntVector av = IntVector.fromArray(SPECIES, a, i);
3787 ra |= av.reduceLanes(VectorOperators.OR, vmask);
3788 }
3789 }
3790
3791 assertReductionArraysEqualsMasked(r, ra, a, mask,
3792 IntMaxVectorTests::ORReduceMasked, IntMaxVectorTests::ORReduceAllMasked);
3793 }
3794
3795 static int XORReduce(int[] a, int idx) {
3796 int res = 0;
3797 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3798 res ^= a[i];
3799 }
3800
3801 return res;
3802 }
3803
3804 static int XORReduceAll(int[] a) {
3805 int res = 0;
3806 for (int i = 0; i < a.length; i += SPECIES.length()) {
3807 res ^= XORReduce(a, i);
3808 }
3809
3810 return res;
3811 }
3812
3813 @Test(dataProvider = "intUnaryOpProvider")
3814 static void XORReduceIntMaxVectorTests(IntFunction<int[]> fa) {
3815 int[] a = fa.apply(SPECIES.length());
3816 int[] r = fr.apply(SPECIES.length());
3817 int ra = 0;
3818
3819 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3820 for (int i = 0; i < a.length; i += SPECIES.length()) {
3821 IntVector av = IntVector.fromArray(SPECIES, a, i);
3822 r[i] = av.reduceLanes(VectorOperators.XOR);
3823 }
3824 }
3825
3826 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3827 ra = 0;
3828 for (int i = 0; i < a.length; i += SPECIES.length()) {
3829 IntVector av = IntVector.fromArray(SPECIES, a, i);
3830 ra ^= av.reduceLanes(VectorOperators.XOR);
3831 }
3832 }
3833
3834 assertReductionArraysEquals(r, ra, a,
3835 IntMaxVectorTests::XORReduce, IntMaxVectorTests::XORReduceAll);
3836 }
3837
3838 static int XORReduceMasked(int[] a, int idx, boolean[] mask) {
3839 int res = 0;
3840 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3841 if (mask[i % SPECIES.length()])
3842 res ^= a[i];
3843 }
3844
3845 return res;
3846 }
3847
3848 static int XORReduceAllMasked(int[] a, boolean[] mask) {
3849 int res = 0;
3850 for (int i = 0; i < a.length; i += SPECIES.length()) {
3851 res ^= XORReduceMasked(a, i, mask);
3852 }
3853
3854 return res;
3855 }
3856
3857 @Test(dataProvider = "intUnaryOpMaskProvider")
3858 static void XORReduceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3859 int[] a = fa.apply(SPECIES.length());
3860 int[] r = fr.apply(SPECIES.length());
3861 boolean[] mask = fm.apply(SPECIES.length());
3862 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3863 int ra = 0;
3864
3865 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3866 for (int i = 0; i < a.length; i += SPECIES.length()) {
3867 IntVector av = IntVector.fromArray(SPECIES, a, i);
3868 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
3869 }
3870 }
3871
3872 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3873 ra = 0;
3874 for (int i = 0; i < a.length; i += SPECIES.length()) {
3875 IntVector av = IntVector.fromArray(SPECIES, a, i);
3876 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
3877 }
3878 }
3879
3880 assertReductionArraysEqualsMasked(r, ra, a, mask,
3881 IntMaxVectorTests::XORReduceMasked, IntMaxVectorTests::XORReduceAllMasked);
3882 }
3883
3884 static int ADDReduce(int[] a, int idx) {
3885 int res = 0;
3886 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3887 res += a[i];
3888 }
3889
3890 return res;
3891 }
3892
3893 static int ADDReduceAll(int[] a) {
3894 int res = 0;
3895 for (int i = 0; i < a.length; i += SPECIES.length()) {
3896 res += ADDReduce(a, i);
3897 }
3898
3899 return res;
3900 }
3901
3902 @Test(dataProvider = "intUnaryOpProvider")
3903 static void ADDReduceIntMaxVectorTests(IntFunction<int[]> fa) {
3904 int[] a = fa.apply(SPECIES.length());
3905 int[] r = fr.apply(SPECIES.length());
3906 int ra = 0;
3907
3908 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3909 for (int i = 0; i < a.length; i += SPECIES.length()) {
3910 IntVector av = IntVector.fromArray(SPECIES, a, i);
3911 r[i] = av.reduceLanes(VectorOperators.ADD);
3912 }
3913 }
3914
3915 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3916 ra = 0;
3917 for (int i = 0; i < a.length; i += SPECIES.length()) {
3918 IntVector av = IntVector.fromArray(SPECIES, a, i);
3919 ra += av.reduceLanes(VectorOperators.ADD);
3920 }
3921 }
3922
3923 assertReductionArraysEquals(r, ra, a,
3924 IntMaxVectorTests::ADDReduce, IntMaxVectorTests::ADDReduceAll);
3925 }
3926
3927 static int ADDReduceMasked(int[] a, int idx, boolean[] mask) {
3928 int res = 0;
3929 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3930 if (mask[i % SPECIES.length()])
3931 res += a[i];
3932 }
3933
3934 return res;
3935 }
3936
3937 static int ADDReduceAllMasked(int[] a, boolean[] mask) {
3938 int res = 0;
3939 for (int i = 0; i < a.length; i += SPECIES.length()) {
3940 res += ADDReduceMasked(a, i, mask);
3941 }
3942
3943 return res;
3944 }
3945
3946 @Test(dataProvider = "intUnaryOpMaskProvider")
3947 static void ADDReduceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
3948 int[] a = fa.apply(SPECIES.length());
3949 int[] r = fr.apply(SPECIES.length());
3950 boolean[] mask = fm.apply(SPECIES.length());
3951 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3952 int ra = 0;
3953
3954 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3955 for (int i = 0; i < a.length; i += SPECIES.length()) {
3956 IntVector av = IntVector.fromArray(SPECIES, a, i);
3957 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
3958 }
3959 }
3960
3961 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3962 ra = 0;
3963 for (int i = 0; i < a.length; i += SPECIES.length()) {
3964 IntVector av = IntVector.fromArray(SPECIES, a, i);
3965 ra += av.reduceLanes(VectorOperators.ADD, vmask);
3966 }
3967 }
3968
3969 assertReductionArraysEqualsMasked(r, ra, a, mask,
3970 IntMaxVectorTests::ADDReduceMasked, IntMaxVectorTests::ADDReduceAllMasked);
3971 }
3972
3973 static int MULReduce(int[] a, int idx) {
3974 int res = 1;
3975 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3976 res *= a[i];
3977 }
3978
3979 return res;
3980 }
3981
3982 static int MULReduceAll(int[] a) {
3983 int res = 1;
3984 for (int i = 0; i < a.length; i += SPECIES.length()) {
3985 res *= MULReduce(a, i);
3986 }
3987
3988 return res;
3989 }
3990
3991 @Test(dataProvider = "intUnaryOpProvider")
3992 static void MULReduceIntMaxVectorTests(IntFunction<int[]> fa) {
3993 int[] a = fa.apply(SPECIES.length());
3994 int[] r = fr.apply(SPECIES.length());
3995 int ra = 1;
3996
3997 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3998 for (int i = 0; i < a.length; i += SPECIES.length()) {
3999 IntVector av = IntVector.fromArray(SPECIES, a, i);
4000 r[i] = av.reduceLanes(VectorOperators.MUL);
4001 }
4002 }
4003
4004 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4005 ra = 1;
4006 for (int i = 0; i < a.length; i += SPECIES.length()) {
4007 IntVector av = IntVector.fromArray(SPECIES, a, i);
4008 ra *= av.reduceLanes(VectorOperators.MUL);
4009 }
4010 }
4011
4012 assertReductionArraysEquals(r, ra, a,
4013 IntMaxVectorTests::MULReduce, IntMaxVectorTests::MULReduceAll);
4014 }
4015
4016 static int MULReduceMasked(int[] a, int idx, boolean[] mask) {
4017 int res = 1;
4018 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4019 if (mask[i % SPECIES.length()])
4020 res *= a[i];
4021 }
4022
4023 return res;
4024 }
4025
4026 static int MULReduceAllMasked(int[] a, boolean[] mask) {
4027 int res = 1;
4028 for (int i = 0; i < a.length; i += SPECIES.length()) {
4029 res *= MULReduceMasked(a, i, mask);
4030 }
4031
4032 return res;
4033 }
4034
4035 @Test(dataProvider = "intUnaryOpMaskProvider")
4036 static void MULReduceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4037 int[] a = fa.apply(SPECIES.length());
4038 int[] r = fr.apply(SPECIES.length());
4039 boolean[] mask = fm.apply(SPECIES.length());
4040 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4041 int ra = 1;
4042
4043 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4044 for (int i = 0; i < a.length; i += SPECIES.length()) {
4045 IntVector av = IntVector.fromArray(SPECIES, a, i);
4046 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
4047 }
4048 }
4049
4050 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4051 ra = 1;
4052 for (int i = 0; i < a.length; i += SPECIES.length()) {
4053 IntVector av = IntVector.fromArray(SPECIES, a, i);
4054 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
4055 }
4056 }
4057
4058 assertReductionArraysEqualsMasked(r, ra, a, mask,
4059 IntMaxVectorTests::MULReduceMasked, IntMaxVectorTests::MULReduceAllMasked);
4060 }
4061
4062 static int MINReduce(int[] a, int idx) {
4063 int res = Integer.MAX_VALUE;
4064 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4065 res = (int) Math.min(res, a[i]);
4066 }
4067
4068 return res;
4069 }
4070
4071 static int MINReduceAll(int[] a) {
4072 int res = Integer.MAX_VALUE;
4073 for (int i = 0; i < a.length; i += SPECIES.length()) {
4074 res = (int) Math.min(res, MINReduce(a, i));
4075 }
4076
4077 return res;
4078 }
4079
4080 @Test(dataProvider = "intUnaryOpProvider")
4081 static void MINReduceIntMaxVectorTests(IntFunction<int[]> fa) {
4082 int[] a = fa.apply(SPECIES.length());
4083 int[] r = fr.apply(SPECIES.length());
4084 int ra = Integer.MAX_VALUE;
4085
4086 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4087 for (int i = 0; i < a.length; i += SPECIES.length()) {
4088 IntVector av = IntVector.fromArray(SPECIES, a, i);
4089 r[i] = av.reduceLanes(VectorOperators.MIN);
4090 }
4091 }
4092
4093 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4094 ra = Integer.MAX_VALUE;
4095 for (int i = 0; i < a.length; i += SPECIES.length()) {
4096 IntVector av = IntVector.fromArray(SPECIES, a, i);
4097 ra = (int) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
4098 }
4099 }
4100
4101 assertReductionArraysEquals(r, ra, a,
4102 IntMaxVectorTests::MINReduce, IntMaxVectorTests::MINReduceAll);
4103 }
4104
4105 static int MINReduceMasked(int[] a, int idx, boolean[] mask) {
4106 int res = Integer.MAX_VALUE;
4107 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4108 if (mask[i % SPECIES.length()])
4109 res = (int) Math.min(res, a[i]);
4110 }
4111
4112 return res;
4113 }
4114
4115 static int MINReduceAllMasked(int[] a, boolean[] mask) {
4116 int res = Integer.MAX_VALUE;
4117 for (int i = 0; i < a.length; i += SPECIES.length()) {
4118 res = (int) Math.min(res, MINReduceMasked(a, i, mask));
4119 }
4120
4121 return res;
4122 }
4123
4124 @Test(dataProvider = "intUnaryOpMaskProvider")
4125 static void MINReduceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4126 int[] a = fa.apply(SPECIES.length());
4127 int[] r = fr.apply(SPECIES.length());
4128 boolean[] mask = fm.apply(SPECIES.length());
4129 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4130 int ra = Integer.MAX_VALUE;
4131
4132 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4133 for (int i = 0; i < a.length; i += SPECIES.length()) {
4134 IntVector av = IntVector.fromArray(SPECIES, a, i);
4135 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
4136 }
4137 }
4138
4139 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4140 ra = Integer.MAX_VALUE;
4141 for (int i = 0; i < a.length; i += SPECIES.length()) {
4142 IntVector av = IntVector.fromArray(SPECIES, a, i);
4143 ra = (int) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
4144 }
4145 }
4146
4147 assertReductionArraysEqualsMasked(r, ra, a, mask,
4148 IntMaxVectorTests::MINReduceMasked, IntMaxVectorTests::MINReduceAllMasked);
4149 }
4150
4151 static int MAXReduce(int[] a, int idx) {
4152 int res = Integer.MIN_VALUE;
4153 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4154 res = (int) Math.max(res, a[i]);
4155 }
4156
4157 return res;
4158 }
4159
4160 static int MAXReduceAll(int[] a) {
4161 int res = Integer.MIN_VALUE;
4162 for (int i = 0; i < a.length; i += SPECIES.length()) {
4163 res = (int) Math.max(res, MAXReduce(a, i));
4164 }
4165
4166 return res;
4167 }
4168
4169 @Test(dataProvider = "intUnaryOpProvider")
4170 static void MAXReduceIntMaxVectorTests(IntFunction<int[]> fa) {
4171 int[] a = fa.apply(SPECIES.length());
4172 int[] r = fr.apply(SPECIES.length());
4173 int ra = Integer.MIN_VALUE;
4174
4175 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4176 for (int i = 0; i < a.length; i += SPECIES.length()) {
4177 IntVector av = IntVector.fromArray(SPECIES, a, i);
4178 r[i] = av.reduceLanes(VectorOperators.MAX);
4179 }
4180 }
4181
4182 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4183 ra = Integer.MIN_VALUE;
4184 for (int i = 0; i < a.length; i += SPECIES.length()) {
4185 IntVector av = IntVector.fromArray(SPECIES, a, i);
4186 ra = (int) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
4187 }
4188 }
4189
4190 assertReductionArraysEquals(r, ra, a,
4191 IntMaxVectorTests::MAXReduce, IntMaxVectorTests::MAXReduceAll);
4192 }
4193
4194 static int MAXReduceMasked(int[] a, int idx, boolean[] mask) {
4195 int res = Integer.MIN_VALUE;
4196 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4197 if (mask[i % SPECIES.length()])
4198 res = (int) Math.max(res, a[i]);
4199 }
4200
4201 return res;
4202 }
4203
4204 static int MAXReduceAllMasked(int[] a, boolean[] mask) {
4205 int res = Integer.MIN_VALUE;
4206 for (int i = 0; i < a.length; i += SPECIES.length()) {
4207 res = (int) Math.max(res, MAXReduceMasked(a, i, mask));
4208 }
4209
4210 return res;
4211 }
4212
4213 @Test(dataProvider = "intUnaryOpMaskProvider")
4214 static void MAXReduceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4215 int[] a = fa.apply(SPECIES.length());
4216 int[] r = fr.apply(SPECIES.length());
4217 boolean[] mask = fm.apply(SPECIES.length());
4218 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4219 int ra = Integer.MIN_VALUE;
4220
4221 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4222 for (int i = 0; i < a.length; i += SPECIES.length()) {
4223 IntVector av = IntVector.fromArray(SPECIES, a, i);
4224 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
4225 }
4226 }
4227
4228 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4229 ra = Integer.MIN_VALUE;
4230 for (int i = 0; i < a.length; i += SPECIES.length()) {
4231 IntVector av = IntVector.fromArray(SPECIES, a, i);
4232 ra = (int) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
4233 }
4234 }
4235
4236 assertReductionArraysEqualsMasked(r, ra, a, mask,
4237 IntMaxVectorTests::MAXReduceMasked, IntMaxVectorTests::MAXReduceAllMasked);
4238 }
4239
4240 static int UMINReduce(int[] a, int idx) {
4241 int res = Integer.MAX_VALUE;
4242 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4243 res = (int) VectorMath.minUnsigned(res, a[i]);
4244 }
4245
4246 return res;
4247 }
4248
4249 static int UMINReduceAll(int[] a) {
4250 int res = Integer.MAX_VALUE;
4251 for (int i = 0; i < a.length; i += SPECIES.length()) {
4252 res = (int) VectorMath.minUnsigned(res, UMINReduce(a, i));
4253 }
4254
4255 return res;
4256 }
4257
4258 @Test(dataProvider = "intUnaryOpProvider")
4259 static void UMINReduceIntMaxVectorTests(IntFunction<int[]> fa) {
4260 int[] a = fa.apply(SPECIES.length());
4261 int[] r = fr.apply(SPECIES.length());
4262 int ra = Integer.MAX_VALUE;
4263
4264 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4265 for (int i = 0; i < a.length; i += SPECIES.length()) {
4266 IntVector av = IntVector.fromArray(SPECIES, a, i);
4267 r[i] = av.reduceLanes(VectorOperators.UMIN);
4268 }
4269 }
4270
4271 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4272 ra = Integer.MAX_VALUE;
4273 for (int i = 0; i < a.length; i += SPECIES.length()) {
4274 IntVector av = IntVector.fromArray(SPECIES, a, i);
4275 ra = (int) VectorMath.minUnsigned(ra, av.reduceLanes(VectorOperators.UMIN));
4276 }
4277 }
4278
4279 assertReductionArraysEquals(r, ra, a,
4280 IntMaxVectorTests::UMINReduce, IntMaxVectorTests::UMINReduceAll);
4281 }
4282
4283 static int UMINReduceMasked(int[] a, int idx, boolean[] mask) {
4284 int res = Integer.MAX_VALUE;
4285 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4286 if (mask[i % SPECIES.length()])
4287 res = (int) VectorMath.minUnsigned(res, a[i]);
4288 }
4289
4290 return res;
4291 }
4292
4293 static int UMINReduceAllMasked(int[] a, boolean[] mask) {
4294 int res = Integer.MAX_VALUE;
4295 for (int i = 0; i < a.length; i += SPECIES.length()) {
4296 res = (int) VectorMath.minUnsigned(res, UMINReduceMasked(a, i, mask));
4297 }
4298
4299 return res;
4300 }
4301
4302 @Test(dataProvider = "intUnaryOpMaskProvider")
4303 static void UMINReduceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4304 int[] a = fa.apply(SPECIES.length());
4305 int[] r = fr.apply(SPECIES.length());
4306 boolean[] mask = fm.apply(SPECIES.length());
4307 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4308 int ra = Integer.MAX_VALUE;
4309
4310 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4311 for (int i = 0; i < a.length; i += SPECIES.length()) {
4312 IntVector av = IntVector.fromArray(SPECIES, a, i);
4313 r[i] = av.reduceLanes(VectorOperators.UMIN, vmask);
4314 }
4315 }
4316
4317 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4318 ra = Integer.MAX_VALUE;
4319 for (int i = 0; i < a.length; i += SPECIES.length()) {
4320 IntVector av = IntVector.fromArray(SPECIES, a, i);
4321 ra = (int) VectorMath.minUnsigned(ra, av.reduceLanes(VectorOperators.UMIN, vmask));
4322 }
4323 }
4324
4325 assertReductionArraysEqualsMasked(r, ra, a, mask,
4326 IntMaxVectorTests::UMINReduceMasked, IntMaxVectorTests::UMINReduceAllMasked);
4327 }
4328
4329 static int UMAXReduce(int[] a, int idx) {
4330 int res = Integer.MIN_VALUE;
4331 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4332 res = (int) VectorMath.maxUnsigned(res, a[i]);
4333 }
4334
4335 return res;
4336 }
4337
4338 static int UMAXReduceAll(int[] a) {
4339 int res = Integer.MIN_VALUE;
4340 for (int i = 0; i < a.length; i += SPECIES.length()) {
4341 res = (int) VectorMath.maxUnsigned(res, UMAXReduce(a, i));
4342 }
4343
4344 return res;
4345 }
4346
4347 @Test(dataProvider = "intUnaryOpProvider")
4348 static void UMAXReduceIntMaxVectorTests(IntFunction<int[]> fa) {
4349 int[] a = fa.apply(SPECIES.length());
4350 int[] r = fr.apply(SPECIES.length());
4351 int ra = Integer.MIN_VALUE;
4352
4353 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4354 for (int i = 0; i < a.length; i += SPECIES.length()) {
4355 IntVector av = IntVector.fromArray(SPECIES, a, i);
4356 r[i] = av.reduceLanes(VectorOperators.UMAX);
4357 }
4358 }
4359
4360 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4361 ra = Integer.MIN_VALUE;
4362 for (int i = 0; i < a.length; i += SPECIES.length()) {
4363 IntVector av = IntVector.fromArray(SPECIES, a, i);
4364 ra = (int) VectorMath.maxUnsigned(ra, av.reduceLanes(VectorOperators.UMAX));
4365 }
4366 }
4367
4368 assertReductionArraysEquals(r, ra, a,
4369 IntMaxVectorTests::UMAXReduce, IntMaxVectorTests::UMAXReduceAll);
4370 }
4371
4372 static int UMAXReduceMasked(int[] a, int idx, boolean[] mask) {
4373 int res = Integer.MIN_VALUE;
4374 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4375 if (mask[i % SPECIES.length()])
4376 res = (int) VectorMath.maxUnsigned(res, a[i]);
4377 }
4378
4379 return res;
4380 }
4381
4382 static int UMAXReduceAllMasked(int[] a, boolean[] mask) {
4383 int res = Integer.MIN_VALUE;
4384 for (int i = 0; i < a.length; i += SPECIES.length()) {
4385 res = (int) VectorMath.maxUnsigned(res, UMAXReduceMasked(a, i, mask));
4386 }
4387
4388 return res;
4389 }
4390
4391 @Test(dataProvider = "intUnaryOpMaskProvider")
4392 static void UMAXReduceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4393 int[] a = fa.apply(SPECIES.length());
4394 int[] r = fr.apply(SPECIES.length());
4395 boolean[] mask = fm.apply(SPECIES.length());
4396 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4397 int ra = Integer.MIN_VALUE;
4398
4399 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4400 for (int i = 0; i < a.length; i += SPECIES.length()) {
4401 IntVector av = IntVector.fromArray(SPECIES, a, i);
4402 r[i] = av.reduceLanes(VectorOperators.UMAX, vmask);
4403 }
4404 }
4405
4406 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4407 ra = Integer.MIN_VALUE;
4408 for (int i = 0; i < a.length; i += SPECIES.length()) {
4409 IntVector av = IntVector.fromArray(SPECIES, a, i);
4410 ra = (int) VectorMath.maxUnsigned(ra, av.reduceLanes(VectorOperators.UMAX, vmask));
4411 }
4412 }
4413
4414 assertReductionArraysEqualsMasked(r, ra, a, mask,
4415 IntMaxVectorTests::UMAXReduceMasked, IntMaxVectorTests::UMAXReduceAllMasked);
4416 }
4417
4418 static int FIRST_NONZEROReduce(int[] a, int idx) {
4419 int res = (int) 0;
4420 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4421 res = firstNonZero(res, a[i]);
4422 }
4423
4424 return res;
4425 }
4426
4427 static int FIRST_NONZEROReduceAll(int[] a) {
4428 int res = (int) 0;
4429 for (int i = 0; i < a.length; i += SPECIES.length()) {
4430 res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
4431 }
4432
4433 return res;
4434 }
4435
4436 @Test(dataProvider = "intUnaryOpProvider")
4437 static void FIRST_NONZEROReduceIntMaxVectorTests(IntFunction<int[]> fa) {
4438 int[] a = fa.apply(SPECIES.length());
4439 int[] r = fr.apply(SPECIES.length());
4440 int ra = (int) 0;
4441
4442 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4443 for (int i = 0; i < a.length; i += SPECIES.length()) {
4444 IntVector av = IntVector.fromArray(SPECIES, a, i);
4445 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO);
4446 }
4447 }
4448
4449 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4450 ra = (int) 0;
4451 for (int i = 0; i < a.length; i += SPECIES.length()) {
4452 IntVector av = IntVector.fromArray(SPECIES, a, i);
4453 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
4454 }
4455 }
4456
4457 assertReductionArraysEquals(r, ra, a,
4458 IntMaxVectorTests::FIRST_NONZEROReduce, IntMaxVectorTests::FIRST_NONZEROReduceAll);
4459 }
4460
4461 static int FIRST_NONZEROReduceMasked(int[] a, int idx, boolean[] mask) {
4462 int res = (int) 0;
4463 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4464 if (mask[i % SPECIES.length()])
4465 res = firstNonZero(res, a[i]);
4466 }
4467
4468 return res;
4469 }
4470
4471 static int FIRST_NONZEROReduceAllMasked(int[] a, boolean[] mask) {
4472 int res = (int) 0;
4473 for (int i = 0; i < a.length; i += SPECIES.length()) {
4474 res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
4475 }
4476
4477 return res;
4478 }
4479
4480 @Test(dataProvider = "intUnaryOpMaskProvider")
4481 static void FIRST_NONZEROReduceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4482 int[] a = fa.apply(SPECIES.length());
4483 int[] r = fr.apply(SPECIES.length());
4484 boolean[] mask = fm.apply(SPECIES.length());
4485 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4486 int ra = (int) 0;
4487
4488 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4489 for (int i = 0; i < a.length; i += SPECIES.length()) {
4490 IntVector av = IntVector.fromArray(SPECIES, a, i);
4491 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask);
4492 }
4493 }
4494
4495 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4496 ra = (int) 0;
4497 for (int i = 0; i < a.length; i += SPECIES.length()) {
4498 IntVector av = IntVector.fromArray(SPECIES, a, i);
4499 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
4500 }
4501 }
4502
4503 assertReductionArraysEqualsMasked(r, ra, a, mask,
4504 IntMaxVectorTests::FIRST_NONZEROReduceMasked, IntMaxVectorTests::FIRST_NONZEROReduceAllMasked);
4505 }
4506
4507 static boolean anyTrue(boolean[] a, int idx) {
4508 boolean res = false;
4509 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4510 res |= a[i];
4511 }
4512
4513 return res;
4514 }
4515
4516 @Test(dataProvider = "boolUnaryOpProvider")
4517 static void anyTrueIntMaxVectorTests(IntFunction<boolean[]> fm) {
4518 boolean[] mask = fm.apply(SPECIES.length());
4519 boolean[] r = fmr.apply(SPECIES.length());
4520
4521 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4522 for (int i = 0; i < mask.length; i += SPECIES.length()) {
4523 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
4524 r[i] = vmask.anyTrue();
4525 }
4526 }
4527
4528 assertReductionBoolArraysEquals(r, mask, IntMaxVectorTests::anyTrue);
4529 }
4530
4531 static boolean allTrue(boolean[] a, int idx) {
4532 boolean res = true;
4533 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4534 res &= a[i];
4535 }
4536
4537 return res;
4538 }
4539
4540 @Test(dataProvider = "boolUnaryOpProvider")
4541 static void allTrueIntMaxVectorTests(IntFunction<boolean[]> fm) {
4542 boolean[] mask = fm.apply(SPECIES.length());
4543 boolean[] r = fmr.apply(SPECIES.length());
4544
4545 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4546 for (int i = 0; i < mask.length; i += SPECIES.length()) {
4547 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
4548 r[i] = vmask.allTrue();
4549 }
4550 }
4551
4552 assertReductionBoolArraysEquals(r, mask, IntMaxVectorTests::allTrue);
4553 }
4554
4555 static int SUADDReduce(int[] a, int idx) {
4556 int res = 0;
4557 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4558 res = (int) VectorMath.addSaturatingUnsigned(res, a[i]);
4559 }
4560
4561 return res;
4562 }
4563
4564 static int SUADDReduceAll(int[] a) {
4565 int res = 0;
4566 for (int i = 0; i < a.length; i += SPECIES.length()) {
4567 res = (int) VectorMath.addSaturatingUnsigned(res, SUADDReduce(a, i));
4568 }
4569
4570 return res;
4571 }
4572
4573 @Test(dataProvider = "intSaturatingUnaryOpProvider")
4574 static void SUADDReduceIntMaxVectorTests(IntFunction<int[]> fa) {
4575 int[] a = fa.apply(SPECIES.length());
4576 int[] r = fr.apply(SPECIES.length());
4577 int ra = 0;
4578
4579 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4580 for (int i = 0; i < a.length; i += SPECIES.length()) {
4581 IntVector av = IntVector.fromArray(SPECIES, a, i);
4582 r[i] = av.reduceLanes(VectorOperators.SUADD);
4583 }
4584 }
4585
4586 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4587 ra = 0;
4588 for (int i = 0; i < a.length; i += SPECIES.length()) {
4589 IntVector av = IntVector.fromArray(SPECIES, a, i);
4590 ra = (int) VectorMath.addSaturatingUnsigned(ra, av.reduceLanes(VectorOperators.SUADD));
4591 }
4592 }
4593
4594 assertReductionArraysEquals(r, ra, a,
4595 IntMaxVectorTests::SUADDReduce, IntMaxVectorTests::SUADDReduceAll);
4596 }
4597
4598 static int SUADDReduceMasked(int[] a, int idx, boolean[] mask) {
4599 int res = 0;
4600 for (int i = idx; i < (idx + SPECIES.length()); i++) {
4601 if (mask[i % SPECIES.length()])
4602 res = (int) VectorMath.addSaturatingUnsigned(res, a[i]);
4603 }
4604
4605 return res;
4606 }
4607
4608 static int SUADDReduceAllMasked(int[] a, boolean[] mask) {
4609 int res = 0;
4610 for (int i = 0; i < a.length; i += SPECIES.length()) {
4611 res = (int) VectorMath.addSaturatingUnsigned(res, SUADDReduceMasked(a, i, mask));
4612 }
4613
4614 return res;
4615 }
4616 @Test(dataProvider = "intSaturatingUnaryOpMaskProvider")
4617 static void SUADDReduceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
4618 int[] a = fa.apply(SPECIES.length());
4619 int[] r = fr.apply(SPECIES.length());
4620 boolean[] mask = fm.apply(SPECIES.length());
4621 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4622 int ra = 0;
4623
4624 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4625 for (int i = 0; i < a.length; i += SPECIES.length()) {
4626 IntVector av = IntVector.fromArray(SPECIES, a, i);
4627 r[i] = av.reduceLanes(VectorOperators.SUADD, vmask);
4628 }
4629 }
4630
4631 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4632 ra = 0;
4633 for (int i = 0; i < a.length; i += SPECIES.length()) {
4634 IntVector av = IntVector.fromArray(SPECIES, a, i);
4635 ra = (int) VectorMath.addSaturatingUnsigned(ra, av.reduceLanes(VectorOperators.SUADD, vmask));
4636 }
4637 }
4638
4639 assertReductionArraysEqualsMasked(r, ra, a, mask,
4640 IntMaxVectorTests::SUADDReduceMasked, IntMaxVectorTests::SUADDReduceAllMasked);
4641 }
4642
4643 @Test(dataProvider = "intBinaryOpProvider")
4644 static void withIntMaxVectorTests(IntFunction<int []> fa, IntFunction<int []> fb) {
4645 int[] a = fa.apply(SPECIES.length());
4646 int[] b = fb.apply(SPECIES.length());
4647 int[] r = fr.apply(SPECIES.length());
4648
4649 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4650 for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
4651 IntVector av = IntVector.fromArray(SPECIES, a, i);
4652 av.withLane(j, b[i + j]).intoArray(r, i);
4653 a[i + j] = b[i + j];
4654 j = (j + 1) & (SPECIES.length() - 1);
4655 }
4656 }
4657
4658
4659 assertArraysStrictlyEquals(r, a);
4660 }
4661
4662 static boolean testIS_DEFAULT(int a) {
4663 return bits(a)==0;
4664 }
4665
4666 @Test(dataProvider = "intTestOpProvider")
4667 static void IS_DEFAULTIntMaxVectorTests(IntFunction<int[]> fa) {
4668 int[] a = fa.apply(SPECIES.length());
4669
4670 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4671 for (int i = 0; i < a.length; i += SPECIES.length()) {
4672 IntVector av = IntVector.fromArray(SPECIES, a, i);
4673 VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT);
4674
4675 // Check results as part of computation.
4676 for (int j = 0; j < SPECIES.length(); j++) {
4677 Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
4678 }
4679 }
4680 }
4681 }
4682
4683 @Test(dataProvider = "intTestOpMaskProvider")
4684 static void IS_DEFAULTMaskedIntMaxVectorTests(IntFunction<int[]> fa,
4685 IntFunction<boolean[]> fm) {
4686 int[] a = fa.apply(SPECIES.length());
4687 boolean[] mask = fm.apply(SPECIES.length());
4688 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4689
4690 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4691 for (int i = 0; i < a.length; i += SPECIES.length()) {
4692 IntVector av = IntVector.fromArray(SPECIES, a, i);
4693 VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
4694
4695 // Check results as part of computation.
4696 for (int j = 0; j < SPECIES.length(); j++) {
4697 Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
4698 }
4699 }
4700 }
4701 }
4702
4703 static boolean testIS_NEGATIVE(int a) {
4704 return bits(a)<0;
4705 }
4706
4707 @Test(dataProvider = "intTestOpProvider")
4708 static void IS_NEGATIVEIntMaxVectorTests(IntFunction<int[]> fa) {
4709 int[] a = fa.apply(SPECIES.length());
4710
4711 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4712 for (int i = 0; i < a.length; i += SPECIES.length()) {
4713 IntVector av = IntVector.fromArray(SPECIES, a, i);
4714 VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE);
4715
4716 // Check results as part of computation.
4717 for (int j = 0; j < SPECIES.length(); j++) {
4718 Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
4719 }
4720 }
4721 }
4722 }
4723
4724 @Test(dataProvider = "intTestOpMaskProvider")
4725 static void IS_NEGATIVEMaskedIntMaxVectorTests(IntFunction<int[]> fa,
4726 IntFunction<boolean[]> fm) {
4727 int[] a = fa.apply(SPECIES.length());
4728 boolean[] mask = fm.apply(SPECIES.length());
4729 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4730
4731 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4732 for (int i = 0; i < a.length; i += SPECIES.length()) {
4733 IntVector av = IntVector.fromArray(SPECIES, a, i);
4734 VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
4735
4736 // Check results as part of computation.
4737 for (int j = 0; j < SPECIES.length(); j++) {
4738 Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
4739 }
4740 }
4741 }
4742 }
4743
4744 @Test(dataProvider = "intCompareOpProvider")
4745 static void LTIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4746 int[] a = fa.apply(SPECIES.length());
4747 int[] b = fb.apply(SPECIES.length());
4748
4749 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4750 for (int i = 0; i < a.length; i += SPECIES.length()) {
4751 IntVector av = IntVector.fromArray(SPECIES, a, i);
4752 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4753 VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv);
4754
4755 // Check results as part of computation.
4756 for (int j = 0; j < SPECIES.length(); j++) {
4757 Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
4758 }
4759 }
4760 }
4761 }
4762
4763 @Test(dataProvider = "intCompareOpProvider")
4764 static void ltIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4765 int[] a = fa.apply(SPECIES.length());
4766 int[] b = fb.apply(SPECIES.length());
4767
4768 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4769 for (int i = 0; i < a.length; i += SPECIES.length()) {
4770 IntVector av = IntVector.fromArray(SPECIES, a, i);
4771 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4772 VectorMask<Integer> mv = av.lt(bv);
4773
4774 // Check results as part of computation.
4775 for (int j = 0; j < SPECIES.length(); j++) {
4776 Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
4777 }
4778 }
4779 }
4780 }
4781
4782 @Test(dataProvider = "intCompareOpMaskProvider")
4783 static void LTIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4784 IntFunction<boolean[]> fm) {
4785 int[] a = fa.apply(SPECIES.length());
4786 int[] b = fb.apply(SPECIES.length());
4787 boolean[] mask = fm.apply(SPECIES.length());
4788
4789 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4790
4791 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4792 for (int i = 0; i < a.length; i += SPECIES.length()) {
4793 IntVector av = IntVector.fromArray(SPECIES, a, i);
4794 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4795 VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv, vmask);
4796
4797 // Check results as part of computation.
4798 for (int j = 0; j < SPECIES.length(); j++) {
4799 Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
4800 }
4801 }
4802 }
4803 }
4804
4805 @Test(dataProvider = "intCompareOpProvider")
4806 static void GTIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4807 int[] a = fa.apply(SPECIES.length());
4808 int[] b = fb.apply(SPECIES.length());
4809
4810 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4811 for (int i = 0; i < a.length; i += SPECIES.length()) {
4812 IntVector av = IntVector.fromArray(SPECIES, a, i);
4813 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4814 VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv);
4815
4816 // Check results as part of computation.
4817 for (int j = 0; j < SPECIES.length(); j++) {
4818 Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
4819 }
4820 }
4821 }
4822 }
4823
4824 @Test(dataProvider = "intCompareOpMaskProvider")
4825 static void GTIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4826 IntFunction<boolean[]> fm) {
4827 int[] a = fa.apply(SPECIES.length());
4828 int[] b = fb.apply(SPECIES.length());
4829 boolean[] mask = fm.apply(SPECIES.length());
4830
4831 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4832
4833 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4834 for (int i = 0; i < a.length; i += SPECIES.length()) {
4835 IntVector av = IntVector.fromArray(SPECIES, a, i);
4836 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4837 VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv, vmask);
4838
4839 // Check results as part of computation.
4840 for (int j = 0; j < SPECIES.length(); j++) {
4841 Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
4842 }
4843 }
4844 }
4845 }
4846
4847 @Test(dataProvider = "intCompareOpProvider")
4848 static void EQIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4849 int[] a = fa.apply(SPECIES.length());
4850 int[] b = fb.apply(SPECIES.length());
4851
4852 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4853 for (int i = 0; i < a.length; i += SPECIES.length()) {
4854 IntVector av = IntVector.fromArray(SPECIES, a, i);
4855 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4856 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv);
4857
4858 // Check results as part of computation.
4859 for (int j = 0; j < SPECIES.length(); j++) {
4860 Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4861 }
4862 }
4863 }
4864 }
4865
4866 @Test(dataProvider = "intCompareOpProvider")
4867 static void eqIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4868 int[] a = fa.apply(SPECIES.length());
4869 int[] b = fb.apply(SPECIES.length());
4870
4871 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4872 for (int i = 0; i < a.length; i += SPECIES.length()) {
4873 IntVector av = IntVector.fromArray(SPECIES, a, i);
4874 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4875 VectorMask<Integer> mv = av.eq(bv);
4876
4877 // Check results as part of computation.
4878 for (int j = 0; j < SPECIES.length(); j++) {
4879 Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
4880 }
4881 }
4882 }
4883 }
4884
4885 @Test(dataProvider = "intCompareOpMaskProvider")
4886 static void EQIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4887 IntFunction<boolean[]> fm) {
4888 int[] a = fa.apply(SPECIES.length());
4889 int[] b = fb.apply(SPECIES.length());
4890 boolean[] mask = fm.apply(SPECIES.length());
4891
4892 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4893
4894 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4895 for (int i = 0; i < a.length; i += SPECIES.length()) {
4896 IntVector av = IntVector.fromArray(SPECIES, a, i);
4897 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4898 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv, vmask);
4899
4900 // Check results as part of computation.
4901 for (int j = 0; j < SPECIES.length(); j++) {
4902 Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
4903 }
4904 }
4905 }
4906 }
4907
4908 @Test(dataProvider = "intCompareOpProvider")
4909 static void NEIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4910 int[] a = fa.apply(SPECIES.length());
4911 int[] b = fb.apply(SPECIES.length());
4912
4913 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4914 for (int i = 0; i < a.length; i += SPECIES.length()) {
4915 IntVector av = IntVector.fromArray(SPECIES, a, i);
4916 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4917 VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv);
4918
4919 // Check results as part of computation.
4920 for (int j = 0; j < SPECIES.length(); j++) {
4921 Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
4922 }
4923 }
4924 }
4925 }
4926
4927 @Test(dataProvider = "intCompareOpMaskProvider")
4928 static void NEIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4929 IntFunction<boolean[]> fm) {
4930 int[] a = fa.apply(SPECIES.length());
4931 int[] b = fb.apply(SPECIES.length());
4932 boolean[] mask = fm.apply(SPECIES.length());
4933
4934 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4935
4936 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4937 for (int i = 0; i < a.length; i += SPECIES.length()) {
4938 IntVector av = IntVector.fromArray(SPECIES, a, i);
4939 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4940 VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv, vmask);
4941
4942 // Check results as part of computation.
4943 for (int j = 0; j < SPECIES.length(); j++) {
4944 Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
4945 }
4946 }
4947 }
4948 }
4949
4950 @Test(dataProvider = "intCompareOpProvider")
4951 static void LEIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4952 int[] a = fa.apply(SPECIES.length());
4953 int[] b = fb.apply(SPECIES.length());
4954
4955 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4956 for (int i = 0; i < a.length; i += SPECIES.length()) {
4957 IntVector av = IntVector.fromArray(SPECIES, a, i);
4958 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4959 VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv);
4960
4961 // Check results as part of computation.
4962 for (int j = 0; j < SPECIES.length(); j++) {
4963 Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
4964 }
4965 }
4966 }
4967 }
4968
4969 @Test(dataProvider = "intCompareOpMaskProvider")
4970 static void LEIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
4971 IntFunction<boolean[]> fm) {
4972 int[] a = fa.apply(SPECIES.length());
4973 int[] b = fb.apply(SPECIES.length());
4974 boolean[] mask = fm.apply(SPECIES.length());
4975
4976 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4977
4978 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4979 for (int i = 0; i < a.length; i += SPECIES.length()) {
4980 IntVector av = IntVector.fromArray(SPECIES, a, i);
4981 IntVector bv = IntVector.fromArray(SPECIES, b, i);
4982 VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv, vmask);
4983
4984 // Check results as part of computation.
4985 for (int j = 0; j < SPECIES.length(); j++) {
4986 Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
4987 }
4988 }
4989 }
4990 }
4991
4992 @Test(dataProvider = "intCompareOpProvider")
4993 static void GEIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
4994 int[] a = fa.apply(SPECIES.length());
4995 int[] b = fb.apply(SPECIES.length());
4996
4997 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4998 for (int i = 0; i < a.length; i += SPECIES.length()) {
4999 IntVector av = IntVector.fromArray(SPECIES, a, i);
5000 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5001 VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv);
5002
5003 // Check results as part of computation.
5004 for (int j = 0; j < SPECIES.length(); j++) {
5005 Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
5006 }
5007 }
5008 }
5009 }
5010
5011 @Test(dataProvider = "intCompareOpMaskProvider")
5012 static void GEIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5013 IntFunction<boolean[]> fm) {
5014 int[] a = fa.apply(SPECIES.length());
5015 int[] b = fb.apply(SPECIES.length());
5016 boolean[] mask = fm.apply(SPECIES.length());
5017
5018 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5019
5020 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5021 for (int i = 0; i < a.length; i += SPECIES.length()) {
5022 IntVector av = IntVector.fromArray(SPECIES, a, i);
5023 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5024 VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv, vmask);
5025
5026 // Check results as part of computation.
5027 for (int j = 0; j < SPECIES.length(); j++) {
5028 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
5029 }
5030 }
5031 }
5032 }
5033
5034 @Test(dataProvider = "intCompareOpProvider")
5035 static void ULTIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5036 int[] a = fa.apply(SPECIES.length());
5037 int[] b = fb.apply(SPECIES.length());
5038
5039 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5040 for (int i = 0; i < a.length; i += SPECIES.length()) {
5041 IntVector av = IntVector.fromArray(SPECIES, a, i);
5042 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5043 VectorMask<Integer> mv = av.compare(VectorOperators.ULT, bv);
5044
5045 // Check results as part of computation.
5046 for (int j = 0; j < SPECIES.length(); j++) {
5047 Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j]));
5048 }
5049 }
5050 }
5051 }
5052
5053 @Test(dataProvider = "intCompareOpMaskProvider")
5054 static void ULTIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5055 IntFunction<boolean[]> fm) {
5056 int[] a = fa.apply(SPECIES.length());
5057 int[] b = fb.apply(SPECIES.length());
5058 boolean[] mask = fm.apply(SPECIES.length());
5059
5060 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5061
5062 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5063 for (int i = 0; i < a.length; i += SPECIES.length()) {
5064 IntVector av = IntVector.fromArray(SPECIES, a, i);
5065 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5066 VectorMask<Integer> mv = av.compare(VectorOperators.ULT, bv, vmask);
5067
5068 // Check results as part of computation.
5069 for (int j = 0; j < SPECIES.length(); j++) {
5070 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j]));
5071 }
5072 }
5073 }
5074 }
5075
5076 @Test(dataProvider = "intCompareOpProvider")
5077 static void UGTIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5078 int[] a = fa.apply(SPECIES.length());
5079 int[] b = fb.apply(SPECIES.length());
5080
5081 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5082 for (int i = 0; i < a.length; i += SPECIES.length()) {
5083 IntVector av = IntVector.fromArray(SPECIES, a, i);
5084 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5085 VectorMask<Integer> mv = av.compare(VectorOperators.UGT, bv);
5086
5087 // Check results as part of computation.
5088 for (int j = 0; j < SPECIES.length(); j++) {
5089 Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j]));
5090 }
5091 }
5092 }
5093 }
5094
5095 @Test(dataProvider = "intCompareOpMaskProvider")
5096 static void UGTIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5097 IntFunction<boolean[]> fm) {
5098 int[] a = fa.apply(SPECIES.length());
5099 int[] b = fb.apply(SPECIES.length());
5100 boolean[] mask = fm.apply(SPECIES.length());
5101
5102 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5103
5104 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5105 for (int i = 0; i < a.length; i += SPECIES.length()) {
5106 IntVector av = IntVector.fromArray(SPECIES, a, i);
5107 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5108 VectorMask<Integer> mv = av.compare(VectorOperators.UGT, bv, vmask);
5109
5110 // Check results as part of computation.
5111 for (int j = 0; j < SPECIES.length(); j++) {
5112 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j]));
5113 }
5114 }
5115 }
5116 }
5117
5118 @Test(dataProvider = "intCompareOpProvider")
5119 static void ULEIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5120 int[] a = fa.apply(SPECIES.length());
5121 int[] b = fb.apply(SPECIES.length());
5122
5123 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5124 for (int i = 0; i < a.length; i += SPECIES.length()) {
5125 IntVector av = IntVector.fromArray(SPECIES, a, i);
5126 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5127 VectorMask<Integer> mv = av.compare(VectorOperators.ULE, bv);
5128
5129 // Check results as part of computation.
5130 for (int j = 0; j < SPECIES.length(); j++) {
5131 Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j]));
5132 }
5133 }
5134 }
5135 }
5136
5137 @Test(dataProvider = "intCompareOpMaskProvider")
5138 static void ULEIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5139 IntFunction<boolean[]> fm) {
5140 int[] a = fa.apply(SPECIES.length());
5141 int[] b = fb.apply(SPECIES.length());
5142 boolean[] mask = fm.apply(SPECIES.length());
5143
5144 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5145
5146 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5147 for (int i = 0; i < a.length; i += SPECIES.length()) {
5148 IntVector av = IntVector.fromArray(SPECIES, a, i);
5149 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5150 VectorMask<Integer> mv = av.compare(VectorOperators.ULE, bv, vmask);
5151
5152 // Check results as part of computation.
5153 for (int j = 0; j < SPECIES.length(); j++) {
5154 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ule(a[i + j], b[i + j]));
5155 }
5156 }
5157 }
5158 }
5159
5160 @Test(dataProvider = "intCompareOpProvider")
5161 static void UGEIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5162 int[] a = fa.apply(SPECIES.length());
5163 int[] b = fb.apply(SPECIES.length());
5164
5165 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5166 for (int i = 0; i < a.length; i += SPECIES.length()) {
5167 IntVector av = IntVector.fromArray(SPECIES, a, i);
5168 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5169 VectorMask<Integer> mv = av.compare(VectorOperators.UGE, bv);
5170
5171 // Check results as part of computation.
5172 for (int j = 0; j < SPECIES.length(); j++) {
5173 Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j]));
5174 }
5175 }
5176 }
5177 }
5178
5179 @Test(dataProvider = "intCompareOpMaskProvider")
5180 static void UGEIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5181 IntFunction<boolean[]> fm) {
5182 int[] a = fa.apply(SPECIES.length());
5183 int[] b = fb.apply(SPECIES.length());
5184 boolean[] mask = fm.apply(SPECIES.length());
5185
5186 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5187
5188 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5189 for (int i = 0; i < a.length; i += SPECIES.length()) {
5190 IntVector av = IntVector.fromArray(SPECIES, a, i);
5191 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5192 VectorMask<Integer> mv = av.compare(VectorOperators.UGE, bv, vmask);
5193
5194 // Check results as part of computation.
5195 for (int j = 0; j < SPECIES.length(); j++) {
5196 Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j]));
5197 }
5198 }
5199 }
5200 }
5201
5202 @Test(dataProvider = "intCompareOpProvider")
5203 static void LTIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5204 int[] a = fa.apply(SPECIES.length());
5205 int[] b = fb.apply(SPECIES.length());
5206
5207 for (int i = 0; i < a.length; i += SPECIES.length()) {
5208 IntVector av = IntVector.fromArray(SPECIES, a, i);
5209 VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i]);
5210
5211 // Check results as part of computation.
5212 for (int j = 0; j < SPECIES.length(); j++) {
5213 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
5214 }
5215 }
5216 }
5217
5218 @Test(dataProvider = "intCompareOpMaskProvider")
5219 static void LTIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa,
5220 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5221 int[] a = fa.apply(SPECIES.length());
5222 int[] b = fb.apply(SPECIES.length());
5223 boolean[] mask = fm.apply(SPECIES.length());
5224
5225 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5226
5227 for (int i = 0; i < a.length; i += SPECIES.length()) {
5228 IntVector av = IntVector.fromArray(SPECIES, a, i);
5229 VectorMask<Integer> mv = av.compare(VectorOperators.LT, b[i], vmask);
5230
5231 // Check results as part of computation.
5232 for (int j = 0; j < SPECIES.length(); j++) {
5233 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
5234 }
5235 }
5236 }
5237
5238 @Test(dataProvider = "intCompareOpProvider")
5239 static void LTIntMaxVectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5240 int[] a = fa.apply(SPECIES.length());
5241 int[] b = fb.apply(SPECIES.length());
5242
5243 for (int i = 0; i < a.length; i += SPECIES.length()) {
5244 IntVector av = IntVector.fromArray(SPECIES, a, i);
5245 VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i]);
5246
5247 // Check results as part of computation.
5248 for (int j = 0; j < SPECIES.length(); j++) {
5249 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (int)((long)b[i]));
5250 }
5251 }
5252 }
5253
5254 @Test(dataProvider = "intCompareOpMaskProvider")
5255 static void LTIntMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa,
5256 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5257 int[] a = fa.apply(SPECIES.length());
5258 int[] b = fb.apply(SPECIES.length());
5259 boolean[] mask = fm.apply(SPECIES.length());
5260
5261 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5262
5263 for (int i = 0; i < a.length; i += SPECIES.length()) {
5264 IntVector av = IntVector.fromArray(SPECIES, a, i);
5265 VectorMask<Integer> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
5266
5267 // Check results as part of computation.
5268 for (int j = 0; j < SPECIES.length(); j++) {
5269 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (int)((long)b[i])));
5270 }
5271 }
5272 }
5273
5274 @Test(dataProvider = "intCompareOpProvider")
5275 static void EQIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5276 int[] a = fa.apply(SPECIES.length());
5277 int[] b = fb.apply(SPECIES.length());
5278
5279 for (int i = 0; i < a.length; i += SPECIES.length()) {
5280 IntVector av = IntVector.fromArray(SPECIES, a, i);
5281 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i]);
5282
5283 // Check results as part of computation.
5284 for (int j = 0; j < SPECIES.length(); j++) {
5285 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
5286 }
5287 }
5288 }
5289
5290 @Test(dataProvider = "intCompareOpMaskProvider")
5291 static void EQIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa,
5292 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5293 int[] a = fa.apply(SPECIES.length());
5294 int[] b = fb.apply(SPECIES.length());
5295 boolean[] mask = fm.apply(SPECIES.length());
5296
5297 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5298
5299 for (int i = 0; i < a.length; i += SPECIES.length()) {
5300 IntVector av = IntVector.fromArray(SPECIES, a, i);
5301 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, b[i], vmask);
5302
5303 // Check results as part of computation.
5304 for (int j = 0; j < SPECIES.length(); j++) {
5305 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
5306 }
5307 }
5308 }
5309
5310 @Test(dataProvider = "intCompareOpProvider")
5311 static void EQIntMaxVectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5312 int[] a = fa.apply(SPECIES.length());
5313 int[] b = fb.apply(SPECIES.length());
5314
5315 for (int i = 0; i < a.length; i += SPECIES.length()) {
5316 IntVector av = IntVector.fromArray(SPECIES, a, i);
5317 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i]);
5318
5319 // Check results as part of computation.
5320 for (int j = 0; j < SPECIES.length(); j++) {
5321 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (int)((long)b[i]));
5322 }
5323 }
5324 }
5325
5326 @Test(dataProvider = "intCompareOpMaskProvider")
5327 static void EQIntMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<int[]> fa,
5328 IntFunction<int[]> fb, IntFunction<boolean[]> fm) {
5329 int[] a = fa.apply(SPECIES.length());
5330 int[] b = fb.apply(SPECIES.length());
5331 boolean[] mask = fm.apply(SPECIES.length());
5332
5333 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5334
5335 for (int i = 0; i < a.length; i += SPECIES.length()) {
5336 IntVector av = IntVector.fromArray(SPECIES, a, i);
5337 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
5338
5339 // Check results as part of computation.
5340 for (int j = 0; j < SPECIES.length(); j++) {
5341 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (int)((long)b[i])));
5342 }
5343 }
5344 }
5345
5346 static int blend(int a, int b, boolean mask) {
5347 return mask ? b : a;
5348 }
5349
5350 @Test(dataProvider = "intBinaryOpMaskProvider")
5351 static void blendIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
5352 IntFunction<boolean[]> fm) {
5353 int[] a = fa.apply(SPECIES.length());
5354 int[] b = fb.apply(SPECIES.length());
5355 int[] r = fr.apply(SPECIES.length());
5356 boolean[] mask = fm.apply(SPECIES.length());
5357 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5358
5359 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5360 for (int i = 0; i < a.length; i += SPECIES.length()) {
5361 IntVector av = IntVector.fromArray(SPECIES, a, i);
5362 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5363 av.blend(bv, vmask).intoArray(r, i);
5364 }
5365 }
5366
5367 assertArraysEquals(r, a, b, mask, IntMaxVectorTests::blend);
5368 }
5369
5370 @Test(dataProvider = "intUnaryOpShuffleProvider")
5371 static void RearrangeIntMaxVectorTests(IntFunction<int[]> fa,
5372 BiFunction<Integer,Integer,int[]> fs) {
5373 int[] a = fa.apply(SPECIES.length());
5374 int[] order = fs.apply(a.length, SPECIES.length());
5375 int[] r = fr.apply(SPECIES.length());
5376
5377 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5378 for (int i = 0; i < a.length; i += SPECIES.length()) {
5379 IntVector av = IntVector.fromArray(SPECIES, a, i);
5380 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
5381 }
5382 }
5383
5384 assertRearrangeArraysEquals(r, a, order, SPECIES.length());
5385 }
5386
5387 @Test(dataProvider = "intUnaryOpShuffleMaskProvider")
5388 static void RearrangeIntMaxVectorTestsMaskedSmokeTest(IntFunction<int[]> fa,
5389 BiFunction<Integer,Integer,int[]> fs,
5390 IntFunction<boolean[]> fm) {
5391 int[] a = fa.apply(SPECIES.length());
5392 int[] order = fs.apply(a.length, SPECIES.length());
5393 int[] r = fr.apply(SPECIES.length());
5394 boolean[] mask = fm.apply(SPECIES.length());
5395 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5396
5397 for (int i = 0; i < a.length; i += SPECIES.length()) {
5398 IntVector av = IntVector.fromArray(SPECIES, a, i);
5399 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
5400 }
5401
5402 assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
5403 }
5404
5405 @Test(dataProvider = "intUnaryOpMaskProvider")
5406 static void compressIntMaxVectorTests(IntFunction<int[]> fa,
5407 IntFunction<boolean[]> fm) {
5408 int[] a = fa.apply(SPECIES.length());
5409 int[] r = fr.apply(SPECIES.length());
5410 boolean[] mask = fm.apply(SPECIES.length());
5411 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5412
5413 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5414 for (int i = 0; i < a.length; i += SPECIES.length()) {
5415 IntVector av = IntVector.fromArray(SPECIES, a, i);
5416 av.compress(vmask).intoArray(r, i);
5417 }
5418 }
5419
5420 assertcompressArraysEquals(r, a, mask, SPECIES.length());
5421 }
5422
5423 @Test(dataProvider = "intUnaryOpMaskProvider")
5424 static void expandIntMaxVectorTests(IntFunction<int[]> fa,
5425 IntFunction<boolean[]> fm) {
5426 int[] a = fa.apply(SPECIES.length());
5427 int[] r = fr.apply(SPECIES.length());
5428 boolean[] mask = fm.apply(SPECIES.length());
5429 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5430
5431 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5432 for (int i = 0; i < a.length; i += SPECIES.length()) {
5433 IntVector av = IntVector.fromArray(SPECIES, a, i);
5434 av.expand(vmask).intoArray(r, i);
5435 }
5436 }
5437
5438 assertexpandArraysEquals(r, a, mask, SPECIES.length());
5439 }
5440
5441 @Test(dataProvider = "intUnaryOpProvider")
5442 static void getIntMaxVectorTests(IntFunction<int[]> fa) {
5443 int[] a = fa.apply(SPECIES.length());
5444 int[] r = fr.apply(SPECIES.length());
5445
5446 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5447 for (int i = 0; i < a.length; i += SPECIES.length()) {
5448 IntVector av = IntVector.fromArray(SPECIES, a, i);
5449 int num_lanes = SPECIES.length();
5450 // Manually unroll because full unroll happens after intrinsification.
5451 // Unroll is needed because get intrinsic requires for index to be a known constant.
5452 if (num_lanes == 1) {
5453 r[i]=av.lane(0);
5454 } else if (num_lanes == 2) {
5455 r[i]=av.lane(0);
5456 r[i+1]=av.lane(1);
5457 } else if (num_lanes == 4) {
5458 r[i]=av.lane(0);
5459 r[i+1]=av.lane(1);
5460 r[i+2]=av.lane(2);
5461 r[i+3]=av.lane(3);
5462 } else if (num_lanes == 8) {
5463 r[i]=av.lane(0);
5464 r[i+1]=av.lane(1);
5465 r[i+2]=av.lane(2);
5466 r[i+3]=av.lane(3);
5467 r[i+4]=av.lane(4);
5468 r[i+5]=av.lane(5);
5469 r[i+6]=av.lane(6);
5470 r[i+7]=av.lane(7);
5471 } else if (num_lanes == 16) {
5472 r[i]=av.lane(0);
5473 r[i+1]=av.lane(1);
5474 r[i+2]=av.lane(2);
5475 r[i+3]=av.lane(3);
5476 r[i+4]=av.lane(4);
5477 r[i+5]=av.lane(5);
5478 r[i+6]=av.lane(6);
5479 r[i+7]=av.lane(7);
5480 r[i+8]=av.lane(8);
5481 r[i+9]=av.lane(9);
5482 r[i+10]=av.lane(10);
5483 r[i+11]=av.lane(11);
5484 r[i+12]=av.lane(12);
5485 r[i+13]=av.lane(13);
5486 r[i+14]=av.lane(14);
5487 r[i+15]=av.lane(15);
5488 } else if (num_lanes == 32) {
5489 r[i]=av.lane(0);
5490 r[i+1]=av.lane(1);
5491 r[i+2]=av.lane(2);
5492 r[i+3]=av.lane(3);
5493 r[i+4]=av.lane(4);
5494 r[i+5]=av.lane(5);
5495 r[i+6]=av.lane(6);
5496 r[i+7]=av.lane(7);
5497 r[i+8]=av.lane(8);
5498 r[i+9]=av.lane(9);
5499 r[i+10]=av.lane(10);
5500 r[i+11]=av.lane(11);
5501 r[i+12]=av.lane(12);
5502 r[i+13]=av.lane(13);
5503 r[i+14]=av.lane(14);
5504 r[i+15]=av.lane(15);
5505 r[i+16]=av.lane(16);
5506 r[i+17]=av.lane(17);
5507 r[i+18]=av.lane(18);
5508 r[i+19]=av.lane(19);
5509 r[i+20]=av.lane(20);
5510 r[i+21]=av.lane(21);
5511 r[i+22]=av.lane(22);
5512 r[i+23]=av.lane(23);
5513 r[i+24]=av.lane(24);
5514 r[i+25]=av.lane(25);
5515 r[i+26]=av.lane(26);
5516 r[i+27]=av.lane(27);
5517 r[i+28]=av.lane(28);
5518 r[i+29]=av.lane(29);
5519 r[i+30]=av.lane(30);
5520 r[i+31]=av.lane(31);
5521 } else if (num_lanes == 64) {
5522 r[i]=av.lane(0);
5523 r[i+1]=av.lane(1);
5524 r[i+2]=av.lane(2);
5525 r[i+3]=av.lane(3);
5526 r[i+4]=av.lane(4);
5527 r[i+5]=av.lane(5);
5528 r[i+6]=av.lane(6);
5529 r[i+7]=av.lane(7);
5530 r[i+8]=av.lane(8);
5531 r[i+9]=av.lane(9);
5532 r[i+10]=av.lane(10);
5533 r[i+11]=av.lane(11);
5534 r[i+12]=av.lane(12);
5535 r[i+13]=av.lane(13);
5536 r[i+14]=av.lane(14);
5537 r[i+15]=av.lane(15);
5538 r[i+16]=av.lane(16);
5539 r[i+17]=av.lane(17);
5540 r[i+18]=av.lane(18);
5541 r[i+19]=av.lane(19);
5542 r[i+20]=av.lane(20);
5543 r[i+21]=av.lane(21);
5544 r[i+22]=av.lane(22);
5545 r[i+23]=av.lane(23);
5546 r[i+24]=av.lane(24);
5547 r[i+25]=av.lane(25);
5548 r[i+26]=av.lane(26);
5549 r[i+27]=av.lane(27);
5550 r[i+28]=av.lane(28);
5551 r[i+29]=av.lane(29);
5552 r[i+30]=av.lane(30);
5553 r[i+31]=av.lane(31);
5554 r[i+32]=av.lane(32);
5555 r[i+33]=av.lane(33);
5556 r[i+34]=av.lane(34);
5557 r[i+35]=av.lane(35);
5558 r[i+36]=av.lane(36);
5559 r[i+37]=av.lane(37);
5560 r[i+38]=av.lane(38);
5561 r[i+39]=av.lane(39);
5562 r[i+40]=av.lane(40);
5563 r[i+41]=av.lane(41);
5564 r[i+42]=av.lane(42);
5565 r[i+43]=av.lane(43);
5566 r[i+44]=av.lane(44);
5567 r[i+45]=av.lane(45);
5568 r[i+46]=av.lane(46);
5569 r[i+47]=av.lane(47);
5570 r[i+48]=av.lane(48);
5571 r[i+49]=av.lane(49);
5572 r[i+50]=av.lane(50);
5573 r[i+51]=av.lane(51);
5574 r[i+52]=av.lane(52);
5575 r[i+53]=av.lane(53);
5576 r[i+54]=av.lane(54);
5577 r[i+55]=av.lane(55);
5578 r[i+56]=av.lane(56);
5579 r[i+57]=av.lane(57);
5580 r[i+58]=av.lane(58);
5581 r[i+59]=av.lane(59);
5582 r[i+60]=av.lane(60);
5583 r[i+61]=av.lane(61);
5584 r[i+62]=av.lane(62);
5585 r[i+63]=av.lane(63);
5586 } else {
5587 for (int j = 0; j < SPECIES.length(); j++) {
5588 r[i+j]=av.lane(j);
5589 }
5590 }
5591 }
5592 }
5593
5594 assertArraysStrictlyEquals(r, a);
5595 }
5596
5597 @Test(dataProvider = "intUnaryOpProvider")
5598 static void BroadcastIntMaxVectorTests(IntFunction<int[]> fa) {
5599 int[] a = fa.apply(SPECIES.length());
5600 int[] r = new int[a.length];
5601
5602 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5603 for (int i = 0; i < a.length; i += SPECIES.length()) {
5604 IntVector.broadcast(SPECIES, a[i]).intoArray(r, i);
5605 }
5606 }
5607
5608 assertBroadcastArraysEquals(r, a);
5609 }
5610
5611 @Test(dataProvider = "intUnaryOpProvider")
5612 static void ZeroIntMaxVectorTests(IntFunction<int[]> fa) {
5613 int[] a = fa.apply(SPECIES.length());
5614 int[] r = new int[a.length];
5615
5616 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5617 for (int i = 0; i < a.length; i += SPECIES.length()) {
5618 IntVector.zero(SPECIES).intoArray(a, i);
5619 }
5620 }
5621
5622 Assert.assertEquals(a, r);
5623 }
5624
5625 static int[] sliceUnary(int[] a, int origin, int idx) {
5626 int[] res = new int[SPECIES.length()];
5627 for (int i = 0; i < SPECIES.length(); i++){
5628 if(i+origin < SPECIES.length())
5629 res[i] = a[idx+i+origin];
5630 else
5631 res[i] = (int)0;
5632 }
5633 return res;
5634 }
5635
5636 @Test(dataProvider = "intUnaryOpProvider")
5637 static void sliceUnaryIntMaxVectorTests(IntFunction<int[]> fa) {
5638 int[] a = fa.apply(SPECIES.length());
5639 int[] r = new int[a.length];
5640 int origin = RAND.nextInt(SPECIES.length());
5641 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5642 for (int i = 0; i < a.length; i += SPECIES.length()) {
5643 IntVector av = IntVector.fromArray(SPECIES, a, i);
5644 av.slice(origin).intoArray(r, i);
5645 }
5646 }
5647
5648 assertArraysEquals(r, a, origin, IntMaxVectorTests::sliceUnary);
5649 }
5650
5651 static int[] sliceBinary(int[] a, int[] b, int origin, int idx) {
5652 int[] res = new int[SPECIES.length()];
5653 for (int i = 0, j = 0; i < SPECIES.length(); i++){
5654 if(i+origin < SPECIES.length())
5655 res[i] = a[idx+i+origin];
5656 else {
5657 res[i] = b[idx+j];
5658 j++;
5659 }
5660 }
5661 return res;
5662 }
5663
5664 @Test(dataProvider = "intBinaryOpProvider")
5665 static void sliceBinaryIntMaxVectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5666 int[] a = fa.apply(SPECIES.length());
5667 int[] b = fb.apply(SPECIES.length());
5668 int[] r = new int[a.length];
5669 int origin = RAND.nextInt(SPECIES.length());
5670 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5671 for (int i = 0; i < a.length; i += SPECIES.length()) {
5672 IntVector av = IntVector.fromArray(SPECIES, a, i);
5673 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5674 av.slice(origin, bv).intoArray(r, i);
5675 }
5676 }
5677
5678 assertArraysEquals(r, a, b, origin, IntMaxVectorTests::sliceBinary);
5679 }
5680
5681 static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) {
5682 int[] res = new int[SPECIES.length()];
5683 for (int i = 0, j = 0; i < SPECIES.length(); i++){
5684 if(i+origin < SPECIES.length())
5685 res[i] = mask[i] ? a[idx+i+origin] : (int)0;
5686 else {
5687 res[i] = mask[i] ? b[idx+j] : (int)0;
5688 j++;
5689 }
5690 }
5691 return res;
5692 }
5693
5694 @Test(dataProvider = "intBinaryOpMaskProvider")
5695 static void sliceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5696 IntFunction<boolean[]> fm) {
5697 int[] a = fa.apply(SPECIES.length());
5698 int[] b = fb.apply(SPECIES.length());
5699 boolean[] mask = fm.apply(SPECIES.length());
5700 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5701
5702 int[] r = new int[a.length];
5703 int origin = RAND.nextInt(SPECIES.length());
5704 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5705 for (int i = 0; i < a.length; i += SPECIES.length()) {
5706 IntVector av = IntVector.fromArray(SPECIES, a, i);
5707 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5708 av.slice(origin, bv, vmask).intoArray(r, i);
5709 }
5710 }
5711
5712 assertArraysEquals(r, a, b, origin, mask, IntMaxVectorTests::slice);
5713 }
5714
5715 static int[] unsliceUnary(int[] a, int origin, int idx) {
5716 int[] res = new int[SPECIES.length()];
5717 for (int i = 0, j = 0; i < SPECIES.length(); i++){
5718 if(i < origin)
5719 res[i] = (int)0;
5720 else {
5721 res[i] = a[idx+j];
5722 j++;
5723 }
5724 }
5725 return res;
5726 }
5727
5728 @Test(dataProvider = "intUnaryOpProvider")
5729 static void unsliceUnaryIntMaxVectorTests(IntFunction<int[]> fa) {
5730 int[] a = fa.apply(SPECIES.length());
5731 int[] r = new int[a.length];
5732 int origin = RAND.nextInt(SPECIES.length());
5733 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5734 for (int i = 0; i < a.length; i += SPECIES.length()) {
5735 IntVector av = IntVector.fromArray(SPECIES, a, i);
5736 av.unslice(origin).intoArray(r, i);
5737 }
5738 }
5739
5740 assertArraysEquals(r, a, origin, IntMaxVectorTests::unsliceUnary);
5741 }
5742
5743 static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) {
5744 int[] res = new int[SPECIES.length()];
5745 for (int i = 0, j = 0; i < SPECIES.length(); i++){
5746 if (part == 0) {
5747 if (i < origin)
5748 res[i] = b[idx+i];
5749 else {
5750 res[i] = a[idx+j];
5751 j++;
5752 }
5753 } else if (part == 1) {
5754 if (i < origin)
5755 res[i] = a[idx+SPECIES.length()-origin+i];
5756 else {
5757 res[i] = b[idx+origin+j];
5758 j++;
5759 }
5760 }
5761 }
5762 return res;
5763 }
5764
5765 @Test(dataProvider = "intBinaryOpProvider")
5766 static void unsliceBinaryIntMaxVectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
5767 int[] a = fa.apply(SPECIES.length());
5768 int[] b = fb.apply(SPECIES.length());
5769 int[] r = new int[a.length];
5770 int origin = RAND.nextInt(SPECIES.length());
5771 int part = RAND.nextInt(2);
5772 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5773 for (int i = 0; i < a.length; i += SPECIES.length()) {
5774 IntVector av = IntVector.fromArray(SPECIES, a, i);
5775 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5776 av.unslice(origin, bv, part).intoArray(r, i);
5777 }
5778 }
5779
5780 assertArraysEquals(r, a, b, origin, part, IntMaxVectorTests::unsliceBinary);
5781 }
5782
5783 static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) {
5784 int[] res = new int[SPECIES.length()];
5785 for (int i = 0, j = 0; i < SPECIES.length(); i++){
5786 if(i+origin < SPECIES.length())
5787 res[i] = b[idx+i+origin];
5788 else {
5789 res[i] = b[idx+j];
5790 j++;
5791 }
5792 }
5793 for (int i = 0; i < SPECIES.length(); i++){
5794 res[i] = mask[i] ? a[idx+i] : res[i];
5795 }
5796 int[] res1 = new int[SPECIES.length()];
5797 if (part == 0) {
5798 for (int i = 0, j = 0; i < SPECIES.length(); i++){
5799 if (i < origin)
5800 res1[i] = b[idx+i];
5801 else {
5802 res1[i] = res[j];
5803 j++;
5804 }
5805 }
5806 } else if (part == 1) {
5807 for (int i = 0, j = 0; i < SPECIES.length(); i++){
5808 if (i < origin)
5809 res1[i] = res[SPECIES.length()-origin+i];
5810 else {
5811 res1[i] = b[idx+origin+j];
5812 j++;
5813 }
5814 }
5815 }
5816 return res1;
5817 }
5818
5819 @Test(dataProvider = "intBinaryOpMaskProvider")
5820 static void unsliceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5821 IntFunction<boolean[]> fm) {
5822 int[] a = fa.apply(SPECIES.length());
5823 int[] b = fb.apply(SPECIES.length());
5824 boolean[] mask = fm.apply(SPECIES.length());
5825 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5826 int[] r = new int[a.length];
5827 int origin = RAND.nextInt(SPECIES.length());
5828 int part = RAND.nextInt(2);
5829 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5830 for (int i = 0; i < a.length; i += SPECIES.length()) {
5831 IntVector av = IntVector.fromArray(SPECIES, a, i);
5832 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5833 av.unslice(origin, bv, part, vmask).intoArray(r, i);
5834 }
5835 }
5836
5837 assertArraysEquals(r, a, b, origin, part, mask, IntMaxVectorTests::unslice);
5838 }
5839
5840 static int BITWISE_BLEND(int a, int b, int c) {
5841 return (int)((a&~(c))|(b&c));
5842 }
5843
5844 static int bitwiseBlend(int a, int b, int c) {
5845 return (int)((a&~(c))|(b&c));
5846 }
5847
5848 @Test(dataProvider = "intTernaryOpProvider")
5849 static void BITWISE_BLENDIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5850 int[] a = fa.apply(SPECIES.length());
5851 int[] b = fb.apply(SPECIES.length());
5852 int[] c = fc.apply(SPECIES.length());
5853 int[] r = fr.apply(SPECIES.length());
5854
5855 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5856 for (int i = 0; i < a.length; i += SPECIES.length()) {
5857 IntVector av = IntVector.fromArray(SPECIES, a, i);
5858 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5859 IntVector cv = IntVector.fromArray(SPECIES, c, i);
5860 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
5861 }
5862 }
5863
5864 assertArraysEquals(r, a, b, c, IntMaxVectorTests::BITWISE_BLEND);
5865 }
5866
5867 @Test(dataProvider = "intTernaryOpProvider")
5868 static void bitwiseBlendIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5869 int[] a = fa.apply(SPECIES.length());
5870 int[] b = fb.apply(SPECIES.length());
5871 int[] c = fc.apply(SPECIES.length());
5872 int[] r = fr.apply(SPECIES.length());
5873
5874 for (int i = 0; i < a.length; i += SPECIES.length()) {
5875 IntVector av = IntVector.fromArray(SPECIES, a, i);
5876 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5877 IntVector cv = IntVector.fromArray(SPECIES, c, i);
5878 av.bitwiseBlend(bv, cv).intoArray(r, i);
5879 }
5880
5881 assertArraysEquals(r, a, b, c, IntMaxVectorTests::bitwiseBlend);
5882 }
5883
5884 @Test(dataProvider = "intTernaryOpMaskProvider")
5885 static void BITWISE_BLENDIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
5886 IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
5887 int[] a = fa.apply(SPECIES.length());
5888 int[] b = fb.apply(SPECIES.length());
5889 int[] c = fc.apply(SPECIES.length());
5890 int[] r = fr.apply(SPECIES.length());
5891 boolean[] mask = fm.apply(SPECIES.length());
5892 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5893
5894 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5895 for (int i = 0; i < a.length; i += SPECIES.length()) {
5896 IntVector av = IntVector.fromArray(SPECIES, a, i);
5897 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5898 IntVector cv = IntVector.fromArray(SPECIES, c, i);
5899 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
5900 }
5901 }
5902
5903 assertArraysEquals(r, a, b, c, mask, IntMaxVectorTests::BITWISE_BLEND);
5904 }
5905
5906 @Test(dataProvider = "intTernaryOpProvider")
5907 static void BITWISE_BLENDIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5908 int[] a = fa.apply(SPECIES.length());
5909 int[] b = fb.apply(SPECIES.length());
5910 int[] c = fc.apply(SPECIES.length());
5911 int[] r = fr.apply(SPECIES.length());
5912
5913 for (int i = 0; i < a.length; i += SPECIES.length()) {
5914 IntVector av = IntVector.fromArray(SPECIES, a, i);
5915 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5916 av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
5917 }
5918 assertBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::BITWISE_BLEND);
5919 }
5920
5921 @Test(dataProvider = "intTernaryOpProvider")
5922 static void BITWISE_BLENDIntMaxVectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5923 int[] a = fa.apply(SPECIES.length());
5924 int[] b = fb.apply(SPECIES.length());
5925 int[] c = fc.apply(SPECIES.length());
5926 int[] r = fr.apply(SPECIES.length());
5927
5928 for (int i = 0; i < a.length; i += SPECIES.length()) {
5929 IntVector av = IntVector.fromArray(SPECIES, a, i);
5930 IntVector cv = IntVector.fromArray(SPECIES, c, i);
5931 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
5932 }
5933 assertAltBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::BITWISE_BLEND);
5934 }
5935
5936 @Test(dataProvider = "intTernaryOpProvider")
5937 static void bitwiseBlendIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5938 int[] a = fa.apply(SPECIES.length());
5939 int[] b = fb.apply(SPECIES.length());
5940 int[] c = fc.apply(SPECIES.length());
5941 int[] r = fr.apply(SPECIES.length());
5942
5943 for (int i = 0; i < a.length; i += SPECIES.length()) {
5944 IntVector av = IntVector.fromArray(SPECIES, a, i);
5945 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5946 av.bitwiseBlend(bv, c[i]).intoArray(r, i);
5947 }
5948 assertBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::bitwiseBlend);
5949 }
5950
5951 @Test(dataProvider = "intTernaryOpProvider")
5952 static void bitwiseBlendIntMaxVectorTestsAltBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
5953 int[] a = fa.apply(SPECIES.length());
5954 int[] b = fb.apply(SPECIES.length());
5955 int[] c = fc.apply(SPECIES.length());
5956 int[] r = fr.apply(SPECIES.length());
5957
5958 for (int i = 0; i < a.length; i += SPECIES.length()) {
5959 IntVector av = IntVector.fromArray(SPECIES, a, i);
5960 IntVector cv = IntVector.fromArray(SPECIES, c, i);
5961 av.bitwiseBlend(b[i], cv).intoArray(r, i);
5962 }
5963 assertAltBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::bitwiseBlend);
5964 }
5965
5966 @Test(dataProvider = "intTernaryOpMaskProvider")
5967 static void BITWISE_BLENDIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
5968 IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
5969 int[] a = fa.apply(SPECIES.length());
5970 int[] b = fb.apply(SPECIES.length());
5971 int[] c = fc.apply(SPECIES.length());
5972 int[] r = fr.apply(SPECIES.length());
5973 boolean[] mask = fm.apply(SPECIES.length());
5974 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5975
5976 for (int i = 0; i < a.length; i += SPECIES.length()) {
5977 IntVector av = IntVector.fromArray(SPECIES, a, i);
5978 IntVector bv = IntVector.fromArray(SPECIES, b, i);
5979 av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
5980 }
5981
5982 assertBroadcastArraysEquals(r, a, b, c, mask, IntMaxVectorTests::BITWISE_BLEND);
5983 }
5984
5985 @Test(dataProvider = "intTernaryOpMaskProvider")
5986 static void BITWISE_BLENDIntMaxVectorTestsAltBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
5987 IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
5988 int[] a = fa.apply(SPECIES.length());
5989 int[] b = fb.apply(SPECIES.length());
5990 int[] c = fc.apply(SPECIES.length());
5991 int[] r = fr.apply(SPECIES.length());
5992 boolean[] mask = fm.apply(SPECIES.length());
5993 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5994
5995 for (int i = 0; i < a.length; i += SPECIES.length()) {
5996 IntVector av = IntVector.fromArray(SPECIES, a, i);
5997 IntVector cv = IntVector.fromArray(SPECIES, c, i);
5998 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
5999 }
6000
6001 assertAltBroadcastArraysEquals(r, a, b, c, mask, IntMaxVectorTests::BITWISE_BLEND);
6002 }
6003
6004 @Test(dataProvider = "intTernaryOpProvider")
6005 static void BITWISE_BLENDIntMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
6006 int[] a = fa.apply(SPECIES.length());
6007 int[] b = fb.apply(SPECIES.length());
6008 int[] c = fc.apply(SPECIES.length());
6009 int[] r = fr.apply(SPECIES.length());
6010
6011 for (int i = 0; i < a.length; i += SPECIES.length()) {
6012 IntVector av = IntVector.fromArray(SPECIES, a, i);
6013 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
6014 }
6015
6016 assertDoubleBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::BITWISE_BLEND);
6017 }
6018
6019 @Test(dataProvider = "intTernaryOpProvider")
6020 static void bitwiseBlendIntMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
6021 int[] a = fa.apply(SPECIES.length());
6022 int[] b = fb.apply(SPECIES.length());
6023 int[] c = fc.apply(SPECIES.length());
6024 int[] r = fr.apply(SPECIES.length());
6025
6026 for (int i = 0; i < a.length; i += SPECIES.length()) {
6027 IntVector av = IntVector.fromArray(SPECIES, a, i);
6028 av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
6029 }
6030
6031 assertDoubleBroadcastArraysEquals(r, a, b, c, IntMaxVectorTests::bitwiseBlend);
6032 }
6033
6034 @Test(dataProvider = "intTernaryOpMaskProvider")
6035 static void BITWISE_BLENDIntMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
6036 IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
6037 int[] a = fa.apply(SPECIES.length());
6038 int[] b = fb.apply(SPECIES.length());
6039 int[] c = fc.apply(SPECIES.length());
6040 int[] r = fr.apply(SPECIES.length());
6041 boolean[] mask = fm.apply(SPECIES.length());
6042 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6043
6044 for (int i = 0; i < a.length; i += SPECIES.length()) {
6045 IntVector av = IntVector.fromArray(SPECIES, a, i);
6046 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
6047 }
6048
6049 assertDoubleBroadcastArraysEquals(r, a, b, c, mask, IntMaxVectorTests::BITWISE_BLEND);
6050 }
6051
6052 static int NEG(int a) {
6053 return (int)(-((int)a));
6054 }
6055
6056 static int neg(int a) {
6057 return (int)(-((int)a));
6058 }
6059
6060 @Test(dataProvider = "intUnaryOpProvider")
6061 static void NEGIntMaxVectorTests(IntFunction<int[]> fa) {
6062 int[] a = fa.apply(SPECIES.length());
6063 int[] r = fr.apply(SPECIES.length());
6064
6065 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6066 for (int i = 0; i < a.length; i += SPECIES.length()) {
6067 IntVector av = IntVector.fromArray(SPECIES, a, i);
6068 av.lanewise(VectorOperators.NEG).intoArray(r, i);
6069 }
6070 }
6071
6072 assertArraysEquals(r, a, IntMaxVectorTests::NEG);
6073 }
6074
6075 @Test(dataProvider = "intUnaryOpProvider")
6076 static void negIntMaxVectorTests(IntFunction<int[]> fa) {
6077 int[] a = fa.apply(SPECIES.length());
6078 int[] r = fr.apply(SPECIES.length());
6079
6080 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6081 for (int i = 0; i < a.length; i += SPECIES.length()) {
6082 IntVector av = IntVector.fromArray(SPECIES, a, i);
6083 av.neg().intoArray(r, i);
6084 }
6085 }
6086
6087 assertArraysEquals(r, a, IntMaxVectorTests::neg);
6088 }
6089
6090 @Test(dataProvider = "intUnaryOpMaskProvider")
6091 static void NEGMaskedIntMaxVectorTests(IntFunction<int[]> fa,
6092 IntFunction<boolean[]> fm) {
6093 int[] a = fa.apply(SPECIES.length());
6094 int[] r = fr.apply(SPECIES.length());
6095 boolean[] mask = fm.apply(SPECIES.length());
6096 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6097
6098 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6099 for (int i = 0; i < a.length; i += SPECIES.length()) {
6100 IntVector av = IntVector.fromArray(SPECIES, a, i);
6101 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
6102 }
6103 }
6104
6105 assertArraysEquals(r, a, mask, IntMaxVectorTests::NEG);
6106 }
6107
6108 static int ABS(int a) {
6109 return (int)(Math.abs((int)a));
6110 }
6111
6112 static int abs(int a) {
6113 return (int)(Math.abs((int)a));
6114 }
6115
6116 @Test(dataProvider = "intUnaryOpProvider")
6117 static void ABSIntMaxVectorTests(IntFunction<int[]> fa) {
6118 int[] a = fa.apply(SPECIES.length());
6119 int[] r = fr.apply(SPECIES.length());
6120
6121 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6122 for (int i = 0; i < a.length; i += SPECIES.length()) {
6123 IntVector av = IntVector.fromArray(SPECIES, a, i);
6124 av.lanewise(VectorOperators.ABS).intoArray(r, i);
6125 }
6126 }
6127
6128 assertArraysEquals(r, a, IntMaxVectorTests::ABS);
6129 }
6130
6131 @Test(dataProvider = "intUnaryOpProvider")
6132 static void absIntMaxVectorTests(IntFunction<int[]> fa) {
6133 int[] a = fa.apply(SPECIES.length());
6134 int[] r = fr.apply(SPECIES.length());
6135
6136 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6137 for (int i = 0; i < a.length; i += SPECIES.length()) {
6138 IntVector av = IntVector.fromArray(SPECIES, a, i);
6139 av.abs().intoArray(r, i);
6140 }
6141 }
6142
6143 assertArraysEquals(r, a, IntMaxVectorTests::abs);
6144 }
6145
6146 @Test(dataProvider = "intUnaryOpMaskProvider")
6147 static void ABSMaskedIntMaxVectorTests(IntFunction<int[]> fa,
6148 IntFunction<boolean[]> fm) {
6149 int[] a = fa.apply(SPECIES.length());
6150 int[] r = fr.apply(SPECIES.length());
6151 boolean[] mask = fm.apply(SPECIES.length());
6152 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6153
6154 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6155 for (int i = 0; i < a.length; i += SPECIES.length()) {
6156 IntVector av = IntVector.fromArray(SPECIES, a, i);
6157 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
6158 }
6159 }
6160
6161 assertArraysEquals(r, a, mask, IntMaxVectorTests::ABS);
6162 }
6163
6164 static int NOT(int a) {
6165 return (int)(~((int)a));
6166 }
6167
6168 static int not(int a) {
6169 return (int)(~((int)a));
6170 }
6171
6172 @Test(dataProvider = "intUnaryOpProvider")
6173 static void NOTIntMaxVectorTests(IntFunction<int[]> fa) {
6174 int[] a = fa.apply(SPECIES.length());
6175 int[] r = fr.apply(SPECIES.length());
6176
6177 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6178 for (int i = 0; i < a.length; i += SPECIES.length()) {
6179 IntVector av = IntVector.fromArray(SPECIES, a, i);
6180 av.lanewise(VectorOperators.NOT).intoArray(r, i);
6181 }
6182 }
6183
6184 assertArraysEquals(r, a, IntMaxVectorTests::NOT);
6185 }
6186
6187 @Test(dataProvider = "intUnaryOpProvider")
6188 static void notIntMaxVectorTests(IntFunction<int[]> fa) {
6189 int[] a = fa.apply(SPECIES.length());
6190 int[] r = fr.apply(SPECIES.length());
6191
6192 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6193 for (int i = 0; i < a.length; i += SPECIES.length()) {
6194 IntVector av = IntVector.fromArray(SPECIES, a, i);
6195 av.not().intoArray(r, i);
6196 }
6197 }
6198
6199 assertArraysEquals(r, a, IntMaxVectorTests::not);
6200 }
6201
6202 @Test(dataProvider = "intUnaryOpMaskProvider")
6203 static void NOTMaskedIntMaxVectorTests(IntFunction<int[]> fa,
6204 IntFunction<boolean[]> fm) {
6205 int[] a = fa.apply(SPECIES.length());
6206 int[] r = fr.apply(SPECIES.length());
6207 boolean[] mask = fm.apply(SPECIES.length());
6208 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6209
6210 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6211 for (int i = 0; i < a.length; i += SPECIES.length()) {
6212 IntVector av = IntVector.fromArray(SPECIES, a, i);
6213 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
6214 }
6215 }
6216
6217 assertArraysEquals(r, a, mask, IntMaxVectorTests::NOT);
6218 }
6219
6220 static int ZOMO(int a) {
6221 return (int)((a==0?0:-1));
6222 }
6223
6224 @Test(dataProvider = "intUnaryOpProvider")
6225 static void ZOMOIntMaxVectorTests(IntFunction<int[]> fa) {
6226 int[] a = fa.apply(SPECIES.length());
6227 int[] r = fr.apply(SPECIES.length());
6228
6229 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6230 for (int i = 0; i < a.length; i += SPECIES.length()) {
6231 IntVector av = IntVector.fromArray(SPECIES, a, i);
6232 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
6233 }
6234 }
6235
6236 assertArraysEquals(r, a, IntMaxVectorTests::ZOMO);
6237 }
6238
6239 @Test(dataProvider = "intUnaryOpMaskProvider")
6240 static void ZOMOMaskedIntMaxVectorTests(IntFunction<int[]> fa,
6241 IntFunction<boolean[]> fm) {
6242 int[] a = fa.apply(SPECIES.length());
6243 int[] r = fr.apply(SPECIES.length());
6244 boolean[] mask = fm.apply(SPECIES.length());
6245 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6246
6247 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6248 for (int i = 0; i < a.length; i += SPECIES.length()) {
6249 IntVector av = IntVector.fromArray(SPECIES, a, i);
6250 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
6251 }
6252 }
6253
6254 assertArraysEquals(r, a, mask, IntMaxVectorTests::ZOMO);
6255 }
6256
6257 static int BIT_COUNT(int a) {
6258 return (int)(Integer.bitCount(a));
6259 }
6260
6261 @Test(dataProvider = "intUnaryOpProvider")
6262 static void BIT_COUNTIntMaxVectorTests(IntFunction<int[]> fa) {
6263 int[] a = fa.apply(SPECIES.length());
6264 int[] r = fr.apply(SPECIES.length());
6265
6266 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6267 for (int i = 0; i < a.length; i += SPECIES.length()) {
6268 IntVector av = IntVector.fromArray(SPECIES, a, i);
6269 av.lanewise(VectorOperators.BIT_COUNT).intoArray(r, i);
6270 }
6271 }
6272
6273 assertArraysEquals(r, a, IntMaxVectorTests::BIT_COUNT);
6274 }
6275
6276 @Test(dataProvider = "intUnaryOpMaskProvider")
6277 static void BIT_COUNTMaskedIntMaxVectorTests(IntFunction<int[]> fa,
6278 IntFunction<boolean[]> fm) {
6279 int[] a = fa.apply(SPECIES.length());
6280 int[] r = fr.apply(SPECIES.length());
6281 boolean[] mask = fm.apply(SPECIES.length());
6282 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6283
6284 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6285 for (int i = 0; i < a.length; i += SPECIES.length()) {
6286 IntVector av = IntVector.fromArray(SPECIES, a, i);
6287 av.lanewise(VectorOperators.BIT_COUNT, vmask).intoArray(r, i);
6288 }
6289 }
6290
6291 assertArraysEquals(r, a, mask, IntMaxVectorTests::BIT_COUNT);
6292 }
6293
6294 static int TRAILING_ZEROS_COUNT(int a) {
6295 return (int)(TRAILING_ZEROS_COUNT_scalar(a));
6296 }
6297
6298 @Test(dataProvider = "intUnaryOpProvider")
6299 static void TRAILING_ZEROS_COUNTIntMaxVectorTests(IntFunction<int[]> fa) {
6300 int[] a = fa.apply(SPECIES.length());
6301 int[] r = fr.apply(SPECIES.length());
6302
6303 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6304 for (int i = 0; i < a.length; i += SPECIES.length()) {
6305 IntVector av = IntVector.fromArray(SPECIES, a, i);
6306 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT).intoArray(r, i);
6307 }
6308 }
6309
6310 assertArraysEquals(r, a, IntMaxVectorTests::TRAILING_ZEROS_COUNT);
6311 }
6312
6313 @Test(dataProvider = "intUnaryOpMaskProvider")
6314 static void TRAILING_ZEROS_COUNTMaskedIntMaxVectorTests(IntFunction<int[]> fa,
6315 IntFunction<boolean[]> fm) {
6316 int[] a = fa.apply(SPECIES.length());
6317 int[] r = fr.apply(SPECIES.length());
6318 boolean[] mask = fm.apply(SPECIES.length());
6319 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6320
6321 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6322 for (int i = 0; i < a.length; i += SPECIES.length()) {
6323 IntVector av = IntVector.fromArray(SPECIES, a, i);
6324 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT, vmask).intoArray(r, i);
6325 }
6326 }
6327
6328 assertArraysEquals(r, a, mask, IntMaxVectorTests::TRAILING_ZEROS_COUNT);
6329 }
6330
6331 static int LEADING_ZEROS_COUNT(int a) {
6332 return (int)(LEADING_ZEROS_COUNT_scalar(a));
6333 }
6334
6335 @Test(dataProvider = "intUnaryOpProvider")
6336 static void LEADING_ZEROS_COUNTIntMaxVectorTests(IntFunction<int[]> fa) {
6337 int[] a = fa.apply(SPECIES.length());
6338 int[] r = fr.apply(SPECIES.length());
6339
6340 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6341 for (int i = 0; i < a.length; i += SPECIES.length()) {
6342 IntVector av = IntVector.fromArray(SPECIES, a, i);
6343 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT).intoArray(r, i);
6344 }
6345 }
6346
6347 assertArraysEquals(r, a, IntMaxVectorTests::LEADING_ZEROS_COUNT);
6348 }
6349
6350 @Test(dataProvider = "intUnaryOpMaskProvider")
6351 static void LEADING_ZEROS_COUNTMaskedIntMaxVectorTests(IntFunction<int[]> fa,
6352 IntFunction<boolean[]> fm) {
6353 int[] a = fa.apply(SPECIES.length());
6354 int[] r = fr.apply(SPECIES.length());
6355 boolean[] mask = fm.apply(SPECIES.length());
6356 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6357
6358 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6359 for (int i = 0; i < a.length; i += SPECIES.length()) {
6360 IntVector av = IntVector.fromArray(SPECIES, a, i);
6361 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT, vmask).intoArray(r, i);
6362 }
6363 }
6364
6365 assertArraysEquals(r, a, mask, IntMaxVectorTests::LEADING_ZEROS_COUNT);
6366 }
6367
6368 static int REVERSE(int a) {
6369 return (int)(REVERSE_scalar(a));
6370 }
6371
6372 @Test(dataProvider = "intUnaryOpProvider")
6373 static void REVERSEIntMaxVectorTests(IntFunction<int[]> fa) {
6374 int[] a = fa.apply(SPECIES.length());
6375 int[] r = fr.apply(SPECIES.length());
6376
6377 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6378 for (int i = 0; i < a.length; i += SPECIES.length()) {
6379 IntVector av = IntVector.fromArray(SPECIES, a, i);
6380 av.lanewise(VectorOperators.REVERSE).intoArray(r, i);
6381 }
6382 }
6383
6384 assertArraysEquals(r, a, IntMaxVectorTests::REVERSE);
6385 }
6386
6387 @Test(dataProvider = "intUnaryOpMaskProvider")
6388 static void REVERSEMaskedIntMaxVectorTests(IntFunction<int[]> fa,
6389 IntFunction<boolean[]> fm) {
6390 int[] a = fa.apply(SPECIES.length());
6391 int[] r = fr.apply(SPECIES.length());
6392 boolean[] mask = fm.apply(SPECIES.length());
6393 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6394
6395 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6396 for (int i = 0; i < a.length; i += SPECIES.length()) {
6397 IntVector av = IntVector.fromArray(SPECIES, a, i);
6398 av.lanewise(VectorOperators.REVERSE, vmask).intoArray(r, i);
6399 }
6400 }
6401
6402 assertArraysEquals(r, a, mask, IntMaxVectorTests::REVERSE);
6403 }
6404
6405 static int REVERSE_BYTES(int a) {
6406 return (int)(Integer.reverseBytes(a));
6407 }
6408
6409 @Test(dataProvider = "intUnaryOpProvider")
6410 static void REVERSE_BYTESIntMaxVectorTests(IntFunction<int[]> fa) {
6411 int[] a = fa.apply(SPECIES.length());
6412 int[] r = fr.apply(SPECIES.length());
6413
6414 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6415 for (int i = 0; i < a.length; i += SPECIES.length()) {
6416 IntVector av = IntVector.fromArray(SPECIES, a, i);
6417 av.lanewise(VectorOperators.REVERSE_BYTES).intoArray(r, i);
6418 }
6419 }
6420
6421 assertArraysEquals(r, a, IntMaxVectorTests::REVERSE_BYTES);
6422 }
6423
6424 @Test(dataProvider = "intUnaryOpMaskProvider")
6425 static void REVERSE_BYTESMaskedIntMaxVectorTests(IntFunction<int[]> fa,
6426 IntFunction<boolean[]> fm) {
6427 int[] a = fa.apply(SPECIES.length());
6428 int[] r = fr.apply(SPECIES.length());
6429 boolean[] mask = fm.apply(SPECIES.length());
6430 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6431
6432 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6433 for (int i = 0; i < a.length; i += SPECIES.length()) {
6434 IntVector av = IntVector.fromArray(SPECIES, a, i);
6435 av.lanewise(VectorOperators.REVERSE_BYTES, vmask).intoArray(r, i);
6436 }
6437 }
6438
6439 assertArraysEquals(r, a, mask, IntMaxVectorTests::REVERSE_BYTES);
6440 }
6441
6442 @Test(dataProvider = "intCompareOpProvider")
6443 static void ltIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
6444 int[] a = fa.apply(SPECIES.length());
6445 int[] b = fb.apply(SPECIES.length());
6446
6447 for (int i = 0; i < a.length; i += SPECIES.length()) {
6448 IntVector av = IntVector.fromArray(SPECIES, a, i);
6449 VectorMask<Integer> mv = av.lt(b[i]);
6450
6451 // Check results as part of computation.
6452 for (int j = 0; j < SPECIES.length(); j++) {
6453 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
6454 }
6455 }
6456 }
6457
6458 @Test(dataProvider = "intCompareOpProvider")
6459 static void eqIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
6460 int[] a = fa.apply(SPECIES.length());
6461 int[] b = fb.apply(SPECIES.length());
6462
6463 for (int i = 0; i < a.length; i += SPECIES.length()) {
6464 IntVector av = IntVector.fromArray(SPECIES, a, i);
6465 VectorMask<Integer> mv = av.eq(b[i]);
6466
6467 // Check results as part of computation.
6468 for (int j = 0; j < SPECIES.length(); j++) {
6469 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
6470 }
6471 }
6472 }
6473
6474 @Test(dataProvider = "intUnaryOpProvider")
6475 static void toIntArrayIntMaxVectorTestsSmokeTest(IntFunction<int[]> fa) {
6476 int[] a = fa.apply(SPECIES.length());
6477
6478 for (int i = 0; i < a.length; i += SPECIES.length()) {
6479 IntVector av = IntVector.fromArray(SPECIES, a, i);
6480 int[] r = av.toIntArray();
6481 assertArraysEquals(r, a, i);
6482 }
6483 }
6484
6485 @Test(dataProvider = "intUnaryOpProvider")
6486 static void toLongArrayIntMaxVectorTestsSmokeTest(IntFunction<int[]> fa) {
6487 int[] a = fa.apply(SPECIES.length());
6488
6489 for (int i = 0; i < a.length; i += SPECIES.length()) {
6490 IntVector av = IntVector.fromArray(SPECIES, a, i);
6491 long[] r = av.toLongArray();
6492 assertArraysEquals(r, a, i);
6493 }
6494 }
6495
6496 @Test(dataProvider = "intUnaryOpProvider")
6497 static void toDoubleArrayIntMaxVectorTestsSmokeTest(IntFunction<int[]> fa) {
6498 int[] a = fa.apply(SPECIES.length());
6499
6500 for (int i = 0; i < a.length; i += SPECIES.length()) {
6501 IntVector av = IntVector.fromArray(SPECIES, a, i);
6502 double[] r = av.toDoubleArray();
6503 assertArraysEquals(r, a, i);
6504 }
6505 }
6506
6507 @Test(dataProvider = "intUnaryOpProvider")
6508 static void toStringIntMaxVectorTestsSmokeTest(IntFunction<int[]> fa) {
6509 int[] a = fa.apply(SPECIES.length());
6510
6511 for (int i = 0; i < a.length; i += SPECIES.length()) {
6512 IntVector av = IntVector.fromArray(SPECIES, a, i);
6513 String str = av.toString();
6514
6515 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6516 Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
6517 }
6518 }
6519
6520 @Test(dataProvider = "intUnaryOpProvider")
6521 static void hashCodeIntMaxVectorTestsSmokeTest(IntFunction<int[]> fa) {
6522 int[] a = fa.apply(SPECIES.length());
6523
6524 for (int i = 0; i < a.length; i += SPECIES.length()) {
6525 IntVector av = IntVector.fromArray(SPECIES, a, i);
6526 int hash = av.hashCode();
6527
6528 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6529 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6530 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6531 }
6532 }
6533
6534
6535 static long ADDReduceLong(int[] a, int idx) {
6536 int res = 0;
6537 for (int i = idx; i < (idx + SPECIES.length()); i++) {
6538 res += a[i];
6539 }
6540
6541 return (long)res;
6542 }
6543
6544 static long ADDReduceAllLong(int[] a) {
6545 long res = 0;
6546 for (int i = 0; i < a.length; i += SPECIES.length()) {
6547 res += ADDReduceLong(a, i);
6548 }
6549
6550 return res;
6551 }
6552
6553 @Test(dataProvider = "intUnaryOpProvider")
6554 static void ADDReduceLongIntMaxVectorTests(IntFunction<int[]> fa) {
6555 int[] a = fa.apply(SPECIES.length());
6556 long[] r = lfr.apply(SPECIES.length());
6557 long ra = 0;
6558
6559 for (int i = 0; i < a.length; i += SPECIES.length()) {
6560 IntVector av = IntVector.fromArray(SPECIES, a, i);
6561 r[i] = av.reduceLanesToLong(VectorOperators.ADD);
6562 }
6563
6564 ra = 0;
6565 for (int i = 0; i < a.length; i ++) {
6566 ra += r[i];
6567 }
6568
6569 assertReductionLongArraysEquals(r, ra, a,
6570 IntMaxVectorTests::ADDReduceLong, IntMaxVectorTests::ADDReduceAllLong);
6571 }
6572
6573 static long ADDReduceLongMasked(int[] a, int idx, boolean[] mask) {
6574 int res = 0;
6575 for (int i = idx; i < (idx + SPECIES.length()); i++) {
6576 if(mask[i % SPECIES.length()])
6577 res += a[i];
6578 }
6579
6580 return (long)res;
6581 }
6582
6583 static long ADDReduceAllLongMasked(int[] a, boolean[] mask) {
6584 long res = 0;
6585 for (int i = 0; i < a.length; i += SPECIES.length()) {
6586 res += ADDReduceLongMasked(a, i, mask);
6587 }
6588
6589 return res;
6590 }
6591
6592 @Test(dataProvider = "intUnaryOpMaskProvider")
6593 static void ADDReduceLongIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
6594 int[] a = fa.apply(SPECIES.length());
6595 long[] r = lfr.apply(SPECIES.length());
6596 boolean[] mask = fm.apply(SPECIES.length());
6597 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6598 long ra = 0;
6599
6600 for (int i = 0; i < a.length; i += SPECIES.length()) {
6601 IntVector av = IntVector.fromArray(SPECIES, a, i);
6602 r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
6603 }
6604
6605 ra = 0;
6606 for (int i = 0; i < a.length; i ++) {
6607 ra += r[i];
6608 }
6609
6610 assertReductionLongArraysEqualsMasked(r, ra, a, mask,
6611 IntMaxVectorTests::ADDReduceLongMasked, IntMaxVectorTests::ADDReduceAllLongMasked);
6612 }
6613
6614 @Test(dataProvider = "intUnaryOpProvider")
6615 static void BroadcastLongIntMaxVectorTestsSmokeTest(IntFunction<int[]> fa) {
6616 int[] a = fa.apply(SPECIES.length());
6617 int[] r = new int[a.length];
6618
6619 for (int i = 0; i < a.length; i += SPECIES.length()) {
6620 IntVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
6621 }
6622 assertBroadcastArraysEquals(r, a);
6623 }
6624
6625 @Test(dataProvider = "intBinaryOpMaskProvider")
6626 static void blendIntMaxVectorTestsBroadcastLongSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
6627 IntFunction<boolean[]> fm) {
6628 int[] a = fa.apply(SPECIES.length());
6629 int[] b = fb.apply(SPECIES.length());
6630 int[] r = fr.apply(SPECIES.length());
6631 boolean[] mask = fm.apply(SPECIES.length());
6632 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6633
6634 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6635 for (int i = 0; i < a.length; i += SPECIES.length()) {
6636 IntVector av = IntVector.fromArray(SPECIES, a, i);
6637 av.blend((long)b[i], vmask).intoArray(r, i);
6638 }
6639 }
6640 assertBroadcastLongArraysEquals(r, a, b, mask, IntMaxVectorTests::blend);
6641 }
6642
6643
6644 @Test(dataProvider = "intUnaryOpShuffleProvider")
6645 static void SelectFromIntMaxVectorTests(IntFunction<int[]> fa,
6646 BiFunction<Integer,Integer,int[]> fs) {
6647 int[] a = fa.apply(SPECIES.length());
6648 int[] order = fs.apply(a.length, SPECIES.length());
6649 int[] r = fr.apply(SPECIES.length());
6650
6651 for (int i = 0; i < a.length; i += SPECIES.length()) {
6652 IntVector av = IntVector.fromArray(SPECIES, a, i);
6653 IntVector bv = IntVector.fromArray(SPECIES, order, i);
6654 bv.selectFrom(av).intoArray(r, i);
6655 }
6656
6657 assertSelectFromArraysEquals(r, a, order, SPECIES.length());
6658 }
6659
6660 @Test(dataProvider = "intSelectFromTwoVectorOpProvider")
6661 static void SelectFromTwoVectorIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
6662 int[] a = fa.apply(SPECIES.length());
6663 int[] b = fb.apply(SPECIES.length());
6664 int[] idx = fc.apply(SPECIES.length());
6665 int[] r = fr.apply(SPECIES.length());
6666
6667 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6668 for (int i = 0; i < idx.length; i += SPECIES.length()) {
6669 IntVector av = IntVector.fromArray(SPECIES, a, i);
6670 IntVector bv = IntVector.fromArray(SPECIES, b, i);
6671 IntVector idxv = IntVector.fromArray(SPECIES, idx, i);
6672 idxv.selectFrom(av, bv).intoArray(r, i);
6673 }
6674 }
6675 assertSelectFromTwoVectorEquals(r, idx, a, b, SPECIES.length());
6676 }
6677
6678 @Test(dataProvider = "intUnaryOpShuffleMaskProvider")
6679 static void SelectFromIntMaxVectorTestsMaskedSmokeTest(IntFunction<int[]> fa,
6680 BiFunction<Integer,Integer,int[]> fs,
6681 IntFunction<boolean[]> fm) {
6682 int[] a = fa.apply(SPECIES.length());
6683 int[] order = fs.apply(a.length, SPECIES.length());
6684 int[] r = fr.apply(SPECIES.length());
6685 boolean[] mask = fm.apply(SPECIES.length());
6686 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
6687
6688 for (int i = 0; i < a.length; i += SPECIES.length()) {
6689 IntVector av = IntVector.fromArray(SPECIES, a, i);
6690 IntVector bv = IntVector.fromArray(SPECIES, order, i);
6691 bv.selectFrom(av, vmask).intoArray(r, i);
6692 }
6693
6694 assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
6695 }
6696
6697 @Test(dataProvider = "shuffleProvider")
6698 static void shuffleMiscellaneousIntMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
6699 int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6700
6701 for (int i = 0; i < a.length; i += SPECIES.length()) {
6702 var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
6703 int hash = shuffle.hashCode();
6704 int length = shuffle.length();
6705
6706 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6707 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6708 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6709 Assert.assertEquals(length, SPECIES.length());
6710 }
6711 }
6712
6713 @Test(dataProvider = "shuffleProvider")
6714 static void shuffleToStringIntMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
6715 int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6716
6717 for (int i = 0; i < a.length; i += SPECIES.length()) {
6718 var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
6719 String str = shuffle.toString();
6720
6721 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6722 Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
6723 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
6724 }
6725 }
6726
6727 @Test(dataProvider = "shuffleCompareOpProvider")
6728 static void shuffleEqualsIntMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
6729 int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6730 int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
6731
6732 for (int i = 0; i < a.length; i += SPECIES.length()) {
6733 var av = VectorShuffle.fromArray(SPECIES, a, i);
6734 var bv = VectorShuffle.fromArray(SPECIES, b, i);
6735 boolean eq = av.equals(bv);
6736 int to = i + SPECIES.length();
6737 Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
6738 }
6739 }
6740
6741 @Test(dataProvider = "maskCompareOpProvider")
6742 static void maskEqualsIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6743 boolean[] a = fa.apply(SPECIES.length());
6744 boolean[] b = fb.apply(SPECIES.length());
6745
6746 for (int i = 0; i < a.length; i += SPECIES.length()) {
6747 var av = SPECIES.loadMask(a, i);
6748 var bv = SPECIES.loadMask(b, i);
6749 boolean equals = av.equals(bv);
6750 int to = i + SPECIES.length();
6751 Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
6752 }
6753 }
6754
6755 static boolean band(boolean a, boolean b) {
6756 return a & b;
6757 }
6758
6759 @Test(dataProvider = "maskCompareOpProvider")
6760 static void maskAndIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6761 boolean[] a = fa.apply(SPECIES.length());
6762 boolean[] b = fb.apply(SPECIES.length());
6763 boolean[] r = new boolean[a.length];
6764
6765 for (int i = 0; i < a.length; i += SPECIES.length()) {
6766 var av = SPECIES.loadMask(a, i);
6767 var bv = SPECIES.loadMask(b, i);
6768 var cv = av.and(bv);
6769 cv.intoArray(r, i);
6770 }
6771 assertArraysEquals(r, a, b, IntMaxVectorTests::band);
6772 }
6773
6774 static boolean bor(boolean a, boolean b) {
6775 return a | b;
6776 }
6777
6778 @Test(dataProvider = "maskCompareOpProvider")
6779 static void maskOrIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6780 boolean[] a = fa.apply(SPECIES.length());
6781 boolean[] b = fb.apply(SPECIES.length());
6782 boolean[] r = new boolean[a.length];
6783
6784 for (int i = 0; i < a.length; i += SPECIES.length()) {
6785 var av = SPECIES.loadMask(a, i);
6786 var bv = SPECIES.loadMask(b, i);
6787 var cv = av.or(bv);
6788 cv.intoArray(r, i);
6789 }
6790 assertArraysEquals(r, a, b, IntMaxVectorTests::bor);
6791 }
6792
6793 static boolean bxor(boolean a, boolean b) {
6794 return a != b;
6795 }
6796
6797 @Test(dataProvider = "maskCompareOpProvider")
6798 static void maskXorIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6799 boolean[] a = fa.apply(SPECIES.length());
6800 boolean[] b = fb.apply(SPECIES.length());
6801 boolean[] r = new boolean[a.length];
6802
6803 for (int i = 0; i < a.length; i += SPECIES.length()) {
6804 var av = SPECIES.loadMask(a, i);
6805 var bv = SPECIES.loadMask(b, i);
6806 var cv = av.xor(bv);
6807 cv.intoArray(r, i);
6808 }
6809 assertArraysEquals(r, a, b, IntMaxVectorTests::bxor);
6810 }
6811
6812 static boolean bandNot(boolean a, boolean b) {
6813 return a & !b;
6814 }
6815
6816 @Test(dataProvider = "maskCompareOpProvider")
6817 static void maskAndNotIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6818 boolean[] a = fa.apply(SPECIES.length());
6819 boolean[] b = fb.apply(SPECIES.length());
6820 boolean[] r = new boolean[a.length];
6821
6822 for (int i = 0; i < a.length; i += SPECIES.length()) {
6823 var av = SPECIES.loadMask(a, i);
6824 var bv = SPECIES.loadMask(b, i);
6825 var cv = av.andNot(bv);
6826 cv.intoArray(r, i);
6827 }
6828 assertArraysEquals(r, a, b, IntMaxVectorTests::bandNot);
6829 }
6830
6831 static boolean beq(boolean a, boolean b) {
6832 return (a == b);
6833 }
6834
6835 @Test(dataProvider = "maskCompareOpProvider")
6836 static void maskEqIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
6837 boolean[] a = fa.apply(SPECIES.length());
6838 boolean[] b = fb.apply(SPECIES.length());
6839 boolean[] r = new boolean[a.length];
6840
6841 for (int i = 0; i < a.length; i += SPECIES.length()) {
6842 var av = SPECIES.loadMask(a, i);
6843 var bv = SPECIES.loadMask(b, i);
6844 var cv = av.eq(bv);
6845 cv.intoArray(r, i);
6846 }
6847 assertArraysEquals(r, a, b, IntMaxVectorTests::beq);
6848 }
6849
6850 @Test(dataProvider = "maskProvider")
6851 static void maskHashCodeIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6852 boolean[] a = fa.apply(SPECIES.length());
6853
6854 for (int i = 0; i < a.length; i += SPECIES.length()) {
6855 var vmask = SPECIES.loadMask(a, i);
6856 int hash = vmask.hashCode();
6857
6858 boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
6859 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
6860 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
6861 }
6862 }
6863
6864 static int maskTrueCount(boolean[] a, int idx) {
6865 int trueCount = 0;
6866 for (int i = idx; i < idx + SPECIES.length(); i++) {
6867 trueCount += a[i] ? 1 : 0;
6868 }
6869 return trueCount;
6870 }
6871
6872 @Test(dataProvider = "maskProvider")
6873 static void maskTrueCountIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6874 boolean[] a = fa.apply(SPECIES.length());
6875 int[] r = new int[a.length];
6876
6877 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6878 for (int i = 0; i < a.length; i += SPECIES.length()) {
6879 var vmask = SPECIES.loadMask(a, i);
6880 r[i] = vmask.trueCount();
6881 }
6882 }
6883
6884 assertMaskReductionArraysEquals(r, a, IntMaxVectorTests::maskTrueCount);
6885 }
6886
6887 static int maskLastTrue(boolean[] a, int idx) {
6888 int i = idx + SPECIES.length() - 1;
6889 for (; i >= idx; i--) {
6890 if (a[i]) {
6891 break;
6892 }
6893 }
6894 return i - idx;
6895 }
6896
6897 @Test(dataProvider = "maskProvider")
6898 static void maskLastTrueIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6899 boolean[] a = fa.apply(SPECIES.length());
6900 int[] r = new int[a.length];
6901
6902 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6903 for (int i = 0; i < a.length; i += SPECIES.length()) {
6904 var vmask = SPECIES.loadMask(a, i);
6905 r[i] = vmask.lastTrue();
6906 }
6907 }
6908
6909 assertMaskReductionArraysEquals(r, a, IntMaxVectorTests::maskLastTrue);
6910 }
6911
6912 static int maskFirstTrue(boolean[] a, int idx) {
6913 int i = idx;
6914 for (; i < idx + SPECIES.length(); i++) {
6915 if (a[i]) {
6916 break;
6917 }
6918 }
6919 return i - idx;
6920 }
6921
6922 @Test(dataProvider = "maskProvider")
6923 static void maskFirstTrueIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6924 boolean[] a = fa.apply(SPECIES.length());
6925 int[] r = new int[a.length];
6926
6927 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6928 for (int i = 0; i < a.length; i += SPECIES.length()) {
6929 var vmask = SPECIES.loadMask(a, i);
6930 r[i] = vmask.firstTrue();
6931 }
6932 }
6933
6934 assertMaskReductionArraysEquals(r, a, IntMaxVectorTests::maskFirstTrue);
6935 }
6936
6937 @Test(dataProvider = "maskProvider")
6938 static void maskCompressIntMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
6939 int trueCount = 0;
6940 boolean[] a = fa.apply(SPECIES.length());
6941
6942 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
6943 for (int i = 0; i < a.length; i += SPECIES.length()) {
6944 var vmask = SPECIES.loadMask(a, i);
6945 trueCount = vmask.trueCount();
6946 var rmask = vmask.compress();
6947 for (int j = 0; j < SPECIES.length(); j++) {
6948 Assert.assertEquals(rmask.laneIsSet(j), j < trueCount);
6949 }
6950 }
6951 }
6952 }
6953
6954
6955 @DataProvider
6956 public static Object[][] offsetProvider() {
6957 return new Object[][]{
6958 {0},
6959 {-1},
6960 {+1},
6961 {+2},
6962 {-2},
6963 };
6964 }
6965
6966 @Test(dataProvider = "offsetProvider")
6967 static void indexInRangeIntMaxVectorTestsSmokeTest(int offset) {
6968 int limit = SPECIES.length() * BUFFER_REPS;
6969 for (int i = 0; i < limit; i += SPECIES.length()) {
6970 var actualMask = SPECIES.indexInRange(i + offset, limit);
6971 var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
6972 assert(actualMask.equals(expectedMask));
6973 for (int j = 0; j < SPECIES.length(); j++) {
6974 int index = i + j + offset;
6975 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
6976 }
6977 }
6978 }
6979
6980 @Test(dataProvider = "offsetProvider")
6981 static void indexInRangeLongIntMaxVectorTestsSmokeTest(int offset) {
6982 long limit = SPECIES.length() * BUFFER_REPS;
6983 for (long i = 0; i < limit; i += SPECIES.length()) {
6984 var actualMask = SPECIES.indexInRange(i + offset, limit);
6985 var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
6986 assert(actualMask.equals(expectedMask));
6987 for (int j = 0; j < SPECIES.length(); j++) {
6988 long index = i + j + offset;
6989 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
6990 }
6991 }
6992 }
6993
6994 @DataProvider
6995 public static Object[][] lengthProvider() {
6996 return new Object[][]{
6997 {0},
6998 {1},
6999 {32},
7000 {37},
7001 {1024},
7002 {1024+1},
7003 {1024+5},
7004 };
7005 }
7006
7007 @Test(dataProvider = "lengthProvider")
7008 static void loopBoundIntMaxVectorTestsSmokeTest(int length) {
7009 int actualLoopBound = SPECIES.loopBound(length);
7010 int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
7011 Assert.assertEquals(actualLoopBound, expectedLoopBound);
7012 }
7013
7014 @Test(dataProvider = "lengthProvider")
7015 static void loopBoundLongIntMaxVectorTestsSmokeTest(int _length) {
7016 long length = _length;
7017 long actualLoopBound = SPECIES.loopBound(length);
7018 long expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
7019 Assert.assertEquals(actualLoopBound, expectedLoopBound);
7020 }
7021
7022 @Test
7023 static void ElementSizeIntMaxVectorTestsSmokeTest() {
7024 IntVector av = IntVector.zero(SPECIES);
7025 int elsize = av.elementSize();
7026 Assert.assertEquals(elsize, Integer.SIZE);
7027 }
7028
7029 @Test
7030 static void VectorShapeIntMaxVectorTestsSmokeTest() {
7031 IntVector av = IntVector.zero(SPECIES);
7032 VectorShape vsh = av.shape();
7033 assert(vsh.equals(VectorShape.S_Max_BIT));
7034 }
7035
7036 @Test
7037 static void ShapeWithLanesIntMaxVectorTestsSmokeTest() {
7038 IntVector av = IntVector.zero(SPECIES);
7039 VectorShape vsh = av.shape();
7040 VectorSpecies species = vsh.withLanes(int.class);
7041 assert(species.equals(SPECIES));
7042 }
7043
7044 @Test
7045 static void ElementTypeIntMaxVectorTestsSmokeTest() {
7046 IntVector av = IntVector.zero(SPECIES);
7047 assert(av.species().elementType() == int.class);
7048 }
7049
7050 @Test
7051 static void SpeciesElementSizeIntMaxVectorTestsSmokeTest() {
7052 IntVector av = IntVector.zero(SPECIES);
7053 assert(av.species().elementSize() == Integer.SIZE);
7054 }
7055
7056 @Test
7057 static void VectorTypeIntMaxVectorTestsSmokeTest() {
7058 IntVector av = IntVector.zero(SPECIES);
7059 assert(av.species().vectorType() == av.getClass());
7060 }
7061
7062 @Test
7063 static void WithLanesIntMaxVectorTestsSmokeTest() {
7064 IntVector av = IntVector.zero(SPECIES);
7065 VectorSpecies species = av.species().withLanes(int.class);
7066 assert(species.equals(SPECIES));
7067 }
7068
7069 @Test
7070 static void WithShapeIntMaxVectorTestsSmokeTest() {
7071 IntVector av = IntVector.zero(SPECIES);
7072 VectorShape vsh = av.shape();
7073 VectorSpecies species = av.species().withShape(vsh);
7074 assert(species.equals(SPECIES));
7075 }
7076
7077 @Test
7078 static void MaskAllTrueIntMaxVectorTestsSmokeTest() {
7079 for (int ic = 0; ic < INVOC_COUNT; ic++) {
7080 Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
7081 }
7082 }
7083 }