Lines Matching refs:args
1098 static public void computeAbs(TestAbs.ArgumentsCharUchar args) {
1099 args.out = (byte)Math.abs(args.inV);
1102 static public void computeAbs(TestAbs.ArgumentsShortUshort args) {
1103 args.out = (short)Math.abs(args.inV);
1106 static public void computeAbs(TestAbs.ArgumentsIntUint args) {
1107 args.out = Math.abs(args.inV);
1110 static public void computeAcos(TestAcos.ArgumentsHalfHalf args, Target t) {
1112 args.out = acos(args.inVDouble, t);
1115 static public void computeAcos(TestAcos.ArgumentsFloatFloat args, Target t) {
1117 args.out = acos(args.inV, t);
1120 static public void computeAcosh(TestAcosh.ArgumentsHalfHalf args, Target t) {
1122 args.out = acosh(args.inVDouble, t);
1125 static public void computeAcosh(TestAcosh.ArgumentsFloatFloat args, Target t) {
1127 args.out = acosh(args.inV, t);
1130 static public void computeAcospi(TestAcospi.ArgumentsHalfHalf args, Target t) {
1132 args.out = acospi(args.inVDouble, t);
1135 static public void computeAcospi(TestAcospi.ArgumentsFloatFloat args, Target t) {
1137 args.out = acospi(args.inV, t);
1140 static public void computeAsin(TestAsin.ArgumentsHalfHalf args, Target t) {
1142 args.out = asin(args.inVDouble, t);
1145 static public void computeAsin(TestAsin.ArgumentsFloatFloat args, Target t) {
1147 args.out = asin(args.inV, t);
1150 static public void computeAsinh(TestAsinh.ArgumentsHalfHalf args, Target t) {
1152 args.out = asinh(args.inVDouble, t);
1155 static public void computeAsinh(TestAsinh.ArgumentsFloatFloat args, Target t) {
1157 args.out = asinh(args.inV, t);
1160 static public void computeAsinpi(TestAsinpi.ArgumentsHalfHalf args, Target t) {
1162 args.out = asinpi(args.inVDouble, t);
1165 static public void computeAsinpi(TestAsinpi.ArgumentsFloatFloat args, Target t) {
1167 args.out = asinpi(args.inV, t);
1170 static public void computeAtan(TestAtan.ArgumentsHalfHalf args, Target t) {
1172 args.out = atan(args.inVDouble, t);
1175 static public void computeAtan(TestAtan.ArgumentsFloatFloat args, Target t) {
1177 args.out = atan(args.inV, t);
1180 static public void computeAtanh(TestAtanh.ArgumentsHalfHalf args, Target t) {
1182 args.out = atanh(args.inVDouble, t);
1185 static public void computeAtanh(TestAtanh.ArgumentsFloatFloat args, Target t) {
1187 args.out = atanh(args.inV, t);
1190 static public void computeAtanpi(TestAtanpi.ArgumentsHalfHalf args, Target t) {
1192 args.out = atanpi(args.inVDouble, t);
1195 static public void computeAtanpi(TestAtanpi.ArgumentsFloatFloat args, Target t) {
1197 args.out = atanpi(args.inV, t);
1200 static public void computeAtan2(TestAtan2.ArgumentsHalfHalfHalf args, Target t) {
1202 args.out = atan2(args.inNumeratorDouble, args.inDenominatorDouble, t);
1205 static public void computeAtan2(TestAtan2.ArgumentsFloatFloatFloat args, Target t) {
1207 args.out = atan2(args.inNumerator, args.inDenominator, t);
1210 static public void computeAtan2pi(TestAtan2pi.ArgumentsHalfHalfHalf args, Target t) {
1212 args.out = atan2pi(args.inNumeratorDouble, args.inDenominatorDouble, t);
1215 static public void computeAtan2pi(TestAtan2pi.ArgumentsFloatFloatFloat args, Target t) {
1217 args.out = atan2pi(args.inNumerator, args.inDenominator, t);
1220 static public void computeCbrt(TestCbrt.ArgumentsHalfHalf args, Target t) {
1222 args.out = cbrt(args.inVDouble, t);
1225 static public void computeCbrt(TestCbrt.ArgumentsFloatFloat args, Target t) {
1227 args.out = cbrt(args.inV, t);
1230 static public void computeCeil(TestCeil.ArgumentsHalfHalf args, Target t) {
1232 Target.Floaty in = t.newFloaty(args.inVDouble);
1233 args.out = t.newFloaty(
1239 static public void computeCeil(TestCeil.ArgumentsFloatFloat args, Target t) {
1241 Target.Floaty in = t.new32(args.inV);
1242 args.out = t.new32(
1248 static public void computeClamp(TestClamp.ArgumentsCharCharCharChar args) {
1249 args.out = minI8(args.inMaxValue, maxI8(args.inValue, args.inMinValue));
1252 static public void computeClamp(TestClamp.ArgumentsUcharUcharUcharUchar args) {
1253 args.out = minU8(args.inMaxValue, maxU8(args.inValue, args.inMinValue));
1256 static public void computeClamp(TestClamp.ArgumentsShortShortShortShort args) {
1257 args.out = minI16(args.inMaxValue, maxI16(args.inValue, args.inMinValue));
1260 static public void computeClamp(TestClamp.ArgumentsUshortUshortUshortUshort args) {
1261 args.out = minU16(args.inMaxValue, maxU16(args.inValue, args.inMinValue));
1264 static public void computeClamp(TestClamp.ArgumentsIntIntIntInt args) {
1265 args.out = minI32(args.inMaxValue, maxI32(args.inValue, args.inMinValue));
1268 static public void computeClamp(TestClamp.ArgumentsUintUintUintUint args) {
1269 args.out = minU32(args.inMaxValue, maxU32(args.inValue, args.inMinValue));
1272 static public void computeClamp(TestClamp.ArgumentsHalfHalfHalfHalf args, Target t) {
1274 args.out = clamp(args.inValueDouble, args.inMinValueDouble, args.inMaxValueDouble, t);
1277 static public void computeClamp(TestClamp.ArgumentsFloatFloatFloatFloat args, Target t) {
1279 args.out = t.new32(Math.min(args.inMaxValue,
1280 Math.max(args.inValue, args.inMinValue)));
1283 static public void computeClamp(TestClamp.ArgumentsLongLongLongLong args) {
1284 args.out = minI64(args.inMaxValue, maxI64(args.inValue, args.inMinValue));
1287 static public void computeClamp(TestClamp.ArgumentsUlongUlongUlongUlong args) {
1288 args.out = minU64(args.inMaxValue, maxU64(args.inValue, args.inMinValue));
1291 static public void computeClz(TestClz.ArgumentsCharChar args) {
1292 int x = args.inValue;
1293 args.out = (byte) (Integer.numberOfLeadingZeros(x & 0xff) - 24);
1296 static public void computeClz(TestClz.ArgumentsUcharUchar args) {
1297 int x = args.inValue;
1298 args.out = (byte) (Integer.numberOfLeadingZeros(x & 0xff) - 24);
1301 static public void computeClz(TestClz.ArgumentsShortShort args) {
1302 args.out = (short) (Integer.numberOfLeadingZeros(args.inValue & 0xffff) - 16);
1305 static public void computeClz(TestClz.ArgumentsUshortUshort args) {
1306 args.out = (short) (Integer.numberOfLeadingZeros(args.inValue & 0xffff) - 16);
1309 static public void computeClz(TestClz.ArgumentsIntInt args) {
1310 args.out = (int) Integer.numberOfLeadingZeros(args.inValue);
1313 static public void computeClz(TestClz.ArgumentsUintUint args) {
1314 args.out = (int) Integer.numberOfLeadingZeros(args.inValue);
1318 static public void computeConvert(TestConvert.ArgumentsCharChar args) {
1319 args.out = convertCharToChar(args.inV);
1321 static public void computeConvert(TestConvert.ArgumentsCharUchar args) {
1322 args.out = convertCharToUchar(args.inV);
1324 static public void computeConvert(TestConvert.ArgumentsCharShort args) {
1325 args.out = convertCharToShort(args.inV);
1327 static public void computeConvert(TestConvert.ArgumentsCharUshort args) {
1328 args.out = convertCharToUshort(args.inV);
1330 static public void computeConvert(TestConvert.ArgumentsCharInt args) {
1331 args.out = convertCharToInt(args.inV);
1333 static public void computeConvert(TestConvert.ArgumentsCharUint args) {
1334 args.out = convertCharToUint(args.inV);
1336 static public void computeConvert(TestConvert.ArgumentsCharLong args) {
1337 args.out = convertCharToLong(args.inV);
1339 static public void computeConvert(TestConvert.ArgumentsCharUlong args) {
1340 args.out = convertCharToUlong(args.inV);
1342 args, Target t) {
1344 args.out = t.newFloaty(convertCharToDouble(args.inV));
1346 static public void computeConvert(TestConvert.ArgumentsCharFloat args, Target t) {
1348 args.out = t.new32(convertCharToFloat(args.inV));
1350 static public void computeConvert(TestConvert.ArgumentsCharDouble args, Target t) {
1352 args.out = t.new64(convertCharToDouble(args.inV));
1355 static public void computeConvert(TestConvert.ArgumentsUcharChar args) {
1356 args.out = convertUcharToChar(args.inV);
1358 static public void computeConvert(TestConvert.ArgumentsUcharUchar args) {
1359 args.out = convertUcharToUchar(args.inV);
1361 static public void computeConvert(TestConvert.ArgumentsUcharShort args) {
1362 args.out = convertUcharToShort(args.inV);
1364 static public void computeConvert(TestConvert.ArgumentsUcharUshort args) {
1365 args.out = convertUcharToUshort(args.inV);
1367 static public void computeConvert(TestConvert.ArgumentsUcharInt args) {
1368 args.out = convertUcharToInt(args.inV);
1370 static public void computeConvert(TestConvert.ArgumentsUcharUint args) {
1371 args.out = convertUcharToUint(args.inV);
1373 static public void computeConvert(TestConvert.ArgumentsUcharLong args) {
1374 args.out = convertUcharToLong(args.inV);
1376 static public void computeConvert(TestConvert.ArgumentsUcharUlong args) {
1377 args.out = convertUcharToUlong(args.inV);
1379 static public void computeConvert(TestConvert.ArgumentsUcharHalf args, Target t) {
1381 args.out = t.newFloaty(convertUcharToDouble(args.inV));
1383 static public void computeConvert(TestConvert.ArgumentsUcharFloat args, Target t) {
1385 args.out = t.new32(convertUcharToFloat(args.inV));
1387 static public void computeConvert(TestConvert.ArgumentsUcharDouble args, Target t) {
1389 args.out = t.new64(convertUcharToDouble(args.inV));
1392 static public void computeConvert(TestConvert.ArgumentsShortChar args) {
1393 args.out = convertShortToChar(args.inV);
1395 static public void computeConvert(TestConvert.ArgumentsShortUchar args) {
1396 args.out = convertShortToUchar(args.inV);
1398 static public void computeConvert(TestConvert.ArgumentsShortShort args) {
1399 args.out = convertShortToShort(args.inV);
1401 static public void computeConvert(TestConvert.ArgumentsShortUshort args) {
1402 args.out = convertShortToUshort(args.inV);
1404 static public void computeConvert(TestConvert.ArgumentsShortInt args) {
1405 args.out = convertShortToInt(args.inV);
1407 static public void computeConvert(TestConvert.ArgumentsShortUint args) {
1408 args.out = convertShortToUint(args.inV);
1410 static public void computeConvert(TestConvert.ArgumentsShortLong args) {
1411 args.out = convertShortToLong(args.inV);
1413 static public void computeConvert(TestConvert.ArgumentsShortUlong args) {
1414 args.out = convertShortToUlong(args.inV);
1416 static public void computeConvert(TestConvert.ArgumentsShortHalf args, Target t) {
1418 args.out = t.newFloaty(convertShortToDouble(args.inV));
1420 static public void computeConvert(TestConvert.ArgumentsShortFloat args, Target t) {
1422 args.out = t.new32(convertShortToFloat(args.inV));
1424 static public void computeConvert(TestConvert.ArgumentsShortDouble args, Target t) {
1426 args.out = t.new64(convertShortToDouble(args.inV));
1429 static public void computeConvert(TestConvert.ArgumentsUshortChar args) {
1430 args.out = convertUshortToChar(args.inV);
1432 static public void computeConvert(TestConvert.ArgumentsUshortUchar args) {
1433 args.out = convertUshortToUchar(args.inV);
1435 static public void computeConvert(TestConvert.ArgumentsUshortShort args) {
1436 args.out = convertUshortToShort(args.inV);
1438 static public void computeConvert(TestConvert.ArgumentsUshortUshort args) {
1439 args.out = convertUshortToUshort(args.inV);
1441 static public void computeConvert(TestConvert.ArgumentsUshortInt args) {
1442 args.out = convertUshortToInt(args.inV);
1444 static public void computeConvert(TestConvert.ArgumentsUshortUint args) {
1445 args.out = convertUshortToUint(args.inV);
1447 static public void computeConvert(TestConvert.ArgumentsUshortLong args) {
1448 args.out = convertUshortToLong(args.inV);
1450 static public void computeConvert(TestConvert.ArgumentsUshortUlong args) {
1451 args.out = convertUshortToUlong(args.inV);
1453 static public void computeConvert(TestConvert.ArgumentsUshortHalf args, Target t) {
1455 args.out = t.newFloaty(convertUshortToDouble(args.inV));
1457 static public void computeConvert(TestConvert.ArgumentsUshortFloat args, Target t) {
1459 args.out = t.new32(convertUshortToFloat(args.inV));
1461 static public void computeConvert(TestConvert.ArgumentsUshortDouble args, Target t) {
1463 args.out = t.new64(convertUshortToDouble(args.inV));
1466 static public void computeConvert(TestConvert.ArgumentsIntChar args) {
1467 args.out = convertIntToChar(args.inV);
1469 static public void computeConvert(TestConvert.ArgumentsIntUchar args) {
1470 args.out = convertIntToUchar(args.inV);
1472 static public void computeConvert(TestConvert.ArgumentsIntShort args) {
1473 args.out = convertIntToShort(args.inV);
1475 static public void computeConvert(TestConvert.ArgumentsIntUshort args) {
1476 args.out = convertIntToUshort(args.inV);
1478 static public void computeConvert(TestConvert.ArgumentsIntInt args) {
1479 args.out = convertIntToInt(args.inV);
1481 static public void computeConvert(TestConvert.ArgumentsIntUint args) {
1482 args.out = convertIntToUint(args.inV);
1484 static public void computeConvert(TestConvert.ArgumentsIntLong args) {
1485 args.out = convertIntToLong(args.inV);
1487 static public void computeConvert(TestConvert.ArgumentsIntUlong args) {
1488 args.out = convertIntToUlong(args.inV);
1490 static public void computeConvert(TestConvert.ArgumentsIntHalf args, Target t) {
1492 args.out = t.newFloaty(convertIntToDouble(args.inV));
1494 static public void computeConvert(TestConvert.ArgumentsIntFloat args, Target t) {
1496 args.out = t.new32(convertIntToFloat(args.inV));
1498 static public void computeConvert(TestConvert.ArgumentsIntDouble args, Target t) {
1500 args.out = t.new64(convertIntToDouble(args.inV));
1503 static public void computeConvert(TestConvert.ArgumentsUintChar args) {
1504 args.out = convertUintToChar(args.inV);
1506 static public void computeConvert(TestConvert.ArgumentsUintUchar args) {
1507 args.out = convertUintToUchar(args.inV);
1509 static public void computeConvert(TestConvert.ArgumentsUintShort args) {
1510 args.out = convertUintToShort(args.inV);
1512 static public void computeConvert(TestConvert.ArgumentsUintUshort args) {
1513 args.out = convertUintToUshort(args.inV);
1515 static public void computeConvert(TestConvert.ArgumentsUintInt args) {
1516 args.out = convertUintToInt(args.inV);
1518 static public void computeConvert(TestConvert.ArgumentsUintUint args) {
1519 args.out = convertUintToUint(args.inV);
1521 static public void computeConvert(TestConvert.ArgumentsUintLong args) {
1522 args.out = convertUintToLong(args.inV);
1524 static public void computeConvert(TestConvert.ArgumentsUintUlong args) {
1525 args.out = convertUintToUlong(args.inV);
1527 static public void computeConvert(TestConvert.ArgumentsUintHalf args, Target t) {
1529 args.out = t.newFloaty(convertUintToDouble(args.inV));
1531 static public void computeConvert(TestConvert.ArgumentsUintFloat args, Target t) {
1533 args.out = t.new32(convertUintToFloat(args.inV));
1535 static public void computeConvert(TestConvert.ArgumentsUintDouble args, Target t) {
1537 args.out = t.new64(convertUintToDouble(args.inV));
1540 static public void computeConvert(TestConvert.ArgumentsLongChar args) {
1541 args.out = convertLongToChar(args.inV);
1543 static public void computeConvert(TestConvert.ArgumentsLongUchar args) {
1544 args.out = convertLongToUchar(args.inV);
1546 static public void computeConvert(TestConvert.ArgumentsLongShort args) {
1547 args.out = convertLongToShort(args.inV);
1549 static public void computeConvert(TestConvert.ArgumentsLongUshort args) {
1550 args.out = convertLongToUshort(args.inV);
1552 static public void computeConvert(TestConvert.ArgumentsLongInt args) {
1553 args.out = convertLongToInt(args.inV);
1555 static public void computeConvert(TestConvert.ArgumentsLongUint args) {
1556 args.out = convertLongToUint(args.inV);
1558 static public void computeConvert(TestConvert.ArgumentsLongLong args) {
1559 args.out = convertLongToLong(args.inV);
1561 static public void computeConvert(TestConvert.ArgumentsLongUlong args) {
1562 args.out = convertLongToUlong(args.inV);
1564 static public void computeConvert(TestConvert.ArgumentsLongHalf args, Target t) {
1566 args.out = t.newFloaty(convertLongToDouble(args.inV));
1568 static public void computeConvert(TestConvert.ArgumentsLongFloat args, Target t) {
1570 args.out = t.new32(convertLongToFloat(args.inV));
1572 static public void computeConvert(TestConvert.ArgumentsLongDouble args, Target t) {
1574 args.out = t.new64(convertLongToDouble(args.inV));
1577 static public void computeConvert(TestConvert.ArgumentsUlongChar args) {
1578 args.out = convertUlongToChar(args.inV);
1580 static public void computeConvert(TestConvert.ArgumentsUlongUchar args) {
1581 args.out = convertUlongToUchar(args.inV);
1583 static public void computeConvert(TestConvert.ArgumentsUlongShort args) {
1584 args.out = convertUlongToShort(args.inV);
1586 static public void computeConvert(TestConvert.ArgumentsUlongUshort args) {
1587 args.out = convertUlongToUshort(args.inV);
1589 static public void computeConvert(TestConvert.ArgumentsUlongInt args) {
1590 args.out = convertUlongToInt(args.inV);
1592 static public void computeConvert(TestConvert.ArgumentsUlongUint args) {
1593 args.out = convertUlongToUint(args.inV);
1595 static public void computeConvert(TestConvert.ArgumentsUlongLong args) {
1596 args.out = convertUlongToLong(args.inV);
1598 static public void computeConvert(TestConvert.ArgumentsUlongUlong args) {
1599 args.out = convertUlongToUlong(args.inV);
1601 static public void computeConvert(TestConvert.ArgumentsUlongHalf args, Target t) {
1603 args.out = t.newFloaty(convertUlongToDouble(args.inV));
1605 static public void computeConvert(TestConvert.ArgumentsUlongFloat args, Target t) {
1607 args.out = t.new32(convertUlongToFloat(args.inV));
1609 static public void computeConvert(TestConvert.ArgumentsUlongDouble args, Target t) {
1611 args.out = t.new64(convertUlongToDouble(args.inV));
1614 static public void computeConvert(TestConvert.ArgumentsHalfChar args) {
1615 args.out = convertDoubleToChar(args.inVDouble);
1617 static public void computeConvert(TestConvert.ArgumentsHalfUchar args) {
1618 args.out = convertDoubleToUchar(args.inVDouble);
1620 static public void computeConvert(TestConvert.ArgumentsHalfShort args) {
1621 args.out = convertDoubleToShort(args.inVDouble);
1623 static public void computeConvert(TestConvert.ArgumentsHalfUshort args) {
1624 args.out = convertDoubleToUshort(args.inVDouble);
1626 static public void computeConvert(TestConvert.ArgumentsHalfInt args) {
1627 args.out = convertDoubleToInt(args.inVDouble);
1629 static public void computeConvert(TestConvert.ArgumentsHalfUint args) {
1630 args.out = convertDoubleToUint(args.inVDouble);
1632 static public void computeConvert(TestConvert.ArgumentsHalfLong args) {
1633 args.out = convertDoubleToLong(args.inVDouble);
1635 static public void computeConvert(TestConvert.ArgumentsHalfUlong args) {
1636 args.out = convertDoubleToUlong(args.inVDouble);
1638 static public void computeConvert(TestConvert.ArgumentsHalfHalf args, Target t) {
1640 args.out = t.newFloaty(args.inVDouble);
1642 static public void computeConvert(TestConvert.ArgumentsHalfFloat args, Target t) {
1644 args.out = t.newFloaty(convertDoubleToFloat(args.inVDouble));
1646 static public void computeConvert(TestConvert.ArgumentsHalfDouble args, Target t) {
1648 args.out = t.newFloaty(args.inVDouble);
1651 static public void computeConvert(TestConvert.ArgumentsFloatChar args) {
1652 args.out = convertFloatToChar(args.inV);
1654 static public void computeConvert(TestConvert.ArgumentsFloatUchar args) {
1655 args.out = convertFloatToUchar(args.inV);
1657 static public void computeConvert(TestConvert.ArgumentsFloatShort args) {
1658 args.out = convertFloatToShort(args.inV);
1660 static public void computeConvert(TestConvert.ArgumentsFloatUshort args) {
1661 args.out = convertFloatToUshort(args.inV);
1663 static public void computeConvert(TestConvert.ArgumentsFloatInt args) {
1664 args.out = convertFloatToInt(args.inV);
1666 static public void computeConvert(TestConvert.ArgumentsFloatUint args) {
1667 args.out = convertFloatToUint(args.inV);
1669 static public void computeConvert(TestConvert.ArgumentsFloatLong args) {
1670 args.out = convertFloatToLong(args.inV);
1672 static public void computeConvert(TestConvert.ArgumentsFloatUlong args) {
1673 args.out = convertFloatToUlong(args.inV);
1675 static public void computeConvert(TestConvert.ArgumentsFloatHalf args, Target t) {
1677 args.out = t.newFloaty(args.inV);
1679 static public void computeConvert(TestConvert.ArgumentsFloatFloat args, Target t) {
1681 args.out = t.new32(convertFloatToFloat(args.inV));
1683 static public void computeConvert(TestConvert.ArgumentsFloatDouble args, Target t) {
1685 args.out = t.new64(convertFloatToDouble(args.inV));
1688 static public void computeConvert(TestConvert.ArgumentsDoubleChar args) {
1689 args.out = convertDoubleToChar(args.inV);
1691 static public void computeConvert(TestConvert.ArgumentsDoubleUchar args) {
1692 args.out = convertDoubleToUchar(args.inV);
1694 static public void computeConvert(TestConvert.ArgumentsDoubleShort args) {
1695 args.out = convertDoubleToShort(args.inV);
1697 static public void computeConvert(TestConvert.ArgumentsDoubleUshort args) {
1698 args.out = convertDoubleToUshort(args.inV);
1700 static public void computeConvert(TestConvert.ArgumentsDoubleInt args) {
1701 args.out = convertDoubleToInt(args.inV);
1703 static public void computeConvert(TestConvert.ArgumentsDoubleUint args) {
1704 args.out = convertDoubleToUint(args.inV);
1706 static public void computeConvert(TestConvert.ArgumentsDoubleLong args) {
1707 args.out = convertDoubleToLong(args.inV);
1709 static public void computeConvert(TestConvert.ArgumentsDoubleUlong args) {
1710 args.out = convertDoubleToUlong(args.inV);
1712 static public void computeConvert(TestConvert.ArgumentsDoubleHalf args, Target t) {
1714 args.out = t.newFloaty(args.inV);
1716 static public void computeConvert(TestConvert.ArgumentsDoubleFloat args, Target t) {
1718 args.out = t.new32(convertDoubleToFloat(args.inV));
1720 static public void computeConvert(TestConvert.ArgumentsDoubleDouble args, Target t) {
1722 args.out = t.new64(convertDoubleToDouble(args.inV));
1725 static public void computeCopysign(TestCopysign.ArgumentsHalfHalfHalf args, Target t) {
1727 args.out = copysign(args.inMagnitudeValueDouble, args.inSignValueDouble, t);
1730 static public void computeCopysign(TestCopysign.ArgumentsFloatFloatFloat args, Target t) {
1732 args.out = t.new32(Math.copySign(args.inMagnitudeValue, args.inSignValue));
1735 static public void computeCos(TestCos.ArgumentsHalfHalf args, Target t) {
1737 args.out = cos(args.inVDouble, t);
1740 static public void computeCos(TestCos.ArgumentsFloatFloat args, Target t) {
1742 args.out = cos(args.inV, t);
1745 static public void computeCosh(TestCosh.ArgumentsHalfHalf args, Target t) {
1747 args.out = cosh(args.inVDouble, t);
1750 static public void computeCosh(TestCosh.ArgumentsFloatFloat args, Target t) {
1752 args.out = cosh(args.inV, t);
1755 static public void computeCospi(TestCospi.ArgumentsHalfHalf args, Target t) {
1757 args.out = cospi(args.inVDouble, t);
1760 static public void computeCospi(TestCospi.ArgumentsFloatFloat args, Target t) {
1762 args.out = cospi(args.inV, t);
1765 static public void computeCross(TestCross.ArgumentsHalfNHalfNHalfN args, Target t) {
1767 cross(args.inLeftVectorDouble, args.inRightVectorDouble, args.out, t);
1770 static public void computeCross(TestCross.ArgumentsFloatNFloatNFloatN args, Target t) {
1772 cross(args.inLeftVector, args.inRightVector, args.out, t);
1775 static public void computeDegrees(TestDegrees.ArgumentsHalfHalf args, Target t) {
1777 args.out = degrees(args.inVDouble, t);
1780 static public void computeDegrees(TestDegrees.ArgumentsFloatFloat args, Target t) {
1782 Target.Floaty in = t.new32(args.inV);
1784 args.out = t.multiply(in, k);
1787 static public void computeDistance(TestDistance.ArgumentsHalfHalfHalf args, Target t) {
1789 args.out = distance(new double[] {args.inLeftVectorDouble},
1790 new double[] {args.inRightVectorDouble}, t);
1792 static public void computeDistance(TestDistance.ArgumentsHalfNHalfNHalf args, Target t) {
1794 args.out = distance(args.inLeftVectorDouble, args.inRightVectorDouble, t);
1797 static public void computeDistance(TestDistance.ArgumentsFloatFloatFloat args, Target t) {
1799 args.out = distance(new float[] {args.inLeftVector}, new float[] {args.inRightVector}, t);
1802 static public void computeDistance(TestDistance.ArgumentsFloatNFloatNFloat args, Target t) {
1804 args.out = distance(args.inLeftVector, args.inRightVector, t);
1807 static public void computeDot(TestDot.ArgumentsHalfHalfHalf args, Target t) {
1809 Target.Floaty a = t.newFloaty(args.inLeftVectorDouble);
1810 Target.Floaty b = t.newFloaty(args.inRightVectorDouble);
1811 args.out = t.multiply(a, b);
1814 static public void computeDot(TestDot.ArgumentsHalfNHalfNHalf args, Target t) {
1817 for (int i = 0; i < args.inLeftVectorDouble.length; i++) {
1818 Target.Floaty a = t.newFloaty(args.inLeftVectorDouble[i]);
1819 Target.Floaty b = t.newFloaty(args.inRightVectorDouble[i]);
1822 args.out = sum;
1825 static public void computeDot(TestDot.ArgumentsFloatFloatFloat args, Target t) {
1827 Target.Floaty a = t.new32(args.inLeftVector);
1828 Target.Floaty b = t.new32(args.inRightVector);
1829 args.out = t.multiply(a, b);
1832 static public void computeDot(TestDot.ArgumentsFloatNFloatNFloat args, Target t) {
1835 for (int i = 0; i < args.inLeftVector.length; i++) {
1836 Target.Floaty a = t.new32(args.inLeftVector[i]);
1837 Target.Floaty b = t.new32(args.inRightVector[i]);
1840 args.out = sum;
1843 static public void computeErf(TestErf.ArgumentsHalfHalf args, Target t) {
1845 args.out = erf(args.inVDouble, t);
1848 static public void computeErf(TestErf.ArgumentsFloatFloat args, Target t) {
1850 Target.Floaty in = t.new32(args.inV);
1851 args.out = t.new32(
1852 erf(args.inV),
1857 static public void computeErfc(TestErfc.ArgumentsHalfHalf args, Target t) {
1859 args.out = erfc(args.inVDouble, t);
1862 static public void computeErfc(TestErfc.ArgumentsFloatFloat args, Target t) {
1864 Target.Floaty in = t.new32(args.inV);
1865 args.out = t.new32(
1866 erfc(args.inV),
1871 static public void computeExp(TestExp.ArgumentsHalfHalf args, Target t) {
1873 args.out = exp(args.inVDouble, t);
1876 static public void computeExp(TestExp.ArgumentsFloatFloat args, Target t) {
1878 args.out = exp(args.inV, t);
1881 static public void computeExp10(TestExp10.ArgumentsHalfHalf args, Target t) {
1883 args.out = exp10(args.inVDouble, t);
1886 static public void computeExp10(TestExp10.ArgumentsFloatFloat args, Target t) {
1888 args.out = exp10(args.inV, t);
1891 static public void computeExp2(TestExp2.ArgumentsHalfHalf args, Target t) {
1893 args.out = exp2(args.inVDouble, t);
1896 static public void computeExp2(TestExp2.ArgumentsFloatFloat args, Target t) {
1898 args.out = exp2(args.inV, t);
1901 static public void computeExpm1(TestExpm1.ArgumentsHalfHalf args, Target t) {
1903 args.out = expm1(args.inVDouble, t);
1906 static public void computeExpm1(TestExpm1.ArgumentsFloatFloat args, Target t) {
1908 args.out = expm1(args.inV, t);
1911 static public void computeFabs(TestFabs.ArgumentsHalfHalf args, Target t) {
1913 args.out = fabs(args.inVDouble, t);
1916 static public void computeFabs(TestFabs.ArgumentsFloatFloat args, Target t) {
1918 Target.Floaty in = t.new32(args.inV);
1919 args.out = t.new32(
1920 Math.abs(args.inV),
1925 static public void computeFastDistance(TestFastDistance.ArgumentsFloatFloatFloat args, Target t) {
1927 args.out = distance(new float[] {args.inLeftVector}, new float[] {args.inRightVector}, t);
1930 static public void computeFastDistance(TestFastDistance.ArgumentsFloatNFloatNFloat args, Target t) {
1932 args.out = distance(args.inLeftVector, args.inRightVector, t);
1935 static public void computeFastLength(TestFastLength.ArgumentsFloatFloat args, Target t) {
1937 args.out = length(new float[] {args.inV}, t);
1940 static public void computeFastLength(TestFastLength.ArgumentsFloatNFloat args, Target t) {
1942 args.out = length(args.inV, t);
1945 static public void computeFastNormalize(TestFastNormalize.ArgumentsFloatFloat args, Target t) {
1948 normalize(new float[] {args.inV}, out, t);
1949 args.out = out[0];
1952 static public void computeFastNormalize(TestFastNormalize.ArgumentsFloatNFloatN args, Target t) {
1954 normalize(args.inV, args.out, t);
1957 static public void computeFdim(TestFdim.ArgumentsHalfHalfHalf args, Target t) {
1959 args.out = fdim(args.inADouble, args.inBDouble, t);
1962 static public void computeFdim(TestFdim.ArgumentsFloatFloatFloat args, Target t) {
1964 Target.Floaty inA = t.new32(args.inA);
1965 Target.Floaty inB = t.new32(args.inB);
1967 args.out = t.new32(
1973 static public void computeFloor(TestFloor.ArgumentsHalfHalf args, Target t) {
1975 args.out = floor(args.inVDouble, t);
1978 static public void computeFloor(TestFloor.ArgumentsFloatFloat args, Target t) {
1980 Target.Floaty in = t.new32(args.inV);
1981 args.out = t.new32(
1982 floor(args.inV),
1987 static public void computeFma(TestFma.ArgumentsHalfHalfHalfHalf args, Target t) {
1989 args.out = fma(args.inMultiplicand1Double, args.inMultiplicand2Double,
1990 args.inOffsetDouble, t);
1993 static public void computeFma(TestFma.ArgumentsFloatFloatFloatFloat args, Target t) {
1995 Target.Floaty ab = t.multiply(t.new32(args.inMultiplicand1), t.new32(args.inMultiplicand2));
1996 args.out = t.add(ab, t.new32(args.inOffset));
1999 static public void computeFmax(TestFmax.ArgumentsHalfHalfHalf args, Target t) {
2001 args.out = fmax(args.inADouble, args.inBDouble, t);
2004 static public void computeFmax(TestFmax.ArgumentsFloatFloatFloat args, Target t) {
2006 Target.Floaty a = t.new32(args.inA);
2007 Target.Floaty b = t.new32(args.inB);
2008 args.out = t.new32(
2009 Math.max(args.inA, args.inB),
2016 static public void computeFmin(TestFmin.ArgumentsHalfHalfHalf args, Target t) {
2018 args.out = fmin(args.inADouble, args.inBDouble, t);
2021 static public void computeFmin(TestFmin.ArgumentsFloatFloatFloat args, Target t) {
2023 Target.Floaty a = t.new32(args.inA);
2024 Target.Floaty b = t.new32(args.inB);
2025 args.out = t.new32(
2026 Math.min(args.inA, args.inB),
2033 static public void computeFmod(TestFmod.ArgumentsHalfHalfHalf args, Target t) {
2035 args.out = fmod(args.inNumeratorDouble, args.inDenominatorDouble, t);
2038 static public void computeFmod(TestFmod.ArgumentsFloatFloatFloat args, Target t) {
2040 Target.Floaty numerator = t.new32(args.inNumerator);
2041 Target.Floaty denominator = t.new32(args.inDenominator);
2042 args.out = t.new32(
2043 args.inNumerator % args.inDenominator,
2050 static public void computeFract(TestFract.ArgumentsHalfHalfHalf args, Target t) {
2052 args.out = fract(args.inVDouble, t, 0.99951171875 /* max float16 smaller than 1.0 */);
2053 args.outFloor = floor(args.inVDouble, t);
2056 static public void computeFract(TestFract.ArgumentsFloatFloatFloat args, Target t) {
2058 float floor = floor(args.inV);
2059 args.outFloor = t.new32(floor);
2061 args.out = t.new32(Math.min(args.inV - floor, 0x1.fffffep-1f));
2064 static public void computeFract(TestFract.ArgumentsHalfHalf args, Target t) {
2066 args.out = fract(args.inVDouble, t, 0.99951171875 /* max float16 smaller than 1.0 */);
2069 static public void computeFract(TestFract.ArgumentsFloatFloat args, Target t) {
2071 float floor = floor(args.inV);
2073 args.out = t.new32(Math.min(args.inV - floor, 0x1.fffffep-1f));
2076 static public void computeFrexp(TestFrexp.ArgumentsFloatIntFloat args, Target t) {
2078 FrexpResult result = frexp(args.inV);
2079 args.out = t.new32(result.significand);
2080 args.outExponent = result.exponent;
2083 static public void computeHalfRecip(TestHalfRecip.ArgumentsFloatFloat args, Target t) {
2085 args.out = recip(args.inV, t);
2088 static public void computeHalfRsqrt(TestHalfRsqrt.ArgumentsFloatFloat args, Target t) {
2090 args.out = rsqrt(args.inV, t);
2093 static public void computeHalfSqrt(TestHalfSqrt.ArgumentsFloatFloat args, Target t) {
2095 args.out = sqrt(args.inV, t);
2098 static public void computeHypot(TestHypot.ArgumentsHalfHalfHalf args, Target t) {
2100 args.out = hypot(args.inADouble, args.inBDouble, t);
2103 static public void computeHypot(TestHypot.ArgumentsFloatFloatFloat args, Target t) {
2105 args.out = hypot(args.inA, args.inB, t);
2108 static public String verifyIlogb(TestIlogb.ArgumentsFloatInt args) {
2110 if (args.inV == 0.f) {
2111 if (args.out != -Integer.MAX_VALUE && args.out != Integer.MIN_VALUE) {
2116 int result = ilogb(args.inV);
2117 if (args.out != result) {
2124 static public void computeLdexp(TestLdexp.ArgumentsFloatIntFloat args, Target t) {
2126 Target.Floaty inMantissa = t.new32(args.inMantissa);
2127 args.out = t.new32(
2128 ldexp(inMantissa.mid32(), args.inExponent),
2129 ldexp(inMantissa.min32(), args.inExponent),
2130 ldexp(inMantissa.max32(), args.inExponent));
2133 static public void computeLength(TestLength.ArgumentsHalfHalf args, Target t) {
2135 args.out = length(new double[]{args.inVDouble}, t);
2138 static public void computeLength(TestLength.ArgumentsHalfNHalf args, Target t) {
2140 args.out = length(args.inVDouble, t);
2143 static public void computeLength(TestLength.ArgumentsFloatFloat args, Target t) {
2145 args.out = length(new float[]{args.inV}, t);
2148 static public void computeLength(TestLength.ArgumentsFloatNFloat args, Target t) {
2150 args.out = length(args.inV, t);
2153 static public void computeLgamma(TestLgamma.ArgumentsFloatFloat args, Target t) {
2155 Target.Floaty in = t.new32(args.inV);
2156 args.out = t.new32(
2165 static public void computeLgamma(TestLgamma.ArgumentsFloatIntFloat args, Target t) {
2167 Target.Floaty in = t.new32(args.inV);
2171 args.out = t.new32(result.lgamma, resultMin.lgamma, resultMax.lgamma);
2172 args.outY = result.gammaSign;
2175 static public String verifyLgamma(TestLgamma.ArgumentsFloatIntFloat args, Target t) {
2177 Target.Floaty in = t.new32(args.inV);
2182 boolean isNegativeZero = args.inV == 0.f && 1.f / args.inV < 0.f;
2186 if (!expectedOut.couldBe(args.out) ||
2187 (args.outSignOfGamma != result.gammaSign && !isNegativeZero)) {
2189 message.append(String.format("Input in %14.8g {%8x}:\n", args.inV, Float.floatToRawIntBits(args.inV)));
2193 message.append(String.format("Actual out: %14.8g {%8x}", args.out, Float.floatToRawIntBits(args.out)));
2195 message.append(String.format("Actual outSign: %d\n", args.outSignOfGamma));
2202 static public void computeLog(TestLog.ArgumentsHalfHalf args, Target t) {
2204 args.out = log(args.inVDouble, t);
2209 static public void computeLog(TestLog.ArgumentsFloatFloat args, Target t) {
2211 args.out = log(args.inV, t);
2214 static public void computeLog10(TestLog10.ArgumentsHalfHalf args, Target t) {
2216 args.out = log10(args.inVDouble, t);
2219 static public void computeLog10(TestLog10.ArgumentsFloatFloat args, Target t) {
2221 args.out = log10(args.inV, t);
2224 static public void computeLog1p(TestLog1p.ArgumentsHalfHalf args, Target t) {
2226 args.out = log1p(args.inVDouble, t);
2229 static public void computeLog1p(TestLog1p.ArgumentsFloatFloat args, Target t) {
2231 args.out = log1p(args.inV, t);
2234 static public void computeLog2(TestLog2.ArgumentsHalfHalf args, Target t) {
2236 args.out = log2(args.inVDouble, t);
2239 static public void computeLog2(TestLog2.ArgumentsFloatFloat args, Target t) {
2241 args.out = log2(args.inV, t);
2244 static public void computeLogb(TestLogb.ArgumentsHalfHalf args, Target t) {
2246 args.out = logb(args.inVDouble, t);
2249 static public void computeLogb(TestLogb.ArgumentsFloatFloat args, Target t) {
2251 Target.Floaty in = t.new32(args.inV);
2252 args.out = t.new32(
2258 static public void computeMad(TestMad.ArgumentsHalfHalfHalfHalf args, Target t) {
2260 args.out = mad(args.inMultiplicand1Double, args.inMultiplicand2Double, args.inOffsetDouble, t);
2263 static public void computeMad(TestMad.ArgumentsFloatFloatFloatFloat args, Target t) {
2265 Target.Floaty ab = t.multiply(t.new32(args.inMultiplicand1), t.new32(args.inMultiplicand2));
2266 args.out = t.add(ab, t.new32(args.inOffset));
2269 static public void computeMax(TestMax.ArgumentsCharCharChar args) {
2270 args.out = maxI8(args.inA, args.inB);
2273 static public void computeMax(TestMax.ArgumentsUcharUcharUchar args) {
2274 args.out = maxU8(args.inA, args.inB);
2277 static public void computeMax(TestMax.ArgumentsShortShortShort args) {
2278 args.out = maxI16(args.inA, args.inB);
2281 static public void computeMax(TestMax.ArgumentsUshortUshortUshort args) {
2282 args.out = maxU16(args.inA, args.inB);
2285 static public void computeMax(TestMax.ArgumentsIntIntInt args) {
2286 args.out = maxI32(args.inA, args.inB);
2289 static public void computeMax(TestMax.ArgumentsUintUintUint args) {
2290 args.out = maxU32(args.inA, args.inB);
2293 static public void computeMax(TestMax.ArgumentsLongLongLong args) {
2294 args.out = maxI64(args.inA, args.inB);
2297 static public void computeMax(TestMax.ArgumentsUlongUlongUlong args) {
2298 args.out = maxU64(args.inA, args.inB);
2301 static public void computeMax(TestMax.ArgumentsHalfHalfHalf args, Target t) {
2303 args.out = max(args.inADouble, args.inBDouble, t);
2306 static public void computeMax(TestMax.ArgumentsFloatFloatFloat args, Target t) {
2308 Target.Floaty a = t.new32(args.inA);
2309 Target.Floaty b = t.new32(args.inB);
2310 args.out = t.new32(
2318 static public void computeMin(TestMin.ArgumentsCharCharChar args) {
2319 args.out = minI8(args.inA, args.inB);
2322 static public void computeMin(TestMin.ArgumentsUcharUcharUchar args) {
2323 args.out = minU8(args.inA, args.inB);
2326 static public void computeMin(TestMin.ArgumentsShortShortShort args) {
2327 args.out = minI16(args.inA, args.inB);
2330 static public void computeMin(TestMin.ArgumentsUshortUshortUshort args) {
2331 args.out = minU16(args.inA, args.inB);
2334 static public void computeMin(TestMin.ArgumentsIntIntInt args) {
2335 args.out = minI32(args.inA, args.inB);
2338 static public void computeMin(TestMin.ArgumentsUintUintUint args) {
2339 args.out = minU32(args.inA, args.inB);
2342 static public void computeMin(TestMin.ArgumentsLongLongLong args) {
2343 args.out = minI64(args.inA, args.inB);
2346 static public void computeMin(TestMin.ArgumentsUlongUlongUlong args) {
2347 args.out = minU64(args.inA, args.inB);
2350 static public void computeMin(TestMin.ArgumentsHalfHalfHalf args, Target t) {
2352 args.out = min(args.inADouble, args.inBDouble, t);
2355 static public void computeMin(TestMin.ArgumentsFloatFloatFloat args, Target t) {
2357 args.out = t.new32(Math.min(args.inA, args.inB));
2360 static public void computeMix(TestMix.ArgumentsHalfHalfHalfHalf args, Target t) {
2362 args.out = mix(args.inStartDouble, args.inStopDouble, args.inFractionDouble, t);
2365 static public void computeMix(TestMix.ArgumentsFloatFloatFloatFloat args, Target t) {
2367 Target.Floaty start = t.new32(args.inStart);
2368 Target.Floaty stop = t.new32(args.inStop);
2370 args.out = t.add(start, t.multiply(diff, t.new32(args.inFraction)));
2373 static public void computeModf(TestModf.ArgumentsFloatFloatFloat args, Target t) {
2375 float ret = (float)(int)args.inV;
2376 args.outIntegralPart = t.new32(ret);
2377 args.out = t.new32(args.inV - ret);
2380 static public void computeNan(TestNan.ArgumentsUintFloat args, Target t) {
2383 args.out = t.new32(Float.NaN);
2386 static public void computeNanHalf(TestNanHalf.ArgumentsHalf args, Target t) {
2388 args.out = t.newFloaty(Double.NaN);
2391 static public void computeNativeAcos(TestNativeAcos.ArgumentsHalfHalf args, Target t) {
2393 args.out = acos(args.inVDouble, t);
2396 static public void computeNativeAcos(TestNativeAcos.ArgumentsFloatFloat args, Target t) {
2398 args.out = acos(args.inV, t);
2401 static public void computeNativeAcosh(TestNativeAcosh.ArgumentsHalfHalf args, Target t) {
2403 args.out = acosh(args.inVDouble, t);
2406 static public void computeNativeAcosh(TestNativeAcosh.ArgumentsFloatFloat args, Target t) {
2408 args.out = acosh(args.inV, t);
2411 static public void computeNativeAcospi(TestNativeAcospi.ArgumentsHalfHalf args, Target t) {
2413 args.out = acospi(args.inVDouble, t);
2416 static public void computeNativeAcospi(TestNativeAcospi.ArgumentsFloatFloat args, Target t) {
2418 args.out = acospi(args.inV, t);
2421 static public void computeNativeAsin(TestNativeAsin.ArgumentsHalfHalf args, Target t) {
2423 args.out = asin(args.inVDouble, t);
2426 static public void computeNativeAsin(TestNativeAsin.ArgumentsFloatFloat args, Target t) {
2428 args.out = asin(args.inV, t);
2431 static public void computeNativeAsinh(TestNativeAsinh.ArgumentsHalfHalf args, Target t) {
2433 args.out = asinh(args.inVDouble, t);
2436 static public void computeNativeAsinh(TestNativeAsinh.ArgumentsFloatFloat args, Target t) {
2438 args.out = asinh(args.inV, t);
2441 static public void computeNativeAsinpi(TestNativeAsinpi.ArgumentsHalfHalf args, Target t) {
2443 args.out = asinpi(args.inVDouble, t);
2446 static public void computeNativeAsinpi(TestNativeAsinpi.ArgumentsFloatFloat args, Target t) {
2448 args.out = asinpi(args.inV, t);
2451 static public void computeNativeAtan(TestNativeAtan.ArgumentsHalfHalf args, Target t) {
2453 args.out = atan(args.inVDouble, t);
2456 static public void computeNativeAtan(TestNativeAtan.ArgumentsFloatFloat args, Target t) {
2458 args.out = atan(args.inV, t);
2461 static public void computeNativeAtanh(TestNativeAtanh.ArgumentsHalfHalf args, Target t) {
2463 args.out = atanh(args.inVDouble, t);
2466 static public void computeNativeAtanh(TestNativeAtanh.ArgumentsFloatFloat args, Target t) {
2468 args.out = atanh(args.inV, t);
2471 static public void computeNativeAtanpi(TestNativeAtanpi.ArgumentsHalfHalf args, Target t) {
2473 args.out = atanpi(args.inVDouble, t);
2476 static public void computeNativeAtanpi(TestNativeAtanpi.ArgumentsFloatFloat args, Target t) {
2478 args.out = atanpi(args.inV, t);
2481 static public void computeNativeAtan2(TestNativeAtan2.ArgumentsHalfHalfHalf args, Target t) {
2483 args.out = atan2(args.inNumeratorDouble, args.inDenominatorDouble, t);
2486 static public void computeNativeAtan2(TestNativeAtan2.ArgumentsFloatFloatFloat args, Target t) {
2488 args.out = atan2(args.inNumerator, args.inDenominator, t);
2491 static public void computeNativeAtan2pi(TestNativeAtan2pi.ArgumentsHalfHalfHalf args, Target t) {
2493 args.out = atan2pi(args.inNumeratorDouble, args.inDenominatorDouble, t);
2496 static public void computeNativeAtan2pi(TestNativeAtan2pi.ArgumentsFloatFloatFloat args, Target t) {
2498 args.out = atan2pi(args.inNumerator, args.inDenominator, t);
2501 static public void computeNativeCbrt(TestNativeCbrt.ArgumentsHalfHalf args, Target t) {
2503 args.out = cbrt(args.inVDouble, t);
2506 static public void computeNativeCbrt(TestNativeCbrt.ArgumentsFloatFloat args, Target t) {
2508 args.out = cbrt(args.inV, t);
2511 static public void computeNativeCos(TestNativeCos.ArgumentsHalfHalf args, Target t) {
2513 args.out = cos(args.inVDouble, t);
2516 static public void computeNativeCos(TestNativeCos.ArgumentsFloatFloat args, Target t) {
2518 args.out = cos(args.inV, t);
2521 static public void computeNativeCosh(TestNativeCosh.ArgumentsHalfHalf args, Target t) {
2523 args.out = cosh(args.inVDouble, t);
2526 static public void computeNativeCosh(TestNativeCosh.ArgumentsFloatFloat args, Target t) {
2528 args.out = cosh(args.inV, t);
2531 static public void computeNativeCospi(TestNativeCospi.ArgumentsHalfHalf args, Target t) {
2533 args.out = cospi(args.inVDouble, t);
2536 static public void computeNativeCospi(TestNativeCospi.ArgumentsFloatFloat args, Target t) {
2538 args.out = cospi(args.inV, t);
2541 static public void computeNativeDistance(TestNativeDistance.ArgumentsHalfHalfHalf args, Target t) {
2543 args.out = distance(new double[] {args.inLeftVectorDouble},
2544 new double[] {args.inRightVectorDouble}, t);
2547 static public void computeNativeDistance(TestNativeDistance.ArgumentsHalfNHalfNHalf args, Target t) {
2549 args.out = distance(args.inLeftVectorDouble, args.inRightVectorDouble, t);
2552 static public void computeNativeDistance(TestNativeDistance.ArgumentsFloatFloatFloat args, Target t) {
2554 args.out = distance(new float[]{args.inLeftVector}, new float[]{args.inRightVector}, t);
2557 args, Target t) {
2559 args.out = distance(args.inLeftVector, args.inRightVector, t);
2562 static public void computeNativeDivide(TestNativeDivide.ArgumentsHalfHalfHalf args, Target t) {
2564 args.out = divide(args.inLeftVectorDouble, args.inRightVectorDouble, t);
2567 static public void computeNativeDivide(TestNativeDivide.ArgumentsFloatFloatFloat args, Target t) {
2569 args.out = t.divide(t.new32(args.inLeftVector), t.new32(args.inRightVector));
2572 static public void computeNativeExp(TestNativeExp.ArgumentsHalfHalf args, Target t) {
2574 args.out = exp(args.inVDouble, t);
2577 static public void computeNativeExp(TestNativeExp.ArgumentsFloatFloat args, Target t) {
2579 args.out = exp(args.inV, t);
2582 static public void computeNativeExp10(TestNativeExp10.ArgumentsHalfHalf args, Target t) {
2584 args.out = exp10(args.inVDouble, t);
2587 static public void computeNativeExp10(TestNativeExp10.ArgumentsFloatFloat args, Target t) {
2589 args.out = exp10(args.inV, t);
2592 static public void computeNativeExp2(TestNativeExp2.ArgumentsHalfHalf args, Target t) {
2594 args.out = exp2(args.inVDouble, t);
2597 static public void computeNativeExp2(TestNativeExp2.ArgumentsFloatFloat args, Target t) {
2600 args.out = exp2(args.inV, t);
2603 static public String verifyNativeExpm1(TestNativeExpm1.ArgumentsHalfHalf args, Target t) {
2609 if (args.inVDouble < 0.6) {
2617 Target.Floaty expectedOut = expm1(args.inVDouble, t);
2618 if (!expectedOut.couldBe(args.outDouble, extraAllowedError)) {
2628 static public void computeNativeExpm1(TestNativeExpm1.ArgumentsFloatFloat args, Target t) {
2630 args.out = expm1(args.inV, t);
2633 static public void computeNativeHypot(TestNativeHypot.ArgumentsHalfHalfHalf args, Target t) {
2635 args.out = hypot(args.inADouble, args.inBDouble, t);
2638 static public void computeNativeHypot(TestNativeHypot.ArgumentsFloatFloatFloat args, Target t) {
2640 args.out = hypot(args.inA, args.inB, t);
2643 static public void computeNativeLength(TestNativeLength.ArgumentsHalfHalf args, Target t) {
2645 args.out = length(new double[]{args.inVDouble}, t);
2648 static public void computeNativeLength(TestNativeLength.ArgumentsHalfNHalf args, Target t) {
2650 args.out = length(args.inVDouble, t);
2653 static public void computeNativeLength(TestNativeLength.ArgumentsFloatFloat args, Target t) {
2655 args.out = length(new float[] {args.inV}, t);
2658 static public void computeNativeLength(TestNativeLength.ArgumentsFloatNFloat args, Target t) {
2660 args.out = length(args.inV, t);
2663 static public void computeNativeLog(TestNativeLog.ArgumentsHalfHalf args, Target t) {
2667 if (Math.abs(args.inVDouble) < 1.e-20) {
2668 args.out = any(t);
2670 args.out = log(args.inVDouble, t);
2674 static public void computeNativeLog(TestNativeLog.ArgumentsFloatFloat args, Target t) {
2677 if (Math.abs(args.inV) < 1.e-20) {
2678 args.out = any32(t);
2680 args.out = log(args.inV, t);
2684 static public void computeNativeLog10(TestNativeLog10.ArgumentsHalfHalf args, Target t) {
2688 if (Math.abs(args.inVDouble) < 1.e-20) {
2689 args.out = any(t);
2691 args.out = log10(args.inVDouble, t);
2695 static public void computeNativeLog10(TestNativeLog10.ArgumentsFloatFloat args, Target t) {
2698 if (Math.abs(args.inV) < 1.e-20) {
2699 args.out = any32(t);
2701 args.out = log10(args.inV, t);
2705 static public void computeNativeLog1p(TestNativeLog1p.ArgumentsHalfHalf args, Target t) {
2707 args.out = log1p(args.inVDouble, t);
2710 static public void computeNativeLog1p(TestNativeLog1p.ArgumentsFloatFloat args, Target t) {
2712 args.out = log1p(args.inV, t);
2715 static public void computeNativeLog2(TestNativeLog2.ArgumentsHalfHalf args, Target t) {
2719 if (Math.abs(args.inVDouble) < 1.e-20) {
2720 args.out = any(t);
2722 args.out = log2(args.inVDouble, t);
2726 static public void computeNativeLog2(TestNativeLog2.ArgumentsFloatFloat args, Target t) {
2729 if (Math.abs(args.inV) < 1.e-20) {
2730 args.out = any32(t);
2732 args.out = log2(args.inV, t);
2736 static public void computeNativeNormalize(TestNativeNormalize.ArgumentsHalfHalf args, Target t) {
2739 normalize(new double[] {args.inVDouble}, out, t);
2740 args.out = out[0];
2743 static public void computeNativeNormalize(TestNativeNormalize.ArgumentsHalfNHalfN args, Target t) {
2745 normalize(args.inVDouble, args.out, t);
2748 static public void computeNativeNormalize(TestNativeNormalize.ArgumentsFloatFloat args, Target t) {
2751 normalize(new float[] {args.inV}, out, t);
2752 args.out = out[0];
2755 static public void computeNativeNormalize(TestNativeNormalize.ArgumentsFloatNFloatN args, Target t) {
2757 normalize(args.inV, args.out, t);
2760 static public void computeNativePowr(TestNativePowr.ArgumentsHalfHalfHalf args, Target t) {
2764 if (Math.abs(args.inBaseDouble) < 1.e-20) {
2765 args.out = any(t);
2767 args.out = pow(args.inBaseDouble, args.inExponentDouble, t);
2771 static public void computeNativePowr(TestNativePowr.ArgumentsFloatFloatFloat args, Target t) {
2775 if (Math.abs(args.inBase) < 1.e-20) {
2776 args.out = any32(t);
2778 args.out = powr(args.inBase, args.inExponent, t);
2782 static public void computeNativeRecip(TestNativeRecip.ArgumentsHalfHalf args, Target t) {
2784 args.out = recip(args.inVDouble, t);
2787 static public void computeNativeRecip(TestNativeRecip.ArgumentsFloatFloat args, Target t) {
2789 args.out = recip(args.inV, t);
2792 static public void computeNativeRootn(TestNativeRootn.ArgumentsFloatIntFloat args, Target t) {
2795 if (args.inN == 0) {
2796 args.out = any32(t);
2798 args.out = rootn(args.inV, args.inN, t);
2802 static public void computeNativeRsqrt(TestNativeRsqrt.ArgumentsHalfHalf args, Target t) {
2804 args.out = rsqrt(args.inVDouble, t);
2807 static public void computeNativeRsqrt(TestNativeRsqrt.ArgumentsFloatFloat args, Target t) {
2809 args.out = rsqrt(args.inV, t);
2812 static public void computeNativeSin(TestNativeSin.ArgumentsHalfHalf args, Target t) {
2814 args.out = sin(args.inVDouble, t);
2817 static public void computeNativeSin(TestNativeSin.ArgumentsFloatFloat args, Target t) {
2819 args.out = sin(args.inV, t);
2822 static public void computeNativeSincos(TestNativeSincos.ArgumentsHalfHalfHalf args, Target t) {
2824 args.outCos = cos(args.inVDouble, t);
2825 args.out = sin(args.inVDouble, t);
2828 static public void computeNativeSincos(TestNativeSincos.ArgumentsFloatFloatFloat args, Target t) {
2830 args.outCos = cos(args.inV, t);
2831 args.out = sin(args.inV, t);
2834 static public void computeNativeSinh(TestNativeSinh.ArgumentsHalfHalf args, Target t) {
2836 args.out = sinh(args.inVDouble, t);
2839 static public void computeNativeSinh(TestNativeSinh.ArgumentsFloatFloat args, Target t) {
2841 args.out = sinh(args.inV, t);
2844 static public void computeNativeSinpi(TestNativeSinpi.ArgumentsHalfHalf args, Target t) {
2846 args.out = sinpi(args.inVDouble, t);
2849 static public void computeNativeSinpi(TestNativeSinpi.ArgumentsFloatFloat args, Target t) {
2851 args.out = sinpi(args.inV, t);
2854 static public void computeNativeSqrt(TestNativeSqrt.ArgumentsHalfHalf args, Target t) {
2856 args.out = sqrt(args.inVDouble, t);
2859 static public void computeNativeSqrt(TestNativeSqrt.ArgumentsFloatFloat args, Target t) {
2861 args.out = sqrt(args.inV, t);
2864 static public String verifyNativeTan(TestNativeTan.ArgumentsHalfHalf args, Target t) {
2870 // Compute the fractional part of args.inVDouble / pi
2871 double absoluteValueOverPi = Math.abs(args.inVDouble) / Math.PI;
2882 Target.Floaty expectedOut = tan(args.inVDouble, t);
2883 if (!expectedOut.couldBe(args.outDouble)) {
2893 static public void computeNativeTan(TestNativeTan.ArgumentsFloatFloat args, Target t) {
2895 args.out = tan(args.inV, t);
2898 static public void computeNativeTanh(TestNativeTanh.ArgumentsHalfHalf args, Target t) {
2900 args.out = tanh(args.inVDouble, t);
2903 static public void computeNativeTanh(TestNativeTanh.ArgumentsFloatFloat args, Target t) {
2905 args.out = tanh(args.inV, t);
2908 static public String verifyNativeTanpi(TestNativeTanpi.ArgumentsHalfHalf args, Target t) {
2914 // Compute the fractional part of args.inVDouble
2915 double absoluteValue = Math.abs(args.inVDouble);
2926 Target.Floaty expectedOut = tanpi(args.inVDouble, t);
2927 if (!expectedOut.couldBe(args.outDouble)) {
2937 static public void computeNativeTanpi(TestNativeTanpi.ArgumentsFloatFloat args, Target t) {
2939 args.out = tanpi(args.inV, t);
2942 static public void computeNextafter(TestNextafter.ArgumentsFloatFloatFloat args, Target t) {
2944 args.out = t.new32(Math.nextAfter(args.inV, args.inTarget));
2947 static public void computeNormalize(TestNormalize.ArgumentsHalfHalf args, Target t) {
2950 normalize(new double[] {args.inVDouble}, out, t);
2951 args.out = out[0];
2954 static public void computeNormalize(TestNormalize.ArgumentsHalfNHalfN args, Target t) {
2956 normalize(args.inVDouble, args.out, t);
2959 static public void computeNormalize(TestNormalize.ArgumentsFloatFloat args, Target t) {
2962 normalize(new float[] {args.inV}, out, t);
2963 args.out = out[0];
2966 static public void computeNormalize(TestNormalize.ArgumentsFloatNFloatN args, Target t) {
2968 normalize(args.inV, args.out, t);
2971 static public void computePow(TestPow.ArgumentsHalfHalfHalf args, Target t) {
2973 args.out = pow(args.inBaseDouble, args.inExponentDouble, t);
2976 static public void computePow(TestPow.ArgumentsFloatFloatFloat args, Target t) {
2978 Target.Floaty base = t.new32(args.inBase);
2979 Target.Floaty exponent = t.new32(args.inExponent);
2980 args.out = t.new32(
2988 static public void computePown(TestPown.ArgumentsHalfIntHalf args, Target t) {
2990 args.out = pow(args.inBaseDouble, (double) args.inExponent, t);
2993 static public void computePown(TestPown.ArgumentsFloatIntFloat args, Target t) {
2995 Target.Floaty in = t.new32(args.inBase);
2999 final double y = (double) args.inExponent;
3000 args.out = t.new32(
3006 static public void computePowr(TestPowr.ArgumentsHalfHalfHalf args, Target t) {
3008 args.out = pow(args.inBaseDouble, args.inExponentDouble, t);
3011 static public void computePowr(TestPowr.ArgumentsFloatFloatFloat args, Target t) {
3013 args.out = powr(args.inBase, args.inExponent, t);
3016 static public void computeRadians(TestRadians.ArgumentsHalfHalf args, Target t) {
3018 args.out = radians(args.inVDouble, t);
3021 static public void computeRadians(TestRadians.ArgumentsFloatFloat args, Target t) {
3023 Target.Floaty in = t.new32(args.inV);
3025 args.out = t.multiply(in, k);
3030 static public void computeRemainder(TestRemainder.ArgumentsHalfHalfHalf args, Target t) {
3032 RemquoResult result = remquo((float) args.inNumeratorDouble,
3033 (float) args.inDenominatorDouble);
3034 args.out = t.newFloaty(result.remainder);
3037 static public void computeRemainder(TestRemainder.ArgumentsFloatFloatFloat args, Target t) {
3039 RemquoResult result = remquo(args.inNumerator, args.inDenominator);
3040 args.out = t.new32(result.remainder);
3043 static public String verifyRemquo(TestRemquo.ArgumentsFloatFloatIntFloat args, Target t) {
3045 RemquoResult expected = remquo(args.inNumerator, args.inDenominator);
3050 if (!Float.isNaN(args.out)) {
3051 return "Expected a remainder of NaN but got " + Float.toString(args.out);
3055 if ((args.outQuotient & 0x07) != (expected.quotient & 0x07)) {
3056 return "Quotient returned " + Integer.toString(args.outQuotient) +
3061 if (!remainder.couldBe(args.out)) {
3062 return "Remainder returned " + Float.toString(args.out) +
3070 static public void computeRint(TestRint.ArgumentsHalfHalf args, Target t) {
3072 args.out = rint(args.inVDouble, t);
3075 static public void computeRint(TestRint.ArgumentsFloatFloat args, Target t) {
3077 Target.Floaty in = t.new32(args.inV);
3078 args.out = t.new32(
3084 static public void computeRootn(TestRootn.ArgumentsFloatIntFloat args, Target t) {
3086 args.out = rootn(args.inV, args.inN, t);
3089 static public void computeRound(TestRound.ArgumentsHalfHalf args, Target t) {
3091 args.out = round(args.inVDouble, t);
3094 static public void computeRound(TestRound.ArgumentsFloatFloat args, Target t) {
3096 Target.Floaty in = t.new32(args.inV);
3097 args.out = t.new32(
3103 static public void computeRsqrt(TestRsqrt.ArgumentsHalfHalf args, Target t) {
3105 args.out = rsqrt(args.inVDouble, t);
3108 static public void computeRsqrt(TestRsqrt.ArgumentsFloatFloat args, Target t) {
3110 args.out = rsqrt(args.inV, t);
3113 static public void computeSign(TestSign.ArgumentsHalfHalf args, Target t) {
3115 args.out = t.newFloaty(Math.signum(args.inVDouble));
3118 static public void computeSign(TestSign.ArgumentsFloatFloat args, Target t) {
3120 args.out = t.new32(Math.signum(args.inV));
3123 static public void computeSin(TestSin.ArgumentsHalfHalf args, Target t) {
3125 args.out = sin(args.inVDouble, t);
3128 static public void computeSin(TestSin.ArgumentsFloatFloat args, Target t) {
3130 args.out = sin(args.inV, t);
3133 static public void computeSincos(TestSincos.ArgumentsHalfHalfHalf args, Target t) {
3135 args.outCos = cos(args.inVDouble, t );
3136 args.out = sin(args.inVDouble, t);
3139 static public void computeSincos(TestSincos.ArgumentsFloatFloatFloat args, Target t) {
3141 args.outCos = cos(args.inV,t );
3142 args.out = sin(args.inV, t);
3145 static public void computeSinh(TestSinh.ArgumentsHalfHalf args, Target t) {
3147 args.out = sinh(args.inVDouble, t);
3150 static public void computeSinh(TestSinh.ArgumentsFloatFloat args, Target t) {
3152 args.out = sinh(args.inV, t);
3155 static public void computeSinpi(TestSinpi.ArgumentsHalfHalf args, Target t) {
3157 args.out = sinpi(args.inVDouble, t);
3160 static public void computeSinpi(TestSinpi.ArgumentsFloatFloat args, Target t) {
3162 args.out = sinpi(args.inV, t);
3165 static public void computeSqrt(TestSqrt.ArgumentsHalfHalf args, Target t) {
3167 args.out = sqrt(args.inVDouble, t);
3170 static public void computeSqrt(TestSqrt.ArgumentsFloatFloat args, Target t) {
3172 args.out = sqrt(args.inV, t);
3175 static public void computeStep(TestStep.ArgumentsHalfHalfHalf args, Target t) {
3177 args.out = step(args.inVDouble, args.inEdgeDouble, t);
3180 static public void computeStep(TestStep.ArgumentsFloatFloatFloat args, Target t) {
3182 args.out = t.new32(args.inV < args.inEdge ? 0.f : 1.f);
3185 static public void computeTan(TestTan.ArgumentsHalfHalf args, Target t) {
3187 args.out = tan(args.inVDouble, t);
3190 static public void computeTan(TestTan.ArgumentsFloatFloat args, Target t) {
3192 args.out = tan(args.inV, t);
3195 static public void computeTanh(TestTanh.ArgumentsHalfHalf args, Target t) {
3197 args.out = tanh(args.inVDouble, t);
3200 static public void computeTanh(TestTanh.ArgumentsFloatFloat args, Target t) {
3202 args.out = tanh(args.inV, t);
3205 static public void computeTanpi(TestTanpi.ArgumentsHalfHalf args, Target t) {
3207 args.out = tanpi(args.inVDouble, t);
3210 static public void computeTanpi(TestTanpi.ArgumentsFloatFloat args, Target t) {
3212 args.out = tanpi(args.inV, t);
3215 static public void computeTgamma(TestTgamma.ArgumentsHalfHalf args, Target t) {
3217 args.out = tgamma(args.inVDouble, t);
3220 static public void computeTgamma(TestTgamma.ArgumentsFloatFloat args, Target t) {
3222 Target.Floaty in = t.new32(args.inV);
3223 args.out = t.new32(
3229 static public void computeTrunc(TestTrunc.ArgumentsHalfHalf args, Target t) {
3231 args.out = trunc(args.inVDouble, t);
3234 static public void computeTrunc(TestTrunc.ArgumentsFloatFloat args, Target t) {
3236 Target.Floaty in = t.new32(args.inV);
3237 args.out = t.new32(
