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