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 $vectorteststype$
28 */
29
30 #warn This file is preprocessed before being compiled
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 #if[Byte]
40 import jdk.incubator.vector.ByteVector;
41 #end[Byte]
42 #if[Float]
43 import jdk.incubator.vector.FloatVector;
44 #end[Float]
45 #if[Int]
46 import jdk.incubator.vector.IntVector;
47 #end[Int]
48 #if[Double]
49 import jdk.incubator.vector.DoubleVector;
50 #end[Double]
51 #if[Short]
52 import jdk.incubator.vector.ShortVector;
53 #end[Short]
54 #if[Long]
55 import jdk.incubator.vector.LongVector;
56 #end[Long]
57
58 import org.testng.Assert;
59 import org.testng.annotations.DataProvider;
60 import org.testng.annotations.Test;
61
62 import java.lang.Integer;
63 import java.util.List;
64 import java.util.Arrays;
65 import java.util.function.BiFunction;
66 import java.util.function.IntFunction;
67 import java.util.Objects;
68 import java.util.stream.Collectors;
69 import java.util.stream.Stream;
70
71 @Test
72 public class $vectorteststype$ extends AbstractVectorTest {
73
74 #if[MaxBit]
75 static final VectorSpecies<$Wideboxtype$> SPECIES =
76 $Type$Vector.SPECIES_MAX;
77 #else[MaxBit]
78 static final VectorSpecies<$Wideboxtype$> SPECIES =
79 $Type$Vector.SPECIES_$bits$;
80 #end[MaxBit]
81
82 static final int INVOC_COUNT = Integer.getInteger("jdk.incubator.vector.test.loop-iterations", 100);
83
84 #if[MaxBit]
85 static VectorShape getMaxBit() {
86 return VectorShape.S_Max_BIT;
87 }
88
89 private static final int Max = 256; // juts so we can do N/$bits$
90 #end[MaxBit]
91
92 private static final $type$ CONST_SHIFT = $Boxtype$.SIZE / 2;
93
94 static final int BUFFER_REPS = Integer.getInteger("jdk.incubator.vector.test.buffer-vectors", 25000 / $bits$);
95
96 interface FUnOp {
97 $type$ apply($type$ a);
98 }
99
100 static void assertArraysEquals($type$[] r, $type$[] a, FUnOp f) {
101 int i = 0;
102 try {
103 for (; i < a.length; i++) {
104 Assert.assertEquals(r[i], f.apply(a[i]));
105 }
106 } catch (AssertionError e) {
107 Assert.assertEquals(r[i], f.apply(a[i]), "at index #" + i + ", input = " + a[i]);
108 }
109 }
110
111 interface FUnArrayOp {
112 $type$[] apply($type$ a);
113 }
114
115 static void assertArraysEquals($type$[] r, $type$[] a, FUnArrayOp f) {
116 int i = 0;
117 try {
118 for (; i < a.length; i += SPECIES.length()) {
119 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
120 f.apply(a[i]));
121 }
122 } catch (AssertionError e) {
123 $type$[] ref = f.apply(a[i]);
124 $type$[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
125 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
126 + ", res: " + Arrays.toString(res)
127 + "), at index #" + i);
128 }
129 }
130
131 static void assertArraysEquals($type$[] r, $type$[] a, boolean[] mask, FUnOp f) {
132 int i = 0;
133 try {
134 for (; i < a.length; i++) {
135 Assert.assertEquals(r[i], mask[i % SPECIES.length()] ? f.apply(a[i]) : a[i]);
136 }
137 } catch (AssertionError e) {
138 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()]);
139 }
140 }
141
142 interface FReductionOp {
143 $type$ apply($type$[] a, int idx);
144 }
145
146 interface FReductionAllOp {
147 $type$ apply($type$[] a);
148 }
149
150 static void assertReductionArraysEquals($type$[] r, $type$ rc, $type$[] a,
151 FReductionOp f, FReductionAllOp fa) {
152 int i = 0;
153 try {
154 Assert.assertEquals(rc, fa.apply(a));
155 for (; i < a.length; i += SPECIES.length()) {
156 Assert.assertEquals(r[i], f.apply(a, i));
157 }
158 } catch (AssertionError e) {
159 Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
160 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
161 }
162 }
163
164 interface FReductionMaskedOp {
165 $type$ apply($type$[] a, int idx, boolean[] mask);
166 }
167
168 interface FReductionAllMaskedOp {
169 $type$ apply($type$[] a, boolean[] mask);
170 }
171
172 static void assertReductionArraysEqualsMasked($type$[] r, $type$ rc, $type$[] a, boolean[] mask,
173 FReductionMaskedOp f, FReductionAllMaskedOp fa) {
174 int i = 0;
175 try {
176 Assert.assertEquals(rc, fa.apply(a, mask));
177 for (; i < a.length; i += SPECIES.length()) {
178 Assert.assertEquals(r[i], f.apply(a, i, mask));
179 }
180 } catch (AssertionError e) {
181 Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
182 Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
183 }
184 }
185
186 #if[!Long]
187 interface FReductionOpLong {
188 long apply($type$[] a, int idx);
189 }
190
191 interface FReductionAllOpLong {
192 long apply($type$[] a);
193 }
194
195 static void assertReductionLongArraysEquals(long[] r, long rc, $type$[] a,
196 FReductionOpLong f, FReductionAllOpLong fa) {
197 int i = 0;
198 try {
199 Assert.assertEquals(rc, fa.apply(a));
200 for (; i < a.length; i += SPECIES.length()) {
201 Assert.assertEquals(r[i], f.apply(a, i));
202 }
203 } catch (AssertionError e) {
204 Assert.assertEquals(rc, fa.apply(a), "Final result is incorrect!");
205 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
206 }
207 }
208
209 interface FReductionMaskedOpLong {
210 long apply($type$[] a, int idx, boolean[] mask);
211 }
212
213 interface FReductionAllMaskedOpLong {
214 long apply($type$[] a, boolean[] mask);
215 }
216
217 static void assertReductionLongArraysEqualsMasked(long[] r, long rc, $type$[] a, boolean[] mask,
218 FReductionMaskedOpLong f, FReductionAllMaskedOpLong fa) {
219 int i = 0;
220 try {
221 Assert.assertEquals(rc, fa.apply(a, mask));
222 for (; i < a.length; i += SPECIES.length()) {
223 Assert.assertEquals(r[i], f.apply(a, i, mask));
224 }
225 } catch (AssertionError e) {
226 Assert.assertEquals(rc, fa.apply(a, mask), "Final result is incorrect!");
227 Assert.assertEquals(r[i], f.apply(a, i, mask), "at index #" + i);
228 }
229 }
230 #end[!Long]
231
232 interface FBoolReductionOp {
233 boolean apply(boolean[] a, int idx);
234 }
235
236 static void assertReductionBoolArraysEquals(boolean[] r, boolean[] a, FBoolReductionOp f) {
237 int i = 0;
238 try {
239 for (; i < a.length; i += SPECIES.length()) {
240 Assert.assertEquals(r[i], f.apply(a, i));
241 }
242 } catch (AssertionError e) {
243 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
244 }
245 }
246
247 interface FMaskReductionOp {
248 int apply(boolean[] a, int idx);
249 }
250
251 static void assertMaskReductionArraysEquals(int[] r, boolean[] a, FMaskReductionOp f) {
252 int i = 0;
253 try {
254 for (; i < a.length; i += SPECIES.length()) {
255 Assert.assertEquals(r[i], f.apply(a, i));
256 }
257 } catch (AssertionError e) {
258 Assert.assertEquals(r[i], f.apply(a, i), "at index #" + i);
259 }
260 }
261
262 static void assertInsertArraysEquals($type$[] r, $type$[] a, $type$ element, int index, int start, int end) {
263 int i = start;
264 try {
265 for (; i < end; i += 1) {
266 if(i%SPECIES.length() == index) {
267 Assert.assertEquals(r[i], element);
268 } else {
269 Assert.assertEquals(r[i], a[i]);
270 }
271 }
272 } catch (AssertionError e) {
273 if (i%SPECIES.length() == index) {
274 Assert.assertEquals(r[i], element, "at index #" + i);
275 } else {
276 Assert.assertEquals(r[i], a[i], "at index #" + i);
277 }
278 }
279 }
280
281 static void assertRearrangeArraysEquals($type$[] r, $type$[] a, int[] order, int vector_len) {
282 int i = 0, j = 0;
283 try {
284 for (; i < a.length; i += vector_len) {
285 for (j = 0; j < vector_len; j++) {
286 Assert.assertEquals(r[i+j], a[i+order[i+j]]);
287 }
288 }
289 } catch (AssertionError e) {
290 int idx = i + j;
291 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]]);
292 }
293 }
294
295 static void assertSelectFromArraysEquals($type$[] r, $type$[] a, $type$[] order, int vector_len) {
296 int i = 0, j = 0;
297 try {
298 for (; i < a.length; i += vector_len) {
299 for (j = 0; j < vector_len; j++) {
300 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
301 }
302 }
303 } catch (AssertionError e) {
304 int idx = i + j;
305 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]], "at index #" + idx + ", input = " + a[i+(int)order[i+j]]);
306 }
307 }
308
309 static void assertRearrangeArraysEquals($type$[] r, $type$[] a, int[] order, boolean[] mask, int vector_len) {
310 int i = 0, j = 0;
311 try {
312 for (; i < a.length; i += vector_len) {
313 for (j = 0; j < vector_len; j++) {
314 if (mask[j % SPECIES.length()])
315 Assert.assertEquals(r[i+j], a[i+order[i+j]]);
316 else
317 Assert.assertEquals(r[i+j], ($type$)0);
318 }
319 }
320 } catch (AssertionError e) {
321 int idx = i + j;
322 if (mask[j % SPECIES.length()])
323 Assert.assertEquals(r[i+j], a[i+order[i+j]], "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
324 else
325 Assert.assertEquals(r[i+j], ($type$)0, "at index #" + idx + ", input = " + a[i+order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
326 }
327 }
328
329 static void assertSelectFromArraysEquals($type$[] r, $type$[] a, $type$[] order, boolean[] mask, int vector_len) {
330 int i = 0, j = 0;
331 try {
332 for (; i < a.length; i += vector_len) {
333 for (j = 0; j < vector_len; j++) {
334 if (mask[j % SPECIES.length()])
335 Assert.assertEquals(r[i+j], a[i+(int)order[i+j]]);
336 else
337 Assert.assertEquals(r[i+j], ($type$)0);
338 }
339 }
340 } catch (AssertionError e) {
341 int idx = i + j;
342 if (mask[j % SPECIES.length()])
343 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()]);
344 else
345 Assert.assertEquals(r[i+j], ($type$)0, "at index #" + idx + ", input = " + a[i+(int)order[i+j]] + ", mask = " + mask[j % SPECIES.length()]);
346 }
347 }
348
349 static void assertBroadcastArraysEquals($type$[] r, $type$[] a) {
350 int i = 0;
351 for (; i < a.length; i += SPECIES.length()) {
352 int idx = i;
353 for (int j = idx; j < (idx + SPECIES.length()); j++)
354 a[j]=a[idx];
355 }
356
357 try {
358 for (i = 0; i < a.length; i++) {
359 Assert.assertEquals(r[i], a[i]);
360 }
361 } catch (AssertionError e) {
362 Assert.assertEquals(r[i], a[i], "at index #" + i + ", input = " + a[i]);
363 }
364 }
365
366 interface FBinOp {
367 $type$ apply($type$ a, $type$ b);
368 }
369
370 interface FBinMaskOp {
371 $type$ apply($type$ a, $type$ b, boolean m);
372
373 static FBinMaskOp lift(FBinOp f) {
374 return (a, b, m) -> m ? f.apply(a, b) : a;
375 }
376 }
377
378 static void assertArraysEquals($type$[] r, $type$[] a, $type$[] b, FBinOp f) {
379 int i = 0;
380 try {
381 for (; i < a.length; i++) {
382 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
383 }
384 } catch (AssertionError e) {
385 Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
386 }
387 }
388
389 static void assertBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, FBinOp f) {
390 int i = 0;
391 try {
392 for (; i < a.length; i++) {
393 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
394 }
395 } catch (AssertionError e) {
396 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]),
397 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
398 }
399 }
400
401 static void assertBroadcastLongArraysEquals($type$[] r, $type$[] a, $type$[] b, FBinOp f) {
402 int i = 0;
403 try {
404 for (; i < a.length; i++) {
405 Assert.assertEquals(r[i], f.apply(a[i], ($type$)((long)b[(i / SPECIES.length()) * SPECIES.length()])));
406 }
407 } catch (AssertionError e) {
408 Assert.assertEquals(r[i], f.apply(a[i], ($type$)((long)b[(i / SPECIES.length()) * SPECIES.length()])),
409 "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
410 }
411 }
412
413 static void assertArraysEquals($type$[] r, $type$[] a, $type$[] b, boolean[] mask, FBinOp f) {
414 assertArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
415 }
416
417 static void assertArraysEquals($type$[] r, $type$[] a, $type$[] b, boolean[] mask, FBinMaskOp f) {
418 int i = 0;
419 try {
420 for (; i < a.length; i++) {
421 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
422 }
423 } catch (AssertionError err) {
424 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()]);
425 }
426 }
427
428 static void assertBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, boolean[] mask, FBinOp f) {
429 assertBroadcastArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
430 }
431
432 static void assertBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, boolean[] mask, FBinMaskOp f) {
433 int i = 0;
434 try {
435 for (; i < a.length; i++) {
436 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
437 }
438 } catch (AssertionError err) {
439 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
440 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
441 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
442 mask[i % SPECIES.length()]);
443 }
444 }
445
446 static void assertBroadcastLongArraysEquals($type$[] r, $type$[] a, $type$[] b, boolean[] mask, FBinOp f) {
447 assertBroadcastLongArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
448 }
449
450 static void assertBroadcastLongArraysEquals($type$[] r, $type$[] a, $type$[] b, boolean[] mask, FBinMaskOp f) {
451 int i = 0;
452 try {
453 for (; i < a.length; i++) {
454 Assert.assertEquals(r[i], f.apply(a[i], ($type$)((long)b[(i / SPECIES.length()) * SPECIES.length()]), mask[i % SPECIES.length()]));
455 }
456 } catch (AssertionError err) {
457 Assert.assertEquals(r[i], f.apply(a[i], ($type$)((long)b[(i / SPECIES.length()) * SPECIES.length()]),
458 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
459 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
460 mask[i % SPECIES.length()]);
461 }
462 }
463
464 static void assertShiftArraysEquals($type$[] r, $type$[] a, $type$[] b, FBinOp f) {
465 int i = 0;
466 int j = 0;
467 try {
468 for (; j < a.length; j += SPECIES.length()) {
469 for (i = 0; i < SPECIES.length(); i++) {
470 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
471 }
472 }
473 } catch (AssertionError e) {
474 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
475 }
476 }
477
478 static void assertShiftArraysEquals($type$[] r, $type$[] a, $type$[] b, boolean[] mask, FBinOp f) {
479 assertShiftArraysEquals(r, a, b, mask, FBinMaskOp.lift(f));
480 }
481
482 static void assertShiftArraysEquals($type$[] r, $type$[] a, $type$[] b, boolean[] mask, FBinMaskOp f) {
483 int i = 0;
484 int j = 0;
485 try {
486 for (; j < a.length; j += SPECIES.length()) {
487 for (i = 0; i < SPECIES.length(); i++) {
488 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j], mask[i]));
489 }
490 }
491 } catch (AssertionError err) {
492 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]);
493 }
494 }
495
496 interface FBinConstOp {
497 $type$ apply($type$ a);
498 }
499
500 interface FBinConstMaskOp {
501 $type$ apply($type$ a, boolean m);
502
503 static FBinConstMaskOp lift(FBinConstOp f) {
504 return (a, m) -> m ? f.apply(a) : a;
505 }
506 }
507
508 static void assertShiftConstEquals($type$[] r, $type$[] a, FBinConstOp f) {
509 int i = 0;
510 int j = 0;
511 try {
512 for (; j < a.length; j += SPECIES.length()) {
513 for (i = 0; i < SPECIES.length(); i++) {
514 Assert.assertEquals(r[i+j], f.apply(a[i+j]));
515 }
516 }
517 } catch (AssertionError e) {
518 Assert.assertEquals(r[i+j], f.apply(a[i+j]), "at index #" + i + ", " + j);
519 }
520 }
521
522 static void assertShiftConstEquals($type$[] r, $type$[] a, boolean[] mask, FBinConstOp f) {
523 assertShiftConstEquals(r, a, mask, FBinConstMaskOp.lift(f));
524 }
525
526 static void assertShiftConstEquals($type$[] r, $type$[] a, boolean[] mask, FBinConstMaskOp f) {
527 int i = 0;
528 int j = 0;
529 try {
530 for (; j < a.length; j += SPECIES.length()) {
531 for (i = 0; i < SPECIES.length(); i++) {
532 Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]));
533 }
534 }
535 } catch (AssertionError err) {
536 Assert.assertEquals(r[i+j], f.apply(a[i+j], mask[i]), "at index #" + i + ", input1 = " + a[i+j] + ", mask = " + mask[i]);
537 }
538 }
539
540 interface FTernOp {
541 $type$ apply($type$ a, $type$ b, $type$ c);
542 }
543
544 interface FTernMaskOp {
545 $type$ apply($type$ a, $type$ b, $type$ c, boolean m);
546
547 static FTernMaskOp lift(FTernOp f) {
548 return (a, b, c, m) -> m ? f.apply(a, b, c) : a;
549 }
550 }
551
552 static void assertArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, FTernOp f) {
553 int i = 0;
554 try {
555 for (; i < a.length; i++) {
556 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]));
557 }
558 } catch (AssertionError e) {
559 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " + c[i]);
560 }
561 }
562
563 static void assertArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, boolean[] mask, FTernOp f) {
564 assertArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
565 }
566
567 static void assertArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, boolean[] mask, FTernMaskOp f) {
568 int i = 0;
569 try {
570 for (; i < a.length; i++) {
571 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]));
572 }
573 } catch (AssertionError err) {
574 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = "
575 + b[i] + ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
576 }
577 }
578
579 static void assertBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, FTernOp f) {
580 int i = 0;
581 try {
582 for (; i < a.length; i++) {
583 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]));
584 }
585 } catch (AssertionError e) {
586 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" +
587 i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", input3 = " +
588 c[(i / SPECIES.length()) * SPECIES.length()]);
589 }
590 }
591
592 static void assertAltBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, FTernOp f) {
593 int i = 0;
594 try {
595 for (; i < a.length; i++) {
596 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]));
597 }
598 } catch (AssertionError e) {
599 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i]), "at index #" +
600 i + ", input1 = " + a[i] + ", input2 = " +
601 b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " + c[i]);
602 }
603 }
604
605 static void assertBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, boolean[] mask,
606 FTernOp f) {
607 assertBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
608 }
609
610 static void assertBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, boolean[] mask,
611 FTernMaskOp f) {
612 int i = 0;
613 try {
614 for (; i < a.length; i++) {
615 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
616 mask[i % SPECIES.length()]));
617 }
618 } catch (AssertionError err) {
619 Assert.assertEquals(r[i], f.apply(a[i], b[i], c[(i / SPECIES.length()) * SPECIES.length()],
620 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
621 b[i] + ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
622 mask[i % SPECIES.length()]);
623 }
624 }
625
626 static void assertAltBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, boolean[] mask,
627 FTernOp f) {
628 assertAltBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
629 }
630
631 static void assertAltBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, boolean[] mask,
632 FTernMaskOp f) {
633 int i = 0;
634 try {
635 for (; i < a.length; i++) {
636 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
637 mask[i % SPECIES.length()]));
638 }
639 } catch (AssertionError err) {
640 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], c[i],
641 mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] +
642 ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
643 ", input3 = " + c[i] + ", mask = " + mask[i % SPECIES.length()]);
644 }
645 }
646
647 static void assertDoubleBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, FTernOp f) {
648 int i = 0;
649 try {
650 for (; i < a.length; i++) {
651 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
652 c[(i / SPECIES.length()) * SPECIES.length()]));
653 }
654 } catch (AssertionError e) {
655 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
656 c[(i / SPECIES.length()) * SPECIES.length()]), "at index #" + i + ", input1 = " + a[i]
657 + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", input3 = " +
658 c[(i / SPECIES.length()) * SPECIES.length()]);
659 }
660 }
661
662 static void assertDoubleBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, boolean[] mask,
663 FTernOp f) {
664 assertDoubleBroadcastArraysEquals(r, a, b, c, mask, FTernMaskOp.lift(f));
665 }
666
667 static void assertDoubleBroadcastArraysEquals($type$[] r, $type$[] a, $type$[] b, $type$[] c, boolean[] mask,
668 FTernMaskOp f) {
669 int i = 0;
670 try {
671 for (; i < a.length; i++) {
672 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
673 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
674 }
675 } catch (AssertionError err) {
676 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()],
677 c[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #"
678 + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] +
679 ", input3 = " + c[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " +
680 mask[i % SPECIES.length()]);
681 }
682 }
683
684
685 #if[FP]
686 static boolean isWithin1Ulp($type$ actual, $type$ expected) {
687 if ($Type$.isNaN(expected) && !$Type$.isNaN(actual)) {
688 return false;
689 } else if (!$Type$.isNaN(expected) && $Type$.isNaN(actual)) {
690 return false;
691 }
692
693 $type$ low = Math.nextDown(expected);
694 $type$ high = Math.nextUp(expected);
695
696 if ($Type$.compare(low, expected) > 0) {
697 return false;
698 }
699
700 if ($Type$.compare(high, expected) < 0) {
701 return false;
702 }
703
704 return true;
705 }
706
707 static void assertArraysEqualsWithinOneUlp($type$[] r, $type$[] a, FUnOp mathf, FUnOp strictmathf) {
708 int i = 0;
709 try {
710 // Check that result is within 1 ulp of strict math or equivalent to math implementation.
711 for (; i < a.length; i++) {
712 Assert.assertTrue($Type$.compare(r[i], mathf.apply(a[i])) == 0 ||
713 isWithin1Ulp(r[i], strictmathf.apply(a[i])));
714 }
715 } catch (AssertionError e) {
716 Assert.assertTrue($Type$.compare(r[i], mathf.apply(a[i])) == 0, "at index #" + i + ", input = " + a[i] + ", actual = " + r[i] + ", expected = " + mathf.apply(a[i]));
717 Assert.assertTrue(isWithin1Ulp(r[i], strictmathf.apply(a[i])), "at index #" + i + ", input = " + a[i] + ", actual = " + r[i] + ", expected (within 1 ulp) = " + strictmathf.apply(a[i]));
718 }
719 }
720
721 static void assertArraysEqualsWithinOneUlp($type$[] r, $type$[] a, $type$[] b, FBinOp mathf, FBinOp strictmathf) {
722 int i = 0;
723 try {
724 // Check that result is within 1 ulp of strict math or equivalent to math implementation.
725 for (; i < a.length; i++) {
726 Assert.assertTrue($Type$.compare(r[i], mathf.apply(a[i], b[i])) == 0 ||
727 isWithin1Ulp(r[i], strictmathf.apply(a[i], b[i])));
728 }
729 } catch (AssertionError e) {
730 Assert.assertTrue($Type$.compare(r[i], mathf.apply(a[i], b[i])) == 0, "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", actual = " + r[i] + ", expected = " + mathf.apply(a[i], b[i]));
731 Assert.assertTrue(isWithin1Ulp(r[i], strictmathf.apply(a[i], b[i])), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", actual = " + r[i] + ", expected (within 1 ulp) = " + strictmathf.apply(a[i], b[i]));
732 }
733 }
734
735 static void assertBroadcastArraysEqualsWithinOneUlp($type$[] r, $type$[] a, $type$[] b,
736 FBinOp mathf, FBinOp strictmathf) {
737 int i = 0;
738 try {
739 // Check that result is within 1 ulp of strict math or equivalent to math implementation.
740 for (; i < a.length; i++) {
741 Assert.assertTrue($Type$.compare(r[i],
742 mathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])) == 0 ||
743 isWithin1Ulp(r[i],
744 strictmathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])));
745 }
746 } catch (AssertionError e) {
747 Assert.assertTrue($Type$.compare(r[i],
748 mathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])) == 0,
749 "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
750 b[(i / SPECIES.length()) * SPECIES.length()] + ", actual = " + r[i] +
751 ", expected = " + mathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
752 Assert.assertTrue(isWithin1Ulp(r[i],
753 strictmathf.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()])),
754 "at index #" + i + ", input1 = " + a[i] + ", input2 = " +
755 b[(i / SPECIES.length()) * SPECIES.length()] + ", actual = " + r[i] +
756 ", expected (within 1 ulp) = " + strictmathf.apply(a[i],
757 b[(i / SPECIES.length()) * SPECIES.length()]));
758 }
759 }
760 #end[FP]
761
762 interface FBinArrayOp {
763 $type$ apply($type$[] a, int b);
764 }
765
766 static void assertArraysEquals($type$[] r, $type$[] a, FBinArrayOp f) {
767 int i = 0;
768 try {
769 for (; i < a.length; i++) {
770 Assert.assertEquals(r[i], f.apply(a, i));
771 }
772 } catch (AssertionError e) {
773 Assert.assertEquals(r[i], f.apply(a,i), "at index #" + i);
774 }
775 }
776
777 interface FGatherScatterOp {
778 $type$[] apply($type$[] a, int ix, int[] b, int iy);
779 }
780
781 static void assertArraysEquals($type$[] r, $type$[] a, int[] b, FGatherScatterOp f) {
782 int i = 0;
783 try {
784 for (; i < a.length; i += SPECIES.length()) {
785 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
786 f.apply(a, i, b, i));
787 }
788 } catch (AssertionError e) {
789 $type$[] ref = f.apply(a, i, b, i);
790 $type$[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
791 Assert.assertEquals(res, ref,
792 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
793 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
794 + ", b: "
795 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
796 + " at index #" + i);
797 }
798 }
799
800 interface FGatherMaskedOp {
801 $type$[] apply($type$[] a, int ix, boolean[] mask, int[] b, int iy);
802 }
803
804 interface FScatterMaskedOp {
805 $type$[] apply($type$[] r, $type$[] a, int ix, boolean[] mask, int[] b, int iy);
806 }
807
808 static void assertArraysEquals($type$[] r, $type$[] a, int[] b, boolean[] mask, FGatherMaskedOp f) {
809 int i = 0;
810 try {
811 for (; i < a.length; i += SPECIES.length()) {
812 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
813 f.apply(a, i, mask, b, i));
814 }
815 } catch (AssertionError e) {
816 $type$[] ref = f.apply(a, i, mask, b, i);
817 $type$[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
818 Assert.assertEquals(res, ref,
819 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
820 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
821 + ", b: "
822 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
823 + ", mask: "
824 + Arrays.toString(mask)
825 + " at index #" + i);
826 }
827 }
828
829 static void assertArraysEquals($type$[] r, $type$[] a, int[] b, boolean[] mask, FScatterMaskedOp f) {
830 int i = 0;
831 try {
832 for (; i < a.length; i += SPECIES.length()) {
833 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
834 f.apply(r, a, i, mask, b, i));
835 }
836 } catch (AssertionError e) {
837 $type$[] ref = f.apply(r, a, i, mask, b, i);
838 $type$[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
839 Assert.assertEquals(res, ref,
840 "(ref: " + Arrays.toString(ref) + ", res: " + Arrays.toString(res) + ", a: "
841 + Arrays.toString(Arrays.copyOfRange(a, i, i+SPECIES.length()))
842 + ", b: "
843 + Arrays.toString(Arrays.copyOfRange(b, i, i+SPECIES.length()))
844 + ", r: "
845 + Arrays.toString(Arrays.copyOfRange(r, i, i+SPECIES.length()))
846 + ", mask: "
847 + Arrays.toString(mask)
848 + " at index #" + i);
849 }
850 }
851
852 interface FLaneOp {
853 $type$[] apply($type$[] a, int origin, int idx);
854 }
855
856 static void assertArraysEquals($type$[] r, $type$[] a, int origin, FLaneOp f) {
857 int i = 0;
858 try {
859 for (; i < a.length; i += SPECIES.length()) {
860 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
861 f.apply(a, origin, i));
862 }
863 } catch (AssertionError e) {
864 $type$[] ref = f.apply(a, origin, i);
865 $type$[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
866 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
867 + ", res: " + Arrays.toString(res)
868 + "), at index #" + i);
869 }
870 }
871
872 interface FLaneBop {
873 $type$[] apply($type$[] a, $type$[] b, int origin, int idx);
874 }
875
876 static void assertArraysEquals($type$[] r, $type$[] a, $type$[] b, int origin, FLaneBop f) {
877 int i = 0;
878 try {
879 for (; i < a.length; i += SPECIES.length()) {
880 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
881 f.apply(a, b, origin, i));
882 }
883 } catch (AssertionError e) {
884 $type$[] ref = f.apply(a, b, origin, i);
885 $type$[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
886 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
887 + ", res: " + Arrays.toString(res)
888 + "), at index #" + i
889 + ", at origin #" + origin);
890 }
891 }
892
893 interface FLaneMaskedBop {
894 $type$[] apply($type$[] a, $type$[] b, int origin, boolean[] mask, int idx);
895 }
896
897 static void assertArraysEquals($type$[] r, $type$[] a, $type$[] b, int origin, boolean[] mask, FLaneMaskedBop f) {
898 int i = 0;
899 try {
900 for (; i < a.length; i += SPECIES.length()) {
901 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
902 f.apply(a, b, origin, mask, i));
903 }
904 } catch (AssertionError e) {
905 $type$[] ref = f.apply(a, b, origin, mask, i);
906 $type$[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
907 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
908 + ", res: " + Arrays.toString(res)
909 + "), at index #" + i
910 + ", at origin #" + origin);
911 }
912 }
913
914 interface FLanePartBop {
915 $type$[] apply($type$[] a, $type$[] b, int origin, int part, int idx);
916 }
917
918 static void assertArraysEquals($type$[] r, $type$[] a, $type$[] b, int origin, int part, FLanePartBop f) {
919 int i = 0;
920 try {
921 for (; i < a.length; i += SPECIES.length()) {
922 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
923 f.apply(a, b, origin, part, i));
924 }
925 } catch (AssertionError e) {
926 $type$[] ref = f.apply(a, b, origin, part, i);
927 $type$[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
928 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
929 + ", res: " + Arrays.toString(res)
930 + "), at index #" + i
931 + ", at origin #" + origin
932 + ", with part #" + part);
933 }
934 }
935
936 interface FLanePartMaskedBop {
937 $type$[] apply($type$[] a, $type$[] b, int origin, int part, boolean[] mask, int idx);
938 }
939
940 static void assertArraysEquals($type$[] r, $type$[] a, $type$[] b, int origin, int part, boolean[] mask, FLanePartMaskedBop f) {
941 int i = 0;
942 try {
943 for (; i < a.length; i += SPECIES.length()) {
944 Assert.assertEquals(Arrays.copyOfRange(r, i, i+SPECIES.length()),
945 f.apply(a, b, origin, part, mask, i));
946 }
947 } catch (AssertionError e) {
948 $type$[] ref = f.apply(a, b, origin, part, mask, i);
949 $type$[] res = Arrays.copyOfRange(r, i, i+SPECIES.length());
950 Assert.assertEquals(res, ref, "(ref: " + Arrays.toString(ref)
951 + ", res: " + Arrays.toString(res)
952 + "), at index #" + i
953 + ", at origin #" + origin
954 + ", with part #" + part);
955 }
956 }
957
958 #if[!Int]
959 #if[!byteOrShort]
960 static int intCornerCaseValue(int i) {
961 switch(i % 5) {
962 case 0:
963 return Integer.MAX_VALUE;
964 case 1:
965 return Integer.MIN_VALUE;
966 case 2:
967 return Integer.MIN_VALUE;
968 case 3:
969 return Integer.MAX_VALUE;
970 default:
971 return (int)0;
972 }
973 }
974
975 static final List<IntFunction<$type$[]>> INT_$TYPE$_GENERATORS = List.of(
976 withToString("$type$[-i * 5]", (int s) -> {
977 return fill(s * BUFFER_REPS,
978 i -> ($type$)(-i * 5));
979 }),
980 withToString("$type$[i * 5]", (int s) -> {
981 return fill(s * BUFFER_REPS,
982 i -> ($type$)(i * 5));
983 }),
984 withToString("$type$[i + 1]", (int s) -> {
985 return fill(s * BUFFER_REPS,
986 i -> ((($type$)(i + 1) == 0) ? 1 : ($type$)(i + 1)));
987 }),
988 withToString("$type$[intCornerCaseValue(i)]", (int s) -> {
989 return fill(s * BUFFER_REPS,
990 i -> ($type$)intCornerCaseValue(i));
991 })
992 );
993 #end[!byteOrShort]
994 #end[!Int]
995
996 static void assertArraysEquals(int[] r, $type$[] a, int offs) {
997 int i = 0;
998 try {
999 for (; i < r.length; i++) {
1000 Assert.assertEquals(r[i], (int)(a[i+offs]));
1001 }
1002 } catch (AssertionError e) {
1003 Assert.assertEquals(r[i], (int)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
1004 }
1005 }
1006
1007 #if[!Long]
1008 #if[FP]
1009 static long longCornerCaseValue(int i) {
1010 switch(i % 5) {
1011 case 0:
1012 return Long.MAX_VALUE;
1013 case 1:
1014 return Long.MIN_VALUE;
1015 case 2:
1016 return Long.MIN_VALUE;
1017 case 3:
1018 return Long.MAX_VALUE;
1019 default:
1020 return (long)0;
1021 }
1022 }
1023
1024 static final List<IntFunction<$type$[]>> LONG_$TYPE$_GENERATORS = List.of(
1025 withToString("$type$[-i * 5]", (int s) -> {
1026 return fill(s * BUFFER_REPS,
1027 i -> ($type$)(-i * 5));
1028 }),
1029 withToString("$type$[i * 5]", (int s) -> {
1030 return fill(s * BUFFER_REPS,
1031 i -> ($type$)(i * 5));
1032 }),
1033 withToString("$type$[i + 1]", (int s) -> {
1034 return fill(s * BUFFER_REPS,
1035 i -> ((($type$)(i + 1) == 0) ? 1 : ($type$)(i + 1)));
1036 }),
1037 withToString("$type$[cornerCaseValue(i)]", (int s) -> {
1038 return fill(s * BUFFER_REPS,
1039 i -> ($type$)longCornerCaseValue(i));
1040 })
1041 );
1042 #end[FP]
1043 #end[!Long]
1044
1045 #if[byte]
1046 static void assertArraysEquals($type$[] r, $type$[] a, int offs) {
1047 int i = 0;
1048 try {
1049 for (; i < r.length; i++) {
1050 Assert.assertEquals(r[i], (long)(a[i+offs]));
1051 }
1052 } catch (AssertionError e) {
1053 Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
1054 }
1055 }
1056 #end[byte]
1057
1058 static void assertArraysEquals(long[] r, $type$[] a, int offs) {
1059 int i = 0;
1060 try {
1061 for (; i < r.length; i++) {
1062 Assert.assertEquals(r[i], (long)(a[i+offs]));
1063 }
1064 } catch (AssertionError e) {
1065 Assert.assertEquals(r[i], (long)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
1066 }
1067 }
1068
1069 #if[!Double]
1070 static void assertArraysEquals(double[] r, $type$[] a, int offs) {
1071 int i = 0;
1072 try {
1073 for (; i < r.length; i++) {
1074 Assert.assertEquals(r[i], (double)(a[i+offs]));
1075 }
1076 } catch (AssertionError e) {
1077 Assert.assertEquals(r[i], (double)(a[i+offs]), "at index #" + i + ", input = " + a[i+offs]);
1078 }
1079 }
1080 #end[!Double]
1081
1082
1083 static $bitstype$ bits($type$ e) {
1084 return {#if[FP]? $Type$.$type$To$Bitstype$Bits(e): e};
1085 }
1086
1087 static final List<IntFunction<$type$[]>> $TYPE$_GENERATORS = List.of(
1088 withToString("$type$[-i * 5]", (int s) -> {
1089 return fill(s * BUFFER_REPS,
1090 i -> ($type$)(-i * 5));
1091 }),
1092 withToString("$type$[i * 5]", (int s) -> {
1093 return fill(s * BUFFER_REPS,
1094 i -> ($type$)(i * 5));
1095 }),
1096 withToString("$type$[i + 1]", (int s) -> {
1097 return fill(s * BUFFER_REPS,
1098 i -> ((($type$)(i + 1) == 0) ? 1 : ($type$)(i + 1)));
1099 }),
1100 withToString("$type$[cornerCaseValue(i)]", (int s) -> {
1101 return fill(s * BUFFER_REPS,
1102 i -> cornerCaseValue(i));
1103 })
1104 );
1105
1106 // Create combinations of pairs
1107 // @@@ Might be sensitive to order e.g. div by 0
1108 static final List<List<IntFunction<$type$[]>>> $TYPE$_GENERATOR_PAIRS =
1109 Stream.of($TYPE$_GENERATORS.get(0)).
1110 flatMap(fa -> $TYPE$_GENERATORS.stream().skip(1).map(fb -> List.of(fa, fb))).
1111 collect(Collectors.toList());
1112
1113 @DataProvider
1114 public Object[][] boolUnaryOpProvider() {
1115 return BOOL_ARRAY_GENERATORS.stream().
1116 map(f -> new Object[]{f}).
1117 toArray(Object[][]::new);
1118 }
1119
1120 static final List<List<IntFunction<$type$[]>>> $TYPE$_GENERATOR_TRIPLES =
1121 $TYPE$_GENERATOR_PAIRS.stream().
1122 flatMap(pair -> $TYPE$_GENERATORS.stream().map(f -> List.of(pair.get(0), pair.get(1), f))).
1123 collect(Collectors.toList());
1124
1125 @DataProvider
1126 public Object[][] $type$BinaryOpProvider() {
1127 return $TYPE$_GENERATOR_PAIRS.stream().map(List::toArray).
1128 toArray(Object[][]::new);
1129 }
1130
1131 @DataProvider
1132 public Object[][] $type$IndexedOpProvider() {
1133 return $TYPE$_GENERATOR_PAIRS.stream().map(List::toArray).
1134 toArray(Object[][]::new);
1135 }
1136
1137 @DataProvider
1138 public Object[][] $type$BinaryOpMaskProvider() {
1139 return BOOLEAN_MASK_GENERATORS.stream().
1140 flatMap(fm -> $TYPE$_GENERATOR_PAIRS.stream().map(lfa -> {
1141 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1142 })).
1143 toArray(Object[][]::new);
1144 }
1145
1146 @DataProvider
1147 public Object[][] $type$TernaryOpProvider() {
1148 return $TYPE$_GENERATOR_TRIPLES.stream().map(List::toArray).
1149 toArray(Object[][]::new);
1150 }
1151
1152 @DataProvider
1153 public Object[][] $type$TernaryOpMaskProvider() {
1154 return BOOLEAN_MASK_GENERATORS.stream().
1155 flatMap(fm -> $TYPE$_GENERATOR_TRIPLES.stream().map(lfa -> {
1156 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1157 })).
1158 toArray(Object[][]::new);
1159 }
1160
1161 @DataProvider
1162 public Object[][] $type$UnaryOpProvider() {
1163 return $TYPE$_GENERATORS.stream().
1164 map(f -> new Object[]{f}).
1165 toArray(Object[][]::new);
1166 }
1167
1168 @DataProvider
1169 public Object[][] $type$UnaryOpMaskProvider() {
1170 return BOOLEAN_MASK_GENERATORS.stream().
1171 flatMap(fm -> $TYPE$_GENERATORS.stream().map(fa -> {
1172 return new Object[] {fa, fm};
1173 })).
1174 toArray(Object[][]::new);
1175 }
1176
1177 #if[!Int]
1178 #if[!byteOrShort]
1179 @DataProvider
1180 public Object[][] $type$toIntUnaryOpProvider() {
1181 return INT_$TYPE$_GENERATORS.stream().
1182 map(f -> new Object[]{f}).
1183 toArray(Object[][]::new);
1184 }
1185 #end[!byteOrShort]
1186 #end[!Int]
1187
1188 #if[FP]
1189 @DataProvider
1190 public Object[][] $type$toLongUnaryOpProvider() {
1191 return LONG_$TYPE$_GENERATORS.stream().
1192 map(f -> new Object[]{f}).
1193 toArray(Object[][]::new);
1194 }
1195 #end[FP]
1196
1197 @DataProvider
1198 public Object[][] maskProvider() {
1199 return BOOLEAN_MASK_GENERATORS.stream().
1200 map(f -> new Object[]{f}).
1201 toArray(Object[][]::new);
1202 }
1203
1204 @DataProvider
1205 public Object[][] maskCompareOpProvider() {
1206 return BOOLEAN_MASK_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1207 toArray(Object[][]::new);
1208 }
1209
1210 @DataProvider
1211 public Object[][] shuffleProvider() {
1212 return INT_SHUFFLE_GENERATORS.stream().
1213 map(f -> new Object[]{f}).
1214 toArray(Object[][]::new);
1215 }
1216
1217 @DataProvider
1218 public Object[][] shuffleCompareOpProvider() {
1219 return INT_SHUFFLE_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1220 toArray(Object[][]::new);
1221 }
1222
1223 @DataProvider
1224 public Object[][] $type$UnaryOpShuffleProvider() {
1225 return INT_SHUFFLE_GENERATORS.stream().
1226 flatMap(fs -> $TYPE$_GENERATORS.stream().map(fa -> {
1227 return new Object[] {fa, fs};
1228 })).
1229 toArray(Object[][]::new);
1230 }
1231
1232 @DataProvider
1233 public Object[][] $type$UnaryOpShuffleMaskProvider() {
1234 return BOOLEAN_MASK_GENERATORS.stream().
1235 flatMap(fm -> INT_SHUFFLE_GENERATORS.stream().
1236 flatMap(fs -> $TYPE$_GENERATORS.stream().map(fa -> {
1237 return new Object[] {fa, fs, fm};
1238 }))).
1239 toArray(Object[][]::new);
1240 }
1241
1242 #if[!Int]
1243 static final List<BiFunction<Integer,Integer,$type$[]>> $TYPE$_SHUFFLE_GENERATORS = List.of(
1244 withToStringBi("shuffle[random]", (Integer l, Integer m) -> {
1245 $type$[] a = new $type$[l];
1246 #if[ByteMax]
1247 int upper = Math.min(Byte.MAX_VALUE + 1, m);
1248 #else[ByteMax]
1249 int upper = m;
1250 #end[ByteMax]
1251 for (int i = 0; i < 1; i++) {
1252 a[i] = ($type$)RAND.nextInt(upper);
1253 }
1254 return a;
1255 })
1256 );
1257
1258 @DataProvider
1259 public Object[][] $type$UnaryOpSelectFromProvider() {
1260 return $TYPE$_SHUFFLE_GENERATORS.stream().
1261 flatMap(fs -> $TYPE$_GENERATORS.stream().map(fa -> {
1262 return new Object[] {fa, fs};
1263 })).
1264 toArray(Object[][]::new);
1265 }
1266
1267 @DataProvider
1268 public Object[][] $type$UnaryOpSelectFromMaskProvider() {
1269 return BOOLEAN_MASK_GENERATORS.stream().
1270 flatMap(fm -> $TYPE$_SHUFFLE_GENERATORS.stream().
1271 flatMap(fs -> $TYPE$_GENERATORS.stream().map(fa -> {
1272 return new Object[] {fa, fs, fm};
1273 }))).
1274 toArray(Object[][]::new);
1275 }
1276
1277 #end[!Int]
1278
1279 static final List<IntFunction<$type$[]>> $TYPE$_COMPARE_GENERATORS = List.of(
1280 withToString("$type$[i]", (int s) -> {
1281 return fill(s * BUFFER_REPS,
1282 i -> ($type$)i);
1283 }),
1284 withToString("$type$[i - length / 2]", (int s) -> {
1285 return fill(s * BUFFER_REPS,
1286 i -> ($type$)(i - (s * BUFFER_REPS / 2)));
1287 }),
1288 withToString("$type$[i + 1]", (int s) -> {
1289 return fill(s * BUFFER_REPS,
1290 i -> ($type$)(i + 1));
1291 }),
1292 withToString("$type$[i - 2]", (int s) -> {
1293 return fill(s * BUFFER_REPS,
1294 i -> ($type$)(i - 2));
1295 }),
1296 withToString("$type$[zigZag(i)]", (int s) -> {
1297 return fill(s * BUFFER_REPS,
1298 i -> i%3 == 0 ? ($type$)i : (i%3 == 1 ? ($type$)(i + 1) : ($type$)(i - 2)));
1299 }),
1300 withToString("$type$[cornerCaseValue(i)]", (int s) -> {
1301 return fill(s * BUFFER_REPS,
1302 i -> cornerCaseValue(i));
1303 })
1304 );
1305
1306 static final List<List<IntFunction<$type$[]>>> $TYPE$_TEST_GENERATOR_ARGS =
1307 $TYPE$_COMPARE_GENERATORS.stream().
1308 map(fa -> List.of(fa)).
1309 collect(Collectors.toList());
1310
1311 @DataProvider
1312 public Object[][] $type$TestOpProvider() {
1313 return $TYPE$_TEST_GENERATOR_ARGS.stream().map(List::toArray).
1314 toArray(Object[][]::new);
1315 }
1316
1317 @DataProvider
1318 public Object[][] $type$TestOpMaskProvider() {
1319 return BOOLEAN_MASK_GENERATORS.stream().
1320 flatMap(fm -> $TYPE$_TEST_GENERATOR_ARGS.stream().map(lfa -> {
1321 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1322 })).
1323 toArray(Object[][]::new);
1324 }
1325
1326 static final List<List<IntFunction<$type$[]>>> $TYPE$_COMPARE_GENERATOR_PAIRS =
1327 $TYPE$_COMPARE_GENERATORS.stream().
1328 flatMap(fa -> $TYPE$_COMPARE_GENERATORS.stream().map(fb -> List.of(fa, fb))).
1329 collect(Collectors.toList());
1330
1331 @DataProvider
1332 public Object[][] $type$CompareOpProvider() {
1333 return $TYPE$_COMPARE_GENERATOR_PAIRS.stream().map(List::toArray).
1334 toArray(Object[][]::new);
1335 }
1336
1337 @DataProvider
1338 public Object[][] $type$CompareOpMaskProvider() {
1339 return BOOLEAN_MASK_GENERATORS.stream().
1340 flatMap(fm -> $TYPE$_COMPARE_GENERATOR_PAIRS.stream().map(lfa -> {
1341 return Stream.concat(lfa.stream(), Stream.of(fm)).toArray();
1342 })).
1343 toArray(Object[][]::new);
1344 }
1345
1346 interface To$Type$F {
1347 $type$ apply(int i);
1348 }
1349
1350 static $type$[] fill(int s , To$Type$F f) {
1351 return fill(new $type$[s], f);
1352 }
1353
1354 static $type$[] fill($type$[] a, To$Type$F f) {
1355 for (int i = 0; i < a.length; i++) {
1356 a[i] = f.apply(i);
1357 }
1358 return a;
1359 }
1360
1361 static $type$ cornerCaseValue(int i) {
1362 #if[FP]
1363 switch(i % 7) {
1364 case 0:
1365 return $Wideboxtype$.MAX_VALUE;
1366 case 1:
1367 return $Wideboxtype$.MIN_VALUE;
1368 case 2:
1369 return $Wideboxtype$.NEGATIVE_INFINITY;
1370 case 3:
1371 return $Wideboxtype$.POSITIVE_INFINITY;
1372 case 4:
1373 return $Wideboxtype$.NaN;
1374 case 5:
1375 return ($type$)0.0;
1376 default:
1377 return ($type$)-0.0;
1378 }
1379 #else[FP]
1380 switch(i % 5) {
1381 case 0:
1382 return $Wideboxtype$.MAX_VALUE;
1383 case 1:
1384 return $Wideboxtype$.MIN_VALUE;
1385 case 2:
1386 return $Wideboxtype$.MIN_VALUE;
1387 case 3:
1388 return $Wideboxtype$.MAX_VALUE;
1389 default:
1390 return ($type$)0;
1391 }
1392 #end[FP]
1393 }
1394
1395 static $type$ get($type$[] a, int i) {
1396 return ($type$) a[i];
1397 }
1398
1399 static final IntFunction<$type$[]> fr = (vl) -> {
1400 int length = BUFFER_REPS * vl;
1401 return new $type$[length];
1402 };
1403
1404 static final IntFunction<boolean[]> fmr = (vl) -> {
1405 int length = BUFFER_REPS * vl;
1406 return new boolean[length];
1407 };
1408
1409 #if[!Long]
1410 static final IntFunction<long[]> lfr = (vl) -> {
1411 int length = BUFFER_REPS * vl;
1412 return new long[length];
1413 };
1414 #end[!Long]
1415
1416 #if[BITWISE]
1417 static void replaceZero($type$[] a, $type$ v) {
1418 for (int i = 0; i < a.length; i++) {
1419 if (a[i] == 0) {
1420 a[i] = v;
1421 }
1422 }
1423 }
1424
1425 static void replaceZero($type$[] a, boolean[] mask, $type$ v) {
1426 for (int i = 0; i < a.length; i++) {
1427 if (mask[i % mask.length] && a[i] == 0) {
1428 a[i] = v;
1429 }
1430 }
1431 }
1432
1433 static $type$ ROL_scalar($type$ a, $type$ b) {
1434 #if[intOrLong]
1435 return $Wideboxtype$.rotateLeft(a, ((int)b));
1436 #else[intOrLong]
1437 #if[short]
1438 return (short)(((((short)a) & 0xFFFF) << (b & 15)) | ((((short)a) & 0xFFFF) >>> (16 - (b & 15))));
1439 #else[short]
1440 return (byte)(((((byte)a) & 0xFF) << (b & 7)) | ((((byte)a) & 0xFF) >>> (8 - (b & 7))));
1441 #end[short]
1442 #end[intOrLong]
1443 }
1444
1445 static $type$ ROR_scalar($type$ a, $type$ b) {
1446 #if[intOrLong]
1447 return $Wideboxtype$.rotateRight(a, ((int)b));
1448 #else[intOrLong]
1449 #if[short]
1450 return (short)(((((short)a) & 0xFFFF) >>> (b & 15)) | ((((short)a) & 0xFFFF) << (16 - (b & 15))));
1451 #else[short]
1452 return (byte)(((((byte)a) & 0xFF) >>> (b & 7)) | ((((byte)a) & 0xFF) << (8 - (b & 7))));
1453 #end[short]
1454 #end[intOrLong]
1455 }
1456 #end[BITWISE]
1457
1458 static boolean eq($type$ a, $type$ b) {
1459 return a == b;
1460 }
1461
1462 static boolean neq($type$ a, $type$ b) {
1463 return a != b;
1464 }
1465
1466 static boolean lt($type$ a, $type$ b) {
1467 return a < b;
1468 }
1469
1470 static boolean le($type$ a, $type$ b) {
1471 return a <= b;
1472 }
1473
1474 static boolean gt($type$ a, $type$ b) {
1475 return a > b;
1476 }
1477
1478 static boolean ge($type$ a, $type$ b) {
1479 return a >= b;
1480 }
1481
1482 #if[!FP]
1483 static boolean ult($type$ a, $type$ b) {
1484 return $Boxtype$.compareUnsigned(a, b) < 0;
1485 }
1486
1487 static boolean ule($type$ a, $type$ b) {
1488 return $Boxtype$.compareUnsigned(a, b) <= 0;
1489 }
1490
1491 static boolean ugt($type$ a, $type$ b) {
1492 return $Boxtype$.compareUnsigned(a, b) > 0;
1493 }
1494
1495 static boolean uge($type$ a, $type$ b) {
1496 return $Boxtype$.compareUnsigned(a, b) >= 0;
1497 }
1498 #end[!FP]
1499
1500 static $type$ firstNonZero($type$ a, $type$ b) {
1501 return $Boxtype$.compare(a, ($type$) 0) != 0 ? a : b;
1502 }
1503
1504 @Test
1505 static void smokeTest1() {
1506 $abstractvectortype$ three = $abstractvectortype$.broadcast(SPECIES, (byte)-3);
1507 $abstractvectortype$ three2 = ($abstractvectortype$) SPECIES.broadcast(-3);
1508 assert(three.eq(three2).allTrue());
1509 $abstractvectortype$ three3 = three2.broadcast(1).broadcast(-3);
1510 assert(three.eq(three3).allTrue());
1511 int scale = 2;
1512 Class<?> ETYPE = $type$.class;
1513 if (ETYPE == double.class || ETYPE == long.class)
1514 scale = 1000000;
1515 else if (ETYPE == byte.class && SPECIES.length() >= 64)
1516 scale = 1;
1517 $abstractvectortype$ higher = three.addIndex(scale);
1518 VectorMask<$Boxtype$> m = three.compare(VectorOperators.LE, higher);
1519 assert(m.allTrue());
1520 m = higher.min(($type$)-1).test(VectorOperators.IS_NEGATIVE);
1521 assert(m.allTrue());
1522 #if[FP]
1523 m = higher.test(VectorOperators.IS_FINITE);
1524 assert(m.allTrue());
1525 #end[FP]
1526 $type$ max = higher.reduceLanes(VectorOperators.MAX);
1527 assert(max == -3 + scale * (SPECIES.length()-1));
1528 }
1529
1530 private static $type$[]
1531 bothToArray($abstractvectortype$ a, $abstractvectortype$ b) {
1532 $type$[] r = new $type$[a.length() + b.length()];
1533 a.intoArray(r, 0);
1534 b.intoArray(r, a.length());
1535 return r;
1536 }
1537
1538 @Test
1539 static void smokeTest2() {
1540 // Do some zipping and shuffling.
1541 $abstractvectortype$ io = ($abstractvectortype$) SPECIES.broadcast(0).addIndex(1);
1542 $abstractvectortype$ io2 = ($abstractvectortype$) VectorShuffle.iota(SPECIES,0,1,false).toVector();
1543 Assert.assertEquals(io, io2);
1544 $abstractvectortype$ a = io.add(($type$)1); //[1,2]
1545 $abstractvectortype$ b = a.neg(); //[-1,-2]
1546 $type$[] abValues = bothToArray(a,b); //[1,2,-1,-2]
1547 VectorShuffle<$Boxtype$> zip0 = VectorShuffle.makeZip(SPECIES, 0);
1548 VectorShuffle<$Boxtype$> zip1 = VectorShuffle.makeZip(SPECIES, 1);
1549 $abstractvectortype$ zab0 = a.rearrange(zip0,b); //[1,-1]
1550 $abstractvectortype$ zab1 = a.rearrange(zip1,b); //[2,-2]
1551 $type$[] zabValues = bothToArray(zab0, zab1); //[1,-1,2,-2]
1552 // manually zip
1553 $type$[] manual = new $type$[zabValues.length];
1554 for (int i = 0; i < manual.length; i += 2) {
1555 manual[i+0] = abValues[i/2];
1556 manual[i+1] = abValues[a.length() + i/2];
1557 }
1558 Assert.assertEquals(Arrays.toString(zabValues), Arrays.toString(manual));
1559 VectorShuffle<$Boxtype$> unz0 = VectorShuffle.makeUnzip(SPECIES, 0);
1560 VectorShuffle<$Boxtype$> unz1 = VectorShuffle.makeUnzip(SPECIES, 1);
1561 $abstractvectortype$ uab0 = zab0.rearrange(unz0,zab1);
1562 $abstractvectortype$ uab1 = zab0.rearrange(unz1,zab1);
1563 $type$[] abValues1 = bothToArray(uab0, uab1);
1564 Assert.assertEquals(Arrays.toString(abValues), Arrays.toString(abValues1));
1565 }
1566
1567 static void iotaShuffle() {
1568 $abstractvectortype$ io = ($abstractvectortype$) SPECIES.broadcast(0).addIndex(1);
1569 $abstractvectortype$ io2 = ($abstractvectortype$) VectorShuffle.iota(SPECIES, 0 , 1, false).toVector();
1570 Assert.assertEquals(io, io2);
1571 }
1572
1573 @Test
1574 // Test all shuffle related operations.
1575 static void shuffleTest() {
1576 // To test backend instructions, make sure that C2 is used.
1577 for (int loop = 0; loop < INVOC_COUNT * INVOC_COUNT; loop++) {
1578 iotaShuffle();
1579 }
1580 }
1581
1582 @Test
1583 void viewAsIntegeralLanesTest() {
1584 #if[FP]
1585 Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1586 VectorSpecies<?> asIntegralSpecies = asIntegral.species();
1587 Assert.assertNotEquals(asIntegralSpecies.elementType(), SPECIES.elementType());
1588 Assert.assertEquals(asIntegralSpecies.vectorShape(), SPECIES.vectorShape());
1589 Assert.assertEquals(asIntegralSpecies.length(), SPECIES.length());
1590 Assert.assertEquals(asIntegral.viewAsFloatingLanes().species(), SPECIES);
1591 #else[FP]
1592 Vector<?> asIntegral = SPECIES.zero().viewAsIntegralLanes();
1593 Assert.assertEquals(asIntegral.species(), SPECIES);
1594 #end[FP]
1595 }
1596
1597 #if[FP]
1598 @Test
1599 void viewAsFloatingLanesTest() {
1600 Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
1601 Assert.assertEquals(asFloating.species(), SPECIES);
1602 }
1603 #else[FP]
1604 #if[byteOrShort]
1605 @Test(expectedExceptions = UnsupportedOperationException.class)
1606 void viewAsFloatingLanesTest() {
1607 SPECIES.zero().viewAsFloatingLanes();
1608 }
1609 #else[byteOrShort]
1610 @Test
1611 void viewAsFloatingLanesTest() {
1612 Vector<?> asFloating = SPECIES.zero().viewAsFloatingLanes();
1613 VectorSpecies<?> asFloatingSpecies = asFloating.species();
1614 Assert.assertNotEquals(asFloatingSpecies.elementType(), SPECIES.elementType());
1615 Assert.assertEquals(asFloatingSpecies.vectorShape(), SPECIES.vectorShape());
1616 Assert.assertEquals(asFloatingSpecies.length(), SPECIES.length());
1617 Assert.assertEquals(asFloating.viewAsIntegralLanes().species(), SPECIES);
1618 }
1619 #end[byteOrShort]
1620 #end[FP]
1621
1622 #if[BITWISE]
1623 @Test
1624 // Test div by 0.
1625 static void bitwiseDivByZeroSmokeTest() {
1626 try {
1627 $abstractvectortype$ a = ($abstractvectortype$) SPECIES.broadcast(0).addIndex(1);
1628 $abstractvectortype$ b = ($abstractvectortype$) SPECIES.broadcast(0);
1629 a.div(b);
1630 Assert.fail();
1631 } catch (ArithmeticException e) {
1632 }
1633
1634 try {
1635 $abstractvectortype$ a = ($abstractvectortype$) SPECIES.broadcast(0).addIndex(1);
1636 $abstractvectortype$ b = ($abstractvectortype$) SPECIES.broadcast(0);
1637 VectorMask<$Boxtype$> m = a.lt(($type$) 1);
1638 a.div(b, m);
1639 Assert.fail();
1640 } catch (ArithmeticException e) {
1641 }
1642 }
1643 #end[BITWISE]