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