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