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