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 ORInt256VectorTests(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, Int256VectorTests::OR);
1376 }
1377
1378
1379
1380 @Test(dataProvider = "intBinaryOpMaskProvider")
1381 static void ORInt256VectorTestsMasked(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 XORInt256VectorTestsMasked(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, Int256VectorTests::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 LSHLInt256VectorTests(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, Int256VectorTests::LSHL);
1464 }
1787 return (int)(Math.max(a, b));
1788 }
1789
1790 @Test(dataProvider = "intBinaryOpProvider")
1791 static void maxInt256VectorTests(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, Int256VectorTests::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, Int256VectorTests::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 NEGInt256VectorTests(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, Int256VectorTests::NEG);
3264 }
3265
3266 @Test(dataProvider = "intUnaryOpMaskProvider")
3267 static void NEGMaskedInt256VectorTests(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, Int256VectorTests::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, Int256VectorTests::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 NOTInt256VectorTests(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, Int256VectorTests::NOT);
3360 }
3361
3362
3363
3364 @Test(dataProvider = "intUnaryOpMaskProvider")
3365 static void NOTMaskedInt256VectorTests(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, Int256VectorTests::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 ORInt256VectorTests(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, Int256VectorTests::OR);
1406 }
1407 static int or(int a, int b) {
1408 return (int)(a | b);
1409 }
1410
1411 @Test(dataProvider = "intBinaryOpProvider")
1412 static void orInt256VectorTests(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, Int256VectorTests::or);
1426 }
1427
1428
1429
1430 @Test(dataProvider = "intBinaryOpMaskProvider")
1431 static void ORInt256VectorTestsMasked(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 XORInt256VectorTestsMasked(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, Int256VectorTests::XOR);
1492 }
1493
1494
1495 @Test(dataProvider = "intBinaryOpProvider")
1496 static void addInt256VectorTestsBroadcastSmokeTest(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, Int256VectorTests::add);
1507 }
1508
1509 @Test(dataProvider = "intBinaryOpMaskProvider")
1510 static void addInt256VectorTestsBroadcastMaskedSmokeTest(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, Int256VectorTests::add);
1524 }
1525
1526 @Test(dataProvider = "intBinaryOpProvider")
1527 static void subInt256VectorTestsBroadcastSmokeTest(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, Int256VectorTests::sub);
1538 }
1539
1540 @Test(dataProvider = "intBinaryOpMaskProvider")
1541 static void subInt256VectorTestsBroadcastMaskedSmokeTest(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, Int256VectorTests::sub);
1555 }
1556
1557 @Test(dataProvider = "intBinaryOpProvider")
1558 static void mulInt256VectorTestsBroadcastSmokeTest(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, Int256VectorTests::mul);
1569 }
1570
1571 @Test(dataProvider = "intBinaryOpMaskProvider")
1572 static void mulInt256VectorTestsBroadcastMaskedSmokeTest(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, Int256VectorTests::mul);
1586 }
1587
1588
1589
1590
1591 @Test(dataProvider = "intBinaryOpProvider")
1592 static void divInt256VectorTestsBroadcastSmokeTest(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, Int256VectorTests::div);
1605 }
1606
1607
1608
1609 @Test(dataProvider = "intBinaryOpMaskProvider")
1610 static void divInt256VectorTestsBroadcastMaskedSmokeTest(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, Int256VectorTests::div);
1626 }
1627
1628
1629
1630 @Test(dataProvider = "intBinaryOpProvider")
1631 static void ORInt256VectorTestsBroadcastSmokeTest(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, Int256VectorTests::OR);
1642 }
1643
1644 @Test(dataProvider = "intBinaryOpProvider")
1645 static void orInt256VectorTestsBroadcastSmokeTest(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, Int256VectorTests::or);
1656 }
1657
1658
1659
1660 @Test(dataProvider = "intBinaryOpMaskProvider")
1661 static void ORInt256VectorTestsBroadcastMaskedSmokeTest(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, Int256VectorTests::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 LSHLInt256VectorTests(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, Int256VectorTests::LSHL);
1697 }
2020 return (int)(Math.max(a, b));
2021 }
2022
2023 @Test(dataProvider = "intBinaryOpProvider")
2024 static void maxInt256VectorTests(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, Int256VectorTests::max);
2038 }
2039
2040 @Test(dataProvider = "intBinaryOpProvider")
2041 static void MINInt256VectorTestsBroadcastSmokeTest(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, Int256VectorTests::MIN);
2052 }
2053
2054 @Test(dataProvider = "intBinaryOpProvider")
2055 static void minInt256VectorTestsBroadcastSmokeTest(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, Int256VectorTests::min);
2066 }
2067
2068 @Test(dataProvider = "intBinaryOpProvider")
2069 static void MAXInt256VectorTestsBroadcastSmokeTest(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, Int256VectorTests::MAX);
2080 }
2081
2082 @Test(dataProvider = "intBinaryOpProvider")
2083 static void maxInt256VectorTestsBroadcastSmokeTest(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, Int256VectorTests::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, Int256VectorTests::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 NEGInt256VectorTests(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, Int256VectorTests::NEG);
3557 }
3558
3559 @Test(dataProvider = "intUnaryOpProvider")
3560 static void negInt256VectorTests(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, Int256VectorTests::neg);
3572 }
3573
3574 @Test(dataProvider = "intUnaryOpMaskProvider")
3575 static void NEGMaskedInt256VectorTests(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, Int256VectorTests::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, Int256VectorTests::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 NOTInt256VectorTests(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, Int256VectorTests::NOT);
3672 }
3673
3674 @Test(dataProvider = "intUnaryOpProvider")
3675 static void notInt256VectorTests(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, Int256VectorTests::not);
3687 }
3688
3689
3690
3691 @Test(dataProvider = "intUnaryOpMaskProvider")
3692 static void NOTMaskedInt256VectorTests(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, Int256VectorTests::NOT);
|