229
230 interface FBinMaskOp {
231 int apply(int a, int b, boolean m);
232
233 static FBinMaskOp lift(FBinOp f) {
234 return (a, b, m) -> m ? f.apply(a, b) : a;
235 }
236 }
237
238 static void assertArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
239 int i = 0;
240 try {
241 for (; i < a.length; i++) {
242 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
243 }
244 } catch (AssertionError e) {
245 Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
246 }
247 }
248
249 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
250 assertArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
251 }
252
253 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
254 int i = 0;
255 try {
256 for (; i < a.length; i++) {
257 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
258 }
259 } catch (AssertionError err) {
260 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", mask = " + mask[i % SPECIES.length()]);
261 }
262 }
263
264 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
265 int i = 0;
266 int j = 0;
267 try {
268 for (; j < a.length; j += SPECIES.length()) {
269 for (i = 0; i < SPECIES.length(); i++) {
270 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
271 }
272 }
273 } catch (AssertionError e) {
274 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
275 }
276 }
277
278 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
279 assertShiftArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
280 }
281
282 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
283 int i = 0;
1362 static int OR(int a, int b) {
1363 return (int)(a | b);
1364 }
1365
1366 @Test(dataProvider = "intBinaryOpProvider")
1367 static void ORIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1368 int[] a = fa.apply(SPECIES.length());
1369 int[] b = fb.apply(SPECIES.length());
1370 int[] r = fr.apply(SPECIES.length());
1371
1372 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1373 for (int i = 0; i < a.length; i += SPECIES.length()) {
1374 IntVector av = IntVector.fromArray(SPECIES, a, i);
1375 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1376 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
1377 }
1378 }
1379
1380 assertArraysEquals(a, b, r, IntMaxVectorTests::OR);
1381 }
1382
1383
1384
1385 @Test(dataProvider = "intBinaryOpMaskProvider")
1386 static void ORIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1387 IntFunction<boolean[]> fm) {
1388 int[] a = fa.apply(SPECIES.length());
1389 int[] b = fb.apply(SPECIES.length());
1390 int[] r = fr.apply(SPECIES.length());
1391 boolean[] mask = fm.apply(SPECIES.length());
1392 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1393
1394 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1395 for (int i = 0; i < a.length; i += SPECIES.length()) {
1396 IntVector av = IntVector.fromArray(SPECIES, a, i);
1397 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1398 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
1399 }
1400 }
1401
1430 static void XORIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1431 IntFunction<boolean[]> fm) {
1432 int[] a = fa.apply(SPECIES.length());
1433 int[] b = fb.apply(SPECIES.length());
1434 int[] r = fr.apply(SPECIES.length());
1435 boolean[] mask = fm.apply(SPECIES.length());
1436 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1437
1438 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1439 for (int i = 0; i < a.length; i += SPECIES.length()) {
1440 IntVector av = IntVector.fromArray(SPECIES, a, i);
1441 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1442 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
1443 }
1444 }
1445
1446 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::XOR);
1447 }
1448
1449
1450 static int LSHL(int a, int b) {
1451 return (int)((a << b));
1452 }
1453
1454 @Test(dataProvider = "intBinaryOpProvider")
1455 static void LSHLIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1456 int[] a = fa.apply(SPECIES.length());
1457 int[] b = fb.apply(SPECIES.length());
1458 int[] r = fr.apply(SPECIES.length());
1459
1460 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1461 for (int i = 0; i < a.length; i += SPECIES.length()) {
1462 IntVector av = IntVector.fromArray(SPECIES, a, i);
1463 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1464 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
1465 }
1466 }
1467
1468 assertArraysEquals(a, b, r, IntMaxVectorTests::LSHL);
1469 }
1792 return (int)(Math.max(a, b));
1793 }
1794
1795 @Test(dataProvider = "intBinaryOpProvider")
1796 static void maxIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1797 int[] a = fa.apply(SPECIES.length());
1798 int[] b = fb.apply(SPECIES.length());
1799 int[] r = fr.apply(SPECIES.length());
1800
1801 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1802 for (int i = 0; i < a.length; i += SPECIES.length()) {
1803 IntVector av = IntVector.fromArray(SPECIES, a, i);
1804 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1805 av.max(bv).intoArray(r, i);
1806 }
1807 }
1808
1809 assertArraysEquals(a, b, r, IntMaxVectorTests::max);
1810 }
1811
1812 static int AND(int[] a, int idx) {
1813 int res = -1;
1814 for (int i = idx; i < (idx + SPECIES.length()); i++) {
1815 res &= a[i];
1816 }
1817
1818 return res;
1819 }
1820
1821 static int AND(int[] a) {
1822 int res = -1;
1823 for (int i = 0; i < a.length; i += SPECIES.length()) {
1824 int tmp = -1;
1825 for (int j = 0; j < SPECIES.length(); j++) {
1826 tmp &= a[i + j];
1827 }
1828 res &= tmp;
1829 }
1830
1831 return res;
3236 boolean[] mask = fm.apply(SPECIES.length());
3237 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3238
3239 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3240 for (int i = 0; i < a.length; i += SPECIES.length()) {
3241 IntVector av = IntVector.fromArray(SPECIES, a, i);
3242 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3243 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3244 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
3245 }
3246 }
3247
3248 assertArraysEquals(a, b, c, r, mask, IntMaxVectorTests::BITWISE_BLEND);
3249 }
3250
3251
3252 static int NEG(int a) {
3253 return (int)(-((int)a));
3254 }
3255
3256 @Test(dataProvider = "intUnaryOpProvider")
3257 static void NEGIntMaxVectorTests(IntFunction<int[]> fa) {
3258 int[] a = fa.apply(SPECIES.length());
3259 int[] r = fr.apply(SPECIES.length());
3260
3261 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3262 for (int i = 0; i < a.length; i += SPECIES.length()) {
3263 IntVector av = IntVector.fromArray(SPECIES, a, i);
3264 av.lanewise(VectorOperators.NEG).intoArray(r, i);
3265 }
3266 }
3267
3268 assertArraysEquals(a, r, IntMaxVectorTests::NEG);
3269 }
3270
3271 @Test(dataProvider = "intUnaryOpMaskProvider")
3272 static void NEGMaskedIntMaxVectorTests(IntFunction<int[]> fa,
3273 IntFunction<boolean[]> fm) {
3274 int[] a = fa.apply(SPECIES.length());
3275 int[] r = fr.apply(SPECIES.length());
3276 boolean[] mask = fm.apply(SPECIES.length());
3277 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3278
3279 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3280 for (int i = 0; i < a.length; i += SPECIES.length()) {
3281 IntVector av = IntVector.fromArray(SPECIES, a, i);
3282 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
3283 }
3284 }
3285
3286 assertArraysEquals(a, r, mask, IntMaxVectorTests::NEG);
3287 }
3288
3289 static int ABS(int a) {
3290 return (int)(Math.abs((int)a));
3330 int[] a = fa.apply(SPECIES.length());
3331 int[] r = fr.apply(SPECIES.length());
3332 boolean[] mask = fm.apply(SPECIES.length());
3333 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3334
3335 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3336 for (int i = 0; i < a.length; i += SPECIES.length()) {
3337 IntVector av = IntVector.fromArray(SPECIES, a, i);
3338 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
3339 }
3340 }
3341
3342 assertArraysEquals(a, r, mask, IntMaxVectorTests::ABS);
3343 }
3344
3345
3346 static int NOT(int a) {
3347 return (int)(~((int)a));
3348 }
3349
3350
3351
3352 @Test(dataProvider = "intUnaryOpProvider")
3353 static void NOTIntMaxVectorTests(IntFunction<int[]> fa) {
3354 int[] a = fa.apply(SPECIES.length());
3355 int[] r = fr.apply(SPECIES.length());
3356
3357 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3358 for (int i = 0; i < a.length; i += SPECIES.length()) {
3359 IntVector av = IntVector.fromArray(SPECIES, a, i);
3360 av.lanewise(VectorOperators.NOT).intoArray(r, i);
3361 }
3362 }
3363
3364 assertArraysEquals(a, r, IntMaxVectorTests::NOT);
3365 }
3366
3367
3368
3369 @Test(dataProvider = "intUnaryOpMaskProvider")
3370 static void NOTMaskedIntMaxVectorTests(IntFunction<int[]> fa,
3371 IntFunction<boolean[]> fm) {
3372 int[] a = fa.apply(SPECIES.length());
3373 int[] r = fr.apply(SPECIES.length());
3374 boolean[] mask = fm.apply(SPECIES.length());
3375 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3376
3377 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3378 for (int i = 0; i < a.length; i += SPECIES.length()) {
3379 IntVector av = IntVector.fromArray(SPECIES, a, i);
3380 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
3381 }
3382 }
3383
3384 assertArraysEquals(a, r, mask, IntMaxVectorTests::NOT);
|
229
230 interface FBinMaskOp {
231 int apply(int a, int b, boolean m);
232
233 static FBinMaskOp lift(FBinOp f) {
234 return (a, b, m) -> m ? f.apply(a, b) : a;
235 }
236 }
237
238 static void assertArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
239 int i = 0;
240 try {
241 for (; i < a.length; i++) {
242 Assert.assertEquals(r[i], f.apply(a[i], b[i]));
243 }
244 } catch (AssertionError e) {
245 Assert.assertEquals(r[i], f.apply(a[i], b[i]), "(" + a[i] + ", " + b[i] + ") at index #" + i);
246 }
247 }
248
249 static void assertBroadcastArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
250 int i = 0;
251 try {
252 for (; i < a.length; i++) {
253 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]));
254 }
255 } catch (AssertionError e) {
256 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()]), "(" + a[i] + ", " + b[(i / SPECIES.length()) * SPECIES.length()] + ") at index #" + i);
257 }
258 }
259
260 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
261 assertArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
262 }
263
264 static void assertArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
265 int i = 0;
266 try {
267 for (; i < a.length; i++) {
268 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]));
269 }
270 } catch (AssertionError err) {
271 Assert.assertEquals(r[i], f.apply(a[i], b[i], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[i] + ", mask = " + mask[i % SPECIES.length()]);
272 }
273 }
274
275 static void assertBroadcastArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
276 assertBroadcastArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
277 }
278
279 static void assertBroadcastArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
280 int i = 0;
281 try {
282 for (; i < a.length; i++) {
283 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]));
284 }
285 } catch (AssertionError err) {
286 Assert.assertEquals(r[i], f.apply(a[i], b[(i / SPECIES.length()) * SPECIES.length()], mask[i % SPECIES.length()]), "at index #" + i + ", input1 = " + a[i] + ", input2 = " + b[(i / SPECIES.length()) * SPECIES.length()] + ", mask = " + mask[i % SPECIES.length()]);
287 }
288 }
289
290 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, FBinOp f) {
291 int i = 0;
292 int j = 0;
293 try {
294 for (; j < a.length; j += SPECIES.length()) {
295 for (i = 0; i < SPECIES.length(); i++) {
296 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]));
297 }
298 }
299 } catch (AssertionError e) {
300 Assert.assertEquals(r[i+j], f.apply(a[i+j], b[j]), "at index #" + i + ", " + j);
301 }
302 }
303
304 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinOp f) {
305 assertShiftArraysEquals(a, b, r, mask, FBinMaskOp.lift(f));
306 }
307
308 static void assertShiftArraysEquals(int[] a, int[] b, int[] r, boolean[] mask, FBinMaskOp f) {
309 int i = 0;
1388 static int OR(int a, int b) {
1389 return (int)(a | b);
1390 }
1391
1392 @Test(dataProvider = "intBinaryOpProvider")
1393 static void ORIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1394 int[] a = fa.apply(SPECIES.length());
1395 int[] b = fb.apply(SPECIES.length());
1396 int[] r = fr.apply(SPECIES.length());
1397
1398 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1399 for (int i = 0; i < a.length; i += SPECIES.length()) {
1400 IntVector av = IntVector.fromArray(SPECIES, a, i);
1401 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1402 av.lanewise(VectorOperators.OR, bv).intoArray(r, i);
1403 }
1404 }
1405
1406 assertArraysEquals(a, b, r, IntMaxVectorTests::OR);
1407 }
1408 static int or(int a, int b) {
1409 return (int)(a | b);
1410 }
1411
1412 @Test(dataProvider = "intBinaryOpProvider")
1413 static void orIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1414 int[] a = fa.apply(SPECIES.length());
1415 int[] b = fb.apply(SPECIES.length());
1416 int[] r = fr.apply(SPECIES.length());
1417
1418 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1419 for (int i = 0; i < a.length; i += SPECIES.length()) {
1420 IntVector av = IntVector.fromArray(SPECIES, a, i);
1421 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1422 av.or(bv).intoArray(r, i);
1423 }
1424 }
1425
1426 assertArraysEquals(a, b, r, IntMaxVectorTests::or);
1427 }
1428
1429
1430
1431 @Test(dataProvider = "intBinaryOpMaskProvider")
1432 static void ORIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1433 IntFunction<boolean[]> fm) {
1434 int[] a = fa.apply(SPECIES.length());
1435 int[] b = fb.apply(SPECIES.length());
1436 int[] r = fr.apply(SPECIES.length());
1437 boolean[] mask = fm.apply(SPECIES.length());
1438 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1439
1440 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1441 for (int i = 0; i < a.length; i += SPECIES.length()) {
1442 IntVector av = IntVector.fromArray(SPECIES, a, i);
1443 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1444 av.lanewise(VectorOperators.OR, bv, vmask).intoArray(r, i);
1445 }
1446 }
1447
1476 static void XORIntMaxVectorTestsMasked(IntFunction<int[]> fa, IntFunction<int[]> fb,
1477 IntFunction<boolean[]> fm) {
1478 int[] a = fa.apply(SPECIES.length());
1479 int[] b = fb.apply(SPECIES.length());
1480 int[] r = fr.apply(SPECIES.length());
1481 boolean[] mask = fm.apply(SPECIES.length());
1482 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1483
1484 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1485 for (int i = 0; i < a.length; i += SPECIES.length()) {
1486 IntVector av = IntVector.fromArray(SPECIES, a, i);
1487 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1488 av.lanewise(VectorOperators.XOR, bv, vmask).intoArray(r, i);
1489 }
1490 }
1491
1492 assertArraysEquals(a, b, r, mask, IntMaxVectorTests::XOR);
1493 }
1494
1495
1496 @Test(dataProvider = "intBinaryOpProvider")
1497 static void addIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1498 int[] a = fa.apply(SPECIES.length());
1499 int[] b = fb.apply(SPECIES.length());
1500 int[] r = fr.apply(SPECIES.length());
1501
1502 for (int i = 0; i < a.length; i += SPECIES.length()) {
1503 IntVector av = IntVector.fromArray(SPECIES, a, i);
1504 av.add(b[i]).intoArray(r, i);
1505 }
1506
1507 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::add);
1508 }
1509
1510 @Test(dataProvider = "intBinaryOpMaskProvider")
1511 static void addIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1512 IntFunction<boolean[]> fm) {
1513 int[] a = fa.apply(SPECIES.length());
1514 int[] b = fb.apply(SPECIES.length());
1515 int[] r = fr.apply(SPECIES.length());
1516 boolean[] mask = fm.apply(SPECIES.length());
1517 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1518
1519 for (int i = 0; i < a.length; i += SPECIES.length()) {
1520 IntVector av = IntVector.fromArray(SPECIES, a, i);
1521 av.add(b[i], vmask).intoArray(r, i);
1522 }
1523
1524 assertBroadcastArraysEquals(a, b, r, mask, IntMaxVectorTests::add);
1525 }
1526
1527 @Test(dataProvider = "intBinaryOpProvider")
1528 static void subIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1529 int[] a = fa.apply(SPECIES.length());
1530 int[] b = fb.apply(SPECIES.length());
1531 int[] r = fr.apply(SPECIES.length());
1532
1533 for (int i = 0; i < a.length; i += SPECIES.length()) {
1534 IntVector av = IntVector.fromArray(SPECIES, a, i);
1535 av.sub(b[i]).intoArray(r, i);
1536 }
1537
1538 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::sub);
1539 }
1540
1541 @Test(dataProvider = "intBinaryOpMaskProvider")
1542 static void subIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1543 IntFunction<boolean[]> fm) {
1544 int[] a = fa.apply(SPECIES.length());
1545 int[] b = fb.apply(SPECIES.length());
1546 int[] r = fr.apply(SPECIES.length());
1547 boolean[] mask = fm.apply(SPECIES.length());
1548 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1549
1550 for (int i = 0; i < a.length; i += SPECIES.length()) {
1551 IntVector av = IntVector.fromArray(SPECIES, a, i);
1552 av.sub(b[i], vmask).intoArray(r, i);
1553 }
1554
1555 assertBroadcastArraysEquals(a, b, r, mask, IntMaxVectorTests::sub);
1556 }
1557
1558 @Test(dataProvider = "intBinaryOpProvider")
1559 static void mulIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1560 int[] a = fa.apply(SPECIES.length());
1561 int[] b = fb.apply(SPECIES.length());
1562 int[] r = fr.apply(SPECIES.length());
1563
1564 for (int i = 0; i < a.length; i += SPECIES.length()) {
1565 IntVector av = IntVector.fromArray(SPECIES, a, i);
1566 av.mul(b[i]).intoArray(r, i);
1567 }
1568
1569 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::mul);
1570 }
1571
1572 @Test(dataProvider = "intBinaryOpMaskProvider")
1573 static void mulIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1574 IntFunction<boolean[]> fm) {
1575 int[] a = fa.apply(SPECIES.length());
1576 int[] b = fb.apply(SPECIES.length());
1577 int[] r = fr.apply(SPECIES.length());
1578 boolean[] mask = fm.apply(SPECIES.length());
1579 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1580
1581 for (int i = 0; i < a.length; i += SPECIES.length()) {
1582 IntVector av = IntVector.fromArray(SPECIES, a, i);
1583 av.mul(b[i], vmask).intoArray(r, i);
1584 }
1585
1586 assertBroadcastArraysEquals(a, b, r, mask, IntMaxVectorTests::mul);
1587 }
1588
1589
1590
1591
1592 @Test(dataProvider = "intBinaryOpProvider")
1593 static void divIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1594 int[] a = fa.apply(SPECIES.length());
1595 int[] b = fb.apply(SPECIES.length());
1596 int[] r = fr.apply(SPECIES.length());
1597
1598 replaceZero(b, (int) 1);
1599
1600 for (int i = 0; i < a.length; i += SPECIES.length()) {
1601 IntVector av = IntVector.fromArray(SPECIES, a, i);
1602 av.div(b[i]).intoArray(r, i);
1603 }
1604
1605 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::div);
1606 }
1607
1608
1609
1610 @Test(dataProvider = "intBinaryOpMaskProvider")
1611 static void divIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1612 IntFunction<boolean[]> fm) {
1613 int[] a = fa.apply(SPECIES.length());
1614 int[] b = fb.apply(SPECIES.length());
1615 int[] r = fr.apply(SPECIES.length());
1616 boolean[] mask = fm.apply(SPECIES.length());
1617 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1618
1619 replaceZero(b, (int) 1);
1620
1621 for (int i = 0; i < a.length; i += SPECIES.length()) {
1622 IntVector av = IntVector.fromArray(SPECIES, a, i);
1623 av.div(b[i], vmask).intoArray(r, i);
1624 }
1625
1626 assertBroadcastArraysEquals(a, b, r, mask, IntMaxVectorTests::div);
1627 }
1628
1629
1630
1631 @Test(dataProvider = "intBinaryOpProvider")
1632 static void ORIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1633 int[] a = fa.apply(SPECIES.length());
1634 int[] b = fb.apply(SPECIES.length());
1635 int[] r = fr.apply(SPECIES.length());
1636
1637 for (int i = 0; i < a.length; i += SPECIES.length()) {
1638 IntVector av = IntVector.fromArray(SPECIES, a, i);
1639 av.lanewise(VectorOperators.OR, b[i]).intoArray(r, i);
1640 }
1641
1642 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::OR);
1643 }
1644
1645 @Test(dataProvider = "intBinaryOpProvider")
1646 static void orIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1647 int[] a = fa.apply(SPECIES.length());
1648 int[] b = fb.apply(SPECIES.length());
1649 int[] r = fr.apply(SPECIES.length());
1650
1651 for (int i = 0; i < a.length; i += SPECIES.length()) {
1652 IntVector av = IntVector.fromArray(SPECIES, a, i);
1653 av.or(b[i]).intoArray(r, i);
1654 }
1655
1656 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::or);
1657 }
1658
1659
1660
1661 @Test(dataProvider = "intBinaryOpMaskProvider")
1662 static void ORIntMaxVectorTestsBroadcastMaskedSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb,
1663 IntFunction<boolean[]> fm) {
1664 int[] a = fa.apply(SPECIES.length());
1665 int[] b = fb.apply(SPECIES.length());
1666 int[] r = fr.apply(SPECIES.length());
1667 boolean[] mask = fm.apply(SPECIES.length());
1668 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
1669
1670 for (int i = 0; i < a.length; i += SPECIES.length()) {
1671 IntVector av = IntVector.fromArray(SPECIES, a, i);
1672 av.lanewise(VectorOperators.OR, b[i], vmask).intoArray(r, i);
1673 }
1674
1675 assertBroadcastArraysEquals(a, b, r, mask, IntMaxVectorTests::OR);
1676 }
1677
1678
1679 static int LSHL(int a, int b) {
1680 return (int)((a << b));
1681 }
1682
1683 @Test(dataProvider = "intBinaryOpProvider")
1684 static void LSHLIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
1685 int[] a = fa.apply(SPECIES.length());
1686 int[] b = fb.apply(SPECIES.length());
1687 int[] r = fr.apply(SPECIES.length());
1688
1689 for (int ic = 0; ic < INVOC_COUNT; ic++) {
1690 for (int i = 0; i < a.length; i += SPECIES.length()) {
1691 IntVector av = IntVector.fromArray(SPECIES, a, i);
1692 IntVector bv = IntVector.fromArray(SPECIES, b, i);
1693 av.lanewise(VectorOperators.LSHL, bv).intoArray(r, i);
1694 }
1695 }
1696
1697 assertArraysEquals(a, b, r, IntMaxVectorTests::LSHL);
1698 }
2021 return (int)(Math.max(a, b));
2022 }
2023
2024 @Test(dataProvider = "intBinaryOpProvider")
2025 static void maxIntMaxVectorTests(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2026 int[] a = fa.apply(SPECIES.length());
2027 int[] b = fb.apply(SPECIES.length());
2028 int[] r = fr.apply(SPECIES.length());
2029
2030 for (int ic = 0; ic < INVOC_COUNT; ic++) {
2031 for (int i = 0; i < a.length; i += SPECIES.length()) {
2032 IntVector av = IntVector.fromArray(SPECIES, a, i);
2033 IntVector bv = IntVector.fromArray(SPECIES, b, i);
2034 av.max(bv).intoArray(r, i);
2035 }
2036 }
2037
2038 assertArraysEquals(a, b, r, IntMaxVectorTests::max);
2039 }
2040
2041 @Test(dataProvider = "intBinaryOpProvider")
2042 static void MINIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2043 int[] a = fa.apply(SPECIES.length());
2044 int[] b = fb.apply(SPECIES.length());
2045 int[] r = fr.apply(SPECIES.length());
2046
2047 for (int i = 0; i < a.length; i += SPECIES.length()) {
2048 IntVector av = IntVector.fromArray(SPECIES, a, i);
2049 av.lanewise(VectorOperators.MIN, b[i]).intoArray(r, i);
2050 }
2051
2052 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::MIN);
2053 }
2054
2055 @Test(dataProvider = "intBinaryOpProvider")
2056 static void minIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2057 int[] a = fa.apply(SPECIES.length());
2058 int[] b = fb.apply(SPECIES.length());
2059 int[] r = fr.apply(SPECIES.length());
2060
2061 for (int i = 0; i < a.length; i += SPECIES.length()) {
2062 IntVector av = IntVector.fromArray(SPECIES, a, i);
2063 av.min(b[i]).intoArray(r, i);
2064 }
2065
2066 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::min);
2067 }
2068
2069 @Test(dataProvider = "intBinaryOpProvider")
2070 static void MAXIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2071 int[] a = fa.apply(SPECIES.length());
2072 int[] b = fb.apply(SPECIES.length());
2073 int[] r = fr.apply(SPECIES.length());
2074
2075 for (int i = 0; i < a.length; i += SPECIES.length()) {
2076 IntVector av = IntVector.fromArray(SPECIES, a, i);
2077 av.lanewise(VectorOperators.MAX, b[i]).intoArray(r, i);
2078 }
2079
2080 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::MAX);
2081 }
2082
2083 @Test(dataProvider = "intBinaryOpProvider")
2084 static void maxIntMaxVectorTestsBroadcastSmokeTest(IntFunction<int[]> fa, IntFunction<int[]> fb) {
2085 int[] a = fa.apply(SPECIES.length());
2086 int[] b = fb.apply(SPECIES.length());
2087 int[] r = fr.apply(SPECIES.length());
2088
2089 for (int i = 0; i < a.length; i += SPECIES.length()) {
2090 IntVector av = IntVector.fromArray(SPECIES, a, i);
2091 av.max(b[i]).intoArray(r, i);
2092 }
2093
2094 assertBroadcastArraysEquals(a, b, r, IntMaxVectorTests::max);
2095 }
2096
2097 static int AND(int[] a, int idx) {
2098 int res = -1;
2099 for (int i = idx; i < (idx + SPECIES.length()); i++) {
2100 res &= a[i];
2101 }
2102
2103 return res;
2104 }
2105
2106 static int AND(int[] a) {
2107 int res = -1;
2108 for (int i = 0; i < a.length; i += SPECIES.length()) {
2109 int tmp = -1;
2110 for (int j = 0; j < SPECIES.length(); j++) {
2111 tmp &= a[i + j];
2112 }
2113 res &= tmp;
2114 }
2115
2116 return res;
3521 boolean[] mask = fm.apply(SPECIES.length());
3522 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3523
3524 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3525 for (int i = 0; i < a.length; i += SPECIES.length()) {
3526 IntVector av = IntVector.fromArray(SPECIES, a, i);
3527 IntVector bv = IntVector.fromArray(SPECIES, b, i);
3528 IntVector cv = IntVector.fromArray(SPECIES, c, i);
3529 av.lanewise(VectorOperators.BITWISE_BLEND, bv, cv, vmask).intoArray(r, i);
3530 }
3531 }
3532
3533 assertArraysEquals(a, b, c, r, mask, IntMaxVectorTests::BITWISE_BLEND);
3534 }
3535
3536
3537 static int NEG(int a) {
3538 return (int)(-((int)a));
3539 }
3540
3541 static int neg(int a) {
3542 return (int)(-((int)a));
3543 }
3544
3545 @Test(dataProvider = "intUnaryOpProvider")
3546 static void NEGIntMaxVectorTests(IntFunction<int[]> fa) {
3547 int[] a = fa.apply(SPECIES.length());
3548 int[] r = fr.apply(SPECIES.length());
3549
3550 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3551 for (int i = 0; i < a.length; i += SPECIES.length()) {
3552 IntVector av = IntVector.fromArray(SPECIES, a, i);
3553 av.lanewise(VectorOperators.NEG).intoArray(r, i);
3554 }
3555 }
3556
3557 assertArraysEquals(a, r, IntMaxVectorTests::NEG);
3558 }
3559
3560 @Test(dataProvider = "intUnaryOpProvider")
3561 static void negIntMaxVectorTests(IntFunction<int[]> fa) {
3562 int[] a = fa.apply(SPECIES.length());
3563 int[] r = fr.apply(SPECIES.length());
3564
3565 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3566 for (int i = 0; i < a.length; i += SPECIES.length()) {
3567 IntVector av = IntVector.fromArray(SPECIES, a, i);
3568 av.neg().intoArray(r, i);
3569 }
3570 }
3571
3572 assertArraysEquals(a, r, IntMaxVectorTests::neg);
3573 }
3574
3575 @Test(dataProvider = "intUnaryOpMaskProvider")
3576 static void NEGMaskedIntMaxVectorTests(IntFunction<int[]> fa,
3577 IntFunction<boolean[]> fm) {
3578 int[] a = fa.apply(SPECIES.length());
3579 int[] r = fr.apply(SPECIES.length());
3580 boolean[] mask = fm.apply(SPECIES.length());
3581 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3582
3583 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3584 for (int i = 0; i < a.length; i += SPECIES.length()) {
3585 IntVector av = IntVector.fromArray(SPECIES, a, i);
3586 av.lanewise(VectorOperators.NEG, vmask).intoArray(r, i);
3587 }
3588 }
3589
3590 assertArraysEquals(a, r, mask, IntMaxVectorTests::NEG);
3591 }
3592
3593 static int ABS(int a) {
3594 return (int)(Math.abs((int)a));
3634 int[] a = fa.apply(SPECIES.length());
3635 int[] r = fr.apply(SPECIES.length());
3636 boolean[] mask = fm.apply(SPECIES.length());
3637 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3638
3639 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3640 for (int i = 0; i < a.length; i += SPECIES.length()) {
3641 IntVector av = IntVector.fromArray(SPECIES, a, i);
3642 av.lanewise(VectorOperators.ABS, vmask).intoArray(r, i);
3643 }
3644 }
3645
3646 assertArraysEquals(a, r, mask, IntMaxVectorTests::ABS);
3647 }
3648
3649
3650 static int NOT(int a) {
3651 return (int)(~((int)a));
3652 }
3653
3654 static int not(int a) {
3655 return (int)(~((int)a));
3656 }
3657
3658
3659
3660 @Test(dataProvider = "intUnaryOpProvider")
3661 static void NOTIntMaxVectorTests(IntFunction<int[]> fa) {
3662 int[] a = fa.apply(SPECIES.length());
3663 int[] r = fr.apply(SPECIES.length());
3664
3665 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3666 for (int i = 0; i < a.length; i += SPECIES.length()) {
3667 IntVector av = IntVector.fromArray(SPECIES, a, i);
3668 av.lanewise(VectorOperators.NOT).intoArray(r, i);
3669 }
3670 }
3671
3672 assertArraysEquals(a, r, IntMaxVectorTests::NOT);
3673 }
3674
3675 @Test(dataProvider = "intUnaryOpProvider")
3676 static void notIntMaxVectorTests(IntFunction<int[]> fa) {
3677 int[] a = fa.apply(SPECIES.length());
3678 int[] r = fr.apply(SPECIES.length());
3679
3680 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3681 for (int i = 0; i < a.length; i += SPECIES.length()) {
3682 IntVector av = IntVector.fromArray(SPECIES, a, i);
3683 av.not().intoArray(r, i);
3684 }
3685 }
3686
3687 assertArraysEquals(a, r, IntMaxVectorTests::not);
3688 }
3689
3690
3691
3692 @Test(dataProvider = "intUnaryOpMaskProvider")
3693 static void NOTMaskedIntMaxVectorTests(IntFunction<int[]> fa,
3694 IntFunction<boolean[]> fm) {
3695 int[] a = fa.apply(SPECIES.length());
3696 int[] r = fr.apply(SPECIES.length());
3697 boolean[] mask = fm.apply(SPECIES.length());
3698 VectorMask<Integer> vmask = VectorMask.fromArray(SPECIES, mask, 0);
3699
3700 for (int ic = 0; ic < INVOC_COUNT; ic++) {
3701 for (int i = 0; i < a.length; i += SPECIES.length()) {
3702 IntVector av = IntVector.fromArray(SPECIES, a, i);
3703 av.lanewise(VectorOperators.NOT, vmask).intoArray(r, i);
3704 }
3705 }
3706
3707 assertArraysEquals(a, r, mask, IntMaxVectorTests::NOT);
|