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