| // FIXME: unskip when playstation's pow() matches other platforms |
| //@ skip if $hostOS == "playstation" |
| |
| function exponentIsZero(x) { |
| return x ** 0; |
| } |
| noInline(exponentIsZero); |
| |
| function testExponentIsZero() { |
| for (var i = 0; i < 10000; ++i) { |
| var result = exponentIsZero(5); |
| if (result !== 1) |
| throw "Error: zeroExponent(5) should be 1, was = " + result; |
| } |
| for (var i = 0; i < 10000; ++i) { |
| var result = exponentIsZero(5.5); |
| if (result !== 1) |
| throw "Error: zeroExponent(5.5) should be 1, was = " + result; |
| } |
| } |
| testExponentIsZero(); |
| |
| |
| function exponentIsOne(x) { |
| return x ** 1; |
| } |
| noInline(exponentIsOne); |
| |
| function testExponentIsOne() { |
| for (var i = 0; i < 10000; ++i) { |
| var result = exponentIsOne(5); |
| if (result !== 5) |
| throw "Error: exponentIsOne(5) should be 5, was = " + result; |
| } |
| for (var i = 0; i < 10000; ++i) { |
| var result = exponentIsOne(5.5); |
| if (result !== 5.5) |
| throw "Error: exponentIsOne(5.5) should be 5.5, was = " + result; |
| } |
| } |
| testExponentIsOne(); |
| |
| |
| function powUsedAsSqrt(x) { |
| return x ** 0.5; |
| } |
| noInline(powUsedAsSqrt); |
| |
| function testPowUsedAsSqrt() { |
| for (let i = 0; i < 1e4; ++i) { |
| let result = powUsedAsSqrt(4); |
| if (result !== Math.sqrt(4)) |
| throw "Error: powUsedAsSqrt(4) should be 2, was = " + result; |
| result = powUsedAsSqrt(4.4); |
| if (result !== Math.sqrt(4.4)) |
| throw "Error: powUsedAsSqrt(4) should be " + Math.sqrt(4.4) + ", was = " + result; |
| if (powUsedAsSqrt(Infinity) !== Infinity) |
| throw "Failed powUsedAsSqrt(Infinity)"; |
| if (powUsedAsSqrt(-Infinity) !== Infinity) |
| throw "Failed powUsedAsSqrt(-Infinity)"; |
| let nanResult = powUsedAsSqrt(NaN) |
| if (nanResult === nanResult) |
| throw "Failed powUsedAsSqrt(NaN)"; |
| let zeroResult = powUsedAsSqrt(0.) |
| if (zeroResult || (1 / zeroResult) !== Infinity) |
| throw "Failed powUsedAsSqrt(0.)"; |
| let negativeZeroResult = powUsedAsSqrt(-0) |
| if (negativeZeroResult || (1 / negativeZeroResult) !== Infinity) |
| throw "Failed powUsedAsSqrt(-0)"; |
| } |
| } |
| testPowUsedAsSqrt(); |
| |
| function powUsedAsOneOverSqrt(x) { |
| return x ** -0.5; |
| } |
| noInline(powUsedAsOneOverSqrt); |
| |
| function testPowUsedAsOneOverSqrt() { |
| for (let i = 0; i < 1e4; ++i) { |
| let result = powUsedAsOneOverSqrt(4); |
| if (result !== 0.5) |
| throw "Error: powUsedAsOneOverSqrt(4) should be 0.5, was = " + result; |
| result = powUsedAsOneOverSqrt(4.4); |
| if (result !== 1/Math.sqrt(4.4)) |
| throw "Error: powUsedAsOneOverSqrt(4) should be " + 1/Math.sqrt(4.4) + ", was = " + result; |
| if (powUsedAsOneOverSqrt(Infinity) !== 0) |
| throw "Failed powUsedAsOneOverSqrt(Infinity)"; |
| if (powUsedAsOneOverSqrt(-Infinity) !== 0) |
| throw "Failed powUsedAsOneOverSqrt(-Infinity)"; |
| let nanResult = powUsedAsOneOverSqrt(NaN) |
| if (nanResult === nanResult) |
| throw "Failed powUsedAsOneOverSqrt(NaN)"; |
| if (powUsedAsOneOverSqrt(0) !== Infinity) |
| throw "Failed powUsedAsOneOverSqrt(0)"; |
| if (powUsedAsOneOverSqrt(-0.) !== Infinity) |
| throw "Failed powUsedAsOneOverSqrt(-0.)"; |
| } |
| } |
| testPowUsedAsOneOverSqrt(); |
| |
| function powUsedAsSquare(x) { |
| return x ** 2; |
| } |
| noInline(powUsedAsSquare); |
| |
| function testPowUsedAsSquare() { |
| for (let i = 0; i < 1e4; ++i) { |
| let result = powUsedAsSquare(2); |
| if (result !== 4) |
| throw "Error: powUsedAsSquare(4) should be 2, was = " + result; |
| result = powUsedAsSquare(4.4); |
| if (result !== 19.360000000000003) |
| throw "Error: powUsedAsSquare(4) should be " + 19.360000000000003 + ", was = " + result; |
| result = powUsedAsSquare(Math.PI); |
| if (result !== 9.869604401089358) |
| throw "Error: powUsedAsSquare(4) should be " + 9.869604401089358 + ", was = " + result; |
| if (powUsedAsSquare(Infinity) !== Infinity) |
| throw "Failed powUsedAsSquare(Infinity)"; |
| if (powUsedAsSquare(-Infinity) !== Infinity) |
| throw "Failed powUsedAsSquare(-Infinity)"; |
| let nanResult = powUsedAsSquare(NaN) |
| if (nanResult === nanResult) |
| throw "Failed powUsedAsSquare(NaN)"; |
| let zeroResult = powUsedAsSquare(0.) |
| if (zeroResult || (1 / zeroResult) !== Infinity) |
| throw "Failed powUsedAsSquare(0.)"; |
| let negativeZeroResult = powUsedAsSquare(-0) |
| if (negativeZeroResult || (1 / negativeZeroResult) !== Infinity) |
| throw "Failed powUsedAsSquare(-0)"; |
| } |
| } |
| testPowUsedAsSquare(); |
| |
| function intIntConstantsSmallNumbers() { |
| return 42 ** 3; |
| } |
| function intIntConstantsLargeNumbers() { |
| // The result does not fit in a integer. |
| return 42 ** 42; |
| } |
| function intIntSmallConstants() { |
| return 42 ** 3; |
| } |
| function intDoubleConstants() { |
| return 14 ** 42.5; |
| } |
| function doubleDoubleConstants() { |
| return 13.5 ** 42.5; |
| } |
| function doubleIntConstants() { |
| return 13.5 ** 52; |
| } |
| noInline(intIntConstantsSmallNumbers); |
| noInline(intIntConstantsLargeNumbers); |
| noInline(intDoubleConstants); |
| noInline(doubleDoubleConstants); |
| noInline(doubleIntConstants); |
| |
| function testBaseAndExponentConstantLiterals() |
| { |
| for (var i = 0; i < 10000; ++i) { |
| var result = intIntConstantsSmallNumbers(); |
| if (result !== 74088) |
| throw "Error: intIntConstantsSmallNumbers() should be 74088, was = " + result; |
| } |
| for (var i = 0; i < 10000; ++i) { |
| var result = intIntConstantsLargeNumbers(); |
| if (result !== 1.5013093754529656e+68) |
| throw "Error: intIntConstantsLargeNumbers() should be 1.5013093754529656e+68, was = " + result; |
| } |
| for (var i = 0; i < 10000; ++i) { |
| var result = intDoubleConstants(); |
| if (result !== 5.1338303882015765e+48) |
| throw "Error: intDoubleConstants() should be 5.1338303882015765e+48, was = " + result; |
| } |
| for (var i = 0; i < 10000; ++i) { |
| var result = doubleDoubleConstants(); |
| if (result !== 1.0944228729647829e+48) |
| throw "Error: doubleDoubleConstants() should be 1.0944228729647829e+48, was = " + result; |
| } |
| for (var i = 0; i < 10000; ++i) { |
| var result = doubleIntConstants(); |
| if (result !== 5.989022735311158e+58) |
| throw "Error: doubleIntConstants() should be 5.989022735311158e+58, was = " + result; |
| } |
| } |
| testBaseAndExponentConstantLiterals(); |
| |
| |
| function exponentIsIntegerConstant(x) { |
| return x ** 42; |
| } |
| noInline(exponentIsIntegerConstant); |
| |
| function testExponentIsIntegerConstant() { |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsIntegerConstant(2); |
| if (result !== 4398046511104) |
| throw "Error: exponentIsIntegerConstant(2) should be 4398046511104, was = " + result; |
| } |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsIntegerConstant(5); |
| if (result !== 2.2737367544323207e+29) |
| throw "Error: exponentIsIntegerConstant(5) should be 2.2737367544323207e+29, was = " + result; |
| } |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsIntegerConstant(2.1); |
| if (result !== 34135823067412.42) |
| throw "Error: exponentIsIntegerConstant(2.1) should be 34135823067412.42, was = " + result; |
| } |
| } |
| testExponentIsIntegerConstant(); |
| |
| |
| function exponentIsDoubleConstant(x) { |
| return x ** 42.5; |
| } |
| noInline(exponentIsDoubleConstant); |
| |
| function testExponentIsDoubleConstant() { |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsDoubleConstant(2); |
| if (result !== 6219777023950.95) |
| throw "Error: exponentIsDoubleConstant(2) should be 6219777023950.95, was = " + result; |
| } |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsDoubleConstant(5); |
| if (result !== 5.084229945850415e+29) |
| throw "Error: exponentIsDoubleConstant(5) should be 5.084229945850415e+29, was = " + result; |
| } |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsDoubleConstant(2.1); |
| if (result !== 49467507261113.805) |
| throw "Error: exponentIsDoubleConstant(2.1) should be 49467507261113.805, was = " + result; |
| } |
| } |
| testExponentIsDoubleConstant(); |
| |
| |
| function exponentIsInfinityConstant(x) { |
| return x ** Infinity; |
| } |
| noInline(exponentIsInfinityConstant); |
| |
| function testExponentIsInfinityConstant() { |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsInfinityConstant(2); |
| if (result !== Infinity) |
| throw "Error: exponentIsInfinityConstant(2) should be Infinity, was = " + result; |
| } |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsInfinityConstant(5); |
| if (result !== Infinity) |
| throw "Error: exponentIsInfinityConstant(5) should be Infinity, was = " + result; |
| } |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsInfinityConstant(2.1); |
| if (result !== Infinity) |
| throw "Error: exponentIsInfinityConstant(2.1) should be Infinity, was = " + result; |
| } |
| } |
| testExponentIsInfinityConstant(); |
| |
| |
| function exponentIsNegativeInfinityConstant(x) { |
| return x ** -Infinity; |
| } |
| noInline(exponentIsNegativeInfinityConstant); |
| |
| function testExponentIsNegativeInfinityConstant() { |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsNegativeInfinityConstant(2); |
| if (result !== 0) |
| throw "Error: exponentIsNegativeInfinityConstant(2) should be zero, was = " + result; |
| } |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsNegativeInfinityConstant(5); |
| if (result !== 0) |
| throw "Error: exponentIsNegativeInfinityConstant(5) should be zero, was = " + result; |
| } |
| for (var i = 0; i < 1000; ++i) { |
| var result = exponentIsNegativeInfinityConstant(2.1); |
| if (result !== 0) |
| throw "Error: exponentIsNegativeInfinityConstant(2.1) should be zero, was = " + result; |
| } |
| } |
| testExponentIsNegativeInfinityConstant(); |