1 /*
2 * Copyright (c) 2018, 2020, 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 * @modules jdk.incubator.vector
27 * @run testng/othervm -ea -esa -Xbatch IntMaxVectorTests
28 */
29
30 // -- This file was mechanically generated: Do not edit! -- //
31
32 import jdk.incubator.vector.VectorShape;
33 import jdk.incubator.vector.VectorSpecies;
34 import jdk.incubator.vector.VectorShuffle;
35 import jdk.incubator.vector.VectorMask;
36 import jdk.incubator.vector.VectorOperators;
37 import jdk.incubator.vector.Vector;
38
39 import jdk.incubator.vector.IntVector;
40
41 import org.testng.Assert;
42 import org.testng.annotations.DataProvider;
43 import org.testng.annotations.Test;
44
45 import java.lang.Integer;
46 import java.util.List;
47 import java.util.Arrays;
48 import java.util.function.BiFunction;
49 import java.util.function.IntFunction;
50 import java.util.stream.Collectors;
51 import java.util.stream.Stream;
52
53 @Test
54 public class IntMaxVectorTests extends AbstractVectorTest {
55
56 static final VectorSpecies<Integer> SPECIES =
57 IntVector.SPECIES_MAX;
58
59 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
60
61 static VectorShape getMaxBit() {
62 return VectorShape.S_Max_BIT;
63 }
64
65 private static final int Max = 256; // juts so we can do N/Max
66
67 static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / Max);
68
69 static final int BUFFER_SIZE = Integer.getInteger("jdk.incubator.vector.test.buffer-size", BUFFER_REPS * (Max / 8));
70
71 interface FUnOp {
72 int apply(int a);
73 }
74
75 static void assertArraysEquals(int[] a, int[] r, FUnOp f) {
76 int i = 0;
77 try {
78 for (; i < a.length; i++) {
79 Assert.assertEquals(r[i], f.apply(a[i]));
80 }
81 } catch (AssertionError e) {
82 Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
83 }
84 }
85
86 interface FUnArrayOp {
87 int[] apply(int a);
88 }
89
90 static void assertArraysEquals(int[] a, int[] r, FUnArrayOp f) {
91 int i = 0;
92 try {
93 for (; i < a.length; i += SPECIES.length()) {
94 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
95 f.apply(a[i]));
96 }
97 } catch (AssertionError e) {
98 int[] ref = f.apply(a[i]);
99 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
100 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
101 + ", res: " + Arrays.toString(res)
102 + "), at index #" + i);
103 }
104 }
105
106 static void assertArraysEquals(int[] a, int[] r, boolean[] mask, FUnOp f) {
107 int i = 0;
108 try {
109 for (; i < a.length; i++) {
110 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
111 }
112 } catch (AssertionError e) {
113 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()]);
114 }
115 }
116
117 interface FReductionOp {
118 int apply(int[] a, int idx);
119 }
120
121 interface FReductionAllOp {
122 int apply(int[] a);
123 }
124
125 static void assertReductionArraysEquals(int[] a, int[] b, int c,
126 FReductionOp f, FReductionAllOp fa) {
127 int i = 0;
128 try {
129 Assert.assertEquals(c, fa.apply(a));
130 for (; i < a.length; i += SPECIES.length()) {
131 Assert.assertEquals(b[i], f.apply(a, i));
132 }
133 } catch (AssertionError e) {
134 Assert.assertEquals(c, fa.apply(a), "Final result is incorrect!");
135 Assert.assertEquals(b[i], f.apply(a, i), "at index #" + i);
136 }
137 }
138
139 interface FReductionMaskedOp {
140 int apply(int[] a, int idx, boolean[] mask);
141 }
142
143 interface FReductionAllMaskedOp {
144 int apply(int[] a, boolean[] mask);
145 }
146
147 static void assertReductionArraysEqualsMasked(int[] a, int[] b, int c, boolean[] mask,
148 FReductionMaskedOp f, FReductionAllMaskedOp fa) {
149 int i = 0;
150 try {
151 Assert.assertEquals(c, fa.apply(a, mask));
152 for (; i < a.length; i += SPECIES.length()) {
153 Assert.assertEquals(b[i], f.apply(a, i, mask));
154 }
155 } catch (AssertionError e) {
156 Assert.assertEquals(c, fa.apply(a, mask), "Final result is incorrect!");
157 Assert.assertEquals(b[i], f.apply(a, i, mask), "at index #" + i);
158 }
159 }
160
161 interface FBoolReductionOp {
162 boolean apply(boolean[] a, int idx);
163 }
164
165 static void assertReductionBoolArraysEquals(boolean[] a, boolean[] b, FBoolReductionOp f) {
166 int i = 0;
167 try {
168 for (; i < a.length; i += SPECIES.length()) {
169 Assert.assertEquals(b[i], f.apply(a, i));
170 }
171 } catch (AssertionError e) {
172 Assert.assertEquals(b[i], f.apply(a, i), "at index #" + i);
173 }
174 }
175
176 static void assertInsertArraysEquals(int[] a, int[] b, int element, int index) {
177 int i = 0;
178 try {
179 for (; i < a.length; i += 1) {
180 if(i%SPECIES.length() == index) {
181 Assert.assertEquals(b[i], element);
182 } else {
183 Assert.assertEquals(b[i], a[i]);
184 }
185 }
186 } catch (AssertionError e) {
187 if (i%SPECIES.length() == index) {
188 Assert.assertEquals(b[i], element, "at index #" + i);
189 } else {
190 Assert.assertEquals(b[i], a[i], "at index #" + i);
191 }
192 }
193 }
194
195 static void assertRearrangeArraysEquals(int[] a, int[] r, int[] order, int vector_len) {
196 int i = 0, j = 0;
197 try {
198 for (; i < a.length; i += vector_len) {
199 for (j = 0; j < vector_len; j++) {
200 Assert.assertEquals(r[i+j], a[i+order[i+j]]);
201 }
202 }
203 } catch (AssertionError e) {
204 int idx = i + j;
205 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
206 }
207 }
208
209 static void assertBroadcastArraysEquals(int[]a, int[]r) {
210 int i = 0;
211 for (; i < a.length; i += SPECIES.length()) {
212 int idx = i;
213 for (int j = idx; j < (idx + SPECIES.length()); j++)
214 a[j]=a[idx];
215 }
216
217 try {
218 for (i = 0; i < a.length; i++) {
219 Assert.assertEquals(r[i], a[i]);
220 }
221 } catch (AssertionError e) {
222 Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
223 }
224 }
225
226 interface FBinOp {
227 int apply(int a, int b);
228 }
229
230 interface FBinMaskOp {
231 int apply(int a, int b, boolean m);
232
233 static FBinMaskOp lift(FBinOp f) {
234 return (a, b, m) -> m ? f.apply(a, b) : a;
235 }
236 }
237
238 static void assertArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
239 int i = 0;
240 try {
241 for (; i < a.length; i++) {
242 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
243 }
244 } catch (AssertionError e) {
245 Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
246 }
247 }
248
249 static void assertBroadcastArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
250 int i = 0;
251 try {
252 for (; i < a.length; i++) {
253 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
254 }
255 } catch (AssertionError e) {
256 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
257 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
258 }
259 }
260
261 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
262 assertArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
263 }
264
265 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
266 int i = 0;
267 try {
268 for (; i < a.length; i++) {
269 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
270 }
271 } catch (AssertionError err) {
272 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()]);
273 }
274 }
275
276 static void assertBroadcastArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
277 assertBroadcastArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
278 }
279
280 static void assertBroadcastArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
281 int i = 0;
282 try {
283 for (; i < a.length; i++) {
284 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
285 }
286 } catch (AssertionError err) {
287 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
288 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
289 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
290 mask[i % SPECIES.length()]);
291 }
292 }
293
294 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
295 int i = 0;
296 int j = 0;
297 try {
298 for (; j < a.length; j += SPECIES.length()) {
299 for (i = 0; i < SPECIES.length(); i++) {
300 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
301 }
302 }
303 } catch (AssertionError e) {
304 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
305 }
306 }
307
308 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
309 assertShiftArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
310 }
311
312 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
313 int i = 0;
314 int j = 0;
315 try {
316 for (; j < a.length; j += SPECIES.length()) {
317 for (i = 0; i < SPECIES.length(); i++) {
318 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
319 }
320 }
321 } catch (AssertionError err) {
322 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]);
323 }
324 }
325
326 interface FTernOp {
327 int apply(int a, int b, int c);
328 }
329
330 interface FTernMaskOp {
331 int apply(int a, int b, int c, boolean m);
332
333 static FTernMaskOp lift(FTernOp f) {
334 return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
335 }
336 }
337
338 static void assertArraysEquals(int[] a, int[] b, int[] c, int[] r, FTernOp f) {
339 int i = 0;
340 try {
341 for (; i < a.length; i++) {
342 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
343 }
344 } catch (AssertionError e) {
345 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
346 }
347 }
348
349 static void assertArraysEquals(int[] a, int[] b, int[] c, int[] r, boolean[] mask, FTernOp f) {
350 assertArraysEquals(a, b, c, r, mask, FTernMaskOp.lift(f));
351 }
352
353 static void assertArraysEquals(int[] a, int[] b, int[] c, int[] r, boolean[] mask, FTernMaskOp f) {
354 int i = 0;
355 try {
356 for (; i < a.length; i++) {
357 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
358 }
359 } catch (AssertionError err) {
360 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
361 + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
362 }
363 }
364
365
366 interface FBinArrayOp {
367 int apply(int[] a, int b);
368 }
369
370 static void assertArraysEquals(int[] a, int[] r, FBinArrayOp f) {
371 int i = 0;
372 try {
373 for (; i < a.length; i++) {
374 Assert.assertEquals(r[i], f.apply(a, i));
375 }
376 } catch (AssertionError e) {
377 Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
378 }
379 }
380
381 interface FGatherScatterOp {
382 int[] apply(int[] a, int ix, int[] b, int iy);
383 }
384
385 static void assertArraysEquals(int[] a, int[] b, int[] r, FGatherScatterOp f) {
386 int i = 0;
387 try {
388 for (; i < a.length; i += SPECIES.length()) {
389 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
390 f.apply(a, i, b, i));
391 }
392 } catch (AssertionError e) {
393 int[] ref = f.apply(a, i, b, i);
394 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
395 Assert.assertEquals(res, ref,
396 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
397 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
398 + ", b: "
399 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
400 + " at index #" + i);
401 }
402 }
403
404 interface FGatherMaskedOp {
405 int[] apply(int[] a, int ix, boolean[] mask, int[] b, int iy);
406 }
407
408 interface FScatterMaskedOp {
409 int[] apply(int[] r, int[] a, int ix, boolean[] mask, int[] b, int iy);
410 }
411
412 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FGatherMaskedOp f) {
413 int i = 0;
414 try {
415 for (; i < a.length; i += SPECIES.length()) {
416 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
417 f.apply(a, i, mask, b, i));
418 }
419 } catch (AssertionError e) {
420 int[] ref = f.apply(a, i, mask, b, i);
421 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
422 Assert.assertEquals(ref, res,
423 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
424 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
425 + ", b: "
426 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
427 + ", mask: "
428 + Arrays.toString(mask)
429 + " at index #" + i);
430 }
431 }
432
433 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FScatterMaskedOp f) {
434 int i = 0;
435 try {
436 for (; i < a.length; i += SPECIES.length()) {
437 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
438 f.apply(r, a, i, mask, b, i));
439 }
440 } catch (AssertionError e) {
441 int[] ref = f.apply(r, a, i, mask, b, i);
442 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
443 Assert.assertEquals(ref, res,
444 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
445 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
446 + ", b: "
447 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
448 + ", r: "
449 + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
450 + ", mask: "
451 + Arrays.toString(mask)
452 + " at index #" + i);
453 }
454 }
455
456 interface FLaneOp {
457 int[] apply(int[] a, int origin, int idx);
458 }
459
460 static void assertArraysEquals(int[] a, int[] r, int origin, FLaneOp f) {
461 int i = 0;
462 try {
463 for (; i < a.length; i += SPECIES.length()) {
464 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
465 f.apply(a, origin, i));
466 }
467 } catch (AssertionError e) {
468 int[] ref = f.apply(a, origin, i);
469 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
470 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
471 + ", res: " + Arrays.toString(res)
472 + "), at index #" + i);
473 }
474 }
475
476 interface FLaneBop {
477 int[] apply(int[] a, int[] b, int origin, int idx);
478 }
479
480 static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, FLaneBop f) {
481 int i = 0;
482 try {
483 for (; i < a.length; i += SPECIES.length()) {
484 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
485 f.apply(a, b, origin, i));
486 }
487 } catch (AssertionError e) {
488 int[] ref = f.apply(a, b, origin, i);
489 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
490 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
491 + ", res: " + Arrays.toString(res)
492 + "), at index #" + i
493 + ", at origin #" + origin);
494 }
495 }
496
497 interface FLaneMaskedBop {
498 int[] apply(int[] a, int[] b, int origin, boolean[] mask, int idx);
499 }
500
501 static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, boolean[] mask, FLaneMaskedBop f) {
502 int i = 0;
503 try {
504 for (; i < a.length; i += SPECIES.length()) {
505 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
506 f.apply(a, b, origin, mask, i));
507 }
508 } catch (AssertionError e) {
509 int[] ref = f.apply(a, b, origin, mask, i);
510 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
511 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
512 + ", res: " + Arrays.toString(res)
513 + "), at index #" + i
514 + ", at origin #" + origin);
515 }
516 }
517
518 interface FLanePartBop {
519 int[] apply(int[] a, int[] b, int origin, int part, int idx);
520 }
521
522 static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, int part, FLanePartBop f) {
523 int i = 0;
524 try {
525 for (; i < a.length; i += SPECIES.length()) {
526 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
527 f.apply(a, b, origin, part, i));
528 }
529 } catch (AssertionError e) {
530 int[] ref = f.apply(a, b, origin, part, i);
531 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
532 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
533 + ", res: " + Arrays.toString(res)
534 + "), at index #" + i
535 + ", at origin #" + origin
536 + ", with part #" + part);
537 }
538 }
539
540 interface FLanePartMaskedBop {
541 int[] apply(int[] a, int[] b, int origin, int part, boolean[] mask, int idx);
542 }
543
544 static void assertArraysEquals(int[] a, int[] b, int[] r, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
545 int i = 0;
546 try {
547 for (; i < a.length; i += SPECIES.length()) {
548 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
549 f.apply(a, b, origin, part, mask, i));
550 }
551 } catch (AssertionError e) {
552 int[] ref = f.apply(a, b, origin, part, mask, i);
553 int[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
554 Assert.assertEquals(ref, res, "(ref: " + Arrays.toString(ref)
555 + ", res: " + Arrays.toString(res)
556 + "), at index #" + i
557 + ", at origin #" + origin
558 + ", with part #" + part);
559 }
560 }
561
562 static int bits(int e) {
563 return e;
564 }
565
566 static final List<IntFunction<int[]>> INT_GENERATORS = List.of(
567 withToString("int[-i * 5]", (int s) -> {
568 return fill(s * BUFFER_REPS,
569 i -> (int)(-i * 5));
570 }),
571 withToString("int[i * 5]", (int s) -> {
572 return fill(s * BUFFER_REPS,
573 i -> (int)(i * 5));
574 }),
575 withToString("int[i + 1]", (int s) -> {
576 return fill(s * BUFFER_REPS,
577 i -> (((int)(i + 1) == 0) ? 1 : (int)(i + 1)));
578 }),
579 withToString("int[cornerCaseValue(i)]", (int s) -> {
580 return fill(s * BUFFER_REPS,
581 i -> cornerCaseValue(i));
582 })
583 );
584
585 // Create combinations of pairs
586 // @@@ Might be sensitive to order e.g. div by 0
587 static final List<List<IntFunction<int[]>>> INT_GENERATOR_PAIRS =
588 Stream.of(INT_GENERATORS.get(0)).
589 flatMap(fa -> INT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
590 collect(Collectors.toList());
591
592 @DataProvider
593 public Object[][] boolUnaryOpProvider() {
594 return BOOL_ARRAY_GENERATORS.stream().
595 map(f -> new Object[]{f}).
596 toArray(Object[][]::new);
597 }
598
599 static final List<List<IntFunction<int[]>>> INT_GENERATOR_TRIPLES =
600 INT_GENERATOR_PAIRS.stream().
601 flatMap(pair -> INT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
602 collect(Collectors.toList());
603
604 @DataProvider
605 public Object[][] intBinaryOpProvider() {
606 return INT_GENERATOR_PAIRS.stream().map(List::toArray).
607 toArray(Object[][]::new);
608 }
609
610 @DataProvider
611 public Object[][] intIndexedOpProvider() {
612 return INT_GENERATOR_PAIRS.stream().map(List::toArray).
613 toArray(Object[][]::new);
614 }
615
616 @DataProvider
617 public Object[][] intBinaryOpMaskProvider() {
618 return BOOLEAN_MASK_GENERATORS.stream().
619 flatMap(fm -> INT_GENERATOR_PAIRS.stream().map(lfa -> {
620 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
621 })).
622 toArray(Object[][]::new);
623 }
624
625 @DataProvider
626 public Object[][] intTernaryOpProvider() {
627 return INT_GENERATOR_TRIPLES.stream().map(List::toArray).
628 toArray(Object[][]::new);
629 }
630
631 @DataProvider
632 public Object[][] intTernaryOpMaskProvider() {
633 return BOOLEAN_MASK_GENERATORS.stream().
634 flatMap(fm -> INT_GENERATOR_TRIPLES.stream().map(lfa -> {
635 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
636 })).
637 toArray(Object[][]::new);
638 }
639
640 @DataProvider
641 public Object[][] intUnaryOpProvider() {
642 return INT_GENERATORS.stream().
643 map(f -> new Object[]{f}).
644 toArray(Object[][]::new);
645 }
646
647 @DataProvider
648 public Object[][] intUnaryOpMaskProvider() {
649 return BOOLEAN_MASK_GENERATORS.stream().
650 flatMap(fm -> INT_GENERATORS.stream().map(fa -> {
651 return new Object[] {fa, fm};
652 })).
653 toArray(Object[][]::new);
654 }
655
656 @DataProvider
657 public Object[][] intUnaryOpShuffleProvider() {
658 return INT_SHUFFLE_GENERATORS.stream().
659 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
660 return new Object[] {fa, fs};
661 })).
662 toArray(Object[][]::new);
663 }
664
665 @DataProvider
666 public Object[][] intUnaryOpIndexProvider() {
667 return INT_INDEX_GENERATORS.stream().
668 flatMap(fs -> INT_GENERATORS.stream().map(fa -> {
669 return new Object[] {fa, fs};
670 })).
671 toArray(Object[][]::new);
672 }
673
674 @DataProvider
675 public Object[][] intUnaryMaskedOpIndexProvider() {
676 return BOOLEAN_MASK_GENERATORS.stream().
677 flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
678 INT_GENERATORS.stream().map(fa -> {
679 return new Object[] {fa, fm, fs};
680 }))).
681 toArray(Object[][]::new);
682 }
683
684 @DataProvider
685 public Object[][] scatterMaskedOpIndexProvider() {
686 return BOOLEAN_MASK_GENERATORS.stream().
687 flatMap(fs -> INT_INDEX_GENERATORS.stream().flatMap(fm ->
688 INT_GENERATORS.stream().flatMap(fn ->
689 INT_GENERATORS.stream().map(fa -> {
690 return new Object[] {fa, fn, fm, fs};
691 })))).
692 toArray(Object[][]::new);
693 }
694
695 static final List<IntFunction<int[]>> INT_COMPARE_GENERATORS = List.of(
696 withToString("int[i]", (int s) -> {
697 return fill(s * BUFFER_REPS,
698 i -> (int)i);
699 }),
700 withToString("int[i + 1]", (int s) -> {
701 return fill(s * BUFFER_REPS,
702 i -> (int)(i + 1));
703 }),
704 withToString("int[i - 2]", (int s) -> {
705 return fill(s * BUFFER_REPS,
706 i -> (int)(i - 2));
707 }),
708 withToString("int[zigZag(i)]", (int s) -> {
709 return fill(s * BUFFER_REPS,
710 i -> i%3 == 0 ? (int)i : (i%3 == 1 ? (int)(i + 1) : (int)(i - 2)));
711 }),
712 withToString("int[cornerCaseValue(i)]", (int s) -> {
713 return fill(s * BUFFER_REPS,
714 i -> cornerCaseValue(i));
715 })
716 );
717
718 static final List<List<IntFunction<int[]>>> INT_TEST_GENERATOR_ARGS =
719 INT_COMPARE_GENERATORS.stream().
720 map(fa -> List.of(fa)).
721 collect(Collectors.toList());
722
723 @DataProvider
724 public Object[][] intTestOpProvider() {
725 return INT_TEST_GENERATOR_ARGS.stream().map(List::toArray).
726 toArray(Object[][]::new);
727 }
728
729 static final List<List<IntFunction<int[]>>> INT_COMPARE_GENERATOR_PAIRS =
730 INT_COMPARE_GENERATORS.stream().
731 flatMap(fa -> INT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
732 collect(Collectors.toList());
733
734 @DataProvider
735 public Object[][] intCompareOpProvider() {
736 return INT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
737 toArray(Object[][]::new);
738 }
739
740 interface ToIntF {
741 int apply(int i);
742 }
743
744 static int[] fill(int s , ToIntF f) {
745 return fill(new int[s], f);
746 }
747
748 static int[] fill(int[] a, ToIntF f) {
749 for (int i = 0; i < a.length; i++) {
750 a[i] = f.apply(i);
751 }
752 return a;
753 }
754
755 static int cornerCaseValue(int i) {
756 switch(i % 5) {
757 case 0:
758 return Integer.MAX_VALUE;
759 case 1:
760 return Integer.MIN_VALUE;
761 case 2:
762 return Integer.MIN_VALUE;
763 case 3:
764 return Integer.MAX_VALUE;
765 default:
766 return (int)0;
767 }
768 }
769 static int get(int[] a, int i) {
770 return (int) a[i];
771 }
772
773 static final IntFunction<int[]> fr = (vl) -> {
774 int length = BUFFER_REPS * vl;
775 return new int[length];
776 };
777
778 static final IntFunction<boolean[]> fmr = (vl) -> {
779 int length = BUFFER_REPS * vl;
780 return new boolean[length];
781 };
782
783 static void replaceZero(int[] a, int v) {
784 for (int i = 0; i < a.length; i++) {
785 if (a[i] == 0) {
786 a[i] = v;
787 }
788 }
789 }
790
791 static void replaceZero(int[] a, boolean[] mask, int v) {
792 for (int i = 0; i < a.length; i++) {
793 if (mask[i % mask.length] && a[i] == 0) {
794 a[i] = v;
795 }
796 }
797 }
798
799 @Test
800 static void smokeTest1() {
801 IntVector three = IntVector.broadcast(SPECIES, (byte)-3);
802 IntVector three2 = (IntVector) SPECIES.broadcast(-3);
803 assert(three.eq(three2).allTrue());
804 IntVector three3 = three2.broadcast(1).broadcast(-3);
805 assert(three.eq(three3).allTrue());
806 int scale = 2;
807 Class<?> ETYPE = int.class;
808 if (ETYPE == double.class || ETYPE == long.class)
809 scale = 1000000;
810 else if (ETYPE == byte.class && SPECIES.length() >= 64)
811 scale = 1;
812 IntVector higher = three.addIndex(scale);
813 VectorMask<Integer> m = three.compare(VectorOperators.LE, higher);
814 assert(m.allTrue());
815 m = higher.min((int)-1).test(VectorOperators.IS_NEGATIVE);
816 assert(m.allTrue());
817 int max = higher.reduceLanes(VectorOperators.MAX);
818 assert(max == -3 + scale * (SPECIES.length()-1));
819 }
820
821 private static int[]
822 bothToArray(IntVector a, IntVector b) {
823 int[] r = new int[a.length() + b.length()];
824 a.intoArray(r, 0);
825 b.intoArray(r, a.length());
826 return r;
827 }
828
829 @Test
830 static void smokeTest2() {
831 // Do some zipping and shuffling.
832 IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
833 IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
834 Assert.assertEquals(io, io2);
835 IntVector a = io.add((int)1); //[1,2]
836 IntVector b = a.neg(); //[-1,-2]
837 int[] abValues = bothToArray(a,b); //[1,2,-1,-2]
838 VectorShuffle<Integer> zip0 = VectorShuffle.makeZip(SPECIES, 0);
839 VectorShuffle<Integer> zip1 = VectorShuffle.makeZip(SPECIES, 1);
840 IntVector zab0 = a.rearrange(zip0,b); //[1,-1]
841 IntVector zab1 = a.rearrange(zip1,b); //[2,-2]
842 int[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
843 // manually zip
844 int[] manual = new int[zabValues.length];
845 for (int i = 0; i < manual.length; i += 2) {
846 manual[i+0] = abValues[i/2];
847 manual[i+1] = abValues[a.length() + i/2];
848 }
849 Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
850 VectorShuffle<Integer> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
851 VectorShuffle<Integer> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
852 IntVector uab0 = zab0.rearrange(unz0,zab1);
853 IntVector uab1 = zab0.rearrange(unz1,zab1);
854 int[] abValues1 = bothToArray(uab0, uab1);
855 Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
856 }
857
858 static void iotaShuffle() {
859 IntVector io = (IntVector) SPECIES.broadcast(0).addIndex(1);
860 IntVector io2 = (IntVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
861 Assert.assertEquals(io, io2);
862 }
863
864 @Test
865 // Test all shuffle related operations.
866 static void shuffleTest() {
867 // To test backend instructions, make sure that C2 is used.
868 for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
869 iotaShuffle();
870 }
871 }
872
873 @Test
874 void viewAsIntegeralLanesTest() {
875 Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
876 Assert.assertEquals(asIntegral.species(), SPECIES);
877 }
878
879 @Test
880 void viewAsFloatingLanesTest() {
881 Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
882 VectorSpecies<?> asFloatingSpecies = asFloating.species();
883 Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType());
884 Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape());
885 Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length());
886 Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES);
887 }
888
889 @Test
890 // Test div by 0.
891 static void bitwiseDivByZeroSmokeTest() {
892 try {
893 IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
894 IntVector b = (IntVector) SPECIES.broadcast(0);
895 a.div(b);
896 Assert.fail();
897 } catch (ArithmeticException e) {
898 }
899
900 try {
901 IntVector a = (IntVector) SPECIES.broadcast(0).addIndex(1);
902 IntVector b = (IntVector) SPECIES.broadcast(0);
903 VectorMask<Integer> m = a.lt((int) 1);
904 a.div(b, m);
905 Assert.fail();
906 } catch (ArithmeticException e) {
907 }
908 }
909 static int ADD(int a, int b) {
910 return (int)(a + b);
911 }
912
913 @Test(dataProvider = "intBinaryOpProvider")
914 static void ADDIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
915 int[] a = fa.apply(SPECIES.length());
916 int[] b = fb.apply(SPECIES.length());
917 int[] r = fr.apply(SPECIES.length());
918
919 for (int ic = 0; ic < INVOC_COUNT; ic++) {
920 for (int i = 0; i < a.length; i += SPECIES.length()) {
921 IntVector av = IntVector.fromArray(SPECIES, a, i);
922 IntVector bv = IntVector.fromArray(SPECIES, b, i);
923 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
924 }
925 }
926
927 assertArraysEquals(a, b, r, IntMaxVectorTests::ADD);
928 }
929 static int add(int a, int b) {
930 return (int)(a + b);
931 }
932
933 @Test(dataProvider = "intBinaryOpProvider")
934 static void addIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
935 int[] a = fa.apply(SPECIES.length());
936 int[] b = fb.apply(SPECIES.length());
937 int[] r = fr.apply(SPECIES.length());
938
939 for (int ic = 0; ic < INVOC_COUNT; ic++) {
940 for (int i = 0; i < a.length; i += SPECIES.length()) {
941 IntVector av = IntVector.fromArray(SPECIES, a, i);
942 IntVector bv = IntVector.fromArray(SPECIES, b, i);
943 av.add(bv).intoArray(r, i);
944 }
945 }
946
947 assertArraysEquals(a, b, r, IntMaxVectorTests::add);
948 }
949
950 @Test(dataProvider = "intBinaryOpMaskProvider")
951 static void ADDIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
952 IntFunction<boolean[]> fm) {
953 int[] a = fa.apply(SPECIES.length());
954 int[] b = fb.apply(SPECIES.length());
955 int[] r = fr.apply(SPECIES.length());
956 boolean[] mask = fm.apply(SPECIES.length());
957 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
958
959 for (int ic = 0; ic < INVOC_COUNT; ic++) {
960 for (int i = 0; i < a.length; i += SPECIES.length()) {
961 IntVector av = IntVector.fromArray(SPECIES, a, i);
962 IntVector bv = IntVector.fromArray(SPECIES, b, i);
963 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
964 }
965 }
966
967 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::ADD);
968 }
969
970 @Test(dataProvider = "intBinaryOpMaskProvider")
971 static void addIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
972 IntFunction<boolean[]> fm) {
973 int[] a = fa.apply(SPECIES.length());
974 int[] b = fb.apply(SPECIES.length());
975 int[] r = fr.apply(SPECIES.length());
976 boolean[] mask = fm.apply(SPECIES.length());
977 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
978
979 for (int ic = 0; ic < INVOC_COUNT; ic++) {
980 for (int i = 0; i < a.length; i += SPECIES.length()) {
981 IntVector av = IntVector.fromArray(SPECIES, a, i);
982 IntVector bv = IntVector.fromArray(SPECIES, b, i);
983 av.add(bv, vmask).intoArray(r, i);
984 }
985 }
986
987 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::add);
988 }
989 static int SUB(int a, int b) {
990 return (int)(a - b);
991 }
992
993 @Test(dataProvider = "intBinaryOpProvider")
994 static void SUBIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
995 int[] a = fa.apply(SPECIES.length());
996 int[] b = fb.apply(SPECIES.length());
997 int[] r = fr.apply(SPECIES.length());
998
999 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1000 for (int i = 0; i < a.length; i += SPECIES.length()) {
1001 IntVector av = IntVector.fromArray(SPECIES, a, i);
1002 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1003 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1004 }
1005 }
1006
1007 assertArraysEquals(a, b, r, IntMaxVectorTests::SUB);
1008 }
1009 static int sub(int a, int b) {
1010 return (int)(a - b);
1011 }
1012
1013 @Test(dataProvider = "intBinaryOpProvider")
1014 static void subIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1015 int[] a = fa.apply(SPECIES.length());
1016 int[] b = fb.apply(SPECIES.length());
1017 int[] r = fr.apply(SPECIES.length());
1018
1019 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1020 for (int i = 0; i < a.length; i += SPECIES.length()) {
1021 IntVector av = IntVector.fromArray(SPECIES, a, i);
1022 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1023 av.sub(bv).intoArray(r, i);
1024 }
1025 }
1026
1027 assertArraysEquals(a, b, r, IntMaxVectorTests::sub);
1028 }
1029
1030 @Test(dataProvider = "intBinaryOpMaskProvider")
1031 static void SUBIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1032 IntFunction<boolean[]> fm) {
1033 int[] a = fa.apply(SPECIES.length());
1034 int[] b = fb.apply(SPECIES.length());
1035 int[] r = fr.apply(SPECIES.length());
1036 boolean[] mask = fm.apply(SPECIES.length());
1037 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1038
1039 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1040 for (int i = 0; i < a.length; i += SPECIES.length()) {
1041 IntVector av = IntVector.fromArray(SPECIES, a, i);
1042 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1043 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1044 }
1045 }
1046
1047 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::SUB);
1048 }
1049
1050 @Test(dataProvider = "intBinaryOpMaskProvider")
1051 static void subIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1052 IntFunction<boolean[]> fm) {
1053 int[] a = fa.apply(SPECIES.length());
1054 int[] b = fb.apply(SPECIES.length());
1055 int[] r = fr.apply(SPECIES.length());
1056 boolean[] mask = fm.apply(SPECIES.length());
1057 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1058
1059 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1060 for (int i = 0; i < a.length; i += SPECIES.length()) {
1061 IntVector av = IntVector.fromArray(SPECIES, a, i);
1062 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1063 av.sub(bv, vmask).intoArray(r, i);
1064 }
1065 }
1066
1067 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::sub);
1068 }
1069 static int MUL(int a, int b) {
1070 return (int)(a * b);
1071 }
1072
1073 @Test(dataProvider = "intBinaryOpProvider")
1074 static void MULIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1075 int[] a = fa.apply(SPECIES.length());
1076 int[] b = fb.apply(SPECIES.length());
1077 int[] r = fr.apply(SPECIES.length());
1078
1079 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1080 for (int i = 0; i < a.length; i += SPECIES.length()) {
1081 IntVector av = IntVector.fromArray(SPECIES, a, i);
1082 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1083 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1084 }
1085 }
1086
1087 assertArraysEquals(a, b, r, IntMaxVectorTests::MUL);
1088 }
1089 static int mul(int a, int b) {
1090 return (int)(a * b);
1091 }
1092
1093 @Test(dataProvider = "intBinaryOpProvider")
1094 static void mulIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1095 int[] a = fa.apply(SPECIES.length());
1096 int[] b = fb.apply(SPECIES.length());
1097 int[] r = fr.apply(SPECIES.length());
1098
1099 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1100 for (int i = 0; i < a.length; i += SPECIES.length()) {
1101 IntVector av = IntVector.fromArray(SPECIES, a, i);
1102 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1103 av.mul(bv).intoArray(r, i);
1104 }
1105 }
1106
1107 assertArraysEquals(a, b, r, IntMaxVectorTests::mul);
1108 }
1109
1110 @Test(dataProvider = "intBinaryOpMaskProvider")
1111 static void MULIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1112 IntFunction<boolean[]> fm) {
1113 int[] a = fa.apply(SPECIES.length());
1114 int[] b = fb.apply(SPECIES.length());
1115 int[] r = fr.apply(SPECIES.length());
1116 boolean[] mask = fm.apply(SPECIES.length());
1117 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1118
1119 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1120 for (int i = 0; i < a.length; i += SPECIES.length()) {
1121 IntVector av = IntVector.fromArray(SPECIES, a, i);
1122 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1123 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1124 }
1125 }
1126
1127 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::MUL);
1128 }
1129
1130 @Test(dataProvider = "intBinaryOpMaskProvider")
1131 static void mulIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1132 IntFunction<boolean[]> fm) {
1133 int[] a = fa.apply(SPECIES.length());
1134 int[] b = fb.apply(SPECIES.length());
1135 int[] r = fr.apply(SPECIES.length());
1136 boolean[] mask = fm.apply(SPECIES.length());
1137 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1138
1139 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1140 for (int i = 0; i < a.length; i += SPECIES.length()) {
1141 IntVector av = IntVector.fromArray(SPECIES, a, i);
1142 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1143 av.mul(bv, vmask).intoArray(r, i);
1144 }
1145 }
1146
1147 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::mul);
1148 }
1149
1150
1151
1152 static int DIV(int a, int b) {
1153 return (int)(a / b);
1154 }
1155
1156 @Test(dataProvider = "intBinaryOpProvider")
1157 static void DIVIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1158 int[] a = fa.apply(SPECIES.length());
1159 int[] b = fb.apply(SPECIES.length());
1160 int[] r = fr.apply(SPECIES.length());
1161
1162 replaceZero(b, (int) 1);
1163
1164 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1165 for (int i = 0; i < a.length; i += SPECIES.length()) {
1166 IntVector av = IntVector.fromArray(SPECIES, a, i);
1167 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1168 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1169 }
1170 }
1171
1172 assertArraysEquals(a, b, r, IntMaxVectorTests::DIV);
1173 }
1174 static int div(int a, int b) {
1175 return (int)(a / b);
1176 }
1177
1178 @Test(dataProvider = "intBinaryOpProvider")
1179 static void divIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1180 int[] a = fa.apply(SPECIES.length());
1181 int[] b = fb.apply(SPECIES.length());
1182 int[] r = fr.apply(SPECIES.length());
1183
1184 replaceZero(b, (int) 1);
1185
1186 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1187 for (int i = 0; i < a.length; i += SPECIES.length()) {
1188 IntVector av = IntVector.fromArray(SPECIES, a, i);
1189 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1190 av.div(bv).intoArray(r, i);
1191 }
1192 }
1193
1194 assertArraysEquals(a, b, r, IntMaxVectorTests::div);
1195 }
1196
1197
1198
1199 @Test(dataProvider = "intBinaryOpMaskProvider")
1200 static void DIVIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1201 IntFunction<boolean[]> fm) {
1202 int[] a = fa.apply(SPECIES.length());
1203 int[] b = fb.apply(SPECIES.length());
1204 int[] r = fr.apply(SPECIES.length());
1205 boolean[] mask = fm.apply(SPECIES.length());
1206 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1207
1208 replaceZero(b, mask, (int) 1);
1209
1210 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1211 for (int i = 0; i < a.length; i += SPECIES.length()) {
1212 IntVector av = IntVector.fromArray(SPECIES, a, i);
1213 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1214 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1215 }
1216 }
1217
1218 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::DIV);
1219 }
1220
1221 @Test(dataProvider = "intBinaryOpMaskProvider")
1222 static void divIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1223 IntFunction<boolean[]> fm) {
1224 int[] a = fa.apply(SPECIES.length());
1225 int[] b = fb.apply(SPECIES.length());
1226 int[] r = fr.apply(SPECIES.length());
1227 boolean[] mask = fm.apply(SPECIES.length());
1228 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1229
1230 replaceZero(b, mask, (int) 1);
1231
1232 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1233 for (int i = 0; i < a.length; i += SPECIES.length()) {
1234 IntVector av = IntVector.fromArray(SPECIES, a, i);
1235 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1236 av.div(bv, vmask).intoArray(r, i);
1237 }
1238 }
1239
1240 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::div);
1241 }
1242
1243 static int FIRST_NONZERO(int a, int b) {
1244 return (int)((a)!=0?a:b);
1245 }
1246
1247 @Test(dataProvider = "intBinaryOpProvider")
1248 static void FIRST_NONZEROIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1249 int[] a = fa.apply(SPECIES.length());
1250 int[] b = fb.apply(SPECIES.length());
1251 int[] r = fr.apply(SPECIES.length());
1252
1253 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1254 for (int i = 0; i < a.length; i += SPECIES.length()) {
1255 IntVector av = IntVector.fromArray(SPECIES, a, i);
1256 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1257 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1258 }
1259 }
1260
1261 assertArraysEquals(a, b, r, IntMaxVectorTests::FIRST_NONZERO);
1262 }
1263
1264 @Test(dataProvider = "intBinaryOpMaskProvider")
1265 static void FIRST_NONZEROIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1266 IntFunction<boolean[]> fm) {
1267 int[] a = fa.apply(SPECIES.length());
1268 int[] b = fb.apply(SPECIES.length());
1269 int[] r = fr.apply(SPECIES.length());
1270 boolean[] mask = fm.apply(SPECIES.length());
1271 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1272
1273 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1274 for (int i = 0; i < a.length; i += SPECIES.length()) {
1275 IntVector av = IntVector.fromArray(SPECIES, a, i);
1276 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1277 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1278 }
1279 }
1280
1281 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::FIRST_NONZERO);
1282 }
1283
1284 static int AND(int a, int b) {
1285 return (int)(a & b);
1286 }
1287
1288 @Test(dataProvider = "intBinaryOpProvider")
1289 static void ANDIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1290 int[] a = fa.apply(SPECIES.length());
1291 int[] b = fb.apply(SPECIES.length());
1292 int[] r = fr.apply(SPECIES.length());
1293
1294 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1295 for (int i = 0; i < a.length; i += SPECIES.length()) {
1296 IntVector av = IntVector.fromArray(SPECIES, a, i);
1297 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1298 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1299 }
1300 }
1301
1302 assertArraysEquals(a, b, r, IntMaxVectorTests::AND);
1303 }
1304 static int and(int a, int b) {
1305 return (int)(a & b);
1306 }
1307
1308 @Test(dataProvider = "intBinaryOpProvider")
1309 static void andIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1310 int[] a = fa.apply(SPECIES.length());
1311 int[] b = fb.apply(SPECIES.length());
1312 int[] r = fr.apply(SPECIES.length());
1313
1314 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1315 for (int i = 0; i < a.length; i += SPECIES.length()) {
1316 IntVector av = IntVector.fromArray(SPECIES, a, i);
1317 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1318 av.and(bv).intoArray(r, i);
1319 }
1320 }
1321
1322 assertArraysEquals(a, b, r, IntMaxVectorTests::and);
1323 }
1324
1325
1326
1327 @Test(dataProvider = "intBinaryOpMaskProvider")
1328 static void ANDIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1329 IntFunction<boolean[]> fm) {
1330 int[] a = fa.apply(SPECIES.length());
1331 int[] b = fb.apply(SPECIES.length());
1332 int[] r = fr.apply(SPECIES.length());
1333 boolean[] mask = fm.apply(SPECIES.length());
1334 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1335
1336 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1337 for (int i = 0; i < a.length; i += SPECIES.length()) {
1338 IntVector av = IntVector.fromArray(SPECIES, a, i);
1339 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1340 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1341 }
1342 }
1343
1344 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::AND);
1345 }
1346
1347
1348 static int AND_NOT(int a, int b) {
1349 return (int)(a & ~b);
1350 }
1351
1352 @Test(dataProvider = "intBinaryOpProvider")
1353 static void AND_NOTIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1354 int[] a = fa.apply(SPECIES.length());
1355 int[] b = fb.apply(SPECIES.length());
1356 int[] r = fr.apply(SPECIES.length());
1357
1358 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1359 for (int i = 0; i < a.length; i += SPECIES.length()) {
1360 IntVector av = IntVector.fromArray(SPECIES, a, i);
1361 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1362 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
1363 }
1364 }
1365
1366 assertArraysEquals(a, b, r, IntMaxVectorTests::AND_NOT);
1367 }
1368
1369
1370
1371 @Test(dataProvider = "intBinaryOpMaskProvider")
1372 static void AND_NOTIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1373 IntFunction<boolean[]> fm) {
1374 int[] a = fa.apply(SPECIES.length());
1375 int[] b = fb.apply(SPECIES.length());
1376 int[] r = fr.apply(SPECIES.length());
1377 boolean[] mask = fm.apply(SPECIES.length());
1378 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1379
1380 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1381 for (int i = 0; i < a.length; i += SPECIES.length()) {
1382 IntVector av = IntVector.fromArray(SPECIES, a, i);
1383 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1384 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
1385 }
1386 }
1387
1388 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::AND_NOT);
1389 }
1390
1391
1392 static int OR(int a, int b) {
1393 return (int)(a | b);
1394 }
1395
1396 @Test(dataProvider = "intBinaryOpProvider")
1397 static void ORIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1398 int[] a = fa.apply(SPECIES.length());
1399 int[] b = fb.apply(SPECIES.length());
1400 int[] r = fr.apply(SPECIES.length());
1401
1402 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1403 for (int i = 0; i < a.length; i += SPECIES.length()) {
1404 IntVector av = IntVector.fromArray(SPECIES, a, i);
1405 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1406 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
1407 }
1408 }
1409
1410 assertArraysEquals(a, b, r, IntMaxVectorTests::OR);
1411 }
1412 static int or(int a, int b) {
1413 return (int)(a | b);
1414 }
1415
1416 @Test(dataProvider = "intBinaryOpProvider")
1417 static void orIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1418 int[] a = fa.apply(SPECIES.length());
1419 int[] b = fb.apply(SPECIES.length());
1420 int[] r = fr.apply(SPECIES.length());
1421
1422 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1423 for (int i = 0; i < a.length; i += SPECIES.length()) {
1424 IntVector av = IntVector.fromArray(SPECIES, a, i);
1425 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1426 av.or(bv).intoArray(r, i);
1427 }
1428 }
1429
1430 assertArraysEquals(a, b, r, IntMaxVectorTests::or);
1431 }
1432
1433
1434
1435 @Test(dataProvider = "intBinaryOpMaskProvider")
1436 static void ORIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1437 IntFunction<boolean[]> fm) {
1438 int[] a = fa.apply(SPECIES.length());
1439 int[] b = fb.apply(SPECIES.length());
1440 int[] r = fr.apply(SPECIES.length());
1441 boolean[] mask = fm.apply(SPECIES.length());
1442 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1443
1444 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1445 for (int i = 0; i < a.length; i += SPECIES.length()) {
1446 IntVector av = IntVector.fromArray(SPECIES, a, i);
1447 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1448 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
1449 }
1450 }
1451
1452 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::OR);
1453 }
1454
1455
1456 static int XOR(int a, int b) {
1457 return (int)(a ^ b);
1458 }
1459
1460 @Test(dataProvider = "intBinaryOpProvider")
1461 static void XORIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1462 int[] a = fa.apply(SPECIES.length());
1463 int[] b = fb.apply(SPECIES.length());
1464 int[] r = fr.apply(SPECIES.length());
1465
1466 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1467 for (int i = 0; i < a.length; i += SPECIES.length()) {
1468 IntVector av = IntVector.fromArray(SPECIES, a, i);
1469 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1470 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
1471 }
1472 }
1473
1474 assertArraysEquals(a, b, r, IntMaxVectorTests::XOR);
1475 }
1476
1477
1478
1479 @Test(dataProvider = "intBinaryOpMaskProvider")
1480 static void XORIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1481 IntFunction<boolean[]> fm) {
1482 int[] a = fa.apply(SPECIES.length());
1483 int[] b = fb.apply(SPECIES.length());
1484 int[] r = fr.apply(SPECIES.length());
1485 boolean[] mask = fm.apply(SPECIES.length());
1486 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1487
1488 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1489 for (int i = 0; i < a.length; i += SPECIES.length()) {
1490 IntVector av = IntVector.fromArray(SPECIES, a, i);
1491 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1492 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
1493 }
1494 }
1495
1496 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::XOR);
1497 }
1498
1499
1500 @Test(dataProvider = "intBinaryOpProvider")
1501 static void addIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1502 int[] a = fa.apply(SPECIES.length());
1503 int[] b = fb.apply(SPECIES.length());
1504 int[] r = fr.apply(SPECIES.length());
1505
1506 for (int i = 0; i < a.length; i += SPECIES.length()) {
1507 IntVector av = IntVector.fromArray(SPECIES, a, i);
1508 av.add(b[i]).intoArray(r, i);
1509 }
1510
1511 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::add);
1512 }
1513
1514 @Test(dataProvider = "intBinaryOpMaskProvider")
1515 static void addIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1516 IntFunction<boolean[]> fm) {
1517 int[] a = fa.apply(SPECIES.length());
1518 int[] b = fb.apply(SPECIES.length());
1519 int[] r = fr.apply(SPECIES.length());
1520 boolean[] mask = fm.apply(SPECIES.length());
1521 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1522
1523 for (int i = 0; i < a.length; i += SPECIES.length()) {
1524 IntVector av = IntVector.fromArray(SPECIES, a, i);
1525 av.add(b[i], vmask).intoArray(r, i);
1526 }
1527
1528 assertBroadcastArraysEquals(a, b, r, mask, IntMaxVectorTests::add);
1529 }
1530
1531 @Test(dataProvider = "intBinaryOpProvider")
1532 static void subIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1533 int[] a = fa.apply(SPECIES.length());
1534 int[] b = fb.apply(SPECIES.length());
1535 int[] r = fr.apply(SPECIES.length());
1536
1537 for (int i = 0; i < a.length; i += SPECIES.length()) {
1538 IntVector av = IntVector.fromArray(SPECIES, a, i);
1539 av.sub(b[i]).intoArray(r, i);
1540 }
1541
1542 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::sub);
1543 }
1544
1545 @Test(dataProvider = "intBinaryOpMaskProvider")
1546 static void subIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1547 IntFunction<boolean[]> fm) {
1548 int[] a = fa.apply(SPECIES.length());
1549 int[] b = fb.apply(SPECIES.length());
1550 int[] r = fr.apply(SPECIES.length());
1551 boolean[] mask = fm.apply(SPECIES.length());
1552 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1553
1554 for (int i = 0; i < a.length; i += SPECIES.length()) {
1555 IntVector av = IntVector.fromArray(SPECIES, a, i);
1556 av.sub(b[i], vmask).intoArray(r, i);
1557 }
1558
1559 assertBroadcastArraysEquals(a, b, r, mask, IntMaxVectorTests::sub);
1560 }
1561
1562 @Test(dataProvider = "intBinaryOpProvider")
1563 static void mulIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1564 int[] a = fa.apply(SPECIES.length());
1565 int[] b = fb.apply(SPECIES.length());
1566 int[] r = fr.apply(SPECIES.length());
1567
1568 for (int i = 0; i < a.length; i += SPECIES.length()) {
1569 IntVector av = IntVector.fromArray(SPECIES, a, i);
1570 av.mul(b[i]).intoArray(r, i);
1571 }
1572
1573 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::mul);
1574 }
1575
1576 @Test(dataProvider = "intBinaryOpMaskProvider")
1577 static void mulIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1578 IntFunction<boolean[]> fm) {
1579 int[] a = fa.apply(SPECIES.length());
1580 int[] b = fb.apply(SPECIES.length());
1581 int[] r = fr.apply(SPECIES.length());
1582 boolean[] mask = fm.apply(SPECIES.length());
1583 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1584
1585 for (int i = 0; i < a.length; i += SPECIES.length()) {
1586 IntVector av = IntVector.fromArray(SPECIES, a, i);
1587 av.mul(b[i], vmask).intoArray(r, i);
1588 }
1589
1590 assertBroadcastArraysEquals(a, b, r, mask, IntMaxVectorTests::mul);
1591 }
1592
1593
1594
1595
1596 @Test(dataProvider = "intBinaryOpProvider")
1597 static void divIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1598 int[] a = fa.apply(SPECIES.length());
1599 int[] b = fb.apply(SPECIES.length());
1600 int[] r = fr.apply(SPECIES.length());
1601
1602 replaceZero(b, (int) 1);
1603
1604 for (int i = 0; i < a.length; i += SPECIES.length()) {
1605 IntVector av = IntVector.fromArray(SPECIES, a, i);
1606 av.div(b[i]).intoArray(r, i);
1607 }
1608
1609 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::div);
1610 }
1611
1612
1613
1614 @Test(dataProvider = "intBinaryOpMaskProvider")
1615 static void divIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1616 IntFunction<boolean[]> fm) {
1617 int[] a = fa.apply(SPECIES.length());
1618 int[] b = fb.apply(SPECIES.length());
1619 int[] r = fr.apply(SPECIES.length());
1620 boolean[] mask = fm.apply(SPECIES.length());
1621 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1622
1623 replaceZero(b, (int) 1);
1624
1625 for (int i = 0; i < a.length; i += SPECIES.length()) {
1626 IntVector av = IntVector.fromArray(SPECIES, a, i);
1627 av.div(b[i], vmask).intoArray(r, i);
1628 }
1629
1630 assertBroadcastArraysEquals(a, b, r, mask, IntMaxVectorTests::div);
1631 }
1632
1633
1634
1635 @Test(dataProvider = "intBinaryOpProvider")
1636 static void ORIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1637 int[] a = fa.apply(SPECIES.length());
1638 int[] b = fb.apply(SPECIES.length());
1639 int[] r = fr.apply(SPECIES.length());
1640
1641 for (int i = 0; i < a.length; i += SPECIES.length()) {
1642 IntVector av = IntVector.fromArray(SPECIES, a, i);
1643 av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
1644 }
1645
1646 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::OR);
1647 }
1648
1649 @Test(dataProvider = "intBinaryOpProvider")
1650 static void orIntMaxVectorTestsBroadcastSmokeTest(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 i = 0; i < a.length; i += SPECIES.length()) {
1656 IntVector av = IntVector.fromArray(SPECIES, a, i);
1657 av.or(b[i]).intoArray(r, i);
1658 }
1659
1660 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::or);
1661 }
1662
1663
1664
1665 @Test(dataProvider = "intBinaryOpMaskProvider")
1666 static void ORIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1667 IntFunction<boolean[]> fm) {
1668 int[] a = fa.apply(SPECIES.length());
1669 int[] b = fb.apply(SPECIES.length());
1670 int[] r = fr.apply(SPECIES.length());
1671 boolean[] mask = fm.apply(SPECIES.length());
1672 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1673
1674 for (int i = 0; i < a.length; i += SPECIES.length()) {
1675 IntVector av = IntVector.fromArray(SPECIES, a, i);
1676 av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
1677 }
1678
1679 assertBroadcastArraysEquals(a, b, r, mask, IntMaxVectorTests::OR);
1680 }
1681
1682
1683 static int LSHL(int a, int b) {
1684 return (int)((a << b));
1685 }
1686
1687 @Test(dataProvider = "intBinaryOpProvider")
1688 static void LSHLIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1689 int[] a = fa.apply(SPECIES.length());
1690 int[] b = fb.apply(SPECIES.length());
1691 int[] r = fr.apply(SPECIES.length());
1692
1693 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1694 for (int i = 0; i < a.length; i += SPECIES.length()) {
1695 IntVector av = IntVector.fromArray(SPECIES, a, i);
1696 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1697 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
1698 }
1699 }
1700
1701 assertArraysEquals(a, b, r, IntMaxVectorTests::LSHL);
1702 }
1703
1704
1705
1706 @Test(dataProvider = "intBinaryOpMaskProvider")
1707 static void LSHLIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1708 IntFunction<boolean[]> fm) {
1709 int[] a = fa.apply(SPECIES.length());
1710 int[] b = fb.apply(SPECIES.length());
1711 int[] r = fr.apply(SPECIES.length());
1712 boolean[] mask = fm.apply(SPECIES.length());
1713 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1714
1715 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1716 for (int i = 0; i < a.length; i += SPECIES.length()) {
1717 IntVector av = IntVector.fromArray(SPECIES, a, i);
1718 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1719 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
1720 }
1721 }
1722
1723 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::LSHL);
1724 }
1725
1726
1727
1728
1729
1730
1731 static int ASHR(int a, int b) {
1732 return (int)((a >> b));
1733 }
1734
1735 @Test(dataProvider = "intBinaryOpProvider")
1736 static void ASHRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1737 int[] a = fa.apply(SPECIES.length());
1738 int[] b = fb.apply(SPECIES.length());
1739 int[] r = fr.apply(SPECIES.length());
1740
1741 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1742 for (int i = 0; i < a.length; i += SPECIES.length()) {
1743 IntVector av = IntVector.fromArray(SPECIES, a, i);
1744 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1745 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
1746 }
1747 }
1748
1749 assertArraysEquals(a, b, r, IntMaxVectorTests::ASHR);
1750 }
1751
1752
1753
1754 @Test(dataProvider = "intBinaryOpMaskProvider")
1755 static void ASHRIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1756 IntFunction<boolean[]> fm) {
1757 int[] a = fa.apply(SPECIES.length());
1758 int[] b = fb.apply(SPECIES.length());
1759 int[] r = fr.apply(SPECIES.length());
1760 boolean[] mask = fm.apply(SPECIES.length());
1761 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1762
1763 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1764 for (int i = 0; i < a.length; i += SPECIES.length()) {
1765 IntVector av = IntVector.fromArray(SPECIES, a, i);
1766 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1767 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
1768 }
1769 }
1770
1771 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::ASHR);
1772 }
1773
1774
1775
1776
1777
1778
1779 static int LSHR(int a, int b) {
1780 return (int)((a >>> b));
1781 }
1782
1783 @Test(dataProvider = "intBinaryOpProvider")
1784 static void LSHRIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1785 int[] a = fa.apply(SPECIES.length());
1786 int[] b = fb.apply(SPECIES.length());
1787 int[] r = fr.apply(SPECIES.length());
1788
1789 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1790 for (int i = 0; i < a.length; i += SPECIES.length()) {
1791 IntVector av = IntVector.fromArray(SPECIES, a, i);
1792 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1793 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
1794 }
1795 }
1796
1797 assertArraysEquals(a, b, r, IntMaxVectorTests::LSHR);
1798 }
1799
1800
1801
1802 @Test(dataProvider = "intBinaryOpMaskProvider")
1803 static void LSHRIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1804 IntFunction<boolean[]> fm) {
1805 int[] a = fa.apply(SPECIES.length());
1806 int[] b = fb.apply(SPECIES.length());
1807 int[] r = fr.apply(SPECIES.length());
1808 boolean[] mask = fm.apply(SPECIES.length());
1809 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1810
1811 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1812 for (int i = 0; i < a.length; i += SPECIES.length()) {
1813 IntVector av = IntVector.fromArray(SPECIES, a, i);
1814 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1815 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
1816 }
1817 }
1818
1819 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::LSHR);
1820 }
1821
1822
1823
1824
1825
1826
1827 static int LSHL_unary(int a, int b) {
1828 return (int)((a << b));
1829 }
1830
1831 @Test(dataProvider = "intBinaryOpProvider")
1832 static void LSHLIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1833 int[] a = fa.apply(SPECIES.length());
1834 int[] b = fb.apply(SPECIES.length());
1835 int[] r = fr.apply(SPECIES.length());
1836
1837 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1838 for (int i = 0; i < a.length; i += SPECIES.length()) {
1839 IntVector av = IntVector.fromArray(SPECIES, a, i);
1840 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
1841 }
1842 }
1843
1844 assertShiftArraysEquals(a, b, r, IntMaxVectorTests::LSHL_unary);
1845 }
1846
1847
1848
1849 @Test(dataProvider = "intBinaryOpMaskProvider")
1850 static void LSHLIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
1851 IntFunction<boolean[]> fm) {
1852 int[] a = fa.apply(SPECIES.length());
1853 int[] b = fb.apply(SPECIES.length());
1854 int[] r = fr.apply(SPECIES.length());
1855 boolean[] mask = fm.apply(SPECIES.length());
1856 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
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 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
1862 }
1863 }
1864
1865 assertShiftArraysEquals(a, b, r, mask, IntMaxVectorTests::LSHL_unary);
1866 }
1867
1868
1869
1870
1871
1872
1873 static int LSHR_unary(int a, int b) {
1874 return (int)((a >>> b));
1875 }
1876
1877 @Test(dataProvider = "intBinaryOpProvider")
1878 static void LSHRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1879 int[] a = fa.apply(SPECIES.length());
1880 int[] b = fb.apply(SPECIES.length());
1881 int[] r = fr.apply(SPECIES.length());
1882
1883 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1884 for (int i = 0; i < a.length; i += SPECIES.length()) {
1885 IntVector av = IntVector.fromArray(SPECIES, a, i);
1886 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
1887 }
1888 }
1889
1890 assertShiftArraysEquals(a, b, r, IntMaxVectorTests::LSHR_unary);
1891 }
1892
1893
1894
1895 @Test(dataProvider = "intBinaryOpMaskProvider")
1896 static void LSHRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
1897 IntFunction<boolean[]> fm) {
1898 int[] a = fa.apply(SPECIES.length());
1899 int[] b = fb.apply(SPECIES.length());
1900 int[] r = fr.apply(SPECIES.length());
1901 boolean[] mask = fm.apply(SPECIES.length());
1902 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1903
1904 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1905 for (int i = 0; i < a.length; i += SPECIES.length()) {
1906 IntVector av = IntVector.fromArray(SPECIES, a, i);
1907 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
1908 }
1909 }
1910
1911 assertShiftArraysEquals(a, b, r, mask, IntMaxVectorTests::LSHR_unary);
1912 }
1913
1914
1915
1916
1917
1918
1919 static int ASHR_unary(int a, int b) {
1920 return (int)((a >> b));
1921 }
1922
1923 @Test(dataProvider = "intBinaryOpProvider")
1924 static void ASHRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1925 int[] a = fa.apply(SPECIES.length());
1926 int[] b = fb.apply(SPECIES.length());
1927 int[] r = fr.apply(SPECIES.length());
1928
1929 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1930 for (int i = 0; i < a.length; i += SPECIES.length()) {
1931 IntVector av = IntVector.fromArray(SPECIES, a, i);
1932 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
1933 }
1934 }
1935
1936 assertShiftArraysEquals(a, b, r, IntMaxVectorTests::ASHR_unary);
1937 }
1938
1939
1940
1941 @Test(dataProvider = "intBinaryOpMaskProvider")
1942 static void ASHRIntMaxVectorTestsShift(IntFunction<int[]> fa, IntFunction<int[]> fb,
1943 IntFunction<boolean[]> fm) {
1944 int[] a = fa.apply(SPECIES.length());
1945 int[] b = fb.apply(SPECIES.length());
1946 int[] r = fr.apply(SPECIES.length());
1947 boolean[] mask = fm.apply(SPECIES.length());
1948 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1949
1950 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1951 for (int i = 0; i < a.length; i += SPECIES.length()) {
1952 IntVector av = IntVector.fromArray(SPECIES, a, i);
1953 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
1954 }
1955 }
1956
1957 assertShiftArraysEquals(a, b, r, mask, IntMaxVectorTests::ASHR_unary);
1958 }
1959
1960
1961
1962
1963
1964 static int MIN(int a, int b) {
1965 return (int)(Math.min(a, b));
1966 }
1967
1968 @Test(dataProvider = "intBinaryOpProvider")
1969 static void MINIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1970 int[] a = fa.apply(SPECIES.length());
1971 int[] b = fb.apply(SPECIES.length());
1972 int[] r = fr.apply(SPECIES.length());
1973
1974 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1975 for (int i = 0; i < a.length; i += SPECIES.length()) {
1976 IntVector av = IntVector.fromArray(SPECIES, a, i);
1977 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1978 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
1979 }
1980 }
1981
1982 assertArraysEquals(a, b, r, IntMaxVectorTests::MIN);
1983 }
1984 static int min(int a, int b) {
1985 return (int)(Math.min(a, b));
1986 }
1987
1988 @Test(dataProvider = "intBinaryOpProvider")
1989 static void minIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1990 int[] a = fa.apply(SPECIES.length());
1991 int[] b = fb.apply(SPECIES.length());
1992 int[] r = fr.apply(SPECIES.length());
1993
1994 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1995 for (int i = 0; i < a.length; i += SPECIES.length()) {
1996 IntVector av = IntVector.fromArray(SPECIES, a, i);
1997 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1998 av.min(bv).intoArray(r, i);
1999 }
2000 }
2001
2002 assertArraysEquals(a, b, r, IntMaxVectorTests::min);
2003 }
2004 static int MAX(int a, int b) {
2005 return (int)(Math.max(a, b));
2006 }
2007
2008 @Test(dataProvider = "intBinaryOpProvider")
2009 static void MAXIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2010 int[] a = fa.apply(SPECIES.length());
2011 int[] b = fb.apply(SPECIES.length());
2012 int[] r = fr.apply(SPECIES.length());
2013
2014 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2015 for (int i = 0; i < a.length; i += SPECIES.length()) {
2016 IntVector av = IntVector.fromArray(SPECIES, a, i);
2017 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2018 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
2019 }
2020 }
2021
2022 assertArraysEquals(a, b, r, IntMaxVectorTests::MAX);
2023 }
2024 static int max(int a, int b) {
2025 return (int)(Math.max(a, b));
2026 }
2027
2028 @Test(dataProvider = "intBinaryOpProvider")
2029 static void maxIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2030 int[] a = fa.apply(SPECIES.length());
2031 int[] b = fb.apply(SPECIES.length());
2032 int[] r = fr.apply(SPECIES.length());
2033
2034 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2035 for (int i = 0; i < a.length; i += SPECIES.length()) {
2036 IntVector av = IntVector.fromArray(SPECIES, a, i);
2037 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2038 av.max(bv).intoArray(r, i);
2039 }
2040 }
2041
2042 assertArraysEquals(a, b, r, IntMaxVectorTests::max);
2043 }
2044
2045 @Test(dataProvider = "intBinaryOpProvider")
2046 static void MINIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2047 int[] a = fa.apply(SPECIES.length());
2048 int[] b = fb.apply(SPECIES.length());
2049 int[] r = fr.apply(SPECIES.length());
2050
2051 for (int i = 0; i < a.length; i += SPECIES.length()) {
2052 IntVector av = IntVector.fromArray(SPECIES, a, i);
2053 av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
2054 }
2055
2056 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::MIN);
2057 }
2058
2059 @Test(dataProvider = "intBinaryOpProvider")
2060 static void minIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2061 int[] a = fa.apply(SPECIES.length());
2062 int[] b = fb.apply(SPECIES.length());
2063 int[] r = fr.apply(SPECIES.length());
2064
2065 for (int i = 0; i < a.length; i += SPECIES.length()) {
2066 IntVector av = IntVector.fromArray(SPECIES, a, i);
2067 av.min(b[i]).intoArray(r, i);
2068 }
2069
2070 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::min);
2071 }
2072
2073 @Test(dataProvider = "intBinaryOpProvider")
2074 static void MAXIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2075 int[] a = fa.apply(SPECIES.length());
2076 int[] b = fb.apply(SPECIES.length());
2077 int[] r = fr.apply(SPECIES.length());
2078
2079 for (int i = 0; i < a.length; i += SPECIES.length()) {
2080 IntVector av = IntVector.fromArray(SPECIES, a, i);
2081 av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
2082 }
2083
2084 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::MAX);
2085 }
2086
2087 @Test(dataProvider = "intBinaryOpProvider")
2088 static void maxIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2089 int[] a = fa.apply(SPECIES.length());
2090 int[] b = fb.apply(SPECIES.length());
2091 int[] r = fr.apply(SPECIES.length());
2092
2093 for (int i = 0; i < a.length; i += SPECIES.length()) {
2094 IntVector av = IntVector.fromArray(SPECIES, a, i);
2095 av.max(b[i]).intoArray(r, i);
2096 }
2097
2098 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::max);
2099 }
2100
2101 static int AND(int[] a, int idx) {
2102 int res = -1;
2103 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2104 res &= a[i];
2105 }
2106
2107 return res;
2108 }
2109
2110 static int AND(int[] a) {
2111 int res = -1;
2112 for (int i = 0; i < a.length; i += SPECIES.length()) {
2113 int tmp = -1;
2114 for (int j = 0; j < SPECIES.length(); j++) {
2115 tmp &= a[i + j];
2116 }
2117 res &= tmp;
2118 }
2119
2120 return res;
2121 }
2122
2123
2124 @Test(dataProvider = "intUnaryOpProvider")
2125 static void ANDIntMaxVectorTests(IntFunction<int[]> fa) {
2126 int[] a = fa.apply(SPECIES.length());
2127 int[] r = fr.apply(SPECIES.length());
2128 int ra = -1;
2129
2130 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2131 for (int i = 0; i < a.length; i += SPECIES.length()) {
2132 IntVector av = IntVector.fromArray(SPECIES, a, i);
2133 r[i] = av.reduceLanes(VectorOperators.AND);
2134 }
2135 }
2136
2137 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2138 ra = -1;
2139 for (int i = 0; i < a.length; i += SPECIES.length()) {
2140 IntVector av = IntVector.fromArray(SPECIES, a, i);
2141 ra &= av.reduceLanes(VectorOperators.AND);
2142 }
2143 }
2144
2145 assertReductionArraysEquals(a, r, ra, IntMaxVectorTests::AND, IntMaxVectorTests::AND);
2146 }
2147
2148
2149 static int ANDMasked(int[] a, int idx, boolean[] mask) {
2150 int res = -1;
2151 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2152 if(mask[i % SPECIES.length()])
2153 res &= a[i];
2154 }
2155
2156 return res;
2157 }
2158
2159 static int ANDMasked(int[] a, boolean[] mask) {
2160 int res = -1;
2161 for (int i = 0; i < a.length; i += SPECIES.length()) {
2162 int tmp = -1;
2163 for (int j = 0; j < SPECIES.length(); j++) {
2164 if(mask[(i + j) % SPECIES.length()])
2165 tmp &= a[i + j];
2166 }
2167 res &= tmp;
2168 }
2169
2170 return res;
2171 }
2172
2173
2174 @Test(dataProvider = "intUnaryOpMaskProvider")
2175 static void ANDIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2176 int[] a = fa.apply(SPECIES.length());
2177 int[] r = fr.apply(SPECIES.length());
2178 boolean[] mask = fm.apply(SPECIES.length());
2179 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2180 int ra = -1;
2181
2182 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2183 for (int i = 0; i < a.length; i += SPECIES.length()) {
2184 IntVector av = IntVector.fromArray(SPECIES, a, i);
2185 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
2186 }
2187 }
2188
2189 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2190 ra = -1;
2191 for (int i = 0; i < a.length; i += SPECIES.length()) {
2192 IntVector av = IntVector.fromArray(SPECIES, a, i);
2193 ra &= av.reduceLanes(VectorOperators.AND, vmask);
2194 }
2195 }
2196
2197 assertReductionArraysEqualsMasked(a, r, ra, mask, IntMaxVectorTests::ANDMasked, IntMaxVectorTests::ANDMasked);
2198 }
2199
2200
2201 static int OR(int[] a, int idx) {
2202 int res = 0;
2203 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2204 res |= a[i];
2205 }
2206
2207 return res;
2208 }
2209
2210 static int OR(int[] a) {
2211 int res = 0;
2212 for (int i = 0; i < a.length; i += SPECIES.length()) {
2213 int tmp = 0;
2214 for (int j = 0; j < SPECIES.length(); j++) {
2215 tmp |= a[i + j];
2216 }
2217 res |= tmp;
2218 }
2219
2220 return res;
2221 }
2222
2223
2224 @Test(dataProvider = "intUnaryOpProvider")
2225 static void ORIntMaxVectorTests(IntFunction<int[]> fa) {
2226 int[] a = fa.apply(SPECIES.length());
2227 int[] r = fr.apply(SPECIES.length());
2228 int ra = 0;
2229
2230 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2231 for (int i = 0; i < a.length; i += SPECIES.length()) {
2232 IntVector av = IntVector.fromArray(SPECIES, a, i);
2233 r[i] = av.reduceLanes(VectorOperators.OR);
2234 }
2235 }
2236
2237 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2238 ra = 0;
2239 for (int i = 0; i < a.length; i += SPECIES.length()) {
2240 IntVector av = IntVector.fromArray(SPECIES, a, i);
2241 ra |= av.reduceLanes(VectorOperators.OR);
2242 }
2243 }
2244
2245 assertReductionArraysEquals(a, r, ra, IntMaxVectorTests::OR, IntMaxVectorTests::OR);
2246 }
2247
2248
2249 static int ORMasked(int[] a, int idx, boolean[] mask) {
2250 int res = 0;
2251 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2252 if(mask[i % SPECIES.length()])
2253 res |= a[i];
2254 }
2255
2256 return res;
2257 }
2258
2259 static int ORMasked(int[] a, boolean[] mask) {
2260 int res = 0;
2261 for (int i = 0; i < a.length; i += SPECIES.length()) {
2262 int tmp = 0;
2263 for (int j = 0; j < SPECIES.length(); j++) {
2264 if(mask[(i + j) % SPECIES.length()])
2265 tmp |= a[i + j];
2266 }
2267 res |= tmp;
2268 }
2269
2270 return res;
2271 }
2272
2273
2274 @Test(dataProvider = "intUnaryOpMaskProvider")
2275 static void ORIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2276 int[] a = fa.apply(SPECIES.length());
2277 int[] r = fr.apply(SPECIES.length());
2278 boolean[] mask = fm.apply(SPECIES.length());
2279 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2280 int ra = 0;
2281
2282 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2283 for (int i = 0; i < a.length; i += SPECIES.length()) {
2284 IntVector av = IntVector.fromArray(SPECIES, a, i);
2285 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
2286 }
2287 }
2288
2289 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2290 ra = 0;
2291 for (int i = 0; i < a.length; i += SPECIES.length()) {
2292 IntVector av = IntVector.fromArray(SPECIES, a, i);
2293 ra |= av.reduceLanes(VectorOperators.OR, vmask);
2294 }
2295 }
2296
2297 assertReductionArraysEqualsMasked(a, r, ra, mask, IntMaxVectorTests::ORMasked, IntMaxVectorTests::ORMasked);
2298 }
2299
2300
2301 static int XOR(int[] a, int idx) {
2302 int res = 0;
2303 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2304 res ^= a[i];
2305 }
2306
2307 return res;
2308 }
2309
2310 static int XOR(int[] a) {
2311 int res = 0;
2312 for (int i = 0; i < a.length; i += SPECIES.length()) {
2313 int tmp = 0;
2314 for (int j = 0; j < SPECIES.length(); j++) {
2315 tmp ^= a[i + j];
2316 }
2317 res ^= tmp;
2318 }
2319
2320 return res;
2321 }
2322
2323
2324 @Test(dataProvider = "intUnaryOpProvider")
2325 static void XORIntMaxVectorTests(IntFunction<int[]> fa) {
2326 int[] a = fa.apply(SPECIES.length());
2327 int[] r = fr.apply(SPECIES.length());
2328 int ra = 0;
2329
2330 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2331 for (int i = 0; i < a.length; i += SPECIES.length()) {
2332 IntVector av = IntVector.fromArray(SPECIES, a, i);
2333 r[i] = av.reduceLanes(VectorOperators.XOR);
2334 }
2335 }
2336
2337 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2338 ra = 0;
2339 for (int i = 0; i < a.length; i += SPECIES.length()) {
2340 IntVector av = IntVector.fromArray(SPECIES, a, i);
2341 ra ^= av.reduceLanes(VectorOperators.XOR);
2342 }
2343 }
2344
2345 assertReductionArraysEquals(a, r, ra, IntMaxVectorTests::XOR, IntMaxVectorTests::XOR);
2346 }
2347
2348
2349 static int XORMasked(int[] a, int idx, boolean[] mask) {
2350 int res = 0;
2351 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2352 if(mask[i % SPECIES.length()])
2353 res ^= a[i];
2354 }
2355
2356 return res;
2357 }
2358
2359 static int XORMasked(int[] a, boolean[] mask) {
2360 int res = 0;
2361 for (int i = 0; i < a.length; i += SPECIES.length()) {
2362 int tmp = 0;
2363 for (int j = 0; j < SPECIES.length(); j++) {
2364 if(mask[(i + j) % SPECIES.length()])
2365 tmp ^= a[i + j];
2366 }
2367 res ^= tmp;
2368 }
2369
2370 return res;
2371 }
2372
2373
2374 @Test(dataProvider = "intUnaryOpMaskProvider")
2375 static void XORIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2376 int[] a = fa.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 int ra = 0;
2381
2382 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2383 for (int i = 0; i < a.length; i += SPECIES.length()) {
2384 IntVector av = IntVector.fromArray(SPECIES, a, i);
2385 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
2386 }
2387 }
2388
2389 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2390 ra = 0;
2391 for (int i = 0; i < a.length; i += SPECIES.length()) {
2392 IntVector av = IntVector.fromArray(SPECIES, a, i);
2393 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
2394 }
2395 }
2396
2397 assertReductionArraysEqualsMasked(a, r, ra, mask, IntMaxVectorTests::XORMasked, IntMaxVectorTests::XORMasked);
2398 }
2399
2400 static int ADD(int[] a, int idx) {
2401 int res = 0;
2402 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2403 res += a[i];
2404 }
2405
2406 return res;
2407 }
2408
2409 static int ADD(int[] a) {
2410 int res = 0;
2411 for (int i = 0; i < a.length; i += SPECIES.length()) {
2412 int tmp = 0;
2413 for (int j = 0; j < SPECIES.length(); j++) {
2414 tmp += a[i + j];
2415 }
2416 res += tmp;
2417 }
2418
2419 return res;
2420 }
2421 @Test(dataProvider = "intUnaryOpProvider")
2422 static void ADDIntMaxVectorTests(IntFunction<int[]> fa) {
2423 int[] a = fa.apply(SPECIES.length());
2424 int[] r = fr.apply(SPECIES.length());
2425 int ra = 0;
2426
2427 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2428 for (int i = 0; i < a.length; i += SPECIES.length()) {
2429 IntVector av = IntVector.fromArray(SPECIES, a, i);
2430 r[i] = av.reduceLanes(VectorOperators.ADD);
2431 }
2432 }
2433
2434 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2435 ra = 0;
2436 for (int i = 0; i < a.length; i += SPECIES.length()) {
2437 IntVector av = IntVector.fromArray(SPECIES, a, i);
2438 ra += av.reduceLanes(VectorOperators.ADD);
2439 }
2440 }
2441
2442 assertReductionArraysEquals(a, r, ra, IntMaxVectorTests::ADD, IntMaxVectorTests::ADD);
2443 }
2444 static int ADDMasked(int[] a, int idx, boolean[] mask) {
2445 int res = 0;
2446 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2447 if(mask[i % SPECIES.length()])
2448 res += a[i];
2449 }
2450
2451 return res;
2452 }
2453
2454 static int ADDMasked(int[] a, boolean[] mask) {
2455 int res = 0;
2456 for (int i = 0; i < a.length; i += SPECIES.length()) {
2457 int tmp = 0;
2458 for (int j = 0; j < SPECIES.length(); j++) {
2459 if(mask[(i + j) % SPECIES.length()])
2460 tmp += a[i + j];
2461 }
2462 res += tmp;
2463 }
2464
2465 return res;
2466 }
2467 @Test(dataProvider = "intUnaryOpMaskProvider")
2468 static void ADDIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2469 int[] a = fa.apply(SPECIES.length());
2470 int[] r = fr.apply(SPECIES.length());
2471 boolean[] mask = fm.apply(SPECIES.length());
2472 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2473 int ra = 0;
2474
2475 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2476 for (int i = 0; i < a.length; i += SPECIES.length()) {
2477 IntVector av = IntVector.fromArray(SPECIES, a, i);
2478 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
2479 }
2480 }
2481
2482 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2483 ra = 0;
2484 for (int i = 0; i < a.length; i += SPECIES.length()) {
2485 IntVector av = IntVector.fromArray(SPECIES, a, i);
2486 ra += av.reduceLanes(VectorOperators.ADD, vmask);
2487 }
2488 }
2489
2490 assertReductionArraysEqualsMasked(a, r, ra, mask, IntMaxVectorTests::ADDMasked, IntMaxVectorTests::ADDMasked);
2491 }
2492 static int MUL(int[] a, int idx) {
2493 int res = 1;
2494 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2495 res *= a[i];
2496 }
2497
2498 return res;
2499 }
2500
2501 static int MUL(int[] a) {
2502 int res = 1;
2503 for (int i = 0; i < a.length; i += SPECIES.length()) {
2504 int tmp = 1;
2505 for (int j = 0; j < SPECIES.length(); j++) {
2506 tmp *= a[i + j];
2507 }
2508 res *= tmp;
2509 }
2510
2511 return res;
2512 }
2513 @Test(dataProvider = "intUnaryOpProvider")
2514 static void MULIntMaxVectorTests(IntFunction<int[]> fa) {
2515 int[] a = fa.apply(SPECIES.length());
2516 int[] r = fr.apply(SPECIES.length());
2517 int ra = 1;
2518
2519 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2520 for (int i = 0; i < a.length; i += SPECIES.length()) {
2521 IntVector av = IntVector.fromArray(SPECIES, a, i);
2522 r[i] = av.reduceLanes(VectorOperators.MUL);
2523 }
2524 }
2525
2526 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2527 ra = 1;
2528 for (int i = 0; i < a.length; i += SPECIES.length()) {
2529 IntVector av = IntVector.fromArray(SPECIES, a, i);
2530 ra *= av.reduceLanes(VectorOperators.MUL);
2531 }
2532 }
2533
2534 assertReductionArraysEquals(a, r, ra, IntMaxVectorTests::MUL, IntMaxVectorTests::MUL);
2535 }
2536 static int MULMasked(int[] a, int idx, boolean[] mask) {
2537 int res = 1;
2538 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2539 if(mask[i % SPECIES.length()])
2540 res *= a[i];
2541 }
2542
2543 return res;
2544 }
2545
2546 static int MULMasked(int[] a, boolean[] mask) {
2547 int res = 1;
2548 for (int i = 0; i < a.length; i += SPECIES.length()) {
2549 int tmp = 1;
2550 for (int j = 0; j < SPECIES.length(); j++) {
2551 if(mask[(i + j) % SPECIES.length()])
2552 tmp *= a[i + j];
2553 }
2554 res *= tmp;
2555 }
2556
2557 return res;
2558 }
2559 @Test(dataProvider = "intUnaryOpMaskProvider")
2560 static void MULIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2561 int[] a = fa.apply(SPECIES.length());
2562 int[] r = fr.apply(SPECIES.length());
2563 boolean[] mask = fm.apply(SPECIES.length());
2564 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2565 int ra = 1;
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 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
2571 }
2572 }
2573
2574 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2575 ra = 1;
2576 for (int i = 0; i < a.length; i += SPECIES.length()) {
2577 IntVector av = IntVector.fromArray(SPECIES, a, i);
2578 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
2579 }
2580 }
2581
2582 assertReductionArraysEqualsMasked(a, r, ra, mask, IntMaxVectorTests::MULMasked, IntMaxVectorTests::MULMasked);
2583 }
2584 static int MIN(int[] a, int idx) {
2585 int res = Integer.MAX_VALUE;
2586 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2587 res = (int)Math.min(res, a[i]);
2588 }
2589
2590 return res;
2591 }
2592
2593 static int MIN(int[] a) {
2594 int res = Integer.MAX_VALUE;
2595 for (int i = 0; i < a.length; i++) {
2596 res = (int)Math.min(res, a[i]);
2597 }
2598
2599 return res;
2600 }
2601 @Test(dataProvider = "intUnaryOpProvider")
2602 static void MINIntMaxVectorTests(IntFunction<int[]> fa) {
2603 int[] a = fa.apply(SPECIES.length());
2604 int[] r = fr.apply(SPECIES.length());
2605 int ra = Integer.MAX_VALUE;
2606
2607 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2608 for (int i = 0; i < a.length; i += SPECIES.length()) {
2609 IntVector av = IntVector.fromArray(SPECIES, a, i);
2610 r[i] = av.reduceLanes(VectorOperators.MIN);
2611 }
2612 }
2613
2614 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2615 ra = Integer.MAX_VALUE;
2616 for (int i = 0; i < a.length; i += SPECIES.length()) {
2617 IntVector av = IntVector.fromArray(SPECIES, a, i);
2618 ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN));
2619 }
2620 }
2621
2622 assertReductionArraysEquals(a, r, ra, IntMaxVectorTests::MIN, IntMaxVectorTests::MIN);
2623 }
2624 static int MINMasked(int[] a, int idx, boolean[] mask) {
2625 int res = Integer.MAX_VALUE;
2626 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2627 if(mask[i % SPECIES.length()])
2628 res = (int)Math.min(res, a[i]);
2629 }
2630
2631 return res;
2632 }
2633
2634 static int MINMasked(int[] a, boolean[] mask) {
2635 int res = Integer.MAX_VALUE;
2636 for (int i = 0; i < a.length; i++) {
2637 if(mask[i % SPECIES.length()])
2638 res = (int)Math.min(res, a[i]);
2639 }
2640
2641 return res;
2642 }
2643 @Test(dataProvider = "intUnaryOpMaskProvider")
2644 static void MINIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2645 int[] a = fa.apply(SPECIES.length());
2646 int[] r = fr.apply(SPECIES.length());
2647 boolean[] mask = fm.apply(SPECIES.length());
2648 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2649 int ra = Integer.MAX_VALUE;
2650
2651 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2652 for (int i = 0; i < a.length; i += SPECIES.length()) {
2653 IntVector av = IntVector.fromArray(SPECIES, a, i);
2654 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
2655 }
2656 }
2657
2658 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2659 ra = Integer.MAX_VALUE;
2660 for (int i = 0; i < a.length; i += SPECIES.length()) {
2661 IntVector av = IntVector.fromArray(SPECIES, a, i);
2662 ra = (int)Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
2663 }
2664 }
2665
2666 assertReductionArraysEqualsMasked(a, r, ra, mask, IntMaxVectorTests::MINMasked, IntMaxVectorTests::MINMasked);
2667 }
2668 static int MAX(int[] a, int idx) {
2669 int res = Integer.MIN_VALUE;
2670 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2671 res = (int)Math.max(res, a[i]);
2672 }
2673
2674 return res;
2675 }
2676
2677 static int MAX(int[] a) {
2678 int res = Integer.MIN_VALUE;
2679 for (int i = 0; i < a.length; i++) {
2680 res = (int)Math.max(res, a[i]);
2681 }
2682
2683 return res;
2684 }
2685 @Test(dataProvider = "intUnaryOpProvider")
2686 static void MAXIntMaxVectorTests(IntFunction<int[]> fa) {
2687 int[] a = fa.apply(SPECIES.length());
2688 int[] r = fr.apply(SPECIES.length());
2689 int ra = Integer.MIN_VALUE;
2690
2691 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2692 for (int i = 0; i < a.length; i += SPECIES.length()) {
2693 IntVector av = IntVector.fromArray(SPECIES, a, i);
2694 r[i] = av.reduceLanes(VectorOperators.MAX);
2695 }
2696 }
2697
2698 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2699 ra = Integer.MIN_VALUE;
2700 for (int i = 0; i < a.length; i += SPECIES.length()) {
2701 IntVector av = IntVector.fromArray(SPECIES, a, i);
2702 ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX));
2703 }
2704 }
2705
2706 assertReductionArraysEquals(a, r, ra, IntMaxVectorTests::MAX, IntMaxVectorTests::MAX);
2707 }
2708 static int MAXMasked(int[] a, int idx, boolean[] mask) {
2709 int res = Integer.MIN_VALUE;
2710 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2711 if(mask[i % SPECIES.length()])
2712 res = (int)Math.max(res, a[i]);
2713 }
2714
2715 return res;
2716 }
2717
2718 static int MAXMasked(int[] a, boolean[] mask) {
2719 int res = Integer.MIN_VALUE;
2720 for (int i = 0; i < a.length; i++) {
2721 if(mask[i % SPECIES.length()])
2722 res = (int)Math.max(res, a[i]);
2723 }
2724
2725 return res;
2726 }
2727 @Test(dataProvider = "intUnaryOpMaskProvider")
2728 static void MAXIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<boolean[]> fm) {
2729 int[] a = fa.apply(SPECIES.length());
2730 int[] r = fr.apply(SPECIES.length());
2731 boolean[] mask = fm.apply(SPECIES.length());
2732 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2733 int ra = Integer.MIN_VALUE;
2734
2735 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2736 for (int i = 0; i < a.length; i += SPECIES.length()) {
2737 IntVector av = IntVector.fromArray(SPECIES, a, i);
2738 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
2739 }
2740 }
2741
2742 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2743 ra = Integer.MIN_VALUE;
2744 for (int i = 0; i < a.length; i += SPECIES.length()) {
2745 IntVector av = IntVector.fromArray(SPECIES, a, i);
2746 ra = (int)Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
2747 }
2748 }
2749
2750 assertReductionArraysEqualsMasked(a, r, ra, mask, IntMaxVectorTests::MAXMasked, IntMaxVectorTests::MAXMasked);
2751 }
2752
2753 static boolean anyTrue(boolean[] a, int idx) {
2754 boolean res = false;
2755 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2756 res |= a[i];
2757 }
2758
2759 return res;
2760 }
2761
2762
2763 @Test(dataProvider = "boolUnaryOpProvider")
2764 static void anyTrueIntMaxVectorTests(IntFunction<boolean[]> fm) {
2765 boolean[] mask = fm.apply(SPECIES.length());
2766 boolean[] r = fmr.apply(SPECIES.length());
2767
2768 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2769 for (int i = 0; i < mask.length; i += SPECIES.length()) {
2770 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
2771 r[i] = vmask.anyTrue();
2772 }
2773 }
2774
2775 assertReductionBoolArraysEquals(mask, r, IntMaxVectorTests::anyTrue);
2776 }
2777
2778
2779 static boolean allTrue(boolean[] a, int idx) {
2780 boolean res = true;
2781 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2782 res &= a[i];
2783 }
2784
2785 return res;
2786 }
2787
2788
2789 @Test(dataProvider = "boolUnaryOpProvider")
2790 static void allTrueIntMaxVectorTests(IntFunction<boolean[]> fm) {
2791 boolean[] mask = fm.apply(SPECIES.length());
2792 boolean[] r = fmr.apply(SPECIES.length());
2793
2794 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2795 for (int i = 0; i < mask.length; i += SPECIES.length()) {
2796 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, i);
2797 r[i] = vmask.allTrue();
2798 }
2799 }
2800
2801 assertReductionBoolArraysEquals(mask, r, IntMaxVectorTests::allTrue);
2802 }
2803
2804
2805 @Test(dataProvider = "intUnaryOpProvider")
2806 static void withIntMaxVectorTests(IntFunction<int []> fa) {
2807 int[] a = fa.apply(SPECIES.length());
2808 int[] r = fr.apply(SPECIES.length());
2809
2810 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2811 for (int i = 0; i < a.length; i += SPECIES.length()) {
2812 IntVector av = IntVector.fromArray(SPECIES, a, i);
2813 av.withLane(0, (int)4).intoArray(r, i);
2814 }
2815 }
2816
2817 assertInsertArraysEquals(a, r, (int)4, 0);
2818 }
2819 static boolean testIS_DEFAULT(int a) {
2820 return bits(a)==0;
2821 }
2822
2823 @Test(dataProvider = "intTestOpProvider")
2824 static void IS_DEFAULTIntMaxVectorTests(IntFunction<int[]> fa) {
2825 int[] a = fa.apply(SPECIES.length());
2826
2827 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2828 for (int i = 0; i < a.length; i += SPECIES.length()) {
2829 IntVector av = IntVector.fromArray(SPECIES, a, i);
2830 VectorMask<Integer> mv = av.test(VectorOperators.IS_DEFAULT);
2831
2832 // Check results as part of computation.
2833 for (int j = 0; j < SPECIES.length(); j++) {
2834
2835 Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
2836 }
2837 }
2838 }
2839 }
2840
2841 static boolean testIS_NEGATIVE(int a) {
2842 return bits(a)<0;
2843 }
2844
2845 @Test(dataProvider = "intTestOpProvider")
2846 static void IS_NEGATIVEIntMaxVectorTests(IntFunction<int[]> fa) {
2847 int[] a = fa.apply(SPECIES.length());
2848
2849 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2850 for (int i = 0; i < a.length; i += SPECIES.length()) {
2851 IntVector av = IntVector.fromArray(SPECIES, a, i);
2852 VectorMask<Integer> mv = av.test(VectorOperators.IS_NEGATIVE);
2853
2854 // Check results as part of computation.
2855 for (int j = 0; j < SPECIES.length(); j++) {
2856
2857 Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
2858 }
2859 }
2860 }
2861 }
2862
2863
2864
2865
2866
2867 @Test(dataProvider = "intCompareOpProvider")
2868 static void LTIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2869 int[] a = fa.apply(SPECIES.length());
2870 int[] b = fb.apply(SPECIES.length());
2871
2872 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2873 for (int i = 0; i < a.length; i += SPECIES.length()) {
2874 IntVector av = IntVector.fromArray(SPECIES, a, i);
2875 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2876 VectorMask<Integer> mv = av.compare(VectorOperators.LT, bv);
2877
2878 // Check results as part of computation.
2879 for (int j = 0; j < SPECIES.length(); j++) {
2880 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i + j]);
2881 }
2882 }
2883 }
2884 }
2885
2886
2887 @Test(dataProvider = "intCompareOpProvider")
2888 static void ltIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2889 int[] a = fa.apply(SPECIES.length());
2890 int[] b = fb.apply(SPECIES.length());
2891
2892 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2893 for (int i = 0; i < a.length; i += SPECIES.length()) {
2894 IntVector av = IntVector.fromArray(SPECIES, a, i);
2895 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2896 VectorMask<Integer> mv = av.lt(bv);
2897
2898 // Check results as part of computation.
2899 for (int j = 0; j < SPECIES.length(); j++) {
2900 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i + j]);
2901 }
2902 }
2903 }
2904 }
2905
2906
2907 @Test(dataProvider = "intCompareOpProvider")
2908 static void GTIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2909 int[] a = fa.apply(SPECIES.length());
2910 int[] b = fb.apply(SPECIES.length());
2911
2912 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2913 for (int i = 0; i < a.length; i += SPECIES.length()) {
2914 IntVector av = IntVector.fromArray(SPECIES, a, i);
2915 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2916 VectorMask<Integer> mv = av.compare(VectorOperators.GT, bv);
2917
2918 // Check results as part of computation.
2919 for (int j = 0; j < SPECIES.length(); j++) {
2920 Assert.assertEquals(mv.laneIsSet(j), a[i + j] > b[i + j]);
2921 }
2922 }
2923 }
2924 }
2925
2926
2927 @Test(dataProvider = "intCompareOpProvider")
2928 static void EQIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2929 int[] a = fa.apply(SPECIES.length());
2930 int[] b = fb.apply(SPECIES.length());
2931
2932 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2933 for (int i = 0; i < a.length; i += SPECIES.length()) {
2934 IntVector av = IntVector.fromArray(SPECIES, a, i);
2935 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2936 VectorMask<Integer> mv = av.compare(VectorOperators.EQ, bv);
2937
2938 // Check results as part of computation.
2939 for (int j = 0; j < SPECIES.length(); j++) {
2940 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i + j]);
2941 }
2942 }
2943 }
2944 }
2945
2946
2947 @Test(dataProvider = "intCompareOpProvider")
2948 static void eqIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2949 int[] a = fa.apply(SPECIES.length());
2950 int[] b = fb.apply(SPECIES.length());
2951
2952 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2953 for (int i = 0; i < a.length; i += SPECIES.length()) {
2954 IntVector av = IntVector.fromArray(SPECIES, a, i);
2955 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2956 VectorMask<Integer> mv = av.eq(bv);
2957
2958 // Check results as part of computation.
2959 for (int j = 0; j < SPECIES.length(); j++) {
2960 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i + j]);
2961 }
2962 }
2963 }
2964 }
2965
2966
2967 @Test(dataProvider = "intCompareOpProvider")
2968 static void NEIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2969 int[] a = fa.apply(SPECIES.length());
2970 int[] b = fb.apply(SPECIES.length());
2971
2972 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2973 for (int i = 0; i < a.length; i += SPECIES.length()) {
2974 IntVector av = IntVector.fromArray(SPECIES, a, i);
2975 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2976 VectorMask<Integer> mv = av.compare(VectorOperators.NE, bv);
2977
2978 // Check results as part of computation.
2979 for (int j = 0; j < SPECIES.length(); j++) {
2980 Assert.assertEquals(mv.laneIsSet(j), a[i + j] != b[i + j]);
2981 }
2982 }
2983 }
2984 }
2985
2986
2987 @Test(dataProvider = "intCompareOpProvider")
2988 static void LEIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2989 int[] a = fa.apply(SPECIES.length());
2990 int[] b = fb.apply(SPECIES.length());
2991
2992 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2993 for (int i = 0; i < a.length; i += SPECIES.length()) {
2994 IntVector av = IntVector.fromArray(SPECIES, a, i);
2995 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2996 VectorMask<Integer> mv = av.compare(VectorOperators.LE, bv);
2997
2998 // Check results as part of computation.
2999 for (int j = 0; j < SPECIES.length(); j++) {
3000 Assert.assertEquals(mv.laneIsSet(j), a[i + j] <= b[i + j]);
3001 }
3002 }
3003 }
3004 }
3005
3006
3007 @Test(dataProvider = "intCompareOpProvider")
3008 static void GEIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3009 int[] a = fa.apply(SPECIES.length());
3010 int[] b = fb.apply(SPECIES.length());
3011
3012 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3013 for (int i = 0; i < a.length; i += SPECIES.length()) {
3014 IntVector av = IntVector.fromArray(SPECIES, a, i);
3015 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3016 VectorMask<Integer> mv = av.compare(VectorOperators.GE, bv);
3017
3018 // Check results as part of computation.
3019 for (int j = 0; j < SPECIES.length(); j++) {
3020 Assert.assertEquals(mv.laneIsSet(j), a[i + j] >= b[i + j]);
3021 }
3022 }
3023 }
3024 }
3025
3026
3027 static int blend(int a, int b, boolean mask) {
3028 return mask ? b : a;
3029 }
3030
3031 @Test(dataProvider = "intBinaryOpMaskProvider")
3032 static void blendIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
3033 IntFunction<boolean[]> fm) {
3034 int[] a = fa.apply(SPECIES.length());
3035 int[] b = fb.apply(SPECIES.length());
3036 int[] r = fr.apply(SPECIES.length());
3037 boolean[] mask = fm.apply(SPECIES.length());
3038 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3039
3040 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3041 for (int i = 0; i < a.length; i += SPECIES.length()) {
3042 IntVector av = IntVector.fromArray(SPECIES, a, i);
3043 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3044 av.blend(bv, vmask).intoArray(r, i);
3045 }
3046 }
3047
3048 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::blend);
3049 }
3050
3051 @Test(dataProvider = "intUnaryOpShuffleProvider")
3052 static void RearrangeIntMaxVectorTests(IntFunction<int[]> fa,
3053 BiFunction<Integer,Integer,int[]> fs) {
3054 int[] a = fa.apply(SPECIES.length());
3055 int[] order = fs.apply(a.length, SPECIES.length());
3056 int[] r = fr.apply(SPECIES.length());
3057
3058 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3059 for (int i = 0; i < a.length; i += SPECIES.length()) {
3060 IntVector av = IntVector.fromArray(SPECIES, a, i);
3061 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
3062 }
3063 }
3064
3065 assertRearrangeArraysEquals(a, r, order, SPECIES.length());
3066 }
3067
3068
3069
3070
3071 @Test(dataProvider = "intUnaryOpProvider")
3072 static void getIntMaxVectorTests(IntFunction<int[]> fa) {
3073 int[] a = fa.apply(SPECIES.length());
3074 int[] r = fr.apply(SPECIES.length());
3075
3076 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3077 for (int i = 0; i < a.length; i += SPECIES.length()) {
3078 IntVector av = IntVector.fromArray(SPECIES, a, i);
3079 int num_lanes = SPECIES.length();
3080 // Manually unroll because full unroll happens after intrinsification.
3081 // Unroll is needed because get intrinsic requires for index to be a known constant.
3082 if (num_lanes == 1) {
3083 r[i]=av.lane(0);
3084 } else if (num_lanes == 2) {
3085 r[i]=av.lane(0);
3086 r[i+1]=av.lane(1);
3087 } else if (num_lanes == 4) {
3088 r[i]=av.lane(0);
3089 r[i+1]=av.lane(1);
3090 r[i+2]=av.lane(2);
3091 r[i+3]=av.lane(3);
3092 } else if (num_lanes == 8) {
3093 r[i]=av.lane(0);
3094 r[i+1]=av.lane(1);
3095 r[i+2]=av.lane(2);
3096 r[i+3]=av.lane(3);
3097 r[i+4]=av.lane(4);
3098 r[i+5]=av.lane(5);
3099 r[i+6]=av.lane(6);
3100 r[i+7]=av.lane(7);
3101 } else if (num_lanes == 16) {
3102 r[i]=av.lane(0);
3103 r[i+1]=av.lane(1);
3104 r[i+2]=av.lane(2);
3105 r[i+3]=av.lane(3);
3106 r[i+4]=av.lane(4);
3107 r[i+5]=av.lane(5);
3108 r[i+6]=av.lane(6);
3109 r[i+7]=av.lane(7);
3110 r[i+8]=av.lane(8);
3111 r[i+9]=av.lane(9);
3112 r[i+10]=av.lane(10);
3113 r[i+11]=av.lane(11);
3114 r[i+12]=av.lane(12);
3115 r[i+13]=av.lane(13);
3116 r[i+14]=av.lane(14);
3117 r[i+15]=av.lane(15);
3118 } else if (num_lanes == 32) {
3119 r[i]=av.lane(0);
3120 r[i+1]=av.lane(1);
3121 r[i+2]=av.lane(2);
3122 r[i+3]=av.lane(3);
3123 r[i+4]=av.lane(4);
3124 r[i+5]=av.lane(5);
3125 r[i+6]=av.lane(6);
3126 r[i+7]=av.lane(7);
3127 r[i+8]=av.lane(8);
3128 r[i+9]=av.lane(9);
3129 r[i+10]=av.lane(10);
3130 r[i+11]=av.lane(11);
3131 r[i+12]=av.lane(12);
3132 r[i+13]=av.lane(13);
3133 r[i+14]=av.lane(14);
3134 r[i+15]=av.lane(15);
3135 r[i+16]=av.lane(16);
3136 r[i+17]=av.lane(17);
3137 r[i+18]=av.lane(18);
3138 r[i+19]=av.lane(19);
3139 r[i+20]=av.lane(20);
3140 r[i+21]=av.lane(21);
3141 r[i+22]=av.lane(22);
3142 r[i+23]=av.lane(23);
3143 r[i+24]=av.lane(24);
3144 r[i+25]=av.lane(25);
3145 r[i+26]=av.lane(26);
3146 r[i+27]=av.lane(27);
3147 r[i+28]=av.lane(28);
3148 r[i+29]=av.lane(29);
3149 r[i+30]=av.lane(30);
3150 r[i+31]=av.lane(31);
3151 } else if (num_lanes == 64) {
3152 r[i]=av.lane(0);
3153 r[i+1]=av.lane(1);
3154 r[i+2]=av.lane(2);
3155 r[i+3]=av.lane(3);
3156 r[i+4]=av.lane(4);
3157 r[i+5]=av.lane(5);
3158 r[i+6]=av.lane(6);
3159 r[i+7]=av.lane(7);
3160 r[i+8]=av.lane(8);
3161 r[i+9]=av.lane(9);
3162 r[i+10]=av.lane(10);
3163 r[i+11]=av.lane(11);
3164 r[i+12]=av.lane(12);
3165 r[i+13]=av.lane(13);
3166 r[i+14]=av.lane(14);
3167 r[i+15]=av.lane(15);
3168 r[i+16]=av.lane(16);
3169 r[i+17]=av.lane(17);
3170 r[i+18]=av.lane(18);
3171 r[i+19]=av.lane(19);
3172 r[i+20]=av.lane(20);
3173 r[i+21]=av.lane(21);
3174 r[i+22]=av.lane(22);
3175 r[i+23]=av.lane(23);
3176 r[i+24]=av.lane(24);
3177 r[i+25]=av.lane(25);
3178 r[i+26]=av.lane(26);
3179 r[i+27]=av.lane(27);
3180 r[i+28]=av.lane(28);
3181 r[i+29]=av.lane(29);
3182 r[i+30]=av.lane(30);
3183 r[i+31]=av.lane(31);
3184 r[i+32]=av.lane(32);
3185 r[i+33]=av.lane(33);
3186 r[i+34]=av.lane(34);
3187 r[i+35]=av.lane(35);
3188 r[i+36]=av.lane(36);
3189 r[i+37]=av.lane(37);
3190 r[i+38]=av.lane(38);
3191 r[i+39]=av.lane(39);
3192 r[i+40]=av.lane(40);
3193 r[i+41]=av.lane(41);
3194 r[i+42]=av.lane(42);
3195 r[i+43]=av.lane(43);
3196 r[i+44]=av.lane(44);
3197 r[i+45]=av.lane(45);
3198 r[i+46]=av.lane(46);
3199 r[i+47]=av.lane(47);
3200 r[i+48]=av.lane(48);
3201 r[i+49]=av.lane(49);
3202 r[i+50]=av.lane(50);
3203 r[i+51]=av.lane(51);
3204 r[i+52]=av.lane(52);
3205 r[i+53]=av.lane(53);
3206 r[i+54]=av.lane(54);
3207 r[i+55]=av.lane(55);
3208 r[i+56]=av.lane(56);
3209 r[i+57]=av.lane(57);
3210 r[i+58]=av.lane(58);
3211 r[i+59]=av.lane(59);
3212 r[i+60]=av.lane(60);
3213 r[i+61]=av.lane(61);
3214 r[i+62]=av.lane(62);
3215 r[i+63]=av.lane(63);
3216 } else {
3217 for (int j = 0; j < SPECIES.length(); j++) {
3218 r[i+j]=av.lane(j);
3219 }
3220 }
3221 }
3222 }
3223
3224 assertArraysEquals(a, r, IntMaxVectorTests::get);
3225 }
3226
3227 @Test(dataProvider = "intUnaryOpProvider")
3228 static void BroadcastIntMaxVectorTests(IntFunction<int[]> fa) {
3229 int[] a = fa.apply(SPECIES.length());
3230 int[] r = new int[a.length];
3231
3232 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3233 for (int i = 0; i < a.length; i += SPECIES.length()) {
3234 IntVector.broadcast(SPECIES, a[i]).intoArray(r, i);
3235 }
3236 }
3237
3238 assertBroadcastArraysEquals(a, r);
3239 }
3240
3241
3242
3243
3244
3245 @Test(dataProvider = "intUnaryOpProvider")
3246 static void ZeroIntMaxVectorTests(IntFunction<int[]> fa) {
3247 int[] a = fa.apply(SPECIES.length());
3248 int[] r = new int[a.length];
3249
3250 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3251 for (int i = 0; i < a.length; i += SPECIES.length()) {
3252 IntVector.zero(SPECIES).intoArray(a, i);
3253 }
3254 }
3255
3256 Assert.assertEquals(a, r);
3257 }
3258
3259
3260
3261
3262 static int[] sliceUnary(int[] a, int origin, int idx) {
3263 int[] res = new int[SPECIES.length()];
3264 for (int i = 0; i < SPECIES.length(); i++){
3265 if(i+origin < SPECIES.length())
3266 res[i] = a[idx+i+origin];
3267 else
3268 res[i] = (int)0;
3269 }
3270 return res;
3271 }
3272
3273 @Test(dataProvider = "intUnaryOpProvider")
3274 static void sliceUnaryIntMaxVectorTests(IntFunction<int[]> fa) {
3275 int[] a = fa.apply(SPECIES.length());
3276 int[] r = new int[a.length];
3277 int origin = (new java.util.Random()).nextInt(SPECIES.length());
3278 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3279 for (int i = 0; i < a.length; i += SPECIES.length()) {
3280 IntVector av = IntVector.fromArray(SPECIES, a, i);
3281 av.slice(origin).intoArray(r, i);
3282 }
3283 }
3284
3285 assertArraysEquals(a, r, origin, IntMaxVectorTests::sliceUnary);
3286 }
3287 static int[] sliceBinary(int[] a, int[] b, int origin, int idx) {
3288 int[] res = new int[SPECIES.length()];
3289 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3290 if(i+origin < SPECIES.length())
3291 res[i] = a[idx+i+origin];
3292 else {
3293 res[i] = b[idx+j];
3294 j++;
3295 }
3296 }
3297 return res;
3298 }
3299
3300 @Test(dataProvider = "intBinaryOpProvider")
3301 static void sliceBinaryIntMaxVectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3302 int[] a = fa.apply(SPECIES.length());
3303 int[] b = fb.apply(SPECIES.length());
3304 int[] r = new int[a.length];
3305 int origin = (new java.util.Random()).nextInt(SPECIES.length());
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.slice(origin, bv).intoArray(r, i);
3311 }
3312 }
3313
3314 assertArraysEquals(a, b, r, origin, IntMaxVectorTests::sliceBinary);
3315 }
3316 static int[] slice(int[] a, int[] b, int origin, boolean[] mask, int idx) {
3317 int[] res = new int[SPECIES.length()];
3318 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3319 if(i+origin < SPECIES.length())
3320 res[i] = mask[i] ? a[idx+i+origin] : (int)0;
3321 else {
3322 res[i] = mask[i] ? b[idx+j] : (int)0;
3323 j++;
3324 }
3325 }
3326 return res;
3327 }
3328
3329 @Test(dataProvider = "intBinaryOpMaskProvider")
3330 static void sliceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3331 IntFunction<boolean[]> fm) {
3332 int[] a = fa.apply(SPECIES.length());
3333 int[] b = fb.apply(SPECIES.length());
3334 boolean[] mask = fm.apply(SPECIES.length());
3335 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3336
3337 int[] r = new int[a.length];
3338 int origin = (new java.util.Random()).nextInt(SPECIES.length());
3339 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3340 for (int i = 0; i < a.length; i += SPECIES.length()) {
3341 IntVector av = IntVector.fromArray(SPECIES, a, i);
3342 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3343 av.slice(origin, bv, vmask).intoArray(r, i);
3344 }
3345 }
3346
3347 assertArraysEquals(a, b, r, origin, mask, IntMaxVectorTests::slice);
3348 }
3349 static int[] unsliceUnary(int[] a, int origin, int idx) {
3350 int[] res = new int[SPECIES.length()];
3351 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3352 if(i < origin)
3353 res[i] = (int)0;
3354 else {
3355 res[i] = a[idx+j];
3356 j++;
3357 }
3358 }
3359 return res;
3360 }
3361
3362 @Test(dataProvider = "intUnaryOpProvider")
3363 static void unsliceUnaryIntMaxVectorTests(IntFunction<int[]> fa) {
3364 int[] a = fa.apply(SPECIES.length());
3365 int[] r = new int[a.length];
3366 int origin = (new java.util.Random()).nextInt(SPECIES.length());
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 av.unslice(origin).intoArray(r, i);
3371 }
3372 }
3373
3374 assertArraysEquals(a, r, origin, IntMaxVectorTests::unsliceUnary);
3375 }
3376 static int[] unsliceBinary(int[] a, int[] b, int origin, int part, int idx) {
3377 int[] res = new int[SPECIES.length()];
3378 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3379 if (part == 0) {
3380 if (i < origin)
3381 res[i] = b[idx+i];
3382 else {
3383 res[i] = a[idx+j];
3384 j++;
3385 }
3386 } else if (part == 1) {
3387 if (i < origin)
3388 res[i] = a[idx+SPECIES.length()-origin+i];
3389 else {
3390 res[i] = b[idx+origin+j];
3391 j++;
3392 }
3393 }
3394 }
3395 return res;
3396 }
3397
3398 @Test(dataProvider = "intBinaryOpProvider")
3399 static void unsliceBinaryIntMaxVectorTestsBinary(IntFunction<int[]> fa, IntFunction<int[]> fb) {
3400 int[] a = fa.apply(SPECIES.length());
3401 int[] b = fb.apply(SPECIES.length());
3402 int[] r = new int[a.length];
3403 int origin = (new java.util.Random()).nextInt(SPECIES.length());
3404 int part = (new java.util.Random()).nextInt(2);
3405 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3406 for (int i = 0; i < a.length; i += SPECIES.length()) {
3407 IntVector av = IntVector.fromArray(SPECIES, a, i);
3408 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3409 av.unslice(origin, bv, part).intoArray(r, i);
3410 }
3411 }
3412
3413 assertArraysEquals(a, b, r, origin, part, IntMaxVectorTests::unsliceBinary);
3414 }
3415 static int[] unslice(int[] a, int[] b, int origin, int part, boolean[] mask, int idx) {
3416 int[] res = new int[SPECIES.length()];
3417 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3418 if(i+origin < SPECIES.length())
3419 res[i] = b[idx+i+origin];
3420 else {
3421 res[i] = b[idx+j];
3422 j++;
3423 }
3424 }
3425 for (int i = 0; i < SPECIES.length(); i++){
3426 res[i] = mask[i] ? a[idx+i] : res[i];
3427 }
3428 int[] res1 = new int[SPECIES.length()];
3429 if (part == 0) {
3430 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3431 if (i < origin)
3432 res1[i] = b[idx+i];
3433 else {
3434 res1[i] = res[j];
3435 j++;
3436 }
3437 }
3438 } else if (part == 1) {
3439 for (int i = 0, j = 0; i < SPECIES.length(); i++){
3440 if (i < origin)
3441 res1[i] = res[SPECIES.length()-origin+i];
3442 else {
3443 res1[i] = b[idx+origin+j];
3444 j++;
3445 }
3446 }
3447 }
3448 return res1;
3449 }
3450
3451 @Test(dataProvider = "intBinaryOpMaskProvider")
3452 static void unsliceIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
3453 IntFunction<boolean[]> fm) {
3454 int[] a = fa.apply(SPECIES.length());
3455 int[] b = fb.apply(SPECIES.length());
3456 boolean[] mask = fm.apply(SPECIES.length());
3457 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3458 int[] r = new int[a.length];
3459 int origin = (new java.util.Random()).nextInt(SPECIES.length());
3460 int part = (new java.util.Random()).nextInt(2);
3461 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3462 for (int i = 0; i < a.length; i += SPECIES.length()) {
3463 IntVector av = IntVector.fromArray(SPECIES, a, i);
3464 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3465 av.unslice(origin, bv, part, vmask).intoArray(r, i);
3466 }
3467 }
3468
3469 assertArraysEquals(a, b, r, origin, part, mask, IntMaxVectorTests::unslice);
3470 }
3471
3472
3473
3474
3475
3476
3477
3478
3479
3480
3481
3482
3483
3484
3485
3486
3487
3488
3489
3490
3491
3492
3493 static int BITWISE_BLEND(int a, int b, int c) {
3494 return (int)((a&~(c))|(b&c));
3495 }
3496
3497
3498 @Test(dataProvider = "intTernaryOpProvider")
3499 static void BITWISE_BLENDIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, IntFunction<int[]> fc) {
3500 int[] a = fa.apply(SPECIES.length());
3501 int[] b = fb.apply(SPECIES.length());
3502 int[] c = fc.apply(SPECIES.length());
3503 int[] r = fr.apply(SPECIES.length());
3504
3505 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3506 for (int i = 0; i < a.length; i += SPECIES.length()) {
3507 IntVector av = IntVector.fromArray(SPECIES, a, i);
3508 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3509 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3510 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
3511 }
3512 }
3513
3514 assertArraysEquals(a, b, c, r, IntMaxVectorTests::BITWISE_BLEND);
3515 }
3516
3517
3518 @Test(dataProvider = "intTernaryOpMaskProvider")
3519 static void BITWISE_BLENDIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb,
3520 IntFunction<int[]> fc, IntFunction<boolean[]> fm) {
3521 int[] a = fa.apply(SPECIES.length());
3522 int[] b = fb.apply(SPECIES.length());
3523 int[] c = fc.apply(SPECIES.length());
3524 int[] r = fr.apply(SPECIES.length());
3525 boolean[] mask = fm.apply(SPECIES.length());
3526 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3527
3528 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3529 for (int i = 0; i < a.length; i += SPECIES.length()) {
3530 IntVector av = IntVector.fromArray(SPECIES, a, i);
3531 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3532 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3533 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
3534 }
3535 }
3536
3537 assertArraysEquals(a, b, c, r, mask, IntMaxVectorTests::BITWISE_BLEND);
3538 }
3539
3540
3541 static int NEG(int a) {
3542 return (int)(-((int)a));
3543 }
3544
3545 static int neg(int a) {
3546 return (int)(-((int)a));
3547 }
3548
3549 @Test(dataProvider = "intUnaryOpProvider")
3550 static void NEGIntMaxVectorTests(IntFunction<int[]> fa) {
3551 int[] a = fa.apply(SPECIES.length());
3552 int[] r = fr.apply(SPECIES.length());
3553
3554 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3555 for (int i = 0; i < a.length; i += SPECIES.length()) {
3556 IntVector av = IntVector.fromArray(SPECIES, a, i);
3557 av.lanewise(VectorOperators.NEG).intoArray(r, i);
3558 }
3559 }
3560
3561 assertArraysEquals(a, r, IntMaxVectorTests::NEG);
3562 }
3563
3564 @Test(dataProvider = "intUnaryOpProvider")
3565 static void negIntMaxVectorTests(IntFunction<int[]> fa) {
3566 int[] a = fa.apply(SPECIES.length());
3567 int[] r = fr.apply(SPECIES.length());
3568
3569 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3570 for (int i = 0; i < a.length; i += SPECIES.length()) {
3571 IntVector av = IntVector.fromArray(SPECIES, a, i);
3572 av.neg().intoArray(r, i);
3573 }
3574 }
3575
3576 assertArraysEquals(a, r, IntMaxVectorTests::neg);
3577 }
3578
3579 @Test(dataProvider = "intUnaryOpMaskProvider")
3580 static void NEGMaskedIntMaxVectorTests(IntFunction<int[]> fa,
3581 IntFunction<boolean[]> fm) {
3582 int[] a = fa.apply(SPECIES.length());
3583 int[] r = fr.apply(SPECIES.length());
3584 boolean[] mask = fm.apply(SPECIES.length());
3585 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3586
3587 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3588 for (int i = 0; i < a.length; i += SPECIES.length()) {
3589 IntVector av = IntVector.fromArray(SPECIES, a, i);
3590 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
3591 }
3592 }
3593
3594 assertArraysEquals(a, r, mask, IntMaxVectorTests::NEG);
3595 }
3596
3597 static int ABS(int a) {
3598 return (int)(Math.abs((int)a));
3599 }
3600
3601 static int abs(int a) {
3602 return (int)(Math.abs((int)a));
3603 }
3604
3605 @Test(dataProvider = "intUnaryOpProvider")
3606 static void ABSIntMaxVectorTests(IntFunction<int[]> fa) {
3607 int[] a = fa.apply(SPECIES.length());
3608 int[] r = fr.apply(SPECIES.length());
3609
3610 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3611 for (int i = 0; i < a.length; i += SPECIES.length()) {
3612 IntVector av = IntVector.fromArray(SPECIES, a, i);
3613 av.lanewise(VectorOperators.ABS).intoArray(r, i);
3614 }
3615 }
3616
3617 assertArraysEquals(a, r, IntMaxVectorTests::ABS);
3618 }
3619
3620 @Test(dataProvider = "intUnaryOpProvider")
3621 static void absIntMaxVectorTests(IntFunction<int[]> fa) {
3622 int[] a = fa.apply(SPECIES.length());
3623 int[] r = fr.apply(SPECIES.length());
3624
3625 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3626 for (int i = 0; i < a.length; i += SPECIES.length()) {
3627 IntVector av = IntVector.fromArray(SPECIES, a, i);
3628 av.abs().intoArray(r, i);
3629 }
3630 }
3631
3632 assertArraysEquals(a, r, IntMaxVectorTests::abs);
3633 }
3634
3635 @Test(dataProvider = "intUnaryOpMaskProvider")
3636 static void ABSMaskedIntMaxVectorTests(IntFunction<int[]> fa,
3637 IntFunction<boolean[]> fm) {
3638 int[] a = fa.apply(SPECIES.length());
3639 int[] r = fr.apply(SPECIES.length());
3640 boolean[] mask = fm.apply(SPECIES.length());
3641 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3642
3643 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3644 for (int i = 0; i < a.length; i += SPECIES.length()) {
3645 IntVector av = IntVector.fromArray(SPECIES, a, i);
3646 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
3647 }
3648 }
3649
3650 assertArraysEquals(a, r, mask, IntMaxVectorTests::ABS);
3651 }
3652
3653
3654 static int NOT(int a) {
3655 return (int)(~((int)a));
3656 }
3657
3658 static int not(int a) {
3659 return (int)(~((int)a));
3660 }
3661
3662
3663
3664 @Test(dataProvider = "intUnaryOpProvider")
3665 static void NOTIntMaxVectorTests(IntFunction<int[]> fa) {
3666 int[] a = fa.apply(SPECIES.length());
3667 int[] r = fr.apply(SPECIES.length());
3668
3669 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3670 for (int i = 0; i < a.length; i += SPECIES.length()) {
3671 IntVector av = IntVector.fromArray(SPECIES, a, i);
3672 av.lanewise(VectorOperators.NOT).intoArray(r, i);
3673 }
3674 }
3675
3676 assertArraysEquals(a, r, IntMaxVectorTests::NOT);
3677 }
3678
3679 @Test(dataProvider = "intUnaryOpProvider")
3680 static void notIntMaxVectorTests(IntFunction<int[]> fa) {
3681 int[] a = fa.apply(SPECIES.length());
3682 int[] r = fr.apply(SPECIES.length());
3683
3684 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3685 for (int i = 0; i < a.length; i += SPECIES.length()) {
3686 IntVector av = IntVector.fromArray(SPECIES, a, i);
3687 av.not().intoArray(r, i);
3688 }
3689 }
3690
3691 assertArraysEquals(a, r, IntMaxVectorTests::not);
3692 }
3693
3694
3695
3696 @Test(dataProvider = "intUnaryOpMaskProvider")
3697 static void NOTMaskedIntMaxVectorTests(IntFunction<int[]> fa,
3698 IntFunction<boolean[]> fm) {
3699 int[] a = fa.apply(SPECIES.length());
3700 int[] r = fr.apply(SPECIES.length());
3701 boolean[] mask = fm.apply(SPECIES.length());
3702 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3703
3704 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3705 for (int i = 0; i < a.length; i += SPECIES.length()) {
3706 IntVector av = IntVector.fromArray(SPECIES, a, i);
3707 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
3708 }
3709 }
3710
3711 assertArraysEquals(a, r, mask, IntMaxVectorTests::NOT);
3712 }
3713
3714
3715
3716 static int ZOMO(int a) {
3717 return (int)((a==0?0:-1));
3718 }
3719
3720
3721
3722 @Test(dataProvider = "intUnaryOpProvider")
3723 static void ZOMOIntMaxVectorTests(IntFunction<int[]> fa) {
3724 int[] a = fa.apply(SPECIES.length());
3725 int[] r = fr.apply(SPECIES.length());
3726
3727 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3728 for (int i = 0; i < a.length; i += SPECIES.length()) {
3729 IntVector av = IntVector.fromArray(SPECIES, a, i);
3730 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
3731 }
3732 }
3733
3734 assertArraysEquals(a, r, IntMaxVectorTests::ZOMO);
3735 }
3736
3737
3738
3739 @Test(dataProvider = "intUnaryOpMaskProvider")
3740 static void ZOMOMaskedIntMaxVectorTests(IntFunction<int[]> fa,
3741 IntFunction<boolean[]> fm) {
3742 int[] a = fa.apply(SPECIES.length());
3743 int[] r = fr.apply(SPECIES.length());
3744 boolean[] mask = fm.apply(SPECIES.length());
3745 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3746
3747 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3748 for (int i = 0; i < a.length; i += SPECIES.length()) {
3749 IntVector av = IntVector.fromArray(SPECIES, a, i);
3750 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
3751 }
3752 }
3753
3754 assertArraysEquals(a, r, mask, IntMaxVectorTests::ZOMO);
3755 }
3756
3757
3758
3759
3760 static int[] gather(int a[], int ix, int[] b, int iy) {
3761 int[] res = new int[SPECIES.length()];
3762 for (int i = 0; i < SPECIES.length(); i++) {
3763 int bi = iy + i;
3764 res[i] = a[b[bi] + ix];
3765 }
3766 return res;
3767 }
3768
3769 @Test(dataProvider = "intUnaryOpIndexProvider")
3770 static void gatherIntMaxVectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
3771 int[] a = fa.apply(SPECIES.length());
3772 int[] b = fs.apply(a.length, SPECIES.length());
3773 int[] r = new int[a.length];
3774
3775 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3776 for (int i = 0; i < a.length; i += SPECIES.length()) {
3777 IntVector av = IntVector.fromArray(SPECIES, a, i, b, i);
3778 av.intoArray(r, i);
3779 }
3780 }
3781
3782 assertArraysEquals(a, b, r, IntMaxVectorTests::gather);
3783 }
3784 static int[] gatherMasked(int a[], int ix, boolean[] mask, int[] b, int iy) {
3785 int[] res = new int[SPECIES.length()];
3786 for (int i = 0; i < SPECIES.length(); i++) {
3787 int bi = iy + i;
3788 if (mask[i]) {
3789 res[i] = a[b[bi] + ix];
3790 }
3791 }
3792 return res;
3793 }
3794
3795 @Test(dataProvider = "intUnaryMaskedOpIndexProvider")
3796 static void gatherMaskedIntMaxVectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
3797 int[] a = fa.apply(SPECIES.length());
3798 int[] b = fs.apply(a.length, SPECIES.length());
3799 int[] r = new int[a.length];
3800 boolean[] mask = fm.apply(SPECIES.length());
3801 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3802
3803 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3804 for (int i = 0; i < a.length; i += SPECIES.length()) {
3805 IntVector av = IntVector.fromArray(SPECIES, a, i, b, i, vmask);
3806 av.intoArray(r, i);
3807 }
3808 }
3809
3810 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::gatherMasked);
3811 }
3812
3813 static int[] scatter(int a[], int ix, int[] b, int iy) {
3814 int[] res = new int[SPECIES.length()];
3815 for (int i = 0; i < SPECIES.length(); i++) {
3816 int bi = iy + i;
3817 res[b[bi]] = a[i + ix];
3818 }
3819 return res;
3820 }
3821
3822 @Test(dataProvider = "intUnaryOpIndexProvider")
3823 static void scatterIntMaxVectorTests(IntFunction<int[]> fa, BiFunction<Integer,Integer,int[]> fs) {
3824 int[] a = fa.apply(SPECIES.length());
3825 int[] b = fs.apply(a.length, SPECIES.length());
3826 int[] r = new int[a.length];
3827
3828 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3829 for (int i = 0; i < a.length; i += SPECIES.length()) {
3830 IntVector av = IntVector.fromArray(SPECIES, a, i);
3831 av.intoArray(r, i, b, i);
3832 }
3833 }
3834
3835 assertArraysEquals(a, b, r, IntMaxVectorTests::scatter);
3836 }
3837
3838 static int[] scatterMasked(int r[], int a[], int ix, boolean[] mask, int[] b, int iy) {
3839 // First, gather r.
3840 int[] oldVal = gather(r, ix, b, iy);
3841 int[] newVal = new int[SPECIES.length()];
3842
3843 // Second, blending it with a.
3844 for (int i = 0; i < SPECIES.length(); i++) {
3845 newVal[i] = blend(oldVal[i], a[i+ix], mask[i]);
3846 }
3847
3848 // Third, scatter: copy old value of r, and scatter it manually.
3849 int[] res = Arrays.copyOfRange(r, ix, ix+SPECIES.length());
3850 for (int i = 0; i < SPECIES.length(); i++) {
3851 int bi = iy + i;
3852 res[b[bi]] = newVal[i];
3853 }
3854
3855 return res;
3856 }
3857
3858 @Test(dataProvider = "scatterMaskedOpIndexProvider")
3859 static void scatterMaskedIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb, BiFunction<Integer,Integer,int[]> fs, IntFunction<boolean[]> fm) {
3860 int[] a = fa.apply(SPECIES.length());
3861 int[] b = fs.apply(a.length, SPECIES.length());
3862 int[] r = fb.apply(SPECIES.length());
3863 boolean[] mask = fm.apply(SPECIES.length());
3864 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3865
3866 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3867 for (int i = 0; i < a.length; i += SPECIES.length()) {
3868 IntVector av = IntVector.fromArray(SPECIES, a, i);
3869 av.intoArray(r, i, b, i, vmask);
3870 }
3871 }
3872
3873 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::scatterMasked);
3874 }
3875
3876 }
3877