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