1 /*
2 * Copyright (c) 2018, 2022, 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 -XX:-TieredCompilation ShortMaxVectorTests
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.ShortVector;
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.Objects;
51 import java.util.stream.Collectors;
52 import java.util.stream.Stream;
53
54 @Test
55 public class ShortMaxVectorTests extends AbstractVectorTest {
56
57 static final VectorSpecies<Short> SPECIES =
58 ShortVector.SPECIES_MAX;
59
60 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
61
62 static VectorShape getMaxBit() {
63 return VectorShape.S_Max_BIT;
64 }
65
66 private static final int Max = 256; // juts so we can do N/Max
67
68 private static final short CONST_SHIFT = Short.SIZE / 2;
69
70 static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / Max);
71
72 interface FUnOp {
73 short apply(short a);
74 }
75
76 static void assertArraysEquals(short[] r, short[] a, FUnOp f) {
77 int i = 0;
78 try {
79 for (; i < a.length; i++) {
80 Assert.assertEquals(r[i], f.apply(a[i]));
81 }
82 } catch (AssertionError e) {
83 Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
84 }
85 }
86
87 interface FUnArrayOp {
88 short[] apply(short a);
89 }
90
91 static void assertArraysEquals(short[] r, short[] a, FUnArrayOp f) {
92 int i = 0;
93 try {
94 for (; i < a.length; i += SPECIES.length()) {
95 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
96 f.apply(a[i]));
97 }
98 } catch (AssertionError e) {
99 short[] ref = f.apply(a[i]);
100 short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
101 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
102 + ", res: " + Arrays.toString(res)
103 + "), at index #" + i);
104 }
105 }
106
107 static void assertArraysEquals(short[] r, short[] a, boolean[] mask, FUnOp f) {
108 int i = 0;
109 try {
110 for (; i < a.length; i++) {
111 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
112 }
113 } catch (AssertionError e) {
114 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()]);
115 }
116 }
117
118 interface FReductionOp {
119 short apply(short[] a, int idx);
120 }
121
122 interface FReductionAllOp {
123 short apply(short[] a);
124 }
125
126 static void assertReductionArraysEquals(short[] r, short rc, short[] a,
127 FReductionOp f, FReductionAllOp fa) {
128 int i = 0;
129 try {
130 Assert.assertEquals(rc, fa.apply(a));
131 for (; i < a.length; i += SPECIES.length()) {
132 Assert.assertEquals(r[i], f.apply(a, i));
133 }
134 } catch (AssertionError e) {
135 Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
136 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
137 }
138 }
139
140 interface FReductionMaskedOp {
141 short apply(short[] a, int idx, boolean[] mask);
142 }
143
144 interface FReductionAllMaskedOp {
145 short apply(short[] a, boolean[] mask);
146 }
147
148 static void assertReductionArraysEqualsMasked(short[] r, short rc, short[] a, boolean[] mask,
149 FReductionMaskedOp f, FReductionAllMaskedOp fa) {
150 int i = 0;
151 try {
152 Assert.assertEquals(rc, fa.apply(a, mask));
153 for (; i < a.length; i += SPECIES.length()) {
154 Assert.assertEquals(r[i], f.apply(a, i, mask));
155 }
156 } catch (AssertionError e) {
157 Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
158 Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
159 }
160 }
161
162 interface FReductionOpLong {
163 long apply(short[] a, int idx);
164 }
165
166 interface FReductionAllOpLong {
167 long apply(short[] a);
168 }
169
170 static void assertReductionLongArraysEquals(long[] r, long rc, short[] a,
171 FReductionOpLong f, FReductionAllOpLong fa) {
172 int i = 0;
173 try {
174 Assert.assertEquals(rc, fa.apply(a));
175 for (; i < a.length; i += SPECIES.length()) {
176 Assert.assertEquals(r[i], f.apply(a, i));
177 }
178 } catch (AssertionError e) {
179 Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
180 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
181 }
182 }
183
184 interface FReductionMaskedOpLong {
185 long apply(short[] a, int idx, boolean[] mask);
186 }
187
188 interface FReductionAllMaskedOpLong {
189 long apply(short[] a, boolean[] mask);
190 }
191
192 static void assertReductionLongArraysEqualsMasked(long[] r, long rc, short[] a, boolean[] mask,
193 FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) {
194 int i = 0;
195 try {
196 Assert.assertEquals(rc, fa.apply(a, mask));
197 for (; i < a.length; i += SPECIES.length()) {
198 Assert.assertEquals(r[i], f.apply(a, i, mask));
199 }
200 } catch (AssertionError e) {
201 Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
202 Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
203 }
204 }
205
206 interface FBoolReductionOp {
207 boolean apply(boolean[] a, int idx);
208 }
209
210 static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
211 int i = 0;
212 try {
213 for (; i < a.length; i += SPECIES.length()) {
214 Assert.assertEquals(r[i], f.apply(a, i));
215 }
216 } catch (AssertionError e) {
217 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
218 }
219 }
220
221 interface FMaskReductionOp {
222 int apply(boolean[] a, int idx);
223 }
224
225 static void assertMaskReductionArraysEquals(int[] r, boolean[] a, FMaskReductionOp f) {
226 int i = 0;
227 try {
228 for (; i < a.length; i += SPECIES.length()) {
229 Assert.assertEquals(r[i], f.apply(a, i));
230 }
231 } catch (AssertionError e) {
232 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
233 }
234 }
235
236 static void assertInsertArraysEquals(short[] r, short[] a, short element, int index, int start, int end) {
237 int i = start;
238 try {
239 for (; i < end; i += 1) {
240 if(i%SPECIES.length() == index) {
241 Assert.assertEquals(r[i], element);
242 } else {
243 Assert.assertEquals(r[i], a[i]);
244 }
245 }
246 } catch (AssertionError e) {
247 if (i%SPECIES.length() == index) {
248 Assert.assertEquals(r[i], element, "at index #" + i);
249 } else {
250 Assert.assertEquals(r[i], a[i], "at index #" + i);
251 }
252 }
253 }
254
255 static void assertRearrangeArraysEquals(short[] r, short[] a, int[] order, int vector_len) {
256 int i = 0, j = 0;
257 try {
258 for (; i < a.length; i += vector_len) {
259 for (j = 0; j < vector_len; j++) {
260 Assert.assertEquals(r[i+j], a[i+order[i+j]]);
261 }
262 }
263 } catch (AssertionError e) {
264 int idx = i + j;
265 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
266 }
267 }
268
269 static void assertcompressArraysEquals(short[] r, short[] a, boolean[] m, int vector_len) {
270 int i = 0, j = 0, k = 0;
271 try {
272 for (; i < a.length; i += vector_len) {
273 k = 0;
274 for (j = 0; j < vector_len; j++) {
275 if (m[(i + j) % SPECIES.length()]) {
276 Assert.assertEquals(r[i + k], a[i + j]);
277 k++;
278 }
279 }
280 for (; k < vector_len; k++) {
281 Assert.assertEquals(r[i + k], (short)0);
282 }
283 }
284 } catch (AssertionError e) {
285 int idx = i + k;
286 if (m[(i + j) % SPECIES.length()]) {
287 Assert.assertEquals(r[idx], a[i + j], "at index #" + idx);
288 } else {
289 Assert.assertEquals(r[idx], (short)0, "at index #" + idx);
290 }
291 }
292 }
293
294 static void assertexpandArraysEquals(short[] r, short[] a, boolean[] m, int vector_len) {
295 int i = 0, j = 0, k = 0;
296 try {
297 for (; i < a.length; i += vector_len) {
298 k = 0;
299 for (j = 0; j < vector_len; j++) {
300 if (m[(i + j) % SPECIES.length()]) {
301 Assert.assertEquals(r[i + j], a[i + k]);
302 k++;
303 } else {
304 Assert.assertEquals(r[i + j], (short)0);
305 }
306 }
307 }
308 } catch (AssertionError e) {
309 int idx = i + j;
310 if (m[idx % SPECIES.length()]) {
311 Assert.assertEquals(r[idx], a[i + k], "at index #" + idx);
312 } else {
313 Assert.assertEquals(r[idx], (short)0, "at index #" + idx);
314 }
315 }
316 }
317
318 static void assertSelectFromArraysEquals(short[] r, short[] a, short[] order, int vector_len) {
319 int i = 0, j = 0;
320 try {
321 for (; i < a.length; i += vector_len) {
322 for (j = 0; j < vector_len; j++) {
323 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
324 }
325 }
326 } catch (AssertionError e) {
327 int idx = i + j;
328 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
329 }
330 }
331
332 static void assertRearrangeArraysEquals(short[] r, short[] a, int[] order, boolean[] mask, int vector_len) {
333 int i = 0, j = 0;
334 try {
335 for (; i < a.length; i += vector_len) {
336 for (j = 0; j < vector_len; j++) {
337 if (mask[j % SPECIES.length()])
338 Assert.assertEquals(r[i+j], a[i+order[i+j]]);
339 else
340 Assert.assertEquals(r[i+j], (short)0);
341 }
342 }
343 } catch (AssertionError e) {
344 int idx = i + j;
345 if (mask[j % SPECIES.length()])
346 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
347 else
348 Assert.assertEquals(r[i+j], (short)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
349 }
350 }
351
352 static void assertSelectFromArraysEquals(short[] r, short[] a, short[] order, boolean[] mask, int vector_len) {
353 int i = 0, j = 0;
354 try {
355 for (; i < a.length; i += vector_len) {
356 for (j = 0; j < vector_len; j++) {
357 if (mask[j % SPECIES.length()])
358 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
359 else
360 Assert.assertEquals(r[i+j], (short)0);
361 }
362 }
363 } catch (AssertionError e) {
364 int idx = i + j;
365 if (mask[j % SPECIES.length()])
366 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
367 else
368 Assert.assertEquals(r[i+j], (short)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
369 }
370 }
371
372 static void assertBroadcastArraysEquals(short[] r, short[] a) {
373 int i = 0;
374 for (; i < a.length; i += SPECIES.length()) {
375 int idx = i;
376 for (int j = idx; j < (idx + SPECIES.length()); j++)
377 a[j]=a[idx];
378 }
379
380 try {
381 for (i = 0; i < a.length; i++) {
382 Assert.assertEquals(r[i], a[i]);
383 }
384 } catch (AssertionError e) {
385 Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
386 }
387 }
388
389 interface FBinOp {
390 short apply(short a, short b);
391 }
392
393 interface FBinMaskOp {
394 short apply(short a, short b, boolean m);
395
396 static FBinMaskOp lift(FBinOp f) {
397 return (a, b, m) -> m ? f.apply(a, b) : a;
398 }
399 }
400
401 static void assertArraysEquals(short[] r, short[] a, short[] b, FBinOp f) {
402 int i = 0;
403 try {
404 for (; i < a.length; i++) {
405 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
406 }
407 } catch (AssertionError e) {
408 Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
409 }
410 }
411
412 static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, FBinOp f) {
413 int i = 0;
414 try {
415 for (; i < a.length; i++) {
416 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
417 }
418 } catch (AssertionError e) {
419 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
420 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
421 }
422 }
423
424 static void assertBroadcastLongArraysEquals(short[] r, short[] a, short[] b, FBinOp f) {
425 int i = 0;
426 try {
427 for (; i < a.length; i++) {
428 Assert.assertEquals(r[i], f.apply(a[i], (short)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
429 }
430 } catch (AssertionError e) {
431 Assert.assertEquals(r[i], f.apply(a[i], (short)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
432 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
433 }
434 }
435
436 static void assertArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
437 assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
438 }
439
440 static void assertArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinMaskOp f) {
441 int i = 0;
442 try {
443 for (; i < a.length; i++) {
444 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
445 }
446 } catch (AssertionError err) {
447 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()]);
448 }
449 }
450
451 static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
452 assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
453 }
454
455 static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinMaskOp f) {
456 int i = 0;
457 try {
458 for (; i < a.length; i++) {
459 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
460 }
461 } catch (AssertionError err) {
462 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
463 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
464 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
465 mask[i % SPECIES.length()]);
466 }
467 }
468
469 static void assertBroadcastLongArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
470 assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
471 }
472
473 static void assertBroadcastLongArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinMaskOp f) {
474 int i = 0;
475 try {
476 for (; i < a.length; i++) {
477 Assert.assertEquals(r[i], f.apply(a[i], (short)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
478 }
479 } catch (AssertionError err) {
480 Assert.assertEquals(r[i], f.apply(a[i], (short)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
481 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
482 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
483 mask[i % SPECIES.length()]);
484 }
485 }
486
487 static void assertShiftArraysEquals(short[] r, short[] a, short[] b, FBinOp f) {
488 int i = 0;
489 int j = 0;
490 try {
491 for (; j < a.length; j += SPECIES.length()) {
492 for (i = 0; i < SPECIES.length(); i++) {
493 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
494 }
495 }
496 } catch (AssertionError e) {
497 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
498 }
499 }
500
501 static void assertShiftArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinOp f) {
502 assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
503 }
504
505 static void assertShiftArraysEquals(short[] r, short[] a, short[] b, boolean[] mask, FBinMaskOp f) {
506 int i = 0;
507 int j = 0;
508 try {
509 for (; j < a.length; j += SPECIES.length()) {
510 for (i = 0; i < SPECIES.length(); i++) {
511 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
512 }
513 }
514 } catch (AssertionError err) {
515 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]);
516 }
517 }
518
519 interface FBinConstOp {
520 short apply(short a);
521 }
522
523 interface FBinConstMaskOp {
524 short apply(short a, boolean m);
525
526 static FBinConstMaskOp lift(FBinConstOp f) {
527 return (a, m) -> m ? f.apply(a) : a;
528 }
529 }
530
531 static void assertShiftConstEquals(short[] r, short[] a, FBinConstOp f) {
532 int i = 0;
533 int j = 0;
534 try {
535 for (; j < a.length; j += SPECIES.length()) {
536 for (i = 0; i < SPECIES.length(); i++) {
537 Assert.assertEquals(r[i+j], f.apply(a[i+j]));
538 }
539 }
540 } catch (AssertionError e) {
541 Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j);
542 }
543 }
544
545 static void assertShiftConstEquals(short[] r, short[] a, boolean[] mask, FBinConstOp f) {
546 assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
547 }
548
549 static void assertShiftConstEquals(short[] r, short[] a, boolean[] mask, FBinConstMaskOp f) {
550 int i = 0;
551 int j = 0;
552 try {
553 for (; j < a.length; j += SPECIES.length()) {
554 for (i = 0; i < SPECIES.length(); i++) {
555 Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]));
556 }
557 }
558 } catch (AssertionError err) {
559 Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]);
560 }
561 }
562
563 interface FTernOp {
564 short apply(short a, short b, short c);
565 }
566
567 interface FTernMaskOp {
568 short apply(short a, short b, short c, boolean m);
569
570 static FTernMaskOp lift(FTernOp f) {
571 return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
572 }
573 }
574
575 static void assertArraysEquals(short[] r, short[] a, short[] b, short[] c, FTernOp f) {
576 int i = 0;
577 try {
578 for (; i < a.length; i++) {
579 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
580 }
581 } catch (AssertionError e) {
582 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
583 }
584 }
585
586 static void assertArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask, FTernOp f) {
587 assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
588 }
589
590 static void assertArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask, FTernMaskOp f) {
591 int i = 0;
592 try {
593 for (; i < a.length; i++) {
594 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
595 }
596 } catch (AssertionError err) {
597 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
598 + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
599 }
600 }
601
602 static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, FTernOp f) {
603 int i = 0;
604 try {
605 for (; i < a.length; i++) {
606 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
607 }
608 } catch (AssertionError e) {
609 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
610 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
611 c[(i / SPECIES.length()) * SPECIES.length()]);
612 }
613 }
614
615 static void assertAltBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, FTernOp f) {
616 int i = 0;
617 try {
618 for (; i < a.length; i++) {
619 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
620 }
621 } catch (AssertionError e) {
622 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
623 i + ", input1 = " + a[i] + ", input2 = " +
624 b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " + c[i]);
625 }
626 }
627
628 static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
629 FTernOp f) {
630 assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
631 }
632
633 static void assertBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
634 FTernMaskOp f) {
635 int i = 0;
636 try {
637 for (; i < a.length; i++) {
638 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
639 mask[i % SPECIES.length()]));
640 }
641 } catch (AssertionError err) {
642 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
643 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
644 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
645 mask[i % SPECIES.length()]);
646 }
647 }
648
649 static void assertAltBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
650 FTernOp f) {
651 assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
652 }
653
654 static void assertAltBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
655 FTernMaskOp f) {
656 int i = 0;
657 try {
658 for (; i < a.length; i++) {
659 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
660 mask[i % SPECIES.length()]));
661 }
662 } catch (AssertionError err) {
663 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
664 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
665 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
666 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
667 }
668 }
669
670 static void assertDoubleBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, FTernOp f) {
671 int i = 0;
672 try {
673 for (; i < a.length; i++) {
674 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
675 c[(i / SPECIES.length()) * SPECIES.length()]));
676 }
677 } catch (AssertionError e) {
678 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
679 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
680 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
681 c[(i / SPECIES.length()) * SPECIES.length()]);
682 }
683 }
684
685 static void assertDoubleBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
686 FTernOp f) {
687 assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
688 }
689
690 static void assertDoubleBroadcastArraysEquals(short[] r, short[] a, short[] b, short[] c, boolean[] mask,
691 FTernMaskOp f) {
692 int i = 0;
693 try {
694 for (; i < a.length; i++) {
695 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
696 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
697 }
698 } catch (AssertionError err) {
699 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
700 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
701 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
702 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
703 mask[i % SPECIES.length()]);
704 }
705 }
706
707
708
709 interface FBinArrayOp {
710 short apply(short[] a, int b);
711 }
712
713 static void assertArraysEquals(short[] r, short[] a, FBinArrayOp f) {
714 int i = 0;
715 try {
716 for (; i < a.length; i++) {
717 Assert.assertEquals(r[i], f.apply(a, i));
718 }
719 } catch (AssertionError e) {
720 Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
721 }
722 }
723
724 interface FGatherScatterOp {
725 short[] apply(short[] a, int ix, int[] b, int iy);
726 }
727
728 static void assertArraysEquals(short[] r, short[] a, int[] b, FGatherScatterOp f) {
729 int i = 0;
730 try {
731 for (; i < a.length; i += SPECIES.length()) {
732 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
733 f.apply(a, i, b, i));
734 }
735 } catch (AssertionError e) {
736 short[] ref = f.apply(a, i, b, i);
737 short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
738 Assert.assertEquals(res, ref,
739 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
740 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
741 + ", b: "
742 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
743 + " at index #" + i);
744 }
745 }
746
747 interface FGatherMaskedOp {
748 short[] apply(short[] a, int ix, boolean[] mask, int[] b, int iy);
749 }
750
751 interface FScatterMaskedOp {
752 short[] apply(short[] r, short[] a, int ix, boolean[] mask, int[] b, int iy);
753 }
754
755 static void assertArraysEquals(short[] r, short[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
756 int i = 0;
757 try {
758 for (; i < a.length; i += SPECIES.length()) {
759 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
760 f.apply(a, i, mask, b, i));
761 }
762 } catch (AssertionError e) {
763 short[] ref = f.apply(a, i, mask, b, i);
764 short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
765 Assert.assertEquals(res, ref,
766 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
767 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
768 + ", b: "
769 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
770 + ", mask: "
771 + Arrays.toString(mask)
772 + " at index #" + i);
773 }
774 }
775
776 static void assertArraysEquals(short[] r, short[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
777 int i = 0;
778 try {
779 for (; i < a.length; i += SPECIES.length()) {
780 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
781 f.apply(r, a, i, mask, b, i));
782 }
783 } catch (AssertionError e) {
784 short[] ref = f.apply(r, a, i, mask, b, i);
785 short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
786 Assert.assertEquals(res, ref,
787 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
788 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
789 + ", b: "
790 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
791 + ", r: "
792 + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
793 + ", mask: "
794 + Arrays.toString(mask)
795 + " at index #" + i);
796 }
797 }
798
799 interface FLaneOp {
800 short[] apply(short[] a, int origin, int idx);
801 }
802
803 static void assertArraysEquals(short[] r, short[] a, int origin, FLaneOp f) {
804 int i = 0;
805 try {
806 for (; i < a.length; i += SPECIES.length()) {
807 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
808 f.apply(a, origin, i));
809 }
810 } catch (AssertionError e) {
811 short[] ref = f.apply(a, origin, i);
812 short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
813 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
814 + ", res: " + Arrays.toString(res)
815 + "), at index #" + i);
816 }
817 }
818
819 interface FLaneBop {
820 short[] apply(short[] a, short[] b, int origin, int idx);
821 }
822
823 static void assertArraysEquals(short[] r, short[] a, short[] b, int origin, FLaneBop f) {
824 int i = 0;
825 try {
826 for (; i < a.length; i += SPECIES.length()) {
827 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
828 f.apply(a, b, origin, i));
829 }
830 } catch (AssertionError e) {
831 short[] ref = f.apply(a, b, origin, i);
832 short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
833 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
834 + ", res: " + Arrays.toString(res)
835 + "), at index #" + i
836 + ", at origin #" + origin);
837 }
838 }
839
840 interface FLaneMaskedBop {
841 short[] apply(short[] a, short[] b, int origin, boolean[] mask, int idx);
842 }
843
844 static void assertArraysEquals(short[] r, short[] a, short[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
845 int i = 0;
846 try {
847 for (; i < a.length; i += SPECIES.length()) {
848 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
849 f.apply(a, b, origin, mask, i));
850 }
851 } catch (AssertionError e) {
852 short[] ref = f.apply(a, b, origin, mask, i);
853 short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
854 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
855 + ", res: " + Arrays.toString(res)
856 + "), at index #" + i
857 + ", at origin #" + origin);
858 }
859 }
860
861 interface FLanePartBop {
862 short[] apply(short[] a, short[] b, int origin, int part, int idx);
863 }
864
865 static void assertArraysEquals(short[] r, short[] a, short[] b, int origin, int part, FLanePartBop f) {
866 int i = 0;
867 try {
868 for (; i < a.length; i += SPECIES.length()) {
869 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
870 f.apply(a, b, origin, part, i));
871 }
872 } catch (AssertionError e) {
873 short[] ref = f.apply(a, b, origin, part, i);
874 short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
875 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
876 + ", res: " + Arrays.toString(res)
877 + "), at index #" + i
878 + ", at origin #" + origin
879 + ", with part #" + part);
880 }
881 }
882
883 interface FLanePartMaskedBop {
884 short[] apply(short[] a, short[] b, int origin, int part, boolean[] mask, int idx);
885 }
886
887 static void assertArraysEquals(short[] r, short[] a, short[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
888 int i = 0;
889 try {
890 for (; i < a.length; i += SPECIES.length()) {
891 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
892 f.apply(a, b, origin, part, mask, i));
893 }
894 } catch (AssertionError e) {
895 short[] ref = f.apply(a, b, origin, part, mask, i);
896 short[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
897 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
898 + ", res: " + Arrays.toString(res)
899 + "), at index #" + i
900 + ", at origin #" + origin
901 + ", with part #" + part);
902 }
903 }
904
905
906 static void assertArraysEquals(int[] r, short[] a, int offs) {
907 int i = 0;
908 try {
909 for (; i < r.length; i++) {
910 Assert.assertEquals(r[i], (int)(a[i+offs]));
911 }
912 } catch (AssertionError e) {
913 Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
914 }
915 }
916
917
918
919 static void assertArraysEquals(long[] r, short[] a, int offs) {
920 int i = 0;
921 try {
922 for (; i < r.length; i++) {
923 Assert.assertEquals(r[i], (long)(a[i+offs]));
924 }
925 } catch (AssertionError e) {
926 Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
927 }
928 }
929
930 static void assertArraysEquals(double[] r, short[] a, int offs) {
931 int i = 0;
932 try {
933 for (; i < r.length; i++) {
934 Assert.assertEquals(r[i], (double)(a[i+offs]));
935 }
936 } catch (AssertionError e) {
937 Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
938 }
939 }
940
941 static short bits(short e) {
942 return e;
943 }
944
945 static final List<IntFunction<short[]>> SHORT_GENERATORS = List.of(
946 withToString("short[-i * 5]", (int s) -> {
947 return fill(s * BUFFER_REPS,
948 i -> (short)(-i * 5));
949 }),
950 withToString("short[i * 5]", (int s) -> {
951 return fill(s * BUFFER_REPS,
952 i -> (short)(i * 5));
953 }),
954 withToString("short[i + 1]", (int s) -> {
955 return fill(s * BUFFER_REPS,
956 i -> (((short)(i + 1) == 0) ? 1 : (short)(i + 1)));
957 }),
958 withToString("short[cornerCaseValue(i)]", (int s) -> {
959 return fill(s * BUFFER_REPS,
960 i -> cornerCaseValue(i));
961 })
962 );
963
964 // Create combinations of pairs
965 // @@@ Might be sensitive to order e.g. div by 0
966 static final List<List<IntFunction<short[]>>> SHORT_GENERATOR_PAIRS =
967 Stream.of(SHORT_GENERATORS.get(0)).
968 flatMap(fa -> SHORT_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
969 collect(Collectors.toList());
970
971 @DataProvider
972 public Object[][] boolUnaryOpProvider() {
973 return BOOL_ARRAY_GENERATORS.stream().
974 map(f -> new Object[]{f}).
975 toArray(Object[][]::new);
976 }
977
978 static final List<List<IntFunction<short[]>>> SHORT_GENERATOR_TRIPLES =
979 SHORT_GENERATOR_PAIRS.stream().
980 flatMap(pair -> SHORT_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
981 collect(Collectors.toList());
982
983 @DataProvider
984 public Object[][] shortBinaryOpProvider() {
985 return SHORT_GENERATOR_PAIRS.stream().map(List::toArray).
986 toArray(Object[][]::new);
987 }
988
989 @DataProvider
990 public Object[][] shortIndexedOpProvider() {
991 return SHORT_GENERATOR_PAIRS.stream().map(List::toArray).
992 toArray(Object[][]::new);
993 }
994
995 @DataProvider
996 public Object[][] shortBinaryOpMaskProvider() {
997 return BOOLEAN_MASK_GENERATORS.stream().
998 flatMap(fm -> SHORT_GENERATOR_PAIRS.stream().map(lfa -> {
999 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1000 })).
1001 toArray(Object[][]::new);
1002 }
1003
1004 @DataProvider
1005 public Object[][] shortTernaryOpProvider() {
1006 return SHORT_GENERATOR_TRIPLES.stream().map(List::toArray).
1007 toArray(Object[][]::new);
1008 }
1009
1010 @DataProvider
1011 public Object[][] shortTernaryOpMaskProvider() {
1012 return BOOLEAN_MASK_GENERATORS.stream().
1013 flatMap(fm -> SHORT_GENERATOR_TRIPLES.stream().map(lfa -> {
1014 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1015 })).
1016 toArray(Object[][]::new);
1017 }
1018
1019 @DataProvider
1020 public Object[][] shortUnaryOpProvider() {
1021 return SHORT_GENERATORS.stream().
1022 map(f -> new Object[]{f}).
1023 toArray(Object[][]::new);
1024 }
1025
1026 @DataProvider
1027 public Object[][] shortUnaryOpMaskProvider() {
1028 return BOOLEAN_MASK_GENERATORS.stream().
1029 flatMap(fm -> SHORT_GENERATORS.stream().map(fa -> {
1030 return new Object[] {fa, fm};
1031 })).
1032 toArray(Object[][]::new);
1033 }
1034
1035 @DataProvider
1036 public Object[][] maskProvider() {
1037 return BOOLEAN_MASK_GENERATORS.stream().
1038 map(f -> new Object[]{f}).
1039 toArray(Object[][]::new);
1040 }
1041
1042 @DataProvider
1043 public Object[][] maskCompareOpProvider() {
1044 return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1045 toArray(Object[][]::new);
1046 }
1047
1048 @DataProvider
1049 public Object[][] shuffleProvider() {
1050 return INT_SHUFFLE_GENERATORS.stream().
1051 map(f -> new Object[]{f}).
1052 toArray(Object[][]::new);
1053 }
1054
1055 @DataProvider
1056 public Object[][] shuffleCompareOpProvider() {
1057 return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1058 toArray(Object[][]::new);
1059 }
1060
1061 @DataProvider
1062 public Object[][] shortUnaryOpShuffleProvider() {
1063 return INT_SHUFFLE_GENERATORS.stream().
1064 flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1065 return new Object[] {fa, fs};
1066 })).
1067 toArray(Object[][]::new);
1068 }
1069
1070 @DataProvider
1071 public Object[][] shortUnaryOpShuffleMaskProvider() {
1072 return BOOLEAN_MASK_GENERATORS.stream().
1073 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1074 flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1075 return new Object[] {fa, fs, fm};
1076 }))).
1077 toArray(Object[][]::new);
1078 }
1079
1080 static final List<BiFunction<Integer,Integer,short[]>> SHORT_SHUFFLE_GENERATORS = List.of(
1081 withToStringBi("shuffle[random]", (Integer l, Integer m) -> {
1082 short[] a = new short[l];
1083 int upper = m;
1084 for (int i = 0; i < 1; i++) {
1085 a[i] = (short)RAND.nextInt(upper);
1086 }
1087 return a;
1088 })
1089 );
1090
1091 @DataProvider
1092 public Object[][] shortUnaryOpSelectFromProvider() {
1093 return SHORT_SHUFFLE_GENERATORS.stream().
1094 flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1095 return new Object[] {fa, fs};
1096 })).
1097 toArray(Object[][]::new);
1098 }
1099
1100 @DataProvider
1101 public Object[][] shortUnaryOpSelectFromMaskProvider() {
1102 return BOOLEAN_MASK_GENERATORS.stream().
1103 flatMap(fm -> SHORT_SHUFFLE_GENERATORS.stream().
1104 flatMap(fs -> SHORT_GENERATORS.stream().map(fa -> {
1105 return new Object[] {fa, fs, fm};
1106 }))).
1107 toArray(Object[][]::new);
1108 }
1109
1110 static final List<IntFunction<short[]>> SHORT_COMPARE_GENERATORS = List.of(
1111 withToString("short[i]", (int s) -> {
1112 return fill(s * BUFFER_REPS,
1113 i -> (short)i);
1114 }),
1115 withToString("short[i - length / 2]", (int s) -> {
1116 return fill(s * BUFFER_REPS,
1117 i -> (short)(i - (s * BUFFER_REPS / 2)));
1118 }),
1119 withToString("short[i + 1]", (int s) -> {
1120 return fill(s * BUFFER_REPS,
1121 i -> (short)(i + 1));
1122 }),
1123 withToString("short[i - 2]", (int s) -> {
1124 return fill(s * BUFFER_REPS,
1125 i -> (short)(i - 2));
1126 }),
1127 withToString("short[zigZag(i)]", (int s) -> {
1128 return fill(s * BUFFER_REPS,
1129 i -> i%3 == 0 ? (short)i : (i%3 == 1 ? (short)(i + 1) : (short)(i - 2)));
1130 }),
1131 withToString("short[cornerCaseValue(i)]", (int s) -> {
1132 return fill(s * BUFFER_REPS,
1133 i -> cornerCaseValue(i));
1134 })
1135 );
1136
1137 static final List<List<IntFunction<short[]>>> SHORT_TEST_GENERATOR_ARGS =
1138 SHORT_COMPARE_GENERATORS.stream().
1139 map(fa -> List.of(fa)).
1140 collect(Collectors.toList());
1141
1142 @DataProvider
1143 public Object[][] shortTestOpProvider() {
1144 return SHORT_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1145 toArray(Object[][]::new);
1146 }
1147
1148 @DataProvider
1149 public Object[][] shortTestOpMaskProvider() {
1150 return BOOLEAN_MASK_GENERATORS.stream().
1151 flatMap(fm -> SHORT_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1152 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1153 })).
1154 toArray(Object[][]::new);
1155 }
1156
1157 static final List<List<IntFunction<short[]>>> SHORT_COMPARE_GENERATOR_PAIRS =
1158 SHORT_COMPARE_GENERATORS.stream().
1159 flatMap(fa -> SHORT_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1160 collect(Collectors.toList());
1161
1162 @DataProvider
1163 public Object[][] shortCompareOpProvider() {
1164 return SHORT_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1165 toArray(Object[][]::new);
1166 }
1167
1168 @DataProvider
1169 public Object[][] shortCompareOpMaskProvider() {
1170 return BOOLEAN_MASK_GENERATORS.stream().
1171 flatMap(fm -> SHORT_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1172 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1173 })).
1174 toArray(Object[][]::new);
1175 }
1176
1177 interface ToShortF {
1178 short apply(int i);
1179 }
1180
1181 static short[] fill(int s , ToShortF f) {
1182 return fill(new short[s], f);
1183 }
1184
1185 static short[] fill(short[] a, ToShortF f) {
1186 for (int i = 0; i < a.length; i++) {
1187 a[i] = f.apply(i);
1188 }
1189 return a;
1190 }
1191
1192 static short cornerCaseValue(int i) {
1193 switch(i % 5) {
1194 case 0:
1195 return Short.MAX_VALUE;
1196 case 1:
1197 return Short.MIN_VALUE;
1198 case 2:
1199 return Short.MIN_VALUE;
1200 case 3:
1201 return Short.MAX_VALUE;
1202 default:
1203 return (short)0;
1204 }
1205 }
1206
1207 static short get(short[] a, int i) {
1208 return (short) a[i];
1209 }
1210
1211 static final IntFunction<short[]> fr = (vl) -> {
1212 int length = BUFFER_REPS * vl;
1213 return new short[length];
1214 };
1215
1216 static final IntFunction<boolean[]> fmr = (vl) -> {
1217 int length = BUFFER_REPS * vl;
1218 return new boolean[length];
1219 };
1220
1221 static final IntFunction<long[]> lfr = (vl) -> {
1222 int length = BUFFER_REPS * vl;
1223 return new long[length];
1224 };
1225
1226 static void replaceZero(short[] a, short v) {
1227 for (int i = 0; i < a.length; i++) {
1228 if (a[i] == 0) {
1229 a[i] = v;
1230 }
1231 }
1232 }
1233
1234 static void replaceZero(short[] a, boolean[] mask, short v) {
1235 for (int i = 0; i < a.length; i++) {
1236 if (mask[i % mask.length] && a[i] == 0) {
1237 a[i] = v;
1238 }
1239 }
1240 }
1241
1242 static short ROL_scalar(short a, short b) {
1243 return (short)(((((short)a) & 0xFFFF) << (b & 15)) | ((((short)a) & 0xFFFF) >>> (16 - (b & 15))));
1244 }
1245
1246 static short ROR_scalar(short a, short b) {
1247 return (short)(((((short)a) & 0xFFFF) >>> (b & 15)) | ((((short)a) & 0xFFFF) << (16 - (b & 15))));
1248 }
1249
1250 static short TRAILING_ZEROS_COUNT_scalar(short a) {
1251 return (short) (a != 0 ? Integer.numberOfTrailingZeros(a) : 16);
1252 }
1253
1254 static short LEADING_ZEROS_COUNT_scalar(short a) {
1255 return (short) (a >= 0 ? Integer.numberOfLeadingZeros(a) - 16 : 0);
1256 }
1257
1258 static short REVERSE_scalar(short a) {
1259 short b = ROL_scalar(a, (short) 8);
1260 b = (short) (((b & 0x5555) << 1) | ((b & 0xAAAA) >>> 1));
1261 b = (short) (((b & 0x3333) << 2) | ((b & 0xCCCC) >>> 2));
1262 b = (short) (((b & 0x0F0F) << 4) | ((b & 0xF0F0) >>> 4));
1263 return b;
1264 }
1265
1266 static boolean eq(short a, short b) {
1267 return a == b;
1268 }
1269
1270 static boolean neq(short a, short b) {
1271 return a != b;
1272 }
1273
1274 static boolean lt(short a, short b) {
1275 return a < b;
1276 }
1277
1278 static boolean le(short a, short b) {
1279 return a <= b;
1280 }
1281
1282 static boolean gt(short a, short b) {
1283 return a > b;
1284 }
1285
1286 static boolean ge(short a, short b) {
1287 return a >= b;
1288 }
1289
1290 static boolean ult(short a, short b) {
1291 return Short.compareUnsigned(a, b) < 0;
1292 }
1293
1294 static boolean ule(short a, short b) {
1295 return Short.compareUnsigned(a, b) <= 0;
1296 }
1297
1298 static boolean ugt(short a, short b) {
1299 return Short.compareUnsigned(a, b) > 0;
1300 }
1301
1302 static boolean uge(short a, short b) {
1303 return Short.compareUnsigned(a, b) >= 0;
1304 }
1305
1306 static short firstNonZero(short a, short b) {
1307 return Short.compare(a, (short) 0) != 0 ? a : b;
1308 }
1309
1310 @Test
1311 static void smokeTest1() {
1312 ShortVector three = ShortVector.broadcast(SPECIES, (byte)-3);
1313 ShortVector three2 = (ShortVector) SPECIES.broadcast(-3);
1314 assert(three.eq(three2).allTrue());
1315 ShortVector three3 = three2.broadcast(1).broadcast(-3);
1316 assert(three.eq(three3).allTrue());
1317 int scale = 2;
1318 Class<?> ETYPE = short.class;
1319 if (ETYPE == double.class || ETYPE == long.class)
1320 scale = 1000000;
1321 else if (ETYPE == byte.class && SPECIES.length() >= 64)
1322 scale = 1;
1323 ShortVector higher = three.addIndex(scale);
1324 VectorMask<Short> m = three.compare(VectorOperators.LE, higher);
1325 assert(m.allTrue());
1326 m = higher.min((short)-1).test(VectorOperators.IS_NEGATIVE);
1327 assert(m.allTrue());
1328 short max = higher.reduceLanes(VectorOperators.MAX);
1329 assert(max == -3 + scale * (SPECIES.length()-1));
1330 }
1331
1332 private static short[]
1333 bothToArray(ShortVector a, ShortVector b) {
1334 short[] r = new short[a.length() + b.length()];
1335 a.intoArray(r, 0);
1336 b.intoArray(r, a.length());
1337 return r;
1338 }
1339
1340 @Test
1341 static void smokeTest2() {
1342 // Do some zipping and shuffling.
1343 ShortVector io = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1344 ShortVector io2 = (ShortVector) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1345 Assert.assertEquals(io, io2);
1346 ShortVector a = io.add((short)1); //[1,2]
1347 ShortVector b = a.neg(); //[-1,-2]
1348 short[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1349 VectorShuffle<Short> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1350 VectorShuffle<Short> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1351 ShortVector zab0 = a.rearrange(zip0,b); //[1,-1]
1352 ShortVector zab1 = a.rearrange(zip1,b); //[2,-2]
1353 short[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1354 // manually zip
1355 short[] manual = new short[zabValues.length];
1356 for (int i = 0; i < manual.length; i += 2) {
1357 manual[i+0] = abValues[i/2];
1358 manual[i+1] = abValues[a.length() + i/2];
1359 }
1360 Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1361 VectorShuffle<Short> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1362 VectorShuffle<Short> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1363 ShortVector uab0 = zab0.rearrange(unz0,zab1);
1364 ShortVector uab1 = zab0.rearrange(unz1,zab1);
1365 short[] abValues1 = bothToArray(uab0, uab1);
1366 Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1367 }
1368
1369 static void iotaShuffle() {
1370 ShortVector io = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1371 ShortVector io2 = (ShortVector) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1372 Assert.assertEquals(io, io2);
1373 }
1374
1375 @Test
1376 // Test all shuffle related operations.
1377 static void shuffleTest() {
1378 // To test backend instructions, make sure that C2 is used.
1379 for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1380 iotaShuffle();
1381 }
1382 }
1383
1384 @Test
1385 void viewAsIntegeralLanesTest() {
1386 Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1387 Assert.assertEquals(asIntegral.species(), SPECIES);
1388 }
1389
1390 @Test(expectedExceptions = UnsupportedOperationException.class)
1391 void viewAsFloatingLanesTest() {
1392 SPECIES.zero().viewAsFloatingLanes();
1393 }
1394
1395 @Test
1396 // Test div by 0.
1397 static void bitwiseDivByZeroSmokeTest() {
1398 try {
1399 ShortVector a = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1400 ShortVector b = (ShortVector) SPECIES.broadcast(0);
1401 a.div(b);
1402 Assert.fail();
1403 } catch (ArithmeticException e) {
1404 }
1405
1406 try {
1407 ShortVector a = (ShortVector) SPECIES.broadcast(0).addIndex(1);
1408 ShortVector b = (ShortVector) SPECIES.broadcast(0);
1409 VectorMask<Short> m = a.lt((short) 1);
1410 a.div(b, m);
1411 Assert.fail();
1412 } catch (ArithmeticException e) {
1413 }
1414 }
1415
1416 static short ADD(short a, short b) {
1417 return (short)(a + b);
1418 }
1419
1420 @Test(dataProvider = "shortBinaryOpProvider")
1421 static void ADDShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1422 short[] a = fa.apply(SPECIES.length());
1423 short[] b = fb.apply(SPECIES.length());
1424 short[] r = fr.apply(SPECIES.length());
1425
1426 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1427 for (int i = 0; i < a.length; i += SPECIES.length()) {
1428 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1429 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1430 av.lanewise(VectorOperators.ADD, bv).intoArray(r, i);
1431 }
1432 }
1433
1434 assertArraysEquals(r, a, b, ShortMaxVectorTests::ADD);
1435 }
1436
1437 static short add(short a, short b) {
1438 return (short)(a + b);
1439 }
1440
1441 @Test(dataProvider = "shortBinaryOpProvider")
1442 static void addShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1443 short[] a = fa.apply(SPECIES.length());
1444 short[] b = fb.apply(SPECIES.length());
1445 short[] r = fr.apply(SPECIES.length());
1446
1447 for (int i = 0; i < a.length; i += SPECIES.length()) {
1448 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1449 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1450 av.add(bv).intoArray(r, i);
1451 }
1452
1453 assertArraysEquals(r, a, b, ShortMaxVectorTests::add);
1454 }
1455
1456 @Test(dataProvider = "shortBinaryOpMaskProvider")
1457 static void ADDShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1458 IntFunction<boolean[]> fm) {
1459 short[] a = fa.apply(SPECIES.length());
1460 short[] b = fb.apply(SPECIES.length());
1461 short[] r = fr.apply(SPECIES.length());
1462 boolean[] mask = fm.apply(SPECIES.length());
1463 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1464
1465 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1466 for (int i = 0; i < a.length; i += SPECIES.length()) {
1467 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1468 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1469 av.lanewise(VectorOperators.ADD, bv, vmask).intoArray(r, i);
1470 }
1471 }
1472
1473 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ADD);
1474 }
1475
1476 @Test(dataProvider = "shortBinaryOpMaskProvider")
1477 static void addShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1478 IntFunction<boolean[]> fm) {
1479 short[] a = fa.apply(SPECIES.length());
1480 short[] b = fb.apply(SPECIES.length());
1481 short[] r = fr.apply(SPECIES.length());
1482 boolean[] mask = fm.apply(SPECIES.length());
1483 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1484
1485 for (int i = 0; i < a.length; i += SPECIES.length()) {
1486 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1487 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1488 av.add(bv, vmask).intoArray(r, i);
1489 }
1490
1491 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::add);
1492 }
1493
1494 static short SUB(short a, short b) {
1495 return (short)(a - b);
1496 }
1497
1498 @Test(dataProvider = "shortBinaryOpProvider")
1499 static void SUBShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1500 short[] a = fa.apply(SPECIES.length());
1501 short[] b = fb.apply(SPECIES.length());
1502 short[] r = fr.apply(SPECIES.length());
1503
1504 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1505 for (int i = 0; i < a.length; i += SPECIES.length()) {
1506 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1507 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1508 av.lanewise(VectorOperators.SUB, bv).intoArray(r, i);
1509 }
1510 }
1511
1512 assertArraysEquals(r, a, b, ShortMaxVectorTests::SUB);
1513 }
1514
1515 static short sub(short a, short b) {
1516 return (short)(a - b);
1517 }
1518
1519 @Test(dataProvider = "shortBinaryOpProvider")
1520 static void subShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1521 short[] a = fa.apply(SPECIES.length());
1522 short[] b = fb.apply(SPECIES.length());
1523 short[] r = fr.apply(SPECIES.length());
1524
1525 for (int i = 0; i < a.length; i += SPECIES.length()) {
1526 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1527 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1528 av.sub(bv).intoArray(r, i);
1529 }
1530
1531 assertArraysEquals(r, a, b, ShortMaxVectorTests::sub);
1532 }
1533
1534 @Test(dataProvider = "shortBinaryOpMaskProvider")
1535 static void SUBShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1536 IntFunction<boolean[]> fm) {
1537 short[] a = fa.apply(SPECIES.length());
1538 short[] b = fb.apply(SPECIES.length());
1539 short[] r = fr.apply(SPECIES.length());
1540 boolean[] mask = fm.apply(SPECIES.length());
1541 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1542
1543 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1544 for (int i = 0; i < a.length; i += SPECIES.length()) {
1545 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1546 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1547 av.lanewise(VectorOperators.SUB, bv, vmask).intoArray(r, i);
1548 }
1549 }
1550
1551 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::SUB);
1552 }
1553
1554 @Test(dataProvider = "shortBinaryOpMaskProvider")
1555 static void subShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1556 IntFunction<boolean[]> fm) {
1557 short[] a = fa.apply(SPECIES.length());
1558 short[] b = fb.apply(SPECIES.length());
1559 short[] r = fr.apply(SPECIES.length());
1560 boolean[] mask = fm.apply(SPECIES.length());
1561 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1562
1563 for (int i = 0; i < a.length; i += SPECIES.length()) {
1564 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1565 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1566 av.sub(bv, vmask).intoArray(r, i);
1567 }
1568
1569 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::sub);
1570 }
1571
1572 static short MUL(short a, short b) {
1573 return (short)(a * b);
1574 }
1575
1576 @Test(dataProvider = "shortBinaryOpProvider")
1577 static void MULShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1578 short[] a = fa.apply(SPECIES.length());
1579 short[] b = fb.apply(SPECIES.length());
1580 short[] r = fr.apply(SPECIES.length());
1581
1582 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1583 for (int i = 0; i < a.length; i += SPECIES.length()) {
1584 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1585 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1586 av.lanewise(VectorOperators.MUL, bv).intoArray(r, i);
1587 }
1588 }
1589
1590 assertArraysEquals(r, a, b, ShortMaxVectorTests::MUL);
1591 }
1592
1593 static short mul(short a, short b) {
1594 return (short)(a * b);
1595 }
1596
1597 @Test(dataProvider = "shortBinaryOpProvider")
1598 static void mulShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1599 short[] a = fa.apply(SPECIES.length());
1600 short[] b = fb.apply(SPECIES.length());
1601 short[] r = fr.apply(SPECIES.length());
1602
1603 for (int i = 0; i < a.length; i += SPECIES.length()) {
1604 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1605 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1606 av.mul(bv).intoArray(r, i);
1607 }
1608
1609 assertArraysEquals(r, a, b, ShortMaxVectorTests::mul);
1610 }
1611
1612 @Test(dataProvider = "shortBinaryOpMaskProvider")
1613 static void MULShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1614 IntFunction<boolean[]> fm) {
1615 short[] a = fa.apply(SPECIES.length());
1616 short[] b = fb.apply(SPECIES.length());
1617 short[] r = fr.apply(SPECIES.length());
1618 boolean[] mask = fm.apply(SPECIES.length());
1619 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1620
1621 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1622 for (int i = 0; i < a.length; i += SPECIES.length()) {
1623 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1624 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1625 av.lanewise(VectorOperators.MUL, bv, vmask).intoArray(r, i);
1626 }
1627 }
1628
1629 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::MUL);
1630 }
1631
1632 @Test(dataProvider = "shortBinaryOpMaskProvider")
1633 static void mulShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1634 IntFunction<boolean[]> fm) {
1635 short[] a = fa.apply(SPECIES.length());
1636 short[] b = fb.apply(SPECIES.length());
1637 short[] r = fr.apply(SPECIES.length());
1638 boolean[] mask = fm.apply(SPECIES.length());
1639 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1640
1641 for (int i = 0; i < a.length; i += SPECIES.length()) {
1642 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1643 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1644 av.mul(bv, vmask).intoArray(r, i);
1645 }
1646
1647 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::mul);
1648 }
1649
1650 static short DIV(short a, short b) {
1651 return (short)(a / b);
1652 }
1653
1654 @Test(dataProvider = "shortBinaryOpProvider")
1655 static void DIVShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1656 short[] a = fa.apply(SPECIES.length());
1657 short[] b = fb.apply(SPECIES.length());
1658 short[] r = fr.apply(SPECIES.length());
1659
1660 replaceZero(b, (short) 1);
1661
1662 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1663 for (int i = 0; i < a.length; i += SPECIES.length()) {
1664 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1665 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1666 av.lanewise(VectorOperators.DIV, bv).intoArray(r, i);
1667 }
1668 }
1669
1670 assertArraysEquals(r, a, b, ShortMaxVectorTests::DIV);
1671 }
1672
1673 static short div(short a, short b) {
1674 return (short)(a / b);
1675 }
1676
1677 @Test(dataProvider = "shortBinaryOpProvider")
1678 static void divShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1679 short[] a = fa.apply(SPECIES.length());
1680 short[] b = fb.apply(SPECIES.length());
1681 short[] r = fr.apply(SPECIES.length());
1682
1683 replaceZero(b, (short) 1);
1684
1685 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1686 for (int i = 0; i < a.length; i += SPECIES.length()) {
1687 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1688 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1689 av.div(bv).intoArray(r, i);
1690 }
1691 }
1692
1693 assertArraysEquals(r, a, b, ShortMaxVectorTests::div);
1694 }
1695
1696 @Test(dataProvider = "shortBinaryOpMaskProvider")
1697 static void DIVShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1698 IntFunction<boolean[]> fm) {
1699 short[] a = fa.apply(SPECIES.length());
1700 short[] b = fb.apply(SPECIES.length());
1701 short[] r = fr.apply(SPECIES.length());
1702 boolean[] mask = fm.apply(SPECIES.length());
1703 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1704
1705 replaceZero(b, mask, (short) 1);
1706
1707 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1708 for (int i = 0; i < a.length; i += SPECIES.length()) {
1709 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1710 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1711 av.lanewise(VectorOperators.DIV, bv, vmask).intoArray(r, i);
1712 }
1713 }
1714
1715 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::DIV);
1716 }
1717
1718 @Test(dataProvider = "shortBinaryOpMaskProvider")
1719 static void divShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1720 IntFunction<boolean[]> fm) {
1721 short[] a = fa.apply(SPECIES.length());
1722 short[] b = fb.apply(SPECIES.length());
1723 short[] r = fr.apply(SPECIES.length());
1724 boolean[] mask = fm.apply(SPECIES.length());
1725 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1726
1727 replaceZero(b, mask, (short) 1);
1728
1729 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1730 for (int i = 0; i < a.length; i += SPECIES.length()) {
1731 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1732 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1733 av.div(bv, vmask).intoArray(r, i);
1734 }
1735 }
1736
1737 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::div);
1738 }
1739
1740 static short FIRST_NONZERO(short a, short b) {
1741 return (short)((a)!=0?a:b);
1742 }
1743
1744 @Test(dataProvider = "shortBinaryOpProvider")
1745 static void FIRST_NONZEROShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1746 short[] a = fa.apply(SPECIES.length());
1747 short[] b = fb.apply(SPECIES.length());
1748 short[] r = fr.apply(SPECIES.length());
1749
1750 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1751 for (int i = 0; i < a.length; i += SPECIES.length()) {
1752 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1753 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1754 av.lanewise(VectorOperators.FIRST_NONZERO, bv).intoArray(r, i);
1755 }
1756 }
1757
1758 assertArraysEquals(r, a, b, ShortMaxVectorTests::FIRST_NONZERO);
1759 }
1760
1761 @Test(dataProvider = "shortBinaryOpMaskProvider")
1762 static void FIRST_NONZEROShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1763 IntFunction<boolean[]> fm) {
1764 short[] a = fa.apply(SPECIES.length());
1765 short[] b = fb.apply(SPECIES.length());
1766 short[] r = fr.apply(SPECIES.length());
1767 boolean[] mask = fm.apply(SPECIES.length());
1768 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1769
1770 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1771 for (int i = 0; i < a.length; i += SPECIES.length()) {
1772 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1773 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1774 av.lanewise(VectorOperators.FIRST_NONZERO, bv, vmask).intoArray(r, i);
1775 }
1776 }
1777
1778 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::FIRST_NONZERO);
1779 }
1780
1781 static short AND(short a, short b) {
1782 return (short)(a & b);
1783 }
1784
1785 @Test(dataProvider = "shortBinaryOpProvider")
1786 static void ANDShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1787 short[] a = fa.apply(SPECIES.length());
1788 short[] b = fb.apply(SPECIES.length());
1789 short[] r = fr.apply(SPECIES.length());
1790
1791 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1792 for (int i = 0; i < a.length; i += SPECIES.length()) {
1793 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1794 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1795 av.lanewise(VectorOperators.AND, bv).intoArray(r, i);
1796 }
1797 }
1798
1799 assertArraysEquals(r, a, b, ShortMaxVectorTests::AND);
1800 }
1801
1802 static short and(short a, short b) {
1803 return (short)(a & b);
1804 }
1805
1806 @Test(dataProvider = "shortBinaryOpProvider")
1807 static void andShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1808 short[] a = fa.apply(SPECIES.length());
1809 short[] b = fb.apply(SPECIES.length());
1810 short[] r = fr.apply(SPECIES.length());
1811
1812 for (int i = 0; i < a.length; i += SPECIES.length()) {
1813 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1814 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1815 av.and(bv).intoArray(r, i);
1816 }
1817
1818 assertArraysEquals(r, a, b, ShortMaxVectorTests::and);
1819 }
1820
1821 @Test(dataProvider = "shortBinaryOpMaskProvider")
1822 static void ANDShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1823 IntFunction<boolean[]> fm) {
1824 short[] a = fa.apply(SPECIES.length());
1825 short[] b = fb.apply(SPECIES.length());
1826 short[] r = fr.apply(SPECIES.length());
1827 boolean[] mask = fm.apply(SPECIES.length());
1828 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1829
1830 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1831 for (int i = 0; i < a.length; i += SPECIES.length()) {
1832 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1833 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1834 av.lanewise(VectorOperators.AND, bv, vmask).intoArray(r, i);
1835 }
1836 }
1837
1838 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::AND);
1839 }
1840
1841 static short AND_NOT(short a, short b) {
1842 return (short)(a & ~b);
1843 }
1844
1845 @Test(dataProvider = "shortBinaryOpProvider")
1846 static void AND_NOTShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1847 short[] a = fa.apply(SPECIES.length());
1848 short[] b = fb.apply(SPECIES.length());
1849 short[] r = fr.apply(SPECIES.length());
1850
1851 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1852 for (int i = 0; i < a.length; i += SPECIES.length()) {
1853 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1854 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1855 av.lanewise(VectorOperators.AND_NOT, bv).intoArray(r, i);
1856 }
1857 }
1858
1859 assertArraysEquals(r, a, b, ShortMaxVectorTests::AND_NOT);
1860 }
1861
1862 @Test(dataProvider = "shortBinaryOpMaskProvider")
1863 static void AND_NOTShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1864 IntFunction<boolean[]> fm) {
1865 short[] a = fa.apply(SPECIES.length());
1866 short[] b = fb.apply(SPECIES.length());
1867 short[] r = fr.apply(SPECIES.length());
1868 boolean[] mask = fm.apply(SPECIES.length());
1869 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1870
1871 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1872 for (int i = 0; i < a.length; i += SPECIES.length()) {
1873 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1874 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1875 av.lanewise(VectorOperators.AND_NOT, bv, vmask).intoArray(r, i);
1876 }
1877 }
1878
1879 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::AND_NOT);
1880 }
1881
1882 static short OR(short a, short b) {
1883 return (short)(a | b);
1884 }
1885
1886 @Test(dataProvider = "shortBinaryOpProvider")
1887 static void ORShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1888 short[] a = fa.apply(SPECIES.length());
1889 short[] b = fb.apply(SPECIES.length());
1890 short[] r = fr.apply(SPECIES.length());
1891
1892 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1893 for (int i = 0; i < a.length; i += SPECIES.length()) {
1894 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1895 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1896 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
1897 }
1898 }
1899
1900 assertArraysEquals(r, a, b, ShortMaxVectorTests::OR);
1901 }
1902
1903 static short or(short a, short b) {
1904 return (short)(a | b);
1905 }
1906
1907 @Test(dataProvider = "shortBinaryOpProvider")
1908 static void orShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1909 short[] a = fa.apply(SPECIES.length());
1910 short[] b = fb.apply(SPECIES.length());
1911 short[] r = fr.apply(SPECIES.length());
1912
1913 for (int i = 0; i < a.length; i += SPECIES.length()) {
1914 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1915 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1916 av.or(bv).intoArray(r, i);
1917 }
1918
1919 assertArraysEquals(r, a, b, ShortMaxVectorTests::or);
1920 }
1921
1922 @Test(dataProvider = "shortBinaryOpMaskProvider")
1923 static void ORShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1924 IntFunction<boolean[]> fm) {
1925 short[] a = fa.apply(SPECIES.length());
1926 short[] b = fb.apply(SPECIES.length());
1927 short[] r = fr.apply(SPECIES.length());
1928 boolean[] mask = fm.apply(SPECIES.length());
1929 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1930
1931 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1932 for (int i = 0; i < a.length; i += SPECIES.length()) {
1933 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1934 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1935 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
1936 }
1937 }
1938
1939 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::OR);
1940 }
1941
1942 static short XOR(short a, short b) {
1943 return (short)(a ^ b);
1944 }
1945
1946 @Test(dataProvider = "shortBinaryOpProvider")
1947 static void XORShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1948 short[] a = fa.apply(SPECIES.length());
1949 short[] b = fb.apply(SPECIES.length());
1950 short[] r = fr.apply(SPECIES.length());
1951
1952 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1953 for (int i = 0; i < a.length; i += SPECIES.length()) {
1954 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1955 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1956 av.lanewise(VectorOperators.XOR, bv).intoArray(r, i);
1957 }
1958 }
1959
1960 assertArraysEquals(r, a, b, ShortMaxVectorTests::XOR);
1961 }
1962
1963 @Test(dataProvider = "shortBinaryOpMaskProvider")
1964 static void XORShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
1965 IntFunction<boolean[]> fm) {
1966 short[] a = fa.apply(SPECIES.length());
1967 short[] b = fb.apply(SPECIES.length());
1968 short[] r = fr.apply(SPECIES.length());
1969 boolean[] mask = fm.apply(SPECIES.length());
1970 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1971
1972 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1973 for (int i = 0; i < a.length; i += SPECIES.length()) {
1974 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1975 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
1976 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
1977 }
1978 }
1979
1980 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::XOR);
1981 }
1982
1983 @Test(dataProvider = "shortBinaryOpProvider")
1984 static void addShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
1985 short[] a = fa.apply(SPECIES.length());
1986 short[] b = fb.apply(SPECIES.length());
1987 short[] r = fr.apply(SPECIES.length());
1988
1989 for (int i = 0; i < a.length; i += SPECIES.length()) {
1990 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
1991 av.add(b[i]).intoArray(r, i);
1992 }
1993
1994 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::add);
1995 }
1996
1997 @Test(dataProvider = "shortBinaryOpMaskProvider")
1998 static void addShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
1999 IntFunction<boolean[]> fm) {
2000 short[] a = fa.apply(SPECIES.length());
2001 short[] b = fb.apply(SPECIES.length());
2002 short[] r = fr.apply(SPECIES.length());
2003 boolean[] mask = fm.apply(SPECIES.length());
2004 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2005
2006 for (int i = 0; i < a.length; i += SPECIES.length()) {
2007 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2008 av.add(b[i], vmask).intoArray(r, i);
2009 }
2010
2011 assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::add);
2012 }
2013
2014 @Test(dataProvider = "shortBinaryOpProvider")
2015 static void subShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2016 short[] a = fa.apply(SPECIES.length());
2017 short[] b = fb.apply(SPECIES.length());
2018 short[] r = fr.apply(SPECIES.length());
2019
2020 for (int i = 0; i < a.length; i += SPECIES.length()) {
2021 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2022 av.sub(b[i]).intoArray(r, i);
2023 }
2024
2025 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::sub);
2026 }
2027
2028 @Test(dataProvider = "shortBinaryOpMaskProvider")
2029 static void subShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2030 IntFunction<boolean[]> fm) {
2031 short[] a = fa.apply(SPECIES.length());
2032 short[] b = fb.apply(SPECIES.length());
2033 short[] r = fr.apply(SPECIES.length());
2034 boolean[] mask = fm.apply(SPECIES.length());
2035 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2036
2037 for (int i = 0; i < a.length; i += SPECIES.length()) {
2038 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2039 av.sub(b[i], vmask).intoArray(r, i);
2040 }
2041
2042 assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::sub);
2043 }
2044
2045 @Test(dataProvider = "shortBinaryOpProvider")
2046 static void mulShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2047 short[] a = fa.apply(SPECIES.length());
2048 short[] b = fb.apply(SPECIES.length());
2049 short[] r = fr.apply(SPECIES.length());
2050
2051 for (int i = 0; i < a.length; i += SPECIES.length()) {
2052 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2053 av.mul(b[i]).intoArray(r, i);
2054 }
2055
2056 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::mul);
2057 }
2058
2059 @Test(dataProvider = "shortBinaryOpMaskProvider")
2060 static void mulShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2061 IntFunction<boolean[]> fm) {
2062 short[] a = fa.apply(SPECIES.length());
2063 short[] b = fb.apply(SPECIES.length());
2064 short[] r = fr.apply(SPECIES.length());
2065 boolean[] mask = fm.apply(SPECIES.length());
2066 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2067
2068 for (int i = 0; i < a.length; i += SPECIES.length()) {
2069 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2070 av.mul(b[i], vmask).intoArray(r, i);
2071 }
2072
2073 assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::mul);
2074 }
2075
2076 @Test(dataProvider = "shortBinaryOpProvider")
2077 static void divShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2078 short[] a = fa.apply(SPECIES.length());
2079 short[] b = fb.apply(SPECIES.length());
2080 short[] r = fr.apply(SPECIES.length());
2081
2082 replaceZero(b, (short) 1);
2083
2084 for (int i = 0; i < a.length; i += SPECIES.length()) {
2085 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2086 av.div(b[i]).intoArray(r, i);
2087 }
2088
2089 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::div);
2090 }
2091
2092 @Test(dataProvider = "shortBinaryOpMaskProvider")
2093 static void divShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2094 IntFunction<boolean[]> fm) {
2095 short[] a = fa.apply(SPECIES.length());
2096 short[] b = fb.apply(SPECIES.length());
2097 short[] r = fr.apply(SPECIES.length());
2098 boolean[] mask = fm.apply(SPECIES.length());
2099 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2100
2101 replaceZero(b, (short) 1);
2102
2103 for (int i = 0; i < a.length; i += SPECIES.length()) {
2104 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2105 av.div(b[i], vmask).intoArray(r, i);
2106 }
2107
2108 assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::div);
2109 }
2110
2111 @Test(dataProvider = "shortBinaryOpProvider")
2112 static void ORShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2113 short[] a = fa.apply(SPECIES.length());
2114 short[] b = fb.apply(SPECIES.length());
2115 short[] r = fr.apply(SPECIES.length());
2116
2117 for (int i = 0; i < a.length; i += SPECIES.length()) {
2118 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2119 av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
2120 }
2121
2122 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::OR);
2123 }
2124
2125 @Test(dataProvider = "shortBinaryOpProvider")
2126 static void orShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2127 short[] a = fa.apply(SPECIES.length());
2128 short[] b = fb.apply(SPECIES.length());
2129 short[] r = fr.apply(SPECIES.length());
2130
2131 for (int i = 0; i < a.length; i += SPECIES.length()) {
2132 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2133 av.or(b[i]).intoArray(r, i);
2134 }
2135
2136 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::or);
2137 }
2138
2139 @Test(dataProvider = "shortBinaryOpMaskProvider")
2140 static void ORShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2141 IntFunction<boolean[]> fm) {
2142 short[] a = fa.apply(SPECIES.length());
2143 short[] b = fb.apply(SPECIES.length());
2144 short[] r = fr.apply(SPECIES.length());
2145 boolean[] mask = fm.apply(SPECIES.length());
2146 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2147
2148 for (int i = 0; i < a.length; i += SPECIES.length()) {
2149 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2150 av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
2151 }
2152
2153 assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::OR);
2154 }
2155
2156 @Test(dataProvider = "shortBinaryOpProvider")
2157 static void ANDShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2158 short[] a = fa.apply(SPECIES.length());
2159 short[] b = fb.apply(SPECIES.length());
2160 short[] r = fr.apply(SPECIES.length());
2161
2162 for (int i = 0; i < a.length; i += SPECIES.length()) {
2163 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2164 av.lanewise(VectorOperators.AND, b[i]).intoArray(r, i);
2165 }
2166
2167 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::AND);
2168 }
2169
2170 @Test(dataProvider = "shortBinaryOpProvider")
2171 static void andShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2172 short[] a = fa.apply(SPECIES.length());
2173 short[] b = fb.apply(SPECIES.length());
2174 short[] r = fr.apply(SPECIES.length());
2175
2176 for (int i = 0; i < a.length; i += SPECIES.length()) {
2177 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2178 av.and(b[i]).intoArray(r, i);
2179 }
2180
2181 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::and);
2182 }
2183
2184 @Test(dataProvider = "shortBinaryOpMaskProvider")
2185 static void ANDShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2186 IntFunction<boolean[]> fm) {
2187 short[] a = fa.apply(SPECIES.length());
2188 short[] b = fb.apply(SPECIES.length());
2189 short[] r = fr.apply(SPECIES.length());
2190 boolean[] mask = fm.apply(SPECIES.length());
2191 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2192
2193 for (int i = 0; i < a.length; i += SPECIES.length()) {
2194 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2195 av.lanewise(VectorOperators.AND, b[i], vmask).intoArray(r, i);
2196 }
2197
2198 assertBroadcastArraysEquals(r, a, b, mask, ShortMaxVectorTests::AND);
2199 }
2200
2201 @Test(dataProvider = "shortBinaryOpProvider")
2202 static void ORShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2203 short[] a = fa.apply(SPECIES.length());
2204 short[] b = fb.apply(SPECIES.length());
2205 short[] r = fr.apply(SPECIES.length());
2206
2207 for (int i = 0; i < a.length; i += SPECIES.length()) {
2208 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2209 av.lanewise(VectorOperators.OR, (long)b[i]).intoArray(r, i);
2210 }
2211
2212 assertBroadcastLongArraysEquals(r, a, b, ShortMaxVectorTests::OR);
2213 }
2214
2215 @Test(dataProvider = "shortBinaryOpMaskProvider")
2216 static void ORShortMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2217 IntFunction<boolean[]> fm) {
2218 short[] a = fa.apply(SPECIES.length());
2219 short[] b = fb.apply(SPECIES.length());
2220 short[] r = fr.apply(SPECIES.length());
2221 boolean[] mask = fm.apply(SPECIES.length());
2222 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2223
2224 for (int i = 0; i < a.length; i += SPECIES.length()) {
2225 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2226 av.lanewise(VectorOperators.OR, (long)b[i], vmask).intoArray(r, i);
2227 }
2228
2229 assertBroadcastLongArraysEquals(r, a, b, mask, ShortMaxVectorTests::OR);
2230 }
2231
2232 @Test(dataProvider = "shortBinaryOpProvider")
2233 static void ADDShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2234 short[] a = fa.apply(SPECIES.length());
2235 short[] b = fb.apply(SPECIES.length());
2236 short[] r = fr.apply(SPECIES.length());
2237
2238 for (int i = 0; i < a.length; i += SPECIES.length()) {
2239 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2240 av.lanewise(VectorOperators.ADD, (long)b[i]).intoArray(r, i);
2241 }
2242
2243 assertBroadcastLongArraysEquals(r, a, b, ShortMaxVectorTests::ADD);
2244 }
2245
2246 @Test(dataProvider = "shortBinaryOpMaskProvider")
2247 static void ADDShortMaxVectorTestsBroadcastMaskedLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
2248 IntFunction<boolean[]> fm) {
2249 short[] a = fa.apply(SPECIES.length());
2250 short[] b = fb.apply(SPECIES.length());
2251 short[] r = fr.apply(SPECIES.length());
2252 boolean[] mask = fm.apply(SPECIES.length());
2253 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2254
2255 for (int i = 0; i < a.length; i += SPECIES.length()) {
2256 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2257 av.lanewise(VectorOperators.ADD, (long)b[i], vmask).intoArray(r, i);
2258 }
2259
2260 assertBroadcastLongArraysEquals(r, a, b, mask, ShortMaxVectorTests::ADD);
2261 }
2262
2263 static short LSHL(short a, short b) {
2264 return (short)((a << (b & 0xF)));
2265 }
2266
2267 @Test(dataProvider = "shortBinaryOpProvider")
2268 static void LSHLShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2269 short[] a = fa.apply(SPECIES.length());
2270 short[] b = fb.apply(SPECIES.length());
2271 short[] r = fr.apply(SPECIES.length());
2272
2273 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2274 for (int i = 0; i < a.length; i += SPECIES.length()) {
2275 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2276 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2277 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
2278 }
2279 }
2280
2281 assertArraysEquals(r, a, b, ShortMaxVectorTests::LSHL);
2282 }
2283
2284 @Test(dataProvider = "shortBinaryOpMaskProvider")
2285 static void LSHLShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2286 IntFunction<boolean[]> fm) {
2287 short[] a = fa.apply(SPECIES.length());
2288 short[] b = fb.apply(SPECIES.length());
2289 short[] r = fr.apply(SPECIES.length());
2290 boolean[] mask = fm.apply(SPECIES.length());
2291 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2292
2293 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2294 for (int i = 0; i < a.length; i += SPECIES.length()) {
2295 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2296 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2297 av.lanewise(VectorOperators.LSHL, bv, vmask).intoArray(r, i);
2298 }
2299 }
2300
2301 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHL);
2302 }
2303
2304 static short ASHR(short a, short b) {
2305 return (short)((a >> (b & 0xF)));
2306 }
2307
2308 @Test(dataProvider = "shortBinaryOpProvider")
2309 static void ASHRShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2310 short[] a = fa.apply(SPECIES.length());
2311 short[] b = fb.apply(SPECIES.length());
2312 short[] r = fr.apply(SPECIES.length());
2313
2314 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2315 for (int i = 0; i < a.length; i += SPECIES.length()) {
2316 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2317 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2318 av.lanewise(VectorOperators.ASHR, bv).intoArray(r, i);
2319 }
2320 }
2321
2322 assertArraysEquals(r, a, b, ShortMaxVectorTests::ASHR);
2323 }
2324
2325 @Test(dataProvider = "shortBinaryOpMaskProvider")
2326 static void ASHRShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2327 IntFunction<boolean[]> fm) {
2328 short[] a = fa.apply(SPECIES.length());
2329 short[] b = fb.apply(SPECIES.length());
2330 short[] r = fr.apply(SPECIES.length());
2331 boolean[] mask = fm.apply(SPECIES.length());
2332 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2333
2334 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2335 for (int i = 0; i < a.length; i += SPECIES.length()) {
2336 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2337 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2338 av.lanewise(VectorOperators.ASHR, bv, vmask).intoArray(r, i);
2339 }
2340 }
2341
2342 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ASHR);
2343 }
2344
2345 static short LSHR(short a, short b) {
2346 return (short)(((a & 0xFFFF) >>> (b & 0xF)));
2347 }
2348
2349 @Test(dataProvider = "shortBinaryOpProvider")
2350 static void LSHRShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2351 short[] a = fa.apply(SPECIES.length());
2352 short[] b = fb.apply(SPECIES.length());
2353 short[] r = fr.apply(SPECIES.length());
2354
2355 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2356 for (int i = 0; i < a.length; i += SPECIES.length()) {
2357 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2358 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2359 av.lanewise(VectorOperators.LSHR, bv).intoArray(r, i);
2360 }
2361 }
2362
2363 assertArraysEquals(r, a, b, ShortMaxVectorTests::LSHR);
2364 }
2365
2366 @Test(dataProvider = "shortBinaryOpMaskProvider")
2367 static void LSHRShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2368 IntFunction<boolean[]> fm) {
2369 short[] a = fa.apply(SPECIES.length());
2370 short[] b = fb.apply(SPECIES.length());
2371 short[] r = fr.apply(SPECIES.length());
2372 boolean[] mask = fm.apply(SPECIES.length());
2373 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2374
2375 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2376 for (int i = 0; i < a.length; i += SPECIES.length()) {
2377 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2378 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2379 av.lanewise(VectorOperators.LSHR, bv, vmask).intoArray(r, i);
2380 }
2381 }
2382
2383 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHR);
2384 }
2385
2386 static short LSHL_unary(short a, short b) {
2387 return (short)((a << (b & 15)));
2388 }
2389
2390 @Test(dataProvider = "shortBinaryOpProvider")
2391 static void LSHLShortMaxVectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2392 short[] a = fa.apply(SPECIES.length());
2393 short[] b = fb.apply(SPECIES.length());
2394 short[] r = fr.apply(SPECIES.length());
2395
2396 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2397 for (int i = 0; i < a.length; i += SPECIES.length()) {
2398 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2399 av.lanewise(VectorOperators.LSHL, (int)b[i]).intoArray(r, i);
2400 }
2401 }
2402
2403 assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::LSHL_unary);
2404 }
2405
2406 @Test(dataProvider = "shortBinaryOpMaskProvider")
2407 static void LSHLShortMaxVectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2408 IntFunction<boolean[]> fm) {
2409 short[] a = fa.apply(SPECIES.length());
2410 short[] b = fb.apply(SPECIES.length());
2411 short[] r = fr.apply(SPECIES.length());
2412 boolean[] mask = fm.apply(SPECIES.length());
2413 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2414
2415 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2416 for (int i = 0; i < a.length; i += SPECIES.length()) {
2417 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2418 av.lanewise(VectorOperators.LSHL, (int)b[i], vmask).intoArray(r, i);
2419 }
2420 }
2421
2422 assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHL_unary);
2423 }
2424
2425 static short LSHR_unary(short a, short b) {
2426 return (short)(((a & 0xFFFF) >>> (b & 15)));
2427 }
2428
2429 @Test(dataProvider = "shortBinaryOpProvider")
2430 static void LSHRShortMaxVectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2431 short[] a = fa.apply(SPECIES.length());
2432 short[] b = fb.apply(SPECIES.length());
2433 short[] r = fr.apply(SPECIES.length());
2434
2435 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2436 for (int i = 0; i < a.length; i += SPECIES.length()) {
2437 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2438 av.lanewise(VectorOperators.LSHR, (int)b[i]).intoArray(r, i);
2439 }
2440 }
2441
2442 assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::LSHR_unary);
2443 }
2444
2445 @Test(dataProvider = "shortBinaryOpMaskProvider")
2446 static void LSHRShortMaxVectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2447 IntFunction<boolean[]> fm) {
2448 short[] a = fa.apply(SPECIES.length());
2449 short[] b = fb.apply(SPECIES.length());
2450 short[] r = fr.apply(SPECIES.length());
2451 boolean[] mask = fm.apply(SPECIES.length());
2452 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2453
2454 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2455 for (int i = 0; i < a.length; i += SPECIES.length()) {
2456 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2457 av.lanewise(VectorOperators.LSHR, (int)b[i], vmask).intoArray(r, i);
2458 }
2459 }
2460
2461 assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::LSHR_unary);
2462 }
2463
2464 static short ASHR_unary(short a, short b) {
2465 return (short)((a >> (b & 15)));
2466 }
2467
2468 @Test(dataProvider = "shortBinaryOpProvider")
2469 static void ASHRShortMaxVectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2470 short[] a = fa.apply(SPECIES.length());
2471 short[] b = fb.apply(SPECIES.length());
2472 short[] r = fr.apply(SPECIES.length());
2473
2474 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2475 for (int i = 0; i < a.length; i += SPECIES.length()) {
2476 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2477 av.lanewise(VectorOperators.ASHR, (int)b[i]).intoArray(r, i);
2478 }
2479 }
2480
2481 assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::ASHR_unary);
2482 }
2483
2484 @Test(dataProvider = "shortBinaryOpMaskProvider")
2485 static void ASHRShortMaxVectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2486 IntFunction<boolean[]> fm) {
2487 short[] a = fa.apply(SPECIES.length());
2488 short[] b = fb.apply(SPECIES.length());
2489 short[] r = fr.apply(SPECIES.length());
2490 boolean[] mask = fm.apply(SPECIES.length());
2491 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2492
2493 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2494 for (int i = 0; i < a.length; i += SPECIES.length()) {
2495 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2496 av.lanewise(VectorOperators.ASHR, (int)b[i], vmask).intoArray(r, i);
2497 }
2498 }
2499
2500 assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::ASHR_unary);
2501 }
2502
2503 static short ROR(short a, short b) {
2504 return (short)(ROR_scalar(a,b));
2505 }
2506
2507 @Test(dataProvider = "shortBinaryOpProvider")
2508 static void RORShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2509 short[] a = fa.apply(SPECIES.length());
2510 short[] b = fb.apply(SPECIES.length());
2511 short[] r = fr.apply(SPECIES.length());
2512
2513 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2514 for (int i = 0; i < a.length; i += SPECIES.length()) {
2515 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2516 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2517 av.lanewise(VectorOperators.ROR, bv).intoArray(r, i);
2518 }
2519 }
2520
2521 assertArraysEquals(r, a, b, ShortMaxVectorTests::ROR);
2522 }
2523
2524 @Test(dataProvider = "shortBinaryOpMaskProvider")
2525 static void RORShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2526 IntFunction<boolean[]> fm) {
2527 short[] a = fa.apply(SPECIES.length());
2528 short[] b = fb.apply(SPECIES.length());
2529 short[] r = fr.apply(SPECIES.length());
2530 boolean[] mask = fm.apply(SPECIES.length());
2531 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2532
2533 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2534 for (int i = 0; i < a.length; i += SPECIES.length()) {
2535 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2536 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2537 av.lanewise(VectorOperators.ROR, bv, vmask).intoArray(r, i);
2538 }
2539 }
2540
2541 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROR);
2542 }
2543
2544 static short ROL(short a, short b) {
2545 return (short)(ROL_scalar(a,b));
2546 }
2547
2548 @Test(dataProvider = "shortBinaryOpProvider")
2549 static void ROLShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2550 short[] a = fa.apply(SPECIES.length());
2551 short[] b = fb.apply(SPECIES.length());
2552 short[] r = fr.apply(SPECIES.length());
2553
2554 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2555 for (int i = 0; i < a.length; i += SPECIES.length()) {
2556 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2557 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2558 av.lanewise(VectorOperators.ROL, bv).intoArray(r, i);
2559 }
2560 }
2561
2562 assertArraysEquals(r, a, b, ShortMaxVectorTests::ROL);
2563 }
2564
2565 @Test(dataProvider = "shortBinaryOpMaskProvider")
2566 static void ROLShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2567 IntFunction<boolean[]> fm) {
2568 short[] a = fa.apply(SPECIES.length());
2569 short[] b = fb.apply(SPECIES.length());
2570 short[] r = fr.apply(SPECIES.length());
2571 boolean[] mask = fm.apply(SPECIES.length());
2572 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2573
2574 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2575 for (int i = 0; i < a.length; i += SPECIES.length()) {
2576 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2577 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2578 av.lanewise(VectorOperators.ROL, bv, vmask).intoArray(r, i);
2579 }
2580 }
2581
2582 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROL);
2583 }
2584
2585 static short ROR_unary(short a, short b) {
2586 return (short)(ROR_scalar(a, b));
2587 }
2588
2589 @Test(dataProvider = "shortBinaryOpProvider")
2590 static void RORShortMaxVectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2591 short[] a = fa.apply(SPECIES.length());
2592 short[] b = fb.apply(SPECIES.length());
2593 short[] r = fr.apply(SPECIES.length());
2594
2595 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2596 for (int i = 0; i < a.length; i += SPECIES.length()) {
2597 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2598 av.lanewise(VectorOperators.ROR, (int)b[i]).intoArray(r, i);
2599 }
2600 }
2601
2602 assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::ROR_unary);
2603 }
2604
2605 @Test(dataProvider = "shortBinaryOpMaskProvider")
2606 static void RORShortMaxVectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2607 IntFunction<boolean[]> fm) {
2608 short[] a = fa.apply(SPECIES.length());
2609 short[] b = fb.apply(SPECIES.length());
2610 short[] r = fr.apply(SPECIES.length());
2611 boolean[] mask = fm.apply(SPECIES.length());
2612 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2613
2614 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2615 for (int i = 0; i < a.length; i += SPECIES.length()) {
2616 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2617 av.lanewise(VectorOperators.ROR, (int)b[i], vmask).intoArray(r, i);
2618 }
2619 }
2620
2621 assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROR_unary);
2622 }
2623
2624 static short ROL_unary(short a, short b) {
2625 return (short)(ROL_scalar(a, b));
2626 }
2627
2628 @Test(dataProvider = "shortBinaryOpProvider")
2629 static void ROLShortMaxVectorTestsScalarShift(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2630 short[] a = fa.apply(SPECIES.length());
2631 short[] b = fb.apply(SPECIES.length());
2632 short[] r = fr.apply(SPECIES.length());
2633
2634 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2635 for (int i = 0; i < a.length; i += SPECIES.length()) {
2636 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2637 av.lanewise(VectorOperators.ROL, (int)b[i]).intoArray(r, i);
2638 }
2639 }
2640
2641 assertShiftArraysEquals(r, a, b, ShortMaxVectorTests::ROL_unary);
2642 }
2643
2644 @Test(dataProvider = "shortBinaryOpMaskProvider")
2645 static void ROLShortMaxVectorTestsScalarShiftMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
2646 IntFunction<boolean[]> fm) {
2647 short[] a = fa.apply(SPECIES.length());
2648 short[] b = fb.apply(SPECIES.length());
2649 short[] r = fr.apply(SPECIES.length());
2650 boolean[] mask = fm.apply(SPECIES.length());
2651 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2652
2653 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2654 for (int i = 0; i < a.length; i += SPECIES.length()) {
2655 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2656 av.lanewise(VectorOperators.ROL, (int)b[i], vmask).intoArray(r, i);
2657 }
2658 }
2659
2660 assertShiftArraysEquals(r, a, b, mask, ShortMaxVectorTests::ROL_unary);
2661 }
2662 static short LSHR_binary_const(short a) {
2663 return (short)(((a & 0xFFFF) >>> CONST_SHIFT));
2664 }
2665
2666 @Test(dataProvider = "shortUnaryOpProvider")
2667 static void LSHRShortMaxVectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2668 short[] a = fa.apply(SPECIES.length());
2669 short[] r = fr.apply(SPECIES.length());
2670
2671 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2672 for (int i = 0; i < a.length; i += SPECIES.length()) {
2673 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2674 av.lanewise(VectorOperators.LSHR, CONST_SHIFT).intoArray(r, i);
2675 }
2676 }
2677
2678 assertShiftConstEquals(r, a, ShortMaxVectorTests::LSHR_binary_const);
2679 }
2680
2681 @Test(dataProvider = "shortUnaryOpMaskProvider")
2682 static void LSHRShortMaxVectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2683 IntFunction<boolean[]> fm) {
2684 short[] a = fa.apply(SPECIES.length());
2685 short[] r = fr.apply(SPECIES.length());
2686 boolean[] mask = fm.apply(SPECIES.length());
2687 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2688
2689 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2690 for (int i = 0; i < a.length; i += SPECIES.length()) {
2691 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2692 av.lanewise(VectorOperators.LSHR, CONST_SHIFT, vmask).intoArray(r, i);
2693 }
2694 }
2695
2696 assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::LSHR_binary_const);
2697 }
2698
2699 static short LSHL_binary_const(short a) {
2700 return (short)((a << CONST_SHIFT));
2701 }
2702
2703 @Test(dataProvider = "shortUnaryOpProvider")
2704 static void LSHLShortMaxVectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2705 short[] a = fa.apply(SPECIES.length());
2706 short[] r = fr.apply(SPECIES.length());
2707
2708 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2709 for (int i = 0; i < a.length; i += SPECIES.length()) {
2710 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2711 av.lanewise(VectorOperators.LSHL, CONST_SHIFT).intoArray(r, i);
2712 }
2713 }
2714
2715 assertShiftConstEquals(r, a, ShortMaxVectorTests::LSHL_binary_const);
2716 }
2717
2718 @Test(dataProvider = "shortUnaryOpMaskProvider")
2719 static void LSHLShortMaxVectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2720 IntFunction<boolean[]> fm) {
2721 short[] a = fa.apply(SPECIES.length());
2722 short[] r = fr.apply(SPECIES.length());
2723 boolean[] mask = fm.apply(SPECIES.length());
2724 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2725
2726 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2727 for (int i = 0; i < a.length; i += SPECIES.length()) {
2728 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2729 av.lanewise(VectorOperators.LSHL, CONST_SHIFT, vmask).intoArray(r, i);
2730 }
2731 }
2732
2733 assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::LSHL_binary_const);
2734 }
2735
2736 static short ASHR_binary_const(short a) {
2737 return (short)((a >> CONST_SHIFT));
2738 }
2739
2740 @Test(dataProvider = "shortUnaryOpProvider")
2741 static void ASHRShortMaxVectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2742 short[] a = fa.apply(SPECIES.length());
2743 short[] r = fr.apply(SPECIES.length());
2744
2745 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2746 for (int i = 0; i < a.length; i += SPECIES.length()) {
2747 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2748 av.lanewise(VectorOperators.ASHR, CONST_SHIFT).intoArray(r, i);
2749 }
2750 }
2751
2752 assertShiftConstEquals(r, a, ShortMaxVectorTests::ASHR_binary_const);
2753 }
2754
2755 @Test(dataProvider = "shortUnaryOpMaskProvider")
2756 static void ASHRShortMaxVectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2757 IntFunction<boolean[]> fm) {
2758 short[] a = fa.apply(SPECIES.length());
2759 short[] r = fr.apply(SPECIES.length());
2760 boolean[] mask = fm.apply(SPECIES.length());
2761 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2762
2763 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2764 for (int i = 0; i < a.length; i += SPECIES.length()) {
2765 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2766 av.lanewise(VectorOperators.ASHR, CONST_SHIFT, vmask).intoArray(r, i);
2767 }
2768 }
2769
2770 assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::ASHR_binary_const);
2771 }
2772
2773 static short ROR_binary_const(short a) {
2774 return (short)(ROR_scalar(a, CONST_SHIFT));
2775 }
2776
2777 @Test(dataProvider = "shortUnaryOpProvider")
2778 static void RORShortMaxVectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2779 short[] a = fa.apply(SPECIES.length());
2780 short[] r = fr.apply(SPECIES.length());
2781
2782 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2783 for (int i = 0; i < a.length; i += SPECIES.length()) {
2784 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2785 av.lanewise(VectorOperators.ROR, CONST_SHIFT).intoArray(r, i);
2786 }
2787 }
2788
2789 assertShiftConstEquals(r, a, ShortMaxVectorTests::ROR_binary_const);
2790 }
2791
2792 @Test(dataProvider = "shortUnaryOpMaskProvider")
2793 static void RORShortMaxVectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2794 IntFunction<boolean[]> fm) {
2795 short[] a = fa.apply(SPECIES.length());
2796 short[] r = fr.apply(SPECIES.length());
2797 boolean[] mask = fm.apply(SPECIES.length());
2798 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2799
2800 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2801 for (int i = 0; i < a.length; i += SPECIES.length()) {
2802 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2803 av.lanewise(VectorOperators.ROR, CONST_SHIFT, vmask).intoArray(r, i);
2804 }
2805 }
2806
2807 assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::ROR_binary_const);
2808 }
2809
2810 static short ROL_binary_const(short a) {
2811 return (short)(ROL_scalar(a, CONST_SHIFT));
2812 }
2813
2814 @Test(dataProvider = "shortUnaryOpProvider")
2815 static void ROLShortMaxVectorTestsScalarShiftConst(IntFunction<short[]> fa) {
2816 short[] a = fa.apply(SPECIES.length());
2817 short[] r = fr.apply(SPECIES.length());
2818
2819 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2820 for (int i = 0; i < a.length; i += SPECIES.length()) {
2821 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2822 av.lanewise(VectorOperators.ROL, CONST_SHIFT).intoArray(r, i);
2823 }
2824 }
2825
2826 assertShiftConstEquals(r, a, ShortMaxVectorTests::ROL_binary_const);
2827 }
2828
2829 @Test(dataProvider = "shortUnaryOpMaskProvider")
2830 static void ROLShortMaxVectorTestsScalarShiftMaskedConst(IntFunction<short[]> fa,
2831 IntFunction<boolean[]> fm) {
2832 short[] a = fa.apply(SPECIES.length());
2833 short[] r = fr.apply(SPECIES.length());
2834 boolean[] mask = fm.apply(SPECIES.length());
2835 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
2836
2837 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2838 for (int i = 0; i < a.length; i += SPECIES.length()) {
2839 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2840 av.lanewise(VectorOperators.ROL, CONST_SHIFT, vmask).intoArray(r, i);
2841 }
2842 }
2843
2844 assertShiftConstEquals(r, a, mask, ShortMaxVectorTests::ROL_binary_const);
2845 }
2846
2847
2848 static short MIN(short a, short b) {
2849 return (short)(Math.min(a, b));
2850 }
2851
2852 @Test(dataProvider = "shortBinaryOpProvider")
2853 static void MINShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2854 short[] a = fa.apply(SPECIES.length());
2855 short[] b = fb.apply(SPECIES.length());
2856 short[] r = fr.apply(SPECIES.length());
2857
2858 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2859 for (int i = 0; i < a.length; i += SPECIES.length()) {
2860 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2861 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2862 av.lanewise(VectorOperators.MIN, bv).intoArray(r, i);
2863 }
2864 }
2865
2866 assertArraysEquals(r, a, b, ShortMaxVectorTests::MIN);
2867 }
2868
2869 static short min(short a, short b) {
2870 return (short)(Math.min(a, b));
2871 }
2872
2873 @Test(dataProvider = "shortBinaryOpProvider")
2874 static void minShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2875 short[] a = fa.apply(SPECIES.length());
2876 short[] b = fb.apply(SPECIES.length());
2877 short[] r = fr.apply(SPECIES.length());
2878
2879 for (int i = 0; i < a.length; i += SPECIES.length()) {
2880 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2881 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2882 av.min(bv).intoArray(r, i);
2883 }
2884
2885 assertArraysEquals(r, a, b, ShortMaxVectorTests::min);
2886 }
2887
2888 static short MAX(short a, short b) {
2889 return (short)(Math.max(a, b));
2890 }
2891
2892 @Test(dataProvider = "shortBinaryOpProvider")
2893 static void MAXShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2894 short[] a = fa.apply(SPECIES.length());
2895 short[] b = fb.apply(SPECIES.length());
2896 short[] r = fr.apply(SPECIES.length());
2897
2898 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2899 for (int i = 0; i < a.length; i += SPECIES.length()) {
2900 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2901 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2902 av.lanewise(VectorOperators.MAX, bv).intoArray(r, i);
2903 }
2904 }
2905
2906 assertArraysEquals(r, a, b, ShortMaxVectorTests::MAX);
2907 }
2908
2909 static short max(short a, short b) {
2910 return (short)(Math.max(a, b));
2911 }
2912
2913 @Test(dataProvider = "shortBinaryOpProvider")
2914 static void maxShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2915 short[] a = fa.apply(SPECIES.length());
2916 short[] b = fb.apply(SPECIES.length());
2917 short[] r = fr.apply(SPECIES.length());
2918
2919 for (int i = 0; i < a.length; i += SPECIES.length()) {
2920 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2921 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
2922 av.max(bv).intoArray(r, i);
2923 }
2924
2925 assertArraysEquals(r, a, b, ShortMaxVectorTests::max);
2926 }
2927
2928 @Test(dataProvider = "shortBinaryOpProvider")
2929 static void MINShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2930 short[] a = fa.apply(SPECIES.length());
2931 short[] b = fb.apply(SPECIES.length());
2932 short[] r = fr.apply(SPECIES.length());
2933
2934 for (int i = 0; i < a.length; i += SPECIES.length()) {
2935 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2936 av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
2937 }
2938
2939 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::MIN);
2940 }
2941
2942 @Test(dataProvider = "shortBinaryOpProvider")
2943 static void minShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2944 short[] a = fa.apply(SPECIES.length());
2945 short[] b = fb.apply(SPECIES.length());
2946 short[] r = fr.apply(SPECIES.length());
2947
2948 for (int i = 0; i < a.length; i += SPECIES.length()) {
2949 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2950 av.min(b[i]).intoArray(r, i);
2951 }
2952
2953 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::min);
2954 }
2955
2956 @Test(dataProvider = "shortBinaryOpProvider")
2957 static void MAXShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2958 short[] a = fa.apply(SPECIES.length());
2959 short[] b = fb.apply(SPECIES.length());
2960 short[] r = fr.apply(SPECIES.length());
2961
2962 for (int i = 0; i < a.length; i += SPECIES.length()) {
2963 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2964 av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
2965 }
2966
2967 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::MAX);
2968 }
2969
2970 @Test(dataProvider = "shortBinaryOpProvider")
2971 static void maxShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
2972 short[] a = fa.apply(SPECIES.length());
2973 short[] b = fb.apply(SPECIES.length());
2974 short[] r = fr.apply(SPECIES.length());
2975
2976 for (int i = 0; i < a.length; i += SPECIES.length()) {
2977 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
2978 av.max(b[i]).intoArray(r, i);
2979 }
2980
2981 assertBroadcastArraysEquals(r, a, b, ShortMaxVectorTests::max);
2982 }
2983
2984 static short ANDReduce(short[] a, int idx) {
2985 short res = -1;
2986 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2987 res &= a[i];
2988 }
2989
2990 return res;
2991 }
2992
2993 static short ANDReduceAll(short[] a) {
2994 short res = -1;
2995 for (int i = 0; i < a.length; i += SPECIES.length()) {
2996 res &= ANDReduce(a, i);
2997 }
2998
2999 return res;
3000 }
3001
3002 @Test(dataProvider = "shortUnaryOpProvider")
3003 static void ANDReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3004 short[] a = fa.apply(SPECIES.length());
3005 short[] r = fr.apply(SPECIES.length());
3006 short ra = -1;
3007
3008 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3009 for (int i = 0; i < a.length; i += SPECIES.length()) {
3010 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3011 r[i] = av.reduceLanes(VectorOperators.AND);
3012 }
3013 }
3014
3015 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3016 ra = -1;
3017 for (int i = 0; i < a.length; i += SPECIES.length()) {
3018 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3019 ra &= av.reduceLanes(VectorOperators.AND);
3020 }
3021 }
3022
3023 assertReductionArraysEquals(r, ra, a,
3024 ShortMaxVectorTests::ANDReduce, ShortMaxVectorTests::ANDReduceAll);
3025 }
3026
3027 static short ANDReduceMasked(short[] a, int idx, boolean[] mask) {
3028 short res = -1;
3029 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3030 if (mask[i % SPECIES.length()])
3031 res &= a[i];
3032 }
3033
3034 return res;
3035 }
3036
3037 static short ANDReduceAllMasked(short[] a, boolean[] mask) {
3038 short res = -1;
3039 for (int i = 0; i < a.length; i += SPECIES.length()) {
3040 res &= ANDReduceMasked(a, i, mask);
3041 }
3042
3043 return res;
3044 }
3045
3046 @Test(dataProvider = "shortUnaryOpMaskProvider")
3047 static void ANDReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3048 short[] a = fa.apply(SPECIES.length());
3049 short[] r = fr.apply(SPECIES.length());
3050 boolean[] mask = fm.apply(SPECIES.length());
3051 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3052 short ra = -1;
3053
3054 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3055 for (int i = 0; i < a.length; i += SPECIES.length()) {
3056 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3057 r[i] = av.reduceLanes(VectorOperators.AND, vmask);
3058 }
3059 }
3060
3061 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3062 ra = -1;
3063 for (int i = 0; i < a.length; i += SPECIES.length()) {
3064 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3065 ra &= av.reduceLanes(VectorOperators.AND, vmask);
3066 }
3067 }
3068
3069 assertReductionArraysEqualsMasked(r, ra, a, mask,
3070 ShortMaxVectorTests::ANDReduceMasked, ShortMaxVectorTests::ANDReduceAllMasked);
3071 }
3072
3073 static short ORReduce(short[] a, int idx) {
3074 short res = 0;
3075 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3076 res |= a[i];
3077 }
3078
3079 return res;
3080 }
3081
3082 static short ORReduceAll(short[] a) {
3083 short res = 0;
3084 for (int i = 0; i < a.length; i += SPECIES.length()) {
3085 res |= ORReduce(a, i);
3086 }
3087
3088 return res;
3089 }
3090
3091 @Test(dataProvider = "shortUnaryOpProvider")
3092 static void ORReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3093 short[] a = fa.apply(SPECIES.length());
3094 short[] r = fr.apply(SPECIES.length());
3095 short ra = 0;
3096
3097 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3098 for (int i = 0; i < a.length; i += SPECIES.length()) {
3099 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3100 r[i] = av.reduceLanes(VectorOperators.OR);
3101 }
3102 }
3103
3104 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3105 ra = 0;
3106 for (int i = 0; i < a.length; i += SPECIES.length()) {
3107 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3108 ra |= av.reduceLanes(VectorOperators.OR);
3109 }
3110 }
3111
3112 assertReductionArraysEquals(r, ra, a,
3113 ShortMaxVectorTests::ORReduce, ShortMaxVectorTests::ORReduceAll);
3114 }
3115
3116 static short ORReduceMasked(short[] a, int idx, boolean[] mask) {
3117 short res = 0;
3118 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3119 if (mask[i % SPECIES.length()])
3120 res |= a[i];
3121 }
3122
3123 return res;
3124 }
3125
3126 static short ORReduceAllMasked(short[] a, boolean[] mask) {
3127 short res = 0;
3128 for (int i = 0; i < a.length; i += SPECIES.length()) {
3129 res |= ORReduceMasked(a, i, mask);
3130 }
3131
3132 return res;
3133 }
3134
3135 @Test(dataProvider = "shortUnaryOpMaskProvider")
3136 static void ORReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3137 short[] a = fa.apply(SPECIES.length());
3138 short[] r = fr.apply(SPECIES.length());
3139 boolean[] mask = fm.apply(SPECIES.length());
3140 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3141 short ra = 0;
3142
3143 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3144 for (int i = 0; i < a.length; i += SPECIES.length()) {
3145 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3146 r[i] = av.reduceLanes(VectorOperators.OR, vmask);
3147 }
3148 }
3149
3150 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3151 ra = 0;
3152 for (int i = 0; i < a.length; i += SPECIES.length()) {
3153 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3154 ra |= av.reduceLanes(VectorOperators.OR, vmask);
3155 }
3156 }
3157
3158 assertReductionArraysEqualsMasked(r, ra, a, mask,
3159 ShortMaxVectorTests::ORReduceMasked, ShortMaxVectorTests::ORReduceAllMasked);
3160 }
3161
3162 static short XORReduce(short[] a, int idx) {
3163 short res = 0;
3164 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3165 res ^= a[i];
3166 }
3167
3168 return res;
3169 }
3170
3171 static short XORReduceAll(short[] a) {
3172 short res = 0;
3173 for (int i = 0; i < a.length; i += SPECIES.length()) {
3174 res ^= XORReduce(a, i);
3175 }
3176
3177 return res;
3178 }
3179
3180 @Test(dataProvider = "shortUnaryOpProvider")
3181 static void XORReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3182 short[] a = fa.apply(SPECIES.length());
3183 short[] r = fr.apply(SPECIES.length());
3184 short ra = 0;
3185
3186 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3187 for (int i = 0; i < a.length; i += SPECIES.length()) {
3188 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3189 r[i] = av.reduceLanes(VectorOperators.XOR);
3190 }
3191 }
3192
3193 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3194 ra = 0;
3195 for (int i = 0; i < a.length; i += SPECIES.length()) {
3196 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3197 ra ^= av.reduceLanes(VectorOperators.XOR);
3198 }
3199 }
3200
3201 assertReductionArraysEquals(r, ra, a,
3202 ShortMaxVectorTests::XORReduce, ShortMaxVectorTests::XORReduceAll);
3203 }
3204
3205 static short XORReduceMasked(short[] a, int idx, boolean[] mask) {
3206 short res = 0;
3207 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3208 if (mask[i % SPECIES.length()])
3209 res ^= a[i];
3210 }
3211
3212 return res;
3213 }
3214
3215 static short XORReduceAllMasked(short[] a, boolean[] mask) {
3216 short res = 0;
3217 for (int i = 0; i < a.length; i += SPECIES.length()) {
3218 res ^= XORReduceMasked(a, i, mask);
3219 }
3220
3221 return res;
3222 }
3223
3224 @Test(dataProvider = "shortUnaryOpMaskProvider")
3225 static void XORReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3226 short[] a = fa.apply(SPECIES.length());
3227 short[] r = fr.apply(SPECIES.length());
3228 boolean[] mask = fm.apply(SPECIES.length());
3229 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3230 short ra = 0;
3231
3232 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3233 for (int i = 0; i < a.length; i += SPECIES.length()) {
3234 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3235 r[i] = av.reduceLanes(VectorOperators.XOR, vmask);
3236 }
3237 }
3238
3239 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3240 ra = 0;
3241 for (int i = 0; i < a.length; i += SPECIES.length()) {
3242 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3243 ra ^= av.reduceLanes(VectorOperators.XOR, vmask);
3244 }
3245 }
3246
3247 assertReductionArraysEqualsMasked(r, ra, a, mask,
3248 ShortMaxVectorTests::XORReduceMasked, ShortMaxVectorTests::XORReduceAllMasked);
3249 }
3250
3251 static short ADDReduce(short[] a, int idx) {
3252 short res = 0;
3253 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3254 res += a[i];
3255 }
3256
3257 return res;
3258 }
3259
3260 static short ADDReduceAll(short[] a) {
3261 short res = 0;
3262 for (int i = 0; i < a.length; i += SPECIES.length()) {
3263 res += ADDReduce(a, i);
3264 }
3265
3266 return res;
3267 }
3268
3269 @Test(dataProvider = "shortUnaryOpProvider")
3270 static void ADDReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3271 short[] a = fa.apply(SPECIES.length());
3272 short[] r = fr.apply(SPECIES.length());
3273 short ra = 0;
3274
3275 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3276 for (int i = 0; i < a.length; i += SPECIES.length()) {
3277 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3278 r[i] = av.reduceLanes(VectorOperators.ADD);
3279 }
3280 }
3281
3282 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3283 ra = 0;
3284 for (int i = 0; i < a.length; i += SPECIES.length()) {
3285 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3286 ra += av.reduceLanes(VectorOperators.ADD);
3287 }
3288 }
3289
3290 assertReductionArraysEquals(r, ra, a,
3291 ShortMaxVectorTests::ADDReduce, ShortMaxVectorTests::ADDReduceAll);
3292 }
3293
3294 static short ADDReduceMasked(short[] a, int idx, boolean[] mask) {
3295 short res = 0;
3296 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3297 if (mask[i % SPECIES.length()])
3298 res += a[i];
3299 }
3300
3301 return res;
3302 }
3303
3304 static short ADDReduceAllMasked(short[] a, boolean[] mask) {
3305 short res = 0;
3306 for (int i = 0; i < a.length; i += SPECIES.length()) {
3307 res += ADDReduceMasked(a, i, mask);
3308 }
3309
3310 return res;
3311 }
3312
3313 @Test(dataProvider = "shortUnaryOpMaskProvider")
3314 static void ADDReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3315 short[] a = fa.apply(SPECIES.length());
3316 short[] r = fr.apply(SPECIES.length());
3317 boolean[] mask = fm.apply(SPECIES.length());
3318 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3319 short ra = 0;
3320
3321 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3322 for (int i = 0; i < a.length; i += SPECIES.length()) {
3323 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3324 r[i] = av.reduceLanes(VectorOperators.ADD, vmask);
3325 }
3326 }
3327
3328 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3329 ra = 0;
3330 for (int i = 0; i < a.length; i += SPECIES.length()) {
3331 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3332 ra += av.reduceLanes(VectorOperators.ADD, vmask);
3333 }
3334 }
3335
3336 assertReductionArraysEqualsMasked(r, ra, a, mask,
3337 ShortMaxVectorTests::ADDReduceMasked, ShortMaxVectorTests::ADDReduceAllMasked);
3338 }
3339
3340 static short MULReduce(short[] a, int idx) {
3341 short res = 1;
3342 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3343 res *= a[i];
3344 }
3345
3346 return res;
3347 }
3348
3349 static short MULReduceAll(short[] a) {
3350 short res = 1;
3351 for (int i = 0; i < a.length; i += SPECIES.length()) {
3352 res *= MULReduce(a, i);
3353 }
3354
3355 return res;
3356 }
3357
3358 @Test(dataProvider = "shortUnaryOpProvider")
3359 static void MULReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3360 short[] a = fa.apply(SPECIES.length());
3361 short[] r = fr.apply(SPECIES.length());
3362 short ra = 1;
3363
3364 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3365 for (int i = 0; i < a.length; i += SPECIES.length()) {
3366 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3367 r[i] = av.reduceLanes(VectorOperators.MUL);
3368 }
3369 }
3370
3371 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3372 ra = 1;
3373 for (int i = 0; i < a.length; i += SPECIES.length()) {
3374 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3375 ra *= av.reduceLanes(VectorOperators.MUL);
3376 }
3377 }
3378
3379 assertReductionArraysEquals(r, ra, a,
3380 ShortMaxVectorTests::MULReduce, ShortMaxVectorTests::MULReduceAll);
3381 }
3382
3383 static short MULReduceMasked(short[] a, int idx, boolean[] mask) {
3384 short res = 1;
3385 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3386 if (mask[i % SPECIES.length()])
3387 res *= a[i];
3388 }
3389
3390 return res;
3391 }
3392
3393 static short MULReduceAllMasked(short[] a, boolean[] mask) {
3394 short res = 1;
3395 for (int i = 0; i < a.length; i += SPECIES.length()) {
3396 res *= MULReduceMasked(a, i, mask);
3397 }
3398
3399 return res;
3400 }
3401
3402 @Test(dataProvider = "shortUnaryOpMaskProvider")
3403 static void MULReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3404 short[] a = fa.apply(SPECIES.length());
3405 short[] r = fr.apply(SPECIES.length());
3406 boolean[] mask = fm.apply(SPECIES.length());
3407 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3408 short ra = 1;
3409
3410 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3411 for (int i = 0; i < a.length; i += SPECIES.length()) {
3412 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3413 r[i] = av.reduceLanes(VectorOperators.MUL, vmask);
3414 }
3415 }
3416
3417 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3418 ra = 1;
3419 for (int i = 0; i < a.length; i += SPECIES.length()) {
3420 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3421 ra *= av.reduceLanes(VectorOperators.MUL, vmask);
3422 }
3423 }
3424
3425 assertReductionArraysEqualsMasked(r, ra, a, mask,
3426 ShortMaxVectorTests::MULReduceMasked, ShortMaxVectorTests::MULReduceAllMasked);
3427 }
3428
3429 static short MINReduce(short[] a, int idx) {
3430 short res = Short.MAX_VALUE;
3431 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3432 res = (short) Math.min(res, a[i]);
3433 }
3434
3435 return res;
3436 }
3437
3438 static short MINReduceAll(short[] a) {
3439 short res = Short.MAX_VALUE;
3440 for (int i = 0; i < a.length; i += SPECIES.length()) {
3441 res = (short) Math.min(res, MINReduce(a, i));
3442 }
3443
3444 return res;
3445 }
3446
3447 @Test(dataProvider = "shortUnaryOpProvider")
3448 static void MINReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3449 short[] a = fa.apply(SPECIES.length());
3450 short[] r = fr.apply(SPECIES.length());
3451 short ra = Short.MAX_VALUE;
3452
3453 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3454 for (int i = 0; i < a.length; i += SPECIES.length()) {
3455 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3456 r[i] = av.reduceLanes(VectorOperators.MIN);
3457 }
3458 }
3459
3460 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3461 ra = Short.MAX_VALUE;
3462 for (int i = 0; i < a.length; i += SPECIES.length()) {
3463 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3464 ra = (short) Math.min(ra, av.reduceLanes(VectorOperators.MIN));
3465 }
3466 }
3467
3468 assertReductionArraysEquals(r, ra, a,
3469 ShortMaxVectorTests::MINReduce, ShortMaxVectorTests::MINReduceAll);
3470 }
3471
3472 static short MINReduceMasked(short[] a, int idx, boolean[] mask) {
3473 short res = Short.MAX_VALUE;
3474 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3475 if (mask[i % SPECIES.length()])
3476 res = (short) Math.min(res, a[i]);
3477 }
3478
3479 return res;
3480 }
3481
3482 static short MINReduceAllMasked(short[] a, boolean[] mask) {
3483 short res = Short.MAX_VALUE;
3484 for (int i = 0; i < a.length; i += SPECIES.length()) {
3485 res = (short) Math.min(res, MINReduceMasked(a, i, mask));
3486 }
3487
3488 return res;
3489 }
3490
3491 @Test(dataProvider = "shortUnaryOpMaskProvider")
3492 static void MINReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3493 short[] a = fa.apply(SPECIES.length());
3494 short[] r = fr.apply(SPECIES.length());
3495 boolean[] mask = fm.apply(SPECIES.length());
3496 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3497 short ra = Short.MAX_VALUE;
3498
3499 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3500 for (int i = 0; i < a.length; i += SPECIES.length()) {
3501 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3502 r[i] = av.reduceLanes(VectorOperators.MIN, vmask);
3503 }
3504 }
3505
3506 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3507 ra = Short.MAX_VALUE;
3508 for (int i = 0; i < a.length; i += SPECIES.length()) {
3509 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3510 ra = (short) Math.min(ra, av.reduceLanes(VectorOperators.MIN, vmask));
3511 }
3512 }
3513
3514 assertReductionArraysEqualsMasked(r, ra, a, mask,
3515 ShortMaxVectorTests::MINReduceMasked, ShortMaxVectorTests::MINReduceAllMasked);
3516 }
3517
3518 static short MAXReduce(short[] a, int idx) {
3519 short res = Short.MIN_VALUE;
3520 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3521 res = (short) Math.max(res, a[i]);
3522 }
3523
3524 return res;
3525 }
3526
3527 static short MAXReduceAll(short[] a) {
3528 short res = Short.MIN_VALUE;
3529 for (int i = 0; i < a.length; i += SPECIES.length()) {
3530 res = (short) Math.max(res, MAXReduce(a, i));
3531 }
3532
3533 return res;
3534 }
3535
3536 @Test(dataProvider = "shortUnaryOpProvider")
3537 static void MAXReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3538 short[] a = fa.apply(SPECIES.length());
3539 short[] r = fr.apply(SPECIES.length());
3540 short ra = Short.MIN_VALUE;
3541
3542 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3543 for (int i = 0; i < a.length; i += SPECIES.length()) {
3544 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3545 r[i] = av.reduceLanes(VectorOperators.MAX);
3546 }
3547 }
3548
3549 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3550 ra = Short.MIN_VALUE;
3551 for (int i = 0; i < a.length; i += SPECIES.length()) {
3552 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3553 ra = (short) Math.max(ra, av.reduceLanes(VectorOperators.MAX));
3554 }
3555 }
3556
3557 assertReductionArraysEquals(r, ra, a,
3558 ShortMaxVectorTests::MAXReduce, ShortMaxVectorTests::MAXReduceAll);
3559 }
3560
3561 static short MAXReduceMasked(short[] a, int idx, boolean[] mask) {
3562 short res = Short.MIN_VALUE;
3563 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3564 if (mask[i % SPECIES.length()])
3565 res = (short) Math.max(res, a[i]);
3566 }
3567
3568 return res;
3569 }
3570
3571 static short MAXReduceAllMasked(short[] a, boolean[] mask) {
3572 short res = Short.MIN_VALUE;
3573 for (int i = 0; i < a.length; i += SPECIES.length()) {
3574 res = (short) Math.max(res, MAXReduceMasked(a, i, mask));
3575 }
3576
3577 return res;
3578 }
3579
3580 @Test(dataProvider = "shortUnaryOpMaskProvider")
3581 static void MAXReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3582 short[] a = fa.apply(SPECIES.length());
3583 short[] r = fr.apply(SPECIES.length());
3584 boolean[] mask = fm.apply(SPECIES.length());
3585 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3586 short ra = Short.MIN_VALUE;
3587
3588 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3589 for (int i = 0; i < a.length; i += SPECIES.length()) {
3590 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3591 r[i] = av.reduceLanes(VectorOperators.MAX, vmask);
3592 }
3593 }
3594
3595 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3596 ra = Short.MIN_VALUE;
3597 for (int i = 0; i < a.length; i += SPECIES.length()) {
3598 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3599 ra = (short) Math.max(ra, av.reduceLanes(VectorOperators.MAX, vmask));
3600 }
3601 }
3602
3603 assertReductionArraysEqualsMasked(r, ra, a, mask,
3604 ShortMaxVectorTests::MAXReduceMasked, ShortMaxVectorTests::MAXReduceAllMasked);
3605 }
3606
3607 static short FIRST_NONZEROReduce(short[] a, int idx) {
3608 short res = (short) 0;
3609 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3610 res = firstNonZero(res, a[i]);
3611 }
3612
3613 return res;
3614 }
3615
3616 static short FIRST_NONZEROReduceAll(short[] a) {
3617 short res = (short) 0;
3618 for (int i = 0; i < a.length; i += SPECIES.length()) {
3619 res = firstNonZero(res, FIRST_NONZEROReduce(a, i));
3620 }
3621
3622 return res;
3623 }
3624
3625 @Test(dataProvider = "shortUnaryOpProvider")
3626 static void FIRST_NONZEROReduceShortMaxVectorTests(IntFunction<short[]> fa) {
3627 short[] a = fa.apply(SPECIES.length());
3628 short[] r = fr.apply(SPECIES.length());
3629 short ra = (short) 0;
3630
3631 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3632 for (int i = 0; i < a.length; i += SPECIES.length()) {
3633 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3634 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO);
3635 }
3636 }
3637
3638 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3639 ra = (short) 0;
3640 for (int i = 0; i < a.length; i += SPECIES.length()) {
3641 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3642 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO));
3643 }
3644 }
3645
3646 assertReductionArraysEquals(r, ra, a,
3647 ShortMaxVectorTests::FIRST_NONZEROReduce, ShortMaxVectorTests::FIRST_NONZEROReduceAll);
3648 }
3649
3650 static short FIRST_NONZEROReduceMasked(short[] a, int idx, boolean[] mask) {
3651 short res = (short) 0;
3652 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3653 if (mask[i % SPECIES.length()])
3654 res = firstNonZero(res, a[i]);
3655 }
3656
3657 return res;
3658 }
3659
3660 static short FIRST_NONZEROReduceAllMasked(short[] a, boolean[] mask) {
3661 short res = (short) 0;
3662 for (int i = 0; i < a.length; i += SPECIES.length()) {
3663 res = firstNonZero(res, FIRST_NONZEROReduceMasked(a, i, mask));
3664 }
3665
3666 return res;
3667 }
3668
3669 @Test(dataProvider = "shortUnaryOpMaskProvider")
3670 static void FIRST_NONZEROReduceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
3671 short[] a = fa.apply(SPECIES.length());
3672 short[] r = fr.apply(SPECIES.length());
3673 boolean[] mask = fm.apply(SPECIES.length());
3674 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3675 short ra = (short) 0;
3676
3677 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3678 for (int i = 0; i < a.length; i += SPECIES.length()) {
3679 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3680 r[i] = av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask);
3681 }
3682 }
3683
3684 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3685 ra = (short) 0;
3686 for (int i = 0; i < a.length; i += SPECIES.length()) {
3687 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3688 ra = firstNonZero(ra, av.reduceLanes(VectorOperators.FIRST_NONZERO, vmask));
3689 }
3690 }
3691
3692 assertReductionArraysEqualsMasked(r, ra, a, mask,
3693 ShortMaxVectorTests::FIRST_NONZEROReduceMasked, ShortMaxVectorTests::FIRST_NONZEROReduceAllMasked);
3694 }
3695
3696 static boolean anyTrue(boolean[] a, int idx) {
3697 boolean res = false;
3698 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3699 res |= a[i];
3700 }
3701
3702 return res;
3703 }
3704
3705 @Test(dataProvider = "boolUnaryOpProvider")
3706 static void anyTrueShortMaxVectorTests(IntFunction<boolean[]> fm) {
3707 boolean[] mask = fm.apply(SPECIES.length());
3708 boolean[] r = fmr.apply(SPECIES.length());
3709
3710 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3711 for (int i = 0; i < mask.length; i += SPECIES.length()) {
3712 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, i);
3713 r[i] = vmask.anyTrue();
3714 }
3715 }
3716
3717 assertReductionBoolArraysEquals(r, mask, ShortMaxVectorTests::anyTrue);
3718 }
3719
3720 static boolean allTrue(boolean[] a, int idx) {
3721 boolean res = true;
3722 for (int i = idx; i < (idx + SPECIES.length()); i++) {
3723 res &= a[i];
3724 }
3725
3726 return res;
3727 }
3728
3729 @Test(dataProvider = "boolUnaryOpProvider")
3730 static void allTrueShortMaxVectorTests(IntFunction<boolean[]> fm) {
3731 boolean[] mask = fm.apply(SPECIES.length());
3732 boolean[] r = fmr.apply(SPECIES.length());
3733
3734 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3735 for (int i = 0; i < mask.length; i += SPECIES.length()) {
3736 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, i);
3737 r[i] = vmask.allTrue();
3738 }
3739 }
3740
3741 assertReductionBoolArraysEquals(r, mask, ShortMaxVectorTests::allTrue);
3742 }
3743
3744 @Test(dataProvider = "shortUnaryOpProvider")
3745 static void withShortMaxVectorTests(IntFunction<short []> fa) {
3746 short[] a = fa.apply(SPECIES.length());
3747 short[] r = fr.apply(SPECIES.length());
3748
3749 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3750 for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
3751 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3752 av.withLane((j++ & (SPECIES.length()-1)), (short)(65535+i)).intoArray(r, i);
3753 }
3754 }
3755
3756
3757 for (int i = 0, j = 0; i < a.length; i += SPECIES.length()) {
3758 assertInsertArraysEquals(r, a, (short)(65535+i), (j++ & (SPECIES.length()-1)), i , i + SPECIES.length());
3759 }
3760 }
3761
3762 static boolean testIS_DEFAULT(short a) {
3763 return bits(a)==0;
3764 }
3765
3766 @Test(dataProvider = "shortTestOpProvider")
3767 static void IS_DEFAULTShortMaxVectorTests(IntFunction<short[]> fa) {
3768 short[] a = fa.apply(SPECIES.length());
3769
3770 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3771 for (int i = 0; i < a.length; i += SPECIES.length()) {
3772 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3773 VectorMask<Short> mv = av.test(VectorOperators.IS_DEFAULT);
3774
3775 // Check results as part of computation.
3776 for (int j = 0; j < SPECIES.length(); j++) {
3777 Assert.assertEquals(mv.laneIsSet(j), testIS_DEFAULT(a[i + j]));
3778 }
3779 }
3780 }
3781 }
3782
3783 @Test(dataProvider = "shortTestOpMaskProvider")
3784 static void IS_DEFAULTMaskedShortMaxVectorTests(IntFunction<short[]> fa,
3785 IntFunction<boolean[]> fm) {
3786 short[] a = fa.apply(SPECIES.length());
3787 boolean[] mask = fm.apply(SPECIES.length());
3788 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3789
3790 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3791 for (int i = 0; i < a.length; i += SPECIES.length()) {
3792 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3793 VectorMask<Short> mv = av.test(VectorOperators.IS_DEFAULT, vmask);
3794
3795 // Check results as part of computation.
3796 for (int j = 0; j < SPECIES.length(); j++) {
3797 Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_DEFAULT(a[i + j]));
3798 }
3799 }
3800 }
3801 }
3802
3803 static boolean testIS_NEGATIVE(short a) {
3804 return bits(a)<0;
3805 }
3806
3807 @Test(dataProvider = "shortTestOpProvider")
3808 static void IS_NEGATIVEShortMaxVectorTests(IntFunction<short[]> fa) {
3809 short[] a = fa.apply(SPECIES.length());
3810
3811 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3812 for (int i = 0; i < a.length; i += SPECIES.length()) {
3813 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3814 VectorMask<Short> mv = av.test(VectorOperators.IS_NEGATIVE);
3815
3816 // Check results as part of computation.
3817 for (int j = 0; j < SPECIES.length(); j++) {
3818 Assert.assertEquals(mv.laneIsSet(j), testIS_NEGATIVE(a[i + j]));
3819 }
3820 }
3821 }
3822 }
3823
3824 @Test(dataProvider = "shortTestOpMaskProvider")
3825 static void IS_NEGATIVEMaskedShortMaxVectorTests(IntFunction<short[]> fa,
3826 IntFunction<boolean[]> fm) {
3827 short[] a = fa.apply(SPECIES.length());
3828 boolean[] mask = fm.apply(SPECIES.length());
3829 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3830
3831 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3832 for (int i = 0; i < a.length; i += SPECIES.length()) {
3833 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3834 VectorMask<Short> mv = av.test(VectorOperators.IS_NEGATIVE, vmask);
3835
3836 // Check results as part of computation.
3837 for (int j = 0; j < SPECIES.length(); j++) {
3838 Assert.assertEquals(mv.laneIsSet(j), vmask.laneIsSet(j) && testIS_NEGATIVE(a[i + j]));
3839 }
3840 }
3841 }
3842 }
3843
3844 @Test(dataProvider = "shortCompareOpProvider")
3845 static void LTShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3846 short[] a = fa.apply(SPECIES.length());
3847 short[] b = fb.apply(SPECIES.length());
3848
3849 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3850 for (int i = 0; i < a.length; i += SPECIES.length()) {
3851 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3852 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3853 VectorMask<Short> mv = av.compare(VectorOperators.LT, bv);
3854
3855 // Check results as part of computation.
3856 for (int j = 0; j < SPECIES.length(); j++) {
3857 Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3858 }
3859 }
3860 }
3861 }
3862
3863 @Test(dataProvider = "shortCompareOpProvider")
3864 static void ltShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3865 short[] a = fa.apply(SPECIES.length());
3866 short[] b = fb.apply(SPECIES.length());
3867
3868 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3869 for (int i = 0; i < a.length; i += SPECIES.length()) {
3870 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3871 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3872 VectorMask<Short> mv = av.lt(bv);
3873
3874 // Check results as part of computation.
3875 for (int j = 0; j < SPECIES.length(); j++) {
3876 Assert.assertEquals(mv.laneIsSet(j), lt(a[i + j], b[i + j]));
3877 }
3878 }
3879 }
3880 }
3881
3882 @Test(dataProvider = "shortCompareOpMaskProvider")
3883 static void LTShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3884 IntFunction<boolean[]> fm) {
3885 short[] a = fa.apply(SPECIES.length());
3886 short[] b = fb.apply(SPECIES.length());
3887 boolean[] mask = fm.apply(SPECIES.length());
3888
3889 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3890
3891 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3892 for (int i = 0; i < a.length; i += SPECIES.length()) {
3893 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3894 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3895 VectorMask<Short> mv = av.compare(VectorOperators.LT, bv, vmask);
3896
3897 // Check results as part of computation.
3898 for (int j = 0; j < SPECIES.length(); j++) {
3899 Assert.assertEquals(mv.laneIsSet(j), mask[j] && lt(a[i + j], b[i + j]));
3900 }
3901 }
3902 }
3903 }
3904
3905 @Test(dataProvider = "shortCompareOpProvider")
3906 static void GTShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3907 short[] a = fa.apply(SPECIES.length());
3908 short[] b = fb.apply(SPECIES.length());
3909
3910 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3911 for (int i = 0; i < a.length; i += SPECIES.length()) {
3912 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3913 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3914 VectorMask<Short> mv = av.compare(VectorOperators.GT, bv);
3915
3916 // Check results as part of computation.
3917 for (int j = 0; j < SPECIES.length(); j++) {
3918 Assert.assertEquals(mv.laneIsSet(j), gt(a[i + j], b[i + j]));
3919 }
3920 }
3921 }
3922 }
3923
3924 @Test(dataProvider = "shortCompareOpMaskProvider")
3925 static void GTShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3926 IntFunction<boolean[]> fm) {
3927 short[] a = fa.apply(SPECIES.length());
3928 short[] b = fb.apply(SPECIES.length());
3929 boolean[] mask = fm.apply(SPECIES.length());
3930
3931 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3932
3933 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3934 for (int i = 0; i < a.length; i += SPECIES.length()) {
3935 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3936 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3937 VectorMask<Short> mv = av.compare(VectorOperators.GT, bv, vmask);
3938
3939 // Check results as part of computation.
3940 for (int j = 0; j < SPECIES.length(); j++) {
3941 Assert.assertEquals(mv.laneIsSet(j), mask[j] && gt(a[i + j], b[i + j]));
3942 }
3943 }
3944 }
3945 }
3946
3947 @Test(dataProvider = "shortCompareOpProvider")
3948 static void EQShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3949 short[] a = fa.apply(SPECIES.length());
3950 short[] b = fb.apply(SPECIES.length());
3951
3952 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3953 for (int i = 0; i < a.length; i += SPECIES.length()) {
3954 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3955 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3956 VectorMask<Short> mv = av.compare(VectorOperators.EQ, bv);
3957
3958 // Check results as part of computation.
3959 for (int j = 0; j < SPECIES.length(); j++) {
3960 Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3961 }
3962 }
3963 }
3964 }
3965
3966 @Test(dataProvider = "shortCompareOpProvider")
3967 static void eqShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
3968 short[] a = fa.apply(SPECIES.length());
3969 short[] b = fb.apply(SPECIES.length());
3970
3971 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3972 for (int i = 0; i < a.length; i += SPECIES.length()) {
3973 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3974 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3975 VectorMask<Short> mv = av.eq(bv);
3976
3977 // Check results as part of computation.
3978 for (int j = 0; j < SPECIES.length(); j++) {
3979 Assert.assertEquals(mv.laneIsSet(j), eq(a[i + j], b[i + j]));
3980 }
3981 }
3982 }
3983 }
3984
3985 @Test(dataProvider = "shortCompareOpMaskProvider")
3986 static void EQShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
3987 IntFunction<boolean[]> fm) {
3988 short[] a = fa.apply(SPECIES.length());
3989 short[] b = fb.apply(SPECIES.length());
3990 boolean[] mask = fm.apply(SPECIES.length());
3991
3992 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3993
3994 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3995 for (int i = 0; i < a.length; i += SPECIES.length()) {
3996 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
3997 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
3998 VectorMask<Short> mv = av.compare(VectorOperators.EQ, bv, vmask);
3999
4000 // Check results as part of computation.
4001 for (int j = 0; j < SPECIES.length(); j++) {
4002 Assert.assertEquals(mv.laneIsSet(j), mask[j] && eq(a[i + j], b[i + j]));
4003 }
4004 }
4005 }
4006 }
4007
4008 @Test(dataProvider = "shortCompareOpProvider")
4009 static void NEShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4010 short[] a = fa.apply(SPECIES.length());
4011 short[] b = fb.apply(SPECIES.length());
4012
4013 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4014 for (int i = 0; i < a.length; i += SPECIES.length()) {
4015 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4016 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4017 VectorMask<Short> mv = av.compare(VectorOperators.NE, bv);
4018
4019 // Check results as part of computation.
4020 for (int j = 0; j < SPECIES.length(); j++) {
4021 Assert.assertEquals(mv.laneIsSet(j), neq(a[i + j], b[i + j]));
4022 }
4023 }
4024 }
4025 }
4026
4027 @Test(dataProvider = "shortCompareOpMaskProvider")
4028 static void NEShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4029 IntFunction<boolean[]> fm) {
4030 short[] a = fa.apply(SPECIES.length());
4031 short[] b = fb.apply(SPECIES.length());
4032 boolean[] mask = fm.apply(SPECIES.length());
4033
4034 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4035
4036 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4037 for (int i = 0; i < a.length; i += SPECIES.length()) {
4038 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4039 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4040 VectorMask<Short> mv = av.compare(VectorOperators.NE, bv, vmask);
4041
4042 // Check results as part of computation.
4043 for (int j = 0; j < SPECIES.length(); j++) {
4044 Assert.assertEquals(mv.laneIsSet(j), mask[j] && neq(a[i + j], b[i + j]));
4045 }
4046 }
4047 }
4048 }
4049
4050 @Test(dataProvider = "shortCompareOpProvider")
4051 static void LEShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4052 short[] a = fa.apply(SPECIES.length());
4053 short[] b = fb.apply(SPECIES.length());
4054
4055 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4056 for (int i = 0; i < a.length; i += SPECIES.length()) {
4057 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4058 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4059 VectorMask<Short> mv = av.compare(VectorOperators.LE, bv);
4060
4061 // Check results as part of computation.
4062 for (int j = 0; j < SPECIES.length(); j++) {
4063 Assert.assertEquals(mv.laneIsSet(j), le(a[i + j], b[i + j]));
4064 }
4065 }
4066 }
4067 }
4068
4069 @Test(dataProvider = "shortCompareOpMaskProvider")
4070 static void LEShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4071 IntFunction<boolean[]> fm) {
4072 short[] a = fa.apply(SPECIES.length());
4073 short[] b = fb.apply(SPECIES.length());
4074 boolean[] mask = fm.apply(SPECIES.length());
4075
4076 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4077
4078 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4079 for (int i = 0; i < a.length; i += SPECIES.length()) {
4080 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4081 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4082 VectorMask<Short> mv = av.compare(VectorOperators.LE, bv, vmask);
4083
4084 // Check results as part of computation.
4085 for (int j = 0; j < SPECIES.length(); j++) {
4086 Assert.assertEquals(mv.laneIsSet(j), mask[j] && le(a[i + j], b[i + j]));
4087 }
4088 }
4089 }
4090 }
4091
4092 @Test(dataProvider = "shortCompareOpProvider")
4093 static void GEShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4094 short[] a = fa.apply(SPECIES.length());
4095 short[] b = fb.apply(SPECIES.length());
4096
4097 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4098 for (int i = 0; i < a.length; i += SPECIES.length()) {
4099 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4100 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4101 VectorMask<Short> mv = av.compare(VectorOperators.GE, bv);
4102
4103 // Check results as part of computation.
4104 for (int j = 0; j < SPECIES.length(); j++) {
4105 Assert.assertEquals(mv.laneIsSet(j), ge(a[i + j], b[i + j]));
4106 }
4107 }
4108 }
4109 }
4110
4111 @Test(dataProvider = "shortCompareOpMaskProvider")
4112 static void GEShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4113 IntFunction<boolean[]> fm) {
4114 short[] a = fa.apply(SPECIES.length());
4115 short[] b = fb.apply(SPECIES.length());
4116 boolean[] mask = fm.apply(SPECIES.length());
4117
4118 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4119
4120 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4121 for (int i = 0; i < a.length; i += SPECIES.length()) {
4122 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4123 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4124 VectorMask<Short> mv = av.compare(VectorOperators.GE, bv, vmask);
4125
4126 // Check results as part of computation.
4127 for (int j = 0; j < SPECIES.length(); j++) {
4128 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ge(a[i + j], b[i + j]));
4129 }
4130 }
4131 }
4132 }
4133
4134 @Test(dataProvider = "shortCompareOpProvider")
4135 static void UNSIGNED_LTShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4136 short[] a = fa.apply(SPECIES.length());
4137 short[] b = fb.apply(SPECIES.length());
4138
4139 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4140 for (int i = 0; i < a.length; i += SPECIES.length()) {
4141 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4142 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4143 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_LT, bv);
4144
4145 // Check results as part of computation.
4146 for (int j = 0; j < SPECIES.length(); j++) {
4147 Assert.assertEquals(mv.laneIsSet(j), ult(a[i + j], b[i + j]));
4148 }
4149 }
4150 }
4151 }
4152
4153 @Test(dataProvider = "shortCompareOpMaskProvider")
4154 static void UNSIGNED_LTShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4155 IntFunction<boolean[]> fm) {
4156 short[] a = fa.apply(SPECIES.length());
4157 short[] b = fb.apply(SPECIES.length());
4158 boolean[] mask = fm.apply(SPECIES.length());
4159
4160 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4161
4162 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4163 for (int i = 0; i < a.length; i += SPECIES.length()) {
4164 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4165 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4166 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_LT, bv, vmask);
4167
4168 // Check results as part of computation.
4169 for (int j = 0; j < SPECIES.length(); j++) {
4170 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ult(a[i + j], b[i + j]));
4171 }
4172 }
4173 }
4174 }
4175
4176 @Test(dataProvider = "shortCompareOpProvider")
4177 static void UNSIGNED_GTShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4178 short[] a = fa.apply(SPECIES.length());
4179 short[] b = fb.apply(SPECIES.length());
4180
4181 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4182 for (int i = 0; i < a.length; i += SPECIES.length()) {
4183 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4184 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4185 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_GT, bv);
4186
4187 // Check results as part of computation.
4188 for (int j = 0; j < SPECIES.length(); j++) {
4189 Assert.assertEquals(mv.laneIsSet(j), ugt(a[i + j], b[i + j]));
4190 }
4191 }
4192 }
4193 }
4194
4195 @Test(dataProvider = "shortCompareOpMaskProvider")
4196 static void UNSIGNED_GTShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4197 IntFunction<boolean[]> fm) {
4198 short[] a = fa.apply(SPECIES.length());
4199 short[] b = fb.apply(SPECIES.length());
4200 boolean[] mask = fm.apply(SPECIES.length());
4201
4202 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4203
4204 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4205 for (int i = 0; i < a.length; i += SPECIES.length()) {
4206 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4207 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4208 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_GT, bv, vmask);
4209
4210 // Check results as part of computation.
4211 for (int j = 0; j < SPECIES.length(); j++) {
4212 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ugt(a[i + j], b[i + j]));
4213 }
4214 }
4215 }
4216 }
4217
4218 @Test(dataProvider = "shortCompareOpProvider")
4219 static void UNSIGNED_LEShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4220 short[] a = fa.apply(SPECIES.length());
4221 short[] b = fb.apply(SPECIES.length());
4222
4223 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4224 for (int i = 0; i < a.length; i += SPECIES.length()) {
4225 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4226 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4227 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_LE, bv);
4228
4229 // Check results as part of computation.
4230 for (int j = 0; j < SPECIES.length(); j++) {
4231 Assert.assertEquals(mv.laneIsSet(j), ule(a[i + j], b[i + j]));
4232 }
4233 }
4234 }
4235 }
4236
4237 @Test(dataProvider = "shortCompareOpMaskProvider")
4238 static void UNSIGNED_LEShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4239 IntFunction<boolean[]> fm) {
4240 short[] a = fa.apply(SPECIES.length());
4241 short[] b = fb.apply(SPECIES.length());
4242 boolean[] mask = fm.apply(SPECIES.length());
4243
4244 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4245
4246 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4247 for (int i = 0; i < a.length; i += SPECIES.length()) {
4248 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4249 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4250 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_LE, bv, vmask);
4251
4252 // Check results as part of computation.
4253 for (int j = 0; j < SPECIES.length(); j++) {
4254 Assert.assertEquals(mv.laneIsSet(j), mask[j] && ule(a[i + j], b[i + j]));
4255 }
4256 }
4257 }
4258 }
4259
4260 @Test(dataProvider = "shortCompareOpProvider")
4261 static void UNSIGNED_GEShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4262 short[] a = fa.apply(SPECIES.length());
4263 short[] b = fb.apply(SPECIES.length());
4264
4265 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4266 for (int i = 0; i < a.length; i += SPECIES.length()) {
4267 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4268 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4269 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_GE, bv);
4270
4271 // Check results as part of computation.
4272 for (int j = 0; j < SPECIES.length(); j++) {
4273 Assert.assertEquals(mv.laneIsSet(j), uge(a[i + j], b[i + j]));
4274 }
4275 }
4276 }
4277 }
4278
4279 @Test(dataProvider = "shortCompareOpMaskProvider")
4280 static void UNSIGNED_GEShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4281 IntFunction<boolean[]> fm) {
4282 short[] a = fa.apply(SPECIES.length());
4283 short[] b = fb.apply(SPECIES.length());
4284 boolean[] mask = fm.apply(SPECIES.length());
4285
4286 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4287
4288 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4289 for (int i = 0; i < a.length; i += SPECIES.length()) {
4290 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4291 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4292 VectorMask<Short> mv = av.compare(VectorOperators.UNSIGNED_GE, bv, vmask);
4293
4294 // Check results as part of computation.
4295 for (int j = 0; j < SPECIES.length(); j++) {
4296 Assert.assertEquals(mv.laneIsSet(j), mask[j] && uge(a[i + j], b[i + j]));
4297 }
4298 }
4299 }
4300 }
4301
4302 @Test(dataProvider = "shortCompareOpProvider")
4303 static void LTShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4304 short[] a = fa.apply(SPECIES.length());
4305 short[] b = fb.apply(SPECIES.length());
4306
4307 for (int i = 0; i < a.length; i += SPECIES.length()) {
4308 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4309 VectorMask<Short> mv = av.compare(VectorOperators.LT, b[i]);
4310
4311 // Check results as part of computation.
4312 for (int j = 0; j < SPECIES.length(); j++) {
4313 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
4314 }
4315 }
4316 }
4317
4318 @Test(dataProvider = "shortCompareOpMaskProvider")
4319 static void LTShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa,
4320 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
4321 short[] a = fa.apply(SPECIES.length());
4322 short[] b = fb.apply(SPECIES.length());
4323 boolean[] mask = fm.apply(SPECIES.length());
4324
4325 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4326
4327 for (int i = 0; i < a.length; i += SPECIES.length()) {
4328 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4329 VectorMask<Short> mv = av.compare(VectorOperators.LT, b[i], vmask);
4330
4331 // Check results as part of computation.
4332 for (int j = 0; j < SPECIES.length(); j++) {
4333 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < b[i]));
4334 }
4335 }
4336 }
4337
4338 @Test(dataProvider = "shortCompareOpProvider")
4339 static void LTShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4340 short[] a = fa.apply(SPECIES.length());
4341 short[] b = fb.apply(SPECIES.length());
4342
4343 for (int i = 0; i < a.length; i += SPECIES.length()) {
4344 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4345 VectorMask<Short> mv = av.compare(VectorOperators.LT, (long)b[i]);
4346
4347 // Check results as part of computation.
4348 for (int j = 0; j < SPECIES.length(); j++) {
4349 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < (short)((long)b[i]));
4350 }
4351 }
4352 }
4353
4354 @Test(dataProvider = "shortCompareOpMaskProvider")
4355 static void LTShortMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<short[]> fa,
4356 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
4357 short[] a = fa.apply(SPECIES.length());
4358 short[] b = fb.apply(SPECIES.length());
4359 boolean[] mask = fm.apply(SPECIES.length());
4360
4361 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4362
4363 for (int i = 0; i < a.length; i += SPECIES.length()) {
4364 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4365 VectorMask<Short> mv = av.compare(VectorOperators.LT, (long)b[i], vmask);
4366
4367 // Check results as part of computation.
4368 for (int j = 0; j < SPECIES.length(); j++) {
4369 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] < (short)((long)b[i])));
4370 }
4371 }
4372 }
4373
4374 @Test(dataProvider = "shortCompareOpProvider")
4375 static void EQShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4376 short[] a = fa.apply(SPECIES.length());
4377 short[] b = fb.apply(SPECIES.length());
4378
4379 for (int i = 0; i < a.length; i += SPECIES.length()) {
4380 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4381 VectorMask<Short> mv = av.compare(VectorOperators.EQ, b[i]);
4382
4383 // Check results as part of computation.
4384 for (int j = 0; j < SPECIES.length(); j++) {
4385 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
4386 }
4387 }
4388 }
4389
4390 @Test(dataProvider = "shortCompareOpMaskProvider")
4391 static void EQShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa,
4392 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
4393 short[] a = fa.apply(SPECIES.length());
4394 short[] b = fb.apply(SPECIES.length());
4395 boolean[] mask = fm.apply(SPECIES.length());
4396
4397 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4398
4399 for (int i = 0; i < a.length; i += SPECIES.length()) {
4400 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4401 VectorMask<Short> mv = av.compare(VectorOperators.EQ, b[i], vmask);
4402
4403 // Check results as part of computation.
4404 for (int j = 0; j < SPECIES.length(); j++) {
4405 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == b[i]));
4406 }
4407 }
4408 }
4409
4410 @Test(dataProvider = "shortCompareOpProvider")
4411 static void EQShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4412 short[] a = fa.apply(SPECIES.length());
4413 short[] b = fb.apply(SPECIES.length());
4414
4415 for (int i = 0; i < a.length; i += SPECIES.length()) {
4416 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4417 VectorMask<Short> mv = av.compare(VectorOperators.EQ, (long)b[i]);
4418
4419 // Check results as part of computation.
4420 for (int j = 0; j < SPECIES.length(); j++) {
4421 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == (short)((long)b[i]));
4422 }
4423 }
4424 }
4425
4426 @Test(dataProvider = "shortCompareOpMaskProvider")
4427 static void EQShortMaxVectorTestsBroadcastLongMaskedSmokeTest(IntFunction<short[]> fa,
4428 IntFunction<short[]> fb, IntFunction<boolean[]> fm) {
4429 short[] a = fa.apply(SPECIES.length());
4430 short[] b = fb.apply(SPECIES.length());
4431 boolean[] mask = fm.apply(SPECIES.length());
4432
4433 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4434
4435 for (int i = 0; i < a.length; i += SPECIES.length()) {
4436 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4437 VectorMask<Short> mv = av.compare(VectorOperators.EQ, (long)b[i], vmask);
4438
4439 // Check results as part of computation.
4440 for (int j = 0; j < SPECIES.length(); j++) {
4441 Assert.assertEquals(mv.laneIsSet(j), mask[j] && (a[i + j] == (short)((long)b[i])));
4442 }
4443 }
4444 }
4445
4446 static short blend(short a, short b, boolean mask) {
4447 return mask ? b : a;
4448 }
4449
4450 @Test(dataProvider = "shortBinaryOpMaskProvider")
4451 static void blendShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb,
4452 IntFunction<boolean[]> fm) {
4453 short[] a = fa.apply(SPECIES.length());
4454 short[] b = fb.apply(SPECIES.length());
4455 short[] r = fr.apply(SPECIES.length());
4456 boolean[] mask = fm.apply(SPECIES.length());
4457 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4458
4459 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4460 for (int i = 0; i < a.length; i += SPECIES.length()) {
4461 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4462 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4463 av.blend(bv, vmask).intoArray(r, i);
4464 }
4465 }
4466
4467 assertArraysEquals(r, a, b, mask, ShortMaxVectorTests::blend);
4468 }
4469
4470 @Test(dataProvider = "shortUnaryOpShuffleProvider")
4471 static void RearrangeShortMaxVectorTests(IntFunction<short[]> fa,
4472 BiFunction<Integer,Integer,int[]> fs) {
4473 short[] a = fa.apply(SPECIES.length());
4474 int[] order = fs.apply(a.length, SPECIES.length());
4475 short[] r = fr.apply(SPECIES.length());
4476
4477 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4478 for (int i = 0; i < a.length; i += SPECIES.length()) {
4479 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4480 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i)).intoArray(r, i);
4481 }
4482 }
4483
4484 assertRearrangeArraysEquals(r, a, order, SPECIES.length());
4485 }
4486
4487 @Test(dataProvider = "shortUnaryOpShuffleMaskProvider")
4488 static void RearrangeShortMaxVectorTestsMaskedSmokeTest(IntFunction<short[]> fa,
4489 BiFunction<Integer,Integer,int[]> fs,
4490 IntFunction<boolean[]> fm) {
4491 short[] a = fa.apply(SPECIES.length());
4492 int[] order = fs.apply(a.length, SPECIES.length());
4493 short[] r = fr.apply(SPECIES.length());
4494 boolean[] mask = fm.apply(SPECIES.length());
4495 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4496
4497 for (int i = 0; i < a.length; i += SPECIES.length()) {
4498 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4499 av.rearrange(VectorShuffle.fromArray(SPECIES, order, i), vmask).intoArray(r, i);
4500 }
4501
4502 assertRearrangeArraysEquals(r, a, order, mask, SPECIES.length());
4503 }
4504
4505 @Test(dataProvider = "shortUnaryOpMaskProvider")
4506 static void compressShortMaxVectorTests(IntFunction<short[]> fa,
4507 IntFunction<boolean[]> fm) {
4508 short[] a = fa.apply(SPECIES.length());
4509 short[] r = fr.apply(SPECIES.length());
4510 boolean[] mask = fm.apply(SPECIES.length());
4511 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4512
4513 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4514 for (int i = 0; i < a.length; i += SPECIES.length()) {
4515 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4516 av.compress(vmask).intoArray(r, i);
4517 }
4518 }
4519
4520 assertcompressArraysEquals(r, a, mask, SPECIES.length());
4521 }
4522
4523 @Test(dataProvider = "shortUnaryOpMaskProvider")
4524 static void expandShortMaxVectorTests(IntFunction<short[]> fa,
4525 IntFunction<boolean[]> fm) {
4526 short[] a = fa.apply(SPECIES.length());
4527 short[] r = fr.apply(SPECIES.length());
4528 boolean[] mask = fm.apply(SPECIES.length());
4529 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4530
4531 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4532 for (int i = 0; i < a.length; i += SPECIES.length()) {
4533 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4534 av.expand(vmask).intoArray(r, i);
4535 }
4536 }
4537
4538 assertexpandArraysEquals(r, a, mask, SPECIES.length());
4539 }
4540
4541 @Test(dataProvider = "shortUnaryOpProvider")
4542 static void getShortMaxVectorTests(IntFunction<short[]> fa) {
4543 short[] a = fa.apply(SPECIES.length());
4544 short[] r = fr.apply(SPECIES.length());
4545
4546 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4547 for (int i = 0; i < a.length; i += SPECIES.length()) {
4548 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4549 int num_lanes = SPECIES.length();
4550 // Manually unroll because full unroll happens after intrinsification.
4551 // Unroll is needed because get intrinsic requires for index to be a known constant.
4552 if (num_lanes == 1) {
4553 r[i]=av.lane(0);
4554 } else if (num_lanes == 2) {
4555 r[i]=av.lane(0);
4556 r[i+1]=av.lane(1);
4557 } else if (num_lanes == 4) {
4558 r[i]=av.lane(0);
4559 r[i+1]=av.lane(1);
4560 r[i+2]=av.lane(2);
4561 r[i+3]=av.lane(3);
4562 } else if (num_lanes == 8) {
4563 r[i]=av.lane(0);
4564 r[i+1]=av.lane(1);
4565 r[i+2]=av.lane(2);
4566 r[i+3]=av.lane(3);
4567 r[i+4]=av.lane(4);
4568 r[i+5]=av.lane(5);
4569 r[i+6]=av.lane(6);
4570 r[i+7]=av.lane(7);
4571 } else if (num_lanes == 16) {
4572 r[i]=av.lane(0);
4573 r[i+1]=av.lane(1);
4574 r[i+2]=av.lane(2);
4575 r[i+3]=av.lane(3);
4576 r[i+4]=av.lane(4);
4577 r[i+5]=av.lane(5);
4578 r[i+6]=av.lane(6);
4579 r[i+7]=av.lane(7);
4580 r[i+8]=av.lane(8);
4581 r[i+9]=av.lane(9);
4582 r[i+10]=av.lane(10);
4583 r[i+11]=av.lane(11);
4584 r[i+12]=av.lane(12);
4585 r[i+13]=av.lane(13);
4586 r[i+14]=av.lane(14);
4587 r[i+15]=av.lane(15);
4588 } else if (num_lanes == 32) {
4589 r[i]=av.lane(0);
4590 r[i+1]=av.lane(1);
4591 r[i+2]=av.lane(2);
4592 r[i+3]=av.lane(3);
4593 r[i+4]=av.lane(4);
4594 r[i+5]=av.lane(5);
4595 r[i+6]=av.lane(6);
4596 r[i+7]=av.lane(7);
4597 r[i+8]=av.lane(8);
4598 r[i+9]=av.lane(9);
4599 r[i+10]=av.lane(10);
4600 r[i+11]=av.lane(11);
4601 r[i+12]=av.lane(12);
4602 r[i+13]=av.lane(13);
4603 r[i+14]=av.lane(14);
4604 r[i+15]=av.lane(15);
4605 r[i+16]=av.lane(16);
4606 r[i+17]=av.lane(17);
4607 r[i+18]=av.lane(18);
4608 r[i+19]=av.lane(19);
4609 r[i+20]=av.lane(20);
4610 r[i+21]=av.lane(21);
4611 r[i+22]=av.lane(22);
4612 r[i+23]=av.lane(23);
4613 r[i+24]=av.lane(24);
4614 r[i+25]=av.lane(25);
4615 r[i+26]=av.lane(26);
4616 r[i+27]=av.lane(27);
4617 r[i+28]=av.lane(28);
4618 r[i+29]=av.lane(29);
4619 r[i+30]=av.lane(30);
4620 r[i+31]=av.lane(31);
4621 } else if (num_lanes == 64) {
4622 r[i]=av.lane(0);
4623 r[i+1]=av.lane(1);
4624 r[i+2]=av.lane(2);
4625 r[i+3]=av.lane(3);
4626 r[i+4]=av.lane(4);
4627 r[i+5]=av.lane(5);
4628 r[i+6]=av.lane(6);
4629 r[i+7]=av.lane(7);
4630 r[i+8]=av.lane(8);
4631 r[i+9]=av.lane(9);
4632 r[i+10]=av.lane(10);
4633 r[i+11]=av.lane(11);
4634 r[i+12]=av.lane(12);
4635 r[i+13]=av.lane(13);
4636 r[i+14]=av.lane(14);
4637 r[i+15]=av.lane(15);
4638 r[i+16]=av.lane(16);
4639 r[i+17]=av.lane(17);
4640 r[i+18]=av.lane(18);
4641 r[i+19]=av.lane(19);
4642 r[i+20]=av.lane(20);
4643 r[i+21]=av.lane(21);
4644 r[i+22]=av.lane(22);
4645 r[i+23]=av.lane(23);
4646 r[i+24]=av.lane(24);
4647 r[i+25]=av.lane(25);
4648 r[i+26]=av.lane(26);
4649 r[i+27]=av.lane(27);
4650 r[i+28]=av.lane(28);
4651 r[i+29]=av.lane(29);
4652 r[i+30]=av.lane(30);
4653 r[i+31]=av.lane(31);
4654 r[i+32]=av.lane(32);
4655 r[i+33]=av.lane(33);
4656 r[i+34]=av.lane(34);
4657 r[i+35]=av.lane(35);
4658 r[i+36]=av.lane(36);
4659 r[i+37]=av.lane(37);
4660 r[i+38]=av.lane(38);
4661 r[i+39]=av.lane(39);
4662 r[i+40]=av.lane(40);
4663 r[i+41]=av.lane(41);
4664 r[i+42]=av.lane(42);
4665 r[i+43]=av.lane(43);
4666 r[i+44]=av.lane(44);
4667 r[i+45]=av.lane(45);
4668 r[i+46]=av.lane(46);
4669 r[i+47]=av.lane(47);
4670 r[i+48]=av.lane(48);
4671 r[i+49]=av.lane(49);
4672 r[i+50]=av.lane(50);
4673 r[i+51]=av.lane(51);
4674 r[i+52]=av.lane(52);
4675 r[i+53]=av.lane(53);
4676 r[i+54]=av.lane(54);
4677 r[i+55]=av.lane(55);
4678 r[i+56]=av.lane(56);
4679 r[i+57]=av.lane(57);
4680 r[i+58]=av.lane(58);
4681 r[i+59]=av.lane(59);
4682 r[i+60]=av.lane(60);
4683 r[i+61]=av.lane(61);
4684 r[i+62]=av.lane(62);
4685 r[i+63]=av.lane(63);
4686 } else {
4687 for (int j = 0; j < SPECIES.length(); j++) {
4688 r[i+j]=av.lane(j);
4689 }
4690 }
4691 }
4692 }
4693
4694 assertArraysEquals(r, a, ShortMaxVectorTests::get);
4695 }
4696
4697 @Test(dataProvider = "shortUnaryOpProvider")
4698 static void BroadcastShortMaxVectorTests(IntFunction<short[]> fa) {
4699 short[] a = fa.apply(SPECIES.length());
4700 short[] r = new short[a.length];
4701
4702 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4703 for (int i = 0; i < a.length; i += SPECIES.length()) {
4704 ShortVector.broadcast(SPECIES, a[i]).intoArray(r, i);
4705 }
4706 }
4707
4708 assertBroadcastArraysEquals(r, a);
4709 }
4710
4711 @Test(dataProvider = "shortUnaryOpProvider")
4712 static void ZeroShortMaxVectorTests(IntFunction<short[]> fa) {
4713 short[] a = fa.apply(SPECIES.length());
4714 short[] r = new short[a.length];
4715
4716 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4717 for (int i = 0; i < a.length; i += SPECIES.length()) {
4718 ShortVector.zero(SPECIES).intoArray(a, i);
4719 }
4720 }
4721
4722 Assert.assertEquals(a, r);
4723 }
4724
4725 static short[] sliceUnary(short[] a, int origin, int idx) {
4726 short[] res = new short[SPECIES.length()];
4727 for (int i = 0; i < SPECIES.length(); i++){
4728 if(i+origin < SPECIES.length())
4729 res[i] = a[idx+i+origin];
4730 else
4731 res[i] = (short)0;
4732 }
4733 return res;
4734 }
4735
4736 @Test(dataProvider = "shortUnaryOpProvider")
4737 static void sliceUnaryShortMaxVectorTests(IntFunction<short[]> fa) {
4738 short[] a = fa.apply(SPECIES.length());
4739 short[] r = new short[a.length];
4740 int origin = (new java.util.Random()).nextInt(SPECIES.length());
4741 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4742 for (int i = 0; i < a.length; i += SPECIES.length()) {
4743 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4744 av.slice(origin).intoArray(r, i);
4745 }
4746 }
4747
4748 assertArraysEquals(r, a, origin, ShortMaxVectorTests::sliceUnary);
4749 }
4750
4751 static short[] sliceBinary(short[] a, short[] b, int origin, int idx) {
4752 short[] res = new short[SPECIES.length()];
4753 for (int i = 0, j = 0; i < SPECIES.length(); i++){
4754 if(i+origin < SPECIES.length())
4755 res[i] = a[idx+i+origin];
4756 else {
4757 res[i] = b[idx+j];
4758 j++;
4759 }
4760 }
4761 return res;
4762 }
4763
4764 @Test(dataProvider = "shortBinaryOpProvider")
4765 static void sliceBinaryShortMaxVectorTestsBinary(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4766 short[] a = fa.apply(SPECIES.length());
4767 short[] b = fb.apply(SPECIES.length());
4768 short[] r = new short[a.length];
4769 int origin = (new java.util.Random()).nextInt(SPECIES.length());
4770 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4771 for (int i = 0; i < a.length; i += SPECIES.length()) {
4772 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4773 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4774 av.slice(origin, bv).intoArray(r, i);
4775 }
4776 }
4777
4778 assertArraysEquals(r, a, b, origin, ShortMaxVectorTests::sliceBinary);
4779 }
4780
4781 static short[] slice(short[] a, short[] b, int origin, boolean[] mask, int idx) {
4782 short[] res = new short[SPECIES.length()];
4783 for (int i = 0, j = 0; i < SPECIES.length(); i++){
4784 if(i+origin < SPECIES.length())
4785 res[i] = mask[i] ? a[idx+i+origin] : (short)0;
4786 else {
4787 res[i] = mask[i] ? b[idx+j] : (short)0;
4788 j++;
4789 }
4790 }
4791 return res;
4792 }
4793
4794 @Test(dataProvider = "shortBinaryOpMaskProvider")
4795 static void sliceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4796 IntFunction<boolean[]> fm) {
4797 short[] a = fa.apply(SPECIES.length());
4798 short[] b = fb.apply(SPECIES.length());
4799 boolean[] mask = fm.apply(SPECIES.length());
4800 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4801
4802 short[] r = new short[a.length];
4803 int origin = (new java.util.Random()).nextInt(SPECIES.length());
4804 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4805 for (int i = 0; i < a.length; i += SPECIES.length()) {
4806 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4807 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4808 av.slice(origin, bv, vmask).intoArray(r, i);
4809 }
4810 }
4811
4812 assertArraysEquals(r, a, b, origin, mask, ShortMaxVectorTests::slice);
4813 }
4814
4815 static short[] unsliceUnary(short[] a, int origin, int idx) {
4816 short[] res = new short[SPECIES.length()];
4817 for (int i = 0, j = 0; i < SPECIES.length(); i++){
4818 if(i < origin)
4819 res[i] = (short)0;
4820 else {
4821 res[i] = a[idx+j];
4822 j++;
4823 }
4824 }
4825 return res;
4826 }
4827
4828 @Test(dataProvider = "shortUnaryOpProvider")
4829 static void unsliceUnaryShortMaxVectorTests(IntFunction<short[]> fa) {
4830 short[] a = fa.apply(SPECIES.length());
4831 short[] r = new short[a.length];
4832 int origin = (new java.util.Random()).nextInt(SPECIES.length());
4833 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4834 for (int i = 0; i < a.length; i += SPECIES.length()) {
4835 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4836 av.unslice(origin).intoArray(r, i);
4837 }
4838 }
4839
4840 assertArraysEquals(r, a, origin, ShortMaxVectorTests::unsliceUnary);
4841 }
4842
4843 static short[] unsliceBinary(short[] a, short[] b, int origin, int part, int idx) {
4844 short[] res = new short[SPECIES.length()];
4845 for (int i = 0, j = 0; i < SPECIES.length(); i++){
4846 if (part == 0) {
4847 if (i < origin)
4848 res[i] = b[idx+i];
4849 else {
4850 res[i] = a[idx+j];
4851 j++;
4852 }
4853 } else if (part == 1) {
4854 if (i < origin)
4855 res[i] = a[idx+SPECIES.length()-origin+i];
4856 else {
4857 res[i] = b[idx+origin+j];
4858 j++;
4859 }
4860 }
4861 }
4862 return res;
4863 }
4864
4865 @Test(dataProvider = "shortBinaryOpProvider")
4866 static void unsliceBinaryShortMaxVectorTestsBinary(IntFunction<short[]> fa, IntFunction<short[]> fb) {
4867 short[] a = fa.apply(SPECIES.length());
4868 short[] b = fb.apply(SPECIES.length());
4869 short[] r = new short[a.length];
4870 int origin = (new java.util.Random()).nextInt(SPECIES.length());
4871 int part = (new java.util.Random()).nextInt(2);
4872 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4873 for (int i = 0; i < a.length; i += SPECIES.length()) {
4874 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4875 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4876 av.unslice(origin, bv, part).intoArray(r, i);
4877 }
4878 }
4879
4880 assertArraysEquals(r, a, b, origin, part, ShortMaxVectorTests::unsliceBinary);
4881 }
4882
4883 static short[] unslice(short[] a, short[] b, int origin, int part, boolean[] mask, int idx) {
4884 short[] res = new short[SPECIES.length()];
4885 for (int i = 0, j = 0; i < SPECIES.length(); i++){
4886 if(i+origin < SPECIES.length())
4887 res[i] = b[idx+i+origin];
4888 else {
4889 res[i] = b[idx+j];
4890 j++;
4891 }
4892 }
4893 for (int i = 0; i < SPECIES.length(); i++){
4894 res[i] = mask[i] ? a[idx+i] : res[i];
4895 }
4896 short[] res1 = new short[SPECIES.length()];
4897 if (part == 0) {
4898 for (int i = 0, j = 0; i < SPECIES.length(); i++){
4899 if (i < origin)
4900 res1[i] = b[idx+i];
4901 else {
4902 res1[i] = res[j];
4903 j++;
4904 }
4905 }
4906 } else if (part == 1) {
4907 for (int i = 0, j = 0; i < SPECIES.length(); i++){
4908 if (i < origin)
4909 res1[i] = res[SPECIES.length()-origin+i];
4910 else {
4911 res1[i] = b[idx+origin+j];
4912 j++;
4913 }
4914 }
4915 }
4916 return res1;
4917 }
4918
4919 @Test(dataProvider = "shortBinaryOpMaskProvider")
4920 static void unsliceShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4921 IntFunction<boolean[]> fm) {
4922 short[] a = fa.apply(SPECIES.length());
4923 short[] b = fb.apply(SPECIES.length());
4924 boolean[] mask = fm.apply(SPECIES.length());
4925 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4926 short[] r = new short[a.length];
4927 int origin = (new java.util.Random()).nextInt(SPECIES.length());
4928 int part = (new java.util.Random()).nextInt(2);
4929 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4930 for (int i = 0; i < a.length; i += SPECIES.length()) {
4931 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4932 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4933 av.unslice(origin, bv, part, vmask).intoArray(r, i);
4934 }
4935 }
4936
4937 assertArraysEquals(r, a, b, origin, part, mask, ShortMaxVectorTests::unslice);
4938 }
4939
4940 static short BITWISE_BLEND(short a, short b, short c) {
4941 return (short)((a&~(c))|(b&c));
4942 }
4943
4944 static short bitwiseBlend(short a, short b, short c) {
4945 return (short)((a&~(c))|(b&c));
4946 }
4947
4948 @Test(dataProvider = "shortTernaryOpProvider")
4949 static void BITWISE_BLENDShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
4950 short[] a = fa.apply(SPECIES.length());
4951 short[] b = fb.apply(SPECIES.length());
4952 short[] c = fc.apply(SPECIES.length());
4953 short[] r = fr.apply(SPECIES.length());
4954
4955 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4956 for (int i = 0; i < a.length; i += SPECIES.length()) {
4957 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4958 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4959 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
4960 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv).intoArray(r, i);
4961 }
4962 }
4963
4964 assertArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND);
4965 }
4966
4967 @Test(dataProvider = "shortTernaryOpProvider")
4968 static void bitwiseBlendShortMaxVectorTests(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
4969 short[] a = fa.apply(SPECIES.length());
4970 short[] b = fb.apply(SPECIES.length());
4971 short[] c = fc.apply(SPECIES.length());
4972 short[] r = fr.apply(SPECIES.length());
4973
4974 for (int i = 0; i < a.length; i += SPECIES.length()) {
4975 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4976 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4977 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
4978 av.bitwiseBlend(bv, cv).intoArray(r, i);
4979 }
4980
4981 assertArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend);
4982 }
4983
4984 @Test(dataProvider = "shortTernaryOpMaskProvider")
4985 static void BITWISE_BLENDShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<short[]> fb,
4986 IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
4987 short[] a = fa.apply(SPECIES.length());
4988 short[] b = fb.apply(SPECIES.length());
4989 short[] c = fc.apply(SPECIES.length());
4990 short[] r = fr.apply(SPECIES.length());
4991 boolean[] mask = fm.apply(SPECIES.length());
4992 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
4993
4994 for (int ic = 0; ic < INVOC_COUNT; ic++) {
4995 for (int i = 0; i < a.length; i += SPECIES.length()) {
4996 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
4997 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
4998 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
4999 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
5000 }
5001 }
5002
5003 assertArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND);
5004 }
5005
5006 @Test(dataProvider = "shortTernaryOpProvider")
5007 static void BITWISE_BLENDShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5008 short[] a = fa.apply(SPECIES.length());
5009 short[] b = fb.apply(SPECIES.length());
5010 short[] c = fc.apply(SPECIES.length());
5011 short[] r = fr.apply(SPECIES.length());
5012
5013 for (int i = 0; i < a.length; i += SPECIES.length()) {
5014 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5015 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5016 av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i]).intoArray(r, i);
5017 }
5018 assertBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND);
5019 }
5020
5021 @Test(dataProvider = "shortTernaryOpProvider")
5022 static void BITWISE_BLENDShortMaxVectorTestsAltBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5023 short[] a = fa.apply(SPECIES.length());
5024 short[] b = fb.apply(SPECIES.length());
5025 short[] c = fc.apply(SPECIES.length());
5026 short[] r = fr.apply(SPECIES.length());
5027
5028 for (int i = 0; i < a.length; i += SPECIES.length()) {
5029 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5030 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5031 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv).intoArray(r, i);
5032 }
5033 assertAltBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND);
5034 }
5035
5036 @Test(dataProvider = "shortTernaryOpProvider")
5037 static void bitwiseBlendShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5038 short[] a = fa.apply(SPECIES.length());
5039 short[] b = fb.apply(SPECIES.length());
5040 short[] c = fc.apply(SPECIES.length());
5041 short[] r = fr.apply(SPECIES.length());
5042
5043 for (int i = 0; i < a.length; i += SPECIES.length()) {
5044 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5045 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5046 av.bitwiseBlend(bv, c[i]).intoArray(r, i);
5047 }
5048 assertBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend);
5049 }
5050
5051 @Test(dataProvider = "shortTernaryOpProvider")
5052 static void bitwiseBlendShortMaxVectorTestsAltBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5053 short[] a = fa.apply(SPECIES.length());
5054 short[] b = fb.apply(SPECIES.length());
5055 short[] c = fc.apply(SPECIES.length());
5056 short[] r = fr.apply(SPECIES.length());
5057
5058 for (int i = 0; i < a.length; i += SPECIES.length()) {
5059 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5060 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5061 av.bitwiseBlend(b[i], cv).intoArray(r, i);
5062 }
5063 assertAltBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend);
5064 }
5065
5066 @Test(dataProvider = "shortTernaryOpMaskProvider")
5067 static void BITWISE_BLENDShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
5068 IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
5069 short[] a = fa.apply(SPECIES.length());
5070 short[] b = fb.apply(SPECIES.length());
5071 short[] c = fc.apply(SPECIES.length());
5072 short[] r = fr.apply(SPECIES.length());
5073 boolean[] mask = fm.apply(SPECIES.length());
5074 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5075
5076 for (int i = 0; i < a.length; i += SPECIES.length()) {
5077 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5078 ShortVector bv = ShortVector.fromArray(SPECIES, b, i);
5079 av.lanewise(VectorOperators.BITWISE_BLEND, bv, c[i], vmask).intoArray(r, i);
5080 }
5081
5082 assertBroadcastArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND);
5083 }
5084
5085 @Test(dataProvider = "shortTernaryOpMaskProvider")
5086 static void BITWISE_BLENDShortMaxVectorTestsAltBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
5087 IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
5088 short[] a = fa.apply(SPECIES.length());
5089 short[] b = fb.apply(SPECIES.length());
5090 short[] c = fc.apply(SPECIES.length());
5091 short[] r = fr.apply(SPECIES.length());
5092 boolean[] mask = fm.apply(SPECIES.length());
5093 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5094
5095 for (int i = 0; i < a.length; i += SPECIES.length()) {
5096 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5097 ShortVector cv = ShortVector.fromArray(SPECIES, c, i);
5098 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], cv, vmask).intoArray(r, i);
5099 }
5100
5101 assertAltBroadcastArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND);
5102 }
5103
5104 @Test(dataProvider = "shortTernaryOpProvider")
5105 static void BITWISE_BLENDShortMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5106 short[] a = fa.apply(SPECIES.length());
5107 short[] b = fb.apply(SPECIES.length());
5108 short[] c = fc.apply(SPECIES.length());
5109 short[] r = fr.apply(SPECIES.length());
5110
5111 for (int i = 0; i < a.length; i += SPECIES.length()) {
5112 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5113 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i]).intoArray(r, i);
5114 }
5115
5116 assertDoubleBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::BITWISE_BLEND);
5117 }
5118
5119 @Test(dataProvider = "shortTernaryOpProvider")
5120 static void bitwiseBlendShortMaxVectorTestsDoubleBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb, IntFunction<short[]> fc) {
5121 short[] a = fa.apply(SPECIES.length());
5122 short[] b = fb.apply(SPECIES.length());
5123 short[] c = fc.apply(SPECIES.length());
5124 short[] r = fr.apply(SPECIES.length());
5125
5126 for (int i = 0; i < a.length; i += SPECIES.length()) {
5127 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5128 av.bitwiseBlend(b[i], c[i]).intoArray(r, i);
5129 }
5130
5131 assertDoubleBroadcastArraysEquals(r, a, b, c, ShortMaxVectorTests::bitwiseBlend);
5132 }
5133
5134 @Test(dataProvider = "shortTernaryOpMaskProvider")
5135 static void BITWISE_BLENDShortMaxVectorTestsDoubleBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
5136 IntFunction<short[]> fc, IntFunction<boolean[]> fm) {
5137 short[] a = fa.apply(SPECIES.length());
5138 short[] b = fb.apply(SPECIES.length());
5139 short[] c = fc.apply(SPECIES.length());
5140 short[] r = fr.apply(SPECIES.length());
5141 boolean[] mask = fm.apply(SPECIES.length());
5142 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5143
5144 for (int i = 0; i < a.length; i += SPECIES.length()) {
5145 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5146 av.lanewise(VectorOperators.BITWISE_BLEND, b[i], c[i], vmask).intoArray(r, i);
5147 }
5148
5149 assertDoubleBroadcastArraysEquals(r, a, b, c, mask, ShortMaxVectorTests::BITWISE_BLEND);
5150 }
5151
5152 static short NEG(short a) {
5153 return (short)(-((short)a));
5154 }
5155
5156 static short neg(short a) {
5157 return (short)(-((short)a));
5158 }
5159
5160 @Test(dataProvider = "shortUnaryOpProvider")
5161 static void NEGShortMaxVectorTests(IntFunction<short[]> fa) {
5162 short[] a = fa.apply(SPECIES.length());
5163 short[] r = fr.apply(SPECIES.length());
5164
5165 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5166 for (int i = 0; i < a.length; i += SPECIES.length()) {
5167 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5168 av.lanewise(VectorOperators.NEG).intoArray(r, i);
5169 }
5170 }
5171
5172 assertArraysEquals(r, a, ShortMaxVectorTests::NEG);
5173 }
5174
5175 @Test(dataProvider = "shortUnaryOpProvider")
5176 static void negShortMaxVectorTests(IntFunction<short[]> fa) {
5177 short[] a = fa.apply(SPECIES.length());
5178 short[] r = fr.apply(SPECIES.length());
5179
5180 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5181 for (int i = 0; i < a.length; i += SPECIES.length()) {
5182 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5183 av.neg().intoArray(r, i);
5184 }
5185 }
5186
5187 assertArraysEquals(r, a, ShortMaxVectorTests::neg);
5188 }
5189
5190 @Test(dataProvider = "shortUnaryOpMaskProvider")
5191 static void NEGMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5192 IntFunction<boolean[]> fm) {
5193 short[] a = fa.apply(SPECIES.length());
5194 short[] r = fr.apply(SPECIES.length());
5195 boolean[] mask = fm.apply(SPECIES.length());
5196 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5197
5198 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5199 for (int i = 0; i < a.length; i += SPECIES.length()) {
5200 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5201 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
5202 }
5203 }
5204
5205 assertArraysEquals(r, a, mask, ShortMaxVectorTests::NEG);
5206 }
5207
5208 static short ABS(short a) {
5209 return (short)(Math.abs((short)a));
5210 }
5211
5212 static short abs(short a) {
5213 return (short)(Math.abs((short)a));
5214 }
5215
5216 @Test(dataProvider = "shortUnaryOpProvider")
5217 static void ABSShortMaxVectorTests(IntFunction<short[]> fa) {
5218 short[] a = fa.apply(SPECIES.length());
5219 short[] r = fr.apply(SPECIES.length());
5220
5221 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5222 for (int i = 0; i < a.length; i += SPECIES.length()) {
5223 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5224 av.lanewise(VectorOperators.ABS).intoArray(r, i);
5225 }
5226 }
5227
5228 assertArraysEquals(r, a, ShortMaxVectorTests::ABS);
5229 }
5230
5231 @Test(dataProvider = "shortUnaryOpProvider")
5232 static void absShortMaxVectorTests(IntFunction<short[]> fa) {
5233 short[] a = fa.apply(SPECIES.length());
5234 short[] r = fr.apply(SPECIES.length());
5235
5236 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5237 for (int i = 0; i < a.length; i += SPECIES.length()) {
5238 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5239 av.abs().intoArray(r, i);
5240 }
5241 }
5242
5243 assertArraysEquals(r, a, ShortMaxVectorTests::abs);
5244 }
5245
5246 @Test(dataProvider = "shortUnaryOpMaskProvider")
5247 static void ABSMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5248 IntFunction<boolean[]> fm) {
5249 short[] a = fa.apply(SPECIES.length());
5250 short[] r = fr.apply(SPECIES.length());
5251 boolean[] mask = fm.apply(SPECIES.length());
5252 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5253
5254 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5255 for (int i = 0; i < a.length; i += SPECIES.length()) {
5256 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5257 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
5258 }
5259 }
5260
5261 assertArraysEquals(r, a, mask, ShortMaxVectorTests::ABS);
5262 }
5263
5264 static short NOT(short a) {
5265 return (short)(~((short)a));
5266 }
5267
5268 static short not(short a) {
5269 return (short)(~((short)a));
5270 }
5271
5272 @Test(dataProvider = "shortUnaryOpProvider")
5273 static void NOTShortMaxVectorTests(IntFunction<short[]> fa) {
5274 short[] a = fa.apply(SPECIES.length());
5275 short[] r = fr.apply(SPECIES.length());
5276
5277 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5278 for (int i = 0; i < a.length; i += SPECIES.length()) {
5279 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5280 av.lanewise(VectorOperators.NOT).intoArray(r, i);
5281 }
5282 }
5283
5284 assertArraysEquals(r, a, ShortMaxVectorTests::NOT);
5285 }
5286
5287 @Test(dataProvider = "shortUnaryOpProvider")
5288 static void notShortMaxVectorTests(IntFunction<short[]> fa) {
5289 short[] a = fa.apply(SPECIES.length());
5290 short[] r = fr.apply(SPECIES.length());
5291
5292 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5293 for (int i = 0; i < a.length; i += SPECIES.length()) {
5294 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5295 av.not().intoArray(r, i);
5296 }
5297 }
5298
5299 assertArraysEquals(r, a, ShortMaxVectorTests::not);
5300 }
5301
5302 @Test(dataProvider = "shortUnaryOpMaskProvider")
5303 static void NOTMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5304 IntFunction<boolean[]> fm) {
5305 short[] a = fa.apply(SPECIES.length());
5306 short[] r = fr.apply(SPECIES.length());
5307 boolean[] mask = fm.apply(SPECIES.length());
5308 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5309
5310 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5311 for (int i = 0; i < a.length; i += SPECIES.length()) {
5312 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5313 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
5314 }
5315 }
5316
5317 assertArraysEquals(r, a, mask, ShortMaxVectorTests::NOT);
5318 }
5319
5320 static short ZOMO(short a) {
5321 return (short)((a==0?0:-1));
5322 }
5323
5324 @Test(dataProvider = "shortUnaryOpProvider")
5325 static void ZOMOShortMaxVectorTests(IntFunction<short[]> fa) {
5326 short[] a = fa.apply(SPECIES.length());
5327 short[] r = fr.apply(SPECIES.length());
5328
5329 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5330 for (int i = 0; i < a.length; i += SPECIES.length()) {
5331 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5332 av.lanewise(VectorOperators.ZOMO).intoArray(r, i);
5333 }
5334 }
5335
5336 assertArraysEquals(r, a, ShortMaxVectorTests::ZOMO);
5337 }
5338
5339 @Test(dataProvider = "shortUnaryOpMaskProvider")
5340 static void ZOMOMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5341 IntFunction<boolean[]> fm) {
5342 short[] a = fa.apply(SPECIES.length());
5343 short[] r = fr.apply(SPECIES.length());
5344 boolean[] mask = fm.apply(SPECIES.length());
5345 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5346
5347 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5348 for (int i = 0; i < a.length; i += SPECIES.length()) {
5349 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5350 av.lanewise(VectorOperators.ZOMO, vmask).intoArray(r, i);
5351 }
5352 }
5353
5354 assertArraysEquals(r, a, mask, ShortMaxVectorTests::ZOMO);
5355 }
5356
5357 static short BIT_COUNT(short a) {
5358 return (short)(Integer.bitCount((int)a & 0xFFFF));
5359 }
5360
5361 @Test(dataProvider = "shortUnaryOpProvider")
5362 static void BIT_COUNTShortMaxVectorTests(IntFunction<short[]> fa) {
5363 short[] a = fa.apply(SPECIES.length());
5364 short[] r = fr.apply(SPECIES.length());
5365
5366 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5367 for (int i = 0; i < a.length; i += SPECIES.length()) {
5368 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5369 av.lanewise(VectorOperators.BIT_COUNT).intoArray(r, i);
5370 }
5371 }
5372
5373 assertArraysEquals(r, a, ShortMaxVectorTests::BIT_COUNT);
5374 }
5375
5376 @Test(dataProvider = "shortUnaryOpMaskProvider")
5377 static void BIT_COUNTMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5378 IntFunction<boolean[]> fm) {
5379 short[] a = fa.apply(SPECIES.length());
5380 short[] r = fr.apply(SPECIES.length());
5381 boolean[] mask = fm.apply(SPECIES.length());
5382 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5383
5384 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5385 for (int i = 0; i < a.length; i += SPECIES.length()) {
5386 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5387 av.lanewise(VectorOperators.BIT_COUNT, vmask).intoArray(r, i);
5388 }
5389 }
5390
5391 assertArraysEquals(r, a, mask, ShortMaxVectorTests::BIT_COUNT);
5392 }
5393
5394 static short TRAILING_ZEROS_COUNT(short a) {
5395 return (short)(TRAILING_ZEROS_COUNT_scalar(a));
5396 }
5397
5398 @Test(dataProvider = "shortUnaryOpProvider")
5399 static void TRAILING_ZEROS_COUNTShortMaxVectorTests(IntFunction<short[]> fa) {
5400 short[] a = fa.apply(SPECIES.length());
5401 short[] r = fr.apply(SPECIES.length());
5402
5403 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5404 for (int i = 0; i < a.length; i += SPECIES.length()) {
5405 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5406 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT).intoArray(r, i);
5407 }
5408 }
5409
5410 assertArraysEquals(r, a, ShortMaxVectorTests::TRAILING_ZEROS_COUNT);
5411 }
5412
5413 @Test(dataProvider = "shortUnaryOpMaskProvider")
5414 static void TRAILING_ZEROS_COUNTMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5415 IntFunction<boolean[]> fm) {
5416 short[] a = fa.apply(SPECIES.length());
5417 short[] r = fr.apply(SPECIES.length());
5418 boolean[] mask = fm.apply(SPECIES.length());
5419 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5420
5421 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5422 for (int i = 0; i < a.length; i += SPECIES.length()) {
5423 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5424 av.lanewise(VectorOperators.TRAILING_ZEROS_COUNT, vmask).intoArray(r, i);
5425 }
5426 }
5427
5428 assertArraysEquals(r, a, mask, ShortMaxVectorTests::TRAILING_ZEROS_COUNT);
5429 }
5430
5431 static short LEADING_ZEROS_COUNT(short a) {
5432 return (short)(LEADING_ZEROS_COUNT_scalar(a));
5433 }
5434
5435 @Test(dataProvider = "shortUnaryOpProvider")
5436 static void LEADING_ZEROS_COUNTShortMaxVectorTests(IntFunction<short[]> fa) {
5437 short[] a = fa.apply(SPECIES.length());
5438 short[] r = fr.apply(SPECIES.length());
5439
5440 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5441 for (int i = 0; i < a.length; i += SPECIES.length()) {
5442 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5443 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT).intoArray(r, i);
5444 }
5445 }
5446
5447 assertArraysEquals(r, a, ShortMaxVectorTests::LEADING_ZEROS_COUNT);
5448 }
5449
5450 @Test(dataProvider = "shortUnaryOpMaskProvider")
5451 static void LEADING_ZEROS_COUNTMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5452 IntFunction<boolean[]> fm) {
5453 short[] a = fa.apply(SPECIES.length());
5454 short[] r = fr.apply(SPECIES.length());
5455 boolean[] mask = fm.apply(SPECIES.length());
5456 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5457
5458 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5459 for (int i = 0; i < a.length; i += SPECIES.length()) {
5460 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5461 av.lanewise(VectorOperators.LEADING_ZEROS_COUNT, vmask).intoArray(r, i);
5462 }
5463 }
5464
5465 assertArraysEquals(r, a, mask, ShortMaxVectorTests::LEADING_ZEROS_COUNT);
5466 }
5467
5468 static short REVERSE(short a) {
5469 return (short)(REVERSE_scalar(a));
5470 }
5471
5472 @Test(dataProvider = "shortUnaryOpProvider")
5473 static void REVERSEShortMaxVectorTests(IntFunction<short[]> fa) {
5474 short[] a = fa.apply(SPECIES.length());
5475 short[] r = fr.apply(SPECIES.length());
5476
5477 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5478 for (int i = 0; i < a.length; i += SPECIES.length()) {
5479 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5480 av.lanewise(VectorOperators.REVERSE).intoArray(r, i);
5481 }
5482 }
5483
5484 assertArraysEquals(r, a, ShortMaxVectorTests::REVERSE);
5485 }
5486
5487 @Test(dataProvider = "shortUnaryOpMaskProvider")
5488 static void REVERSEMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5489 IntFunction<boolean[]> fm) {
5490 short[] a = fa.apply(SPECIES.length());
5491 short[] r = fr.apply(SPECIES.length());
5492 boolean[] mask = fm.apply(SPECIES.length());
5493 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5494
5495 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5496 for (int i = 0; i < a.length; i += SPECIES.length()) {
5497 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5498 av.lanewise(VectorOperators.REVERSE, vmask).intoArray(r, i);
5499 }
5500 }
5501
5502 assertArraysEquals(r, a, mask, ShortMaxVectorTests::REVERSE);
5503 }
5504
5505 static short REVERSE_BYTES(short a) {
5506 return (short)(Short.reverseBytes(a));
5507 }
5508
5509 @Test(dataProvider = "shortUnaryOpProvider")
5510 static void REVERSE_BYTESShortMaxVectorTests(IntFunction<short[]> fa) {
5511 short[] a = fa.apply(SPECIES.length());
5512 short[] r = fr.apply(SPECIES.length());
5513
5514 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5515 for (int i = 0; i < a.length; i += SPECIES.length()) {
5516 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5517 av.lanewise(VectorOperators.REVERSE_BYTES).intoArray(r, i);
5518 }
5519 }
5520
5521 assertArraysEquals(r, a, ShortMaxVectorTests::REVERSE_BYTES);
5522 }
5523
5524 @Test(dataProvider = "shortUnaryOpMaskProvider")
5525 static void REVERSE_BYTESMaskedShortMaxVectorTests(IntFunction<short[]> fa,
5526 IntFunction<boolean[]> fm) {
5527 short[] a = fa.apply(SPECIES.length());
5528 short[] r = fr.apply(SPECIES.length());
5529 boolean[] mask = fm.apply(SPECIES.length());
5530 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5531
5532 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5533 for (int i = 0; i < a.length; i += SPECIES.length()) {
5534 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5535 av.lanewise(VectorOperators.REVERSE_BYTES, vmask).intoArray(r, i);
5536 }
5537 }
5538
5539 assertArraysEquals(r, a, mask, ShortMaxVectorTests::REVERSE_BYTES);
5540 }
5541
5542 @Test(dataProvider = "shortCompareOpProvider")
5543 static void ltShortMaxVectorTestsBroadcastSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5544 short[] a = fa.apply(SPECIES.length());
5545 short[] b = fb.apply(SPECIES.length());
5546
5547 for (int i = 0; i < a.length; i += SPECIES.length()) {
5548 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5549 VectorMask<Short> mv = av.lt(b[i]);
5550
5551 // Check results as part of computation.
5552 for (int j = 0; j < SPECIES.length(); j++) {
5553 Assert.assertEquals(mv.laneIsSet(j), a[i + j] < b[i]);
5554 }
5555 }
5556 }
5557
5558 @Test(dataProvider = "shortCompareOpProvider")
5559 static void eqShortMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb) {
5560 short[] a = fa.apply(SPECIES.length());
5561 short[] b = fb.apply(SPECIES.length());
5562
5563 for (int i = 0; i < a.length; i += SPECIES.length()) {
5564 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5565 VectorMask<Short> mv = av.eq(b[i]);
5566
5567 // Check results as part of computation.
5568 for (int j = 0; j < SPECIES.length(); j++) {
5569 Assert.assertEquals(mv.laneIsSet(j), a[i + j] == b[i]);
5570 }
5571 }
5572 }
5573
5574 @Test(dataProvider = "shortUnaryOpProvider")
5575 static void toIntArrayShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5576 short[] a = fa.apply(SPECIES.length());
5577
5578 for (int i = 0; i < a.length; i += SPECIES.length()) {
5579 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5580 int[] r = av.toIntArray();
5581 assertArraysEquals(r, a, i);
5582 }
5583 }
5584
5585 @Test(dataProvider = "shortUnaryOpProvider")
5586 static void toLongArrayShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5587 short[] a = fa.apply(SPECIES.length());
5588
5589 for (int i = 0; i < a.length; i += SPECIES.length()) {
5590 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5591 long[] r = av.toLongArray();
5592 assertArraysEquals(r, a, i);
5593 }
5594 }
5595
5596 @Test(dataProvider = "shortUnaryOpProvider")
5597 static void toDoubleArrayShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5598 short[] a = fa.apply(SPECIES.length());
5599
5600 for (int i = 0; i < a.length; i += SPECIES.length()) {
5601 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5602 double[] r = av.toDoubleArray();
5603 assertArraysEquals(r, a, i);
5604 }
5605 }
5606
5607 @Test(dataProvider = "shortUnaryOpProvider")
5608 static void toStringShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5609 short[] a = fa.apply(SPECIES.length());
5610
5611 for (int i = 0; i < a.length; i += SPECIES.length()) {
5612 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5613 String str = av.toString();
5614
5615 short subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5616 Assert.assertTrue(str.equals(Arrays.toString(subarr)), "at index " + i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5617 }
5618 }
5619
5620 @Test(dataProvider = "shortUnaryOpProvider")
5621 static void hashCodeShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5622 short[] a = fa.apply(SPECIES.length());
5623
5624 for (int i = 0; i < a.length; i += SPECIES.length()) {
5625 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5626 int hash = av.hashCode();
5627
5628 short subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5629 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5630 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5631 }
5632 }
5633
5634
5635 static long ADDReduceLong(short[] a, int idx) {
5636 short res = 0;
5637 for (int i = idx; i < (idx + SPECIES.length()); i++) {
5638 res += a[i];
5639 }
5640
5641 return (long)res;
5642 }
5643
5644 static long ADDReduceAllLong(short[] a) {
5645 long res = 0;
5646 for (int i = 0; i < a.length; i += SPECIES.length()) {
5647 res += ADDReduceLong(a, i);
5648 }
5649
5650 return res;
5651 }
5652
5653 @Test(dataProvider = "shortUnaryOpProvider")
5654 static void ADDReduceLongShortMaxVectorTests(IntFunction<short[]> fa) {
5655 short[] a = fa.apply(SPECIES.length());
5656 long[] r = lfr.apply(SPECIES.length());
5657 long ra = 0;
5658
5659 for (int i = 0; i < a.length; i += SPECIES.length()) {
5660 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5661 r[i] = av.reduceLanesToLong(VectorOperators.ADD);
5662 }
5663
5664 ra = 0;
5665 for (int i = 0; i < a.length; i ++) {
5666 ra += r[i];
5667 }
5668
5669 assertReductionLongArraysEquals(r, ra, a,
5670 ShortMaxVectorTests::ADDReduceLong, ShortMaxVectorTests::ADDReduceAllLong);
5671 }
5672
5673 static long ADDReduceLongMasked(short[] a, int idx, boolean[] mask) {
5674 short res = 0;
5675 for (int i = idx; i < (idx + SPECIES.length()); i++) {
5676 if(mask[i % SPECIES.length()])
5677 res += a[i];
5678 }
5679
5680 return (long)res;
5681 }
5682
5683 static long ADDReduceAllLongMasked(short[] a, boolean[] mask) {
5684 long res = 0;
5685 for (int i = 0; i < a.length; i += SPECIES.length()) {
5686 res += ADDReduceLongMasked(a, i, mask);
5687 }
5688
5689 return res;
5690 }
5691
5692 @Test(dataProvider = "shortUnaryOpMaskProvider")
5693 static void ADDReduceLongShortMaxVectorTestsMasked(IntFunction<short[]> fa, IntFunction<boolean[]> fm) {
5694 short[] a = fa.apply(SPECIES.length());
5695 long[] r = lfr.apply(SPECIES.length());
5696 boolean[] mask = fm.apply(SPECIES.length());
5697 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5698 long ra = 0;
5699
5700 for (int i = 0; i < a.length; i += SPECIES.length()) {
5701 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5702 r[i] = av.reduceLanesToLong(VectorOperators.ADD, vmask);
5703 }
5704
5705 ra = 0;
5706 for (int i = 0; i < a.length; i ++) {
5707 ra += r[i];
5708 }
5709
5710 assertReductionLongArraysEqualsMasked(r, ra, a, mask,
5711 ShortMaxVectorTests::ADDReduceLongMasked, ShortMaxVectorTests::ADDReduceAllLongMasked);
5712 }
5713
5714 @Test(dataProvider = "shortUnaryOpProvider")
5715 static void BroadcastLongShortMaxVectorTestsSmokeTest(IntFunction<short[]> fa) {
5716 short[] a = fa.apply(SPECIES.length());
5717 short[] r = new short[a.length];
5718
5719 for (int i = 0; i < a.length; i += SPECIES.length()) {
5720 ShortVector.broadcast(SPECIES, (long)a[i]).intoArray(r, i);
5721 }
5722 assertBroadcastArraysEquals(r, a);
5723 }
5724
5725 @Test(dataProvider = "shortBinaryOpMaskProvider")
5726 static void blendShortMaxVectorTestsBroadcastLongSmokeTest(IntFunction<short[]> fa, IntFunction<short[]> fb,
5727 IntFunction<boolean[]> fm) {
5728 short[] a = fa.apply(SPECIES.length());
5729 short[] b = fb.apply(SPECIES.length());
5730 short[] r = fr.apply(SPECIES.length());
5731 boolean[] mask = fm.apply(SPECIES.length());
5732 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5733
5734 for (int ic = 0; ic < INVOC_COUNT; ic++) {
5735 for (int i = 0; i < a.length; i += SPECIES.length()) {
5736 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5737 av.blend((long)b[i], vmask).intoArray(r, i);
5738 }
5739 }
5740 assertBroadcastLongArraysEquals(r, a, b, mask, ShortMaxVectorTests::blend);
5741 }
5742
5743
5744 @Test(dataProvider = "shortUnaryOpSelectFromProvider")
5745 static void SelectFromShortMaxVectorTests(IntFunction<short[]> fa,
5746 BiFunction<Integer,Integer,short[]> fs) {
5747 short[] a = fa.apply(SPECIES.length());
5748 short[] order = fs.apply(a.length, SPECIES.length());
5749 short[] r = fr.apply(SPECIES.length());
5750
5751 for (int i = 0; i < a.length; i += SPECIES.length()) {
5752 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5753 ShortVector bv = ShortVector.fromArray(SPECIES, order, i);
5754 bv.selectFrom(av).intoArray(r, i);
5755 }
5756
5757 assertSelectFromArraysEquals(r, a, order, SPECIES.length());
5758 }
5759
5760 @Test(dataProvider = "shortUnaryOpSelectFromMaskProvider")
5761 static void SelectFromShortMaxVectorTestsMaskedSmokeTest(IntFunction<short[]> fa,
5762 BiFunction<Integer,Integer,short[]> fs,
5763 IntFunction<boolean[]> fm) {
5764 short[] a = fa.apply(SPECIES.length());
5765 short[] order = fs.apply(a.length, SPECIES.length());
5766 short[] r = fr.apply(SPECIES.length());
5767 boolean[] mask = fm.apply(SPECIES.length());
5768 VectorMask<Short> vmask = VectorMask.fromArray(SPECIES, mask, 0);
5769
5770 for (int i = 0; i < a.length; i += SPECIES.length()) {
5771 ShortVector av = ShortVector.fromArray(SPECIES, a, i);
5772 ShortVector bv = ShortVector.fromArray(SPECIES, order, i);
5773 bv.selectFrom(av, vmask).intoArray(r, i);
5774 }
5775
5776 assertSelectFromArraysEquals(r, a, order, mask, SPECIES.length());
5777 }
5778
5779 @Test(dataProvider = "shuffleProvider")
5780 static void shuffleMiscellaneousShortMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5781 int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5782
5783 for (int i = 0; i < a.length; i += SPECIES.length()) {
5784 var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5785 int hash = shuffle.hashCode();
5786 int length = shuffle.length();
5787
5788 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5789 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5790 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5791 Assert.assertEquals(length, SPECIES.length());
5792 }
5793 }
5794
5795 @Test(dataProvider = "shuffleProvider")
5796 static void shuffleToStringShortMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fs) {
5797 int[] a = fs.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5798
5799 for (int i = 0; i < a.length; i += SPECIES.length()) {
5800 var shuffle = VectorShuffle.fromArray(SPECIES, a, i);
5801 String str = shuffle.toString();
5802
5803 int subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5804 Assert.assertTrue(str.equals("Shuffle" + Arrays.toString(subarr)), "at index " +
5805 i + ", string should be = " + Arrays.toString(subarr) + ", but is = " + str);
5806 }
5807 }
5808
5809 @Test(dataProvider = "shuffleCompareOpProvider")
5810 static void shuffleEqualsShortMaxVectorTestsSmokeTest(BiFunction<Integer,Integer,int[]> fa, BiFunction<Integer,Integer,int[]> fb) {
5811 int[] a = fa.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5812 int[] b = fb.apply(SPECIES.length() * BUFFER_REPS, SPECIES.length());
5813
5814 for (int i = 0; i < a.length; i += SPECIES.length()) {
5815 var av = VectorShuffle.fromArray(SPECIES, a, i);
5816 var bv = VectorShuffle.fromArray(SPECIES, b, i);
5817 boolean eq = av.equals(bv);
5818 int to = i + SPECIES.length();
5819 Assert.assertEquals(eq, Arrays.equals(a, i, to, b, i, to));
5820 }
5821 }
5822
5823 @Test(dataProvider = "maskCompareOpProvider")
5824 static void maskEqualsShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5825 boolean[] a = fa.apply(SPECIES.length());
5826 boolean[] b = fb.apply(SPECIES.length());
5827
5828 for (int i = 0; i < a.length; i += SPECIES.length()) {
5829 var av = SPECIES.loadMask(a, i);
5830 var bv = SPECIES.loadMask(b, i);
5831 boolean equals = av.equals(bv);
5832 int to = i + SPECIES.length();
5833 Assert.assertEquals(equals, Arrays.equals(a, i, to, b, i, to));
5834 }
5835 }
5836
5837 static boolean beq(boolean a, boolean b) {
5838 return (a == b);
5839 }
5840
5841 @Test(dataProvider = "maskCompareOpProvider")
5842 static void maskEqShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa, IntFunction<boolean[]> fb) {
5843 boolean[] a = fa.apply(SPECIES.length());
5844 boolean[] b = fb.apply(SPECIES.length());
5845 boolean[] r = new boolean[a.length];
5846
5847 for (int i = 0; i < a.length; i += SPECIES.length()) {
5848 var av = SPECIES.loadMask(a, i);
5849 var bv = SPECIES.loadMask(b, i);
5850 var cv = av.eq(bv);
5851 cv.intoArray(r, i);
5852 }
5853 assertArraysEquals(r, a, b, ShortMaxVectorTests::beq);
5854 }
5855
5856 @Test(dataProvider = "maskProvider")
5857 static void maskHashCodeShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5858 boolean[] a = fa.apply(SPECIES.length());
5859
5860 for (int i = 0; i < a.length; i += SPECIES.length()) {
5861 var vmask = SPECIES.loadMask(a, i);
5862 int hash = vmask.hashCode();
5863
5864 boolean subarr[] = Arrays.copyOfRange(a, i, i + SPECIES.length());
5865 int expectedHash = Objects.hash(SPECIES, Arrays.hashCode(subarr));
5866 Assert.assertTrue(hash == expectedHash, "at index " + i + ", hash should be = " + expectedHash + ", but is = " + hash);
5867 }
5868 }
5869
5870 static int maskTrueCount(boolean[] a, int idx) {
5871 int trueCount = 0;
5872 for (int i = idx; i < idx + SPECIES.length(); i++) {
5873 trueCount += a[i] ? 1 : 0;
5874 }
5875 return trueCount;
5876 }
5877
5878 @Test(dataProvider = "maskProvider")
5879 static void maskTrueCountShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5880 boolean[] a = fa.apply(SPECIES.length());
5881 int[] r = new int[a.length];
5882
5883 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5884 for (int i = 0; i < a.length; i += SPECIES.length()) {
5885 var vmask = SPECIES.loadMask(a, i);
5886 r[i] = vmask.trueCount();
5887 }
5888 }
5889
5890 assertMaskReductionArraysEquals(r, a, ShortMaxVectorTests::maskTrueCount);
5891 }
5892
5893 static int maskLastTrue(boolean[] a, int idx) {
5894 int i = idx + SPECIES.length() - 1;
5895 for (; i >= idx; i--) {
5896 if (a[i]) {
5897 break;
5898 }
5899 }
5900 return i - idx;
5901 }
5902
5903 @Test(dataProvider = "maskProvider")
5904 static void maskLastTrueShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5905 boolean[] a = fa.apply(SPECIES.length());
5906 int[] r = new int[a.length];
5907
5908 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5909 for (int i = 0; i < a.length; i += SPECIES.length()) {
5910 var vmask = SPECIES.loadMask(a, i);
5911 r[i] = vmask.lastTrue();
5912 }
5913 }
5914
5915 assertMaskReductionArraysEquals(r, a, ShortMaxVectorTests::maskLastTrue);
5916 }
5917
5918 static int maskFirstTrue(boolean[] a, int idx) {
5919 int i = idx;
5920 for (; i < idx + SPECIES.length(); i++) {
5921 if (a[i]) {
5922 break;
5923 }
5924 }
5925 return i - idx;
5926 }
5927
5928 @Test(dataProvider = "maskProvider")
5929 static void maskFirstTrueShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5930 boolean[] a = fa.apply(SPECIES.length());
5931 int[] r = new int[a.length];
5932
5933 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5934 for (int i = 0; i < a.length; i += SPECIES.length()) {
5935 var vmask = SPECIES.loadMask(a, i);
5936 r[i] = vmask.firstTrue();
5937 }
5938 }
5939
5940 assertMaskReductionArraysEquals(r, a, ShortMaxVectorTests::maskFirstTrue);
5941 }
5942
5943 @Test(dataProvider = "maskProvider")
5944 static void maskCompressShortMaxVectorTestsSmokeTest(IntFunction<boolean[]> fa) {
5945 int trueCount = 0;
5946 boolean[] a = fa.apply(SPECIES.length());
5947
5948 for (int ic = 0; ic < INVOC_COUNT * INVOC_COUNT; ic++) {
5949 for (int i = 0; i < a.length; i += SPECIES.length()) {
5950 var vmask = SPECIES.loadMask(a, i);
5951 trueCount = vmask.trueCount();
5952 var rmask = vmask.compress();
5953 for (int j = 0; j < SPECIES.length(); j++) {
5954 Assert.assertEquals(rmask.laneIsSet(j), j < trueCount);
5955 }
5956 }
5957 }
5958 }
5959
5960
5961 @DataProvider
5962 public static Object[][] offsetProvider() {
5963 return new Object[][]{
5964 {0},
5965 {-1},
5966 {+1},
5967 {+2},
5968 {-2},
5969 };
5970 }
5971
5972 @Test(dataProvider = "offsetProvider")
5973 static void indexInRangeShortMaxVectorTestsSmokeTest(int offset) {
5974 int limit = SPECIES.length() * BUFFER_REPS;
5975 for (int i = 0; i < limit; i += SPECIES.length()) {
5976 var actualMask = SPECIES.indexInRange(i + offset, limit);
5977 var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5978 assert(actualMask.equals(expectedMask));
5979 for (int j = 0; j < SPECIES.length(); j++) {
5980 int index = i + j + offset;
5981 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
5982 }
5983 }
5984 }
5985
5986 @Test(dataProvider = "offsetProvider")
5987 static void indexInRangeLongShortMaxVectorTestsSmokeTest(int offset) {
5988 long limit = SPECIES.length() * BUFFER_REPS;
5989 for (long i = 0; i < limit; i += SPECIES.length()) {
5990 var actualMask = SPECIES.indexInRange(i + offset, limit);
5991 var expectedMask = SPECIES.maskAll(true).indexInRange(i + offset, limit);
5992 assert(actualMask.equals(expectedMask));
5993 for (int j = 0; j < SPECIES.length(); j++) {
5994 long index = i + j + offset;
5995 Assert.assertEquals(actualMask.laneIsSet(j), index >= 0 && index < limit);
5996 }
5997 }
5998 }
5999
6000 @DataProvider
6001 public static Object[][] lengthProvider() {
6002 return new Object[][]{
6003 {0},
6004 {1},
6005 {32},
6006 {37},
6007 {1024},
6008 {1024+1},
6009 {1024+5},
6010 };
6011 }
6012
6013 @Test(dataProvider = "lengthProvider")
6014 static void loopBoundShortMaxVectorTestsSmokeTest(int length) {
6015 int actualLoopBound = SPECIES.loopBound(length);
6016 int expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
6017 Assert.assertEquals(actualLoopBound, expectedLoopBound);
6018 }
6019
6020 @Test(dataProvider = "lengthProvider")
6021 static void loopBoundLongShortMaxVectorTestsSmokeTest(int _length) {
6022 long length = _length;
6023 long actualLoopBound = SPECIES.loopBound(length);
6024 long expectedLoopBound = length - Math.floorMod(length, SPECIES.length());
6025 Assert.assertEquals(actualLoopBound, expectedLoopBound);
6026 }
6027
6028 @Test
6029 static void ElementSizeShortMaxVectorTestsSmokeTest() {
6030 ShortVector av = ShortVector.zero(SPECIES);
6031 int elsize = av.elementSize();
6032 Assert.assertEquals(elsize, Short.SIZE);
6033 }
6034
6035 @Test
6036 static void VectorShapeShortMaxVectorTestsSmokeTest() {
6037 ShortVector av = ShortVector.zero(SPECIES);
6038 VectorShape vsh = av.shape();
6039 assert(vsh.equals(VectorShape.S_Max_BIT));
6040 }
6041
6042 @Test
6043 static void ShapeWithLanesShortMaxVectorTestsSmokeTest() {
6044 ShortVector av = ShortVector.zero(SPECIES);
6045 VectorShape vsh = av.shape();
6046 VectorSpecies species = vsh.withLanes(short.class);
6047 assert(species.equals(SPECIES));
6048 }
6049
6050 @Test
6051 static void ElementTypeShortMaxVectorTestsSmokeTest() {
6052 ShortVector av = ShortVector.zero(SPECIES);
6053 assert(av.species().elementType() == short.class);
6054 }
6055
6056 @Test
6057 static void SpeciesElementSizeShortMaxVectorTestsSmokeTest() {
6058 ShortVector av = ShortVector.zero(SPECIES);
6059 assert(av.species().elementSize() == Short.SIZE);
6060 }
6061
6062 @Test
6063 static void VectorTypeShortMaxVectorTestsSmokeTest() {
6064 ShortVector av = ShortVector.zero(SPECIES);
6065 assert(av.species().vectorType() == av.getClass());
6066 }
6067
6068 @Test
6069 static void WithLanesShortMaxVectorTestsSmokeTest() {
6070 ShortVector av = ShortVector.zero(SPECIES);
6071 VectorSpecies species = av.species().withLanes(short.class);
6072 assert(species.equals(SPECIES));
6073 }
6074
6075 @Test
6076 static void WithShapeShortMaxVectorTestsSmokeTest() {
6077 ShortVector av = ShortVector.zero(SPECIES);
6078 VectorShape vsh = av.shape();
6079 VectorSpecies species = av.species().withShape(vsh);
6080 assert(species.equals(SPECIES));
6081 }
6082
6083 @Test
6084 static void MaskAllTrueShortMaxVectorTestsSmokeTest() {
6085 for (int ic = 0; ic < INVOC_COUNT; ic++) {
6086 Assert.assertEquals(SPECIES.maskAll(true).toLong(), -1L >>> (64 - SPECIES.length()));
6087 }
6088 }
6089 }
--- EOF ---