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