| //------------------------------------------------------------------------------------------------------- |
| // Copyright (C) Microsoft. All rights reserved. |
| // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information. |
| //------------------------------------------------------------------------------------------------------- |
| |
| // ES6 Math API extensions tests -- verifies the API shape and basic functionality |
| |
| WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js"); |
| |
| // WARNING!! As a convenience in this test suite assert.areEqual is |
| // overridden so that -0 does not equal +0. The tests here all make |
| // the distinction between negative and positive zero. |
| assert.areEqual = (function () { |
| var areEqual = assert.areEqual; |
| |
| return function (expected, actual, message) { |
| if (expected === 0 && actual === 0) { |
| var isNegativeZero = function isNegativeZero(x) { return x === 0 && (1 / x) === -Infinity; }; |
| |
| if (isNegativeZero(expected) !== isNegativeZero(actual)) { |
| if (isNegativeZero(expected)) expected = "-0"; |
| if (isNegativeZero(actual)) actual = "-0"; |
| |
| throw "assert.areEqualSignedZero failed: expected: " + expected + " actual: " + actual + (message !== undefined ? ": " + message : ""); |
| } |
| } |
| return areEqual(expected, actual, message); |
| }; |
| })(); |
| |
| var assertFunctionExactlyEqual = function (expected, fn, x, message) { |
| assert.areEqual(expected, fn(x), message); |
| }; |
| |
| var assertFunctionExactlyEqual2 = function (expected, fn, x, y, message) { |
| assert.areEqual(expected, fn(x, y), message); |
| }; |
| |
| var assertFunctionExactlyEqual3 = function (expected, fn, x, y, z, message) { |
| assert.areEqual(expected, fn(x, y, z), message); |
| }; |
| |
| var assertFunctionExactlyEqual4 = function (expected, fn, x, y, z, w, message) { |
| assert.areEqual(expected, fn(x, y, z, w), message); |
| }; |
| |
| var assertFunctionExactlyEqual7 = function (expected, fn, x, y, z, w, a, b, c, message) { |
| assert.areEqual(expected, fn(x, y, z, w, a, b, c), message); |
| }; |
| |
| var assertFunctionAlmostEqual = function (expected, fn, x, message) { |
| assert.areAlmostEqual(expected, fn(x), message); |
| }; |
| |
| var assertFunctionAlmostEqual2 = function (expected, fn, x, y, message) { |
| assert.areAlmostEqual(expected, fn(x, y), message); |
| }; |
| |
| var assertFunctionAlmostEqual3 = function (expected, fn, x, y, z, message) { |
| assert.areAlmostEqual(expected, fn(x, y, z), message); |
| }; |
| |
| var tests = [ |
| { |
| name: "Math object should have spec defined built-ins with correct lengths", |
| body: function () { |
| assert.isTrue(Math.hasOwnProperty('log10'), "Math should have a log10 method"); |
| assert.isTrue(Math.hasOwnProperty('log2'), "Math should have a log2 method"); |
| assert.isTrue(Math.hasOwnProperty('log1p'), "Math should have a log1p method"); |
| assert.isTrue(Math.hasOwnProperty('expm1'), "Math should have a expm1 method"); |
| assert.isTrue(Math.hasOwnProperty('cosh'), "Math should have a cosh method"); |
| assert.isTrue(Math.hasOwnProperty('sinh'), "Math should have a sinh method"); |
| assert.isTrue(Math.hasOwnProperty('tanh'), "Math should have a tanh method"); |
| assert.isTrue(Math.hasOwnProperty('acosh'), "Math should have a acosh method"); |
| assert.isTrue(Math.hasOwnProperty('asinh'), "Math should have a asinh method"); |
| assert.isTrue(Math.hasOwnProperty('atanh'), "Math should have a atanh method"); |
| assert.isTrue(Math.hasOwnProperty('hypot'), "Math should have a hypot method"); |
| assert.isTrue(Math.hasOwnProperty('trunc'), "Math should have a trunc method"); |
| assert.isTrue(Math.hasOwnProperty('sign'), "Math should have a sign method"); |
| assert.isTrue(Math.hasOwnProperty('cbrt'), "Math should have a cbrt method"); |
| assert.isTrue(Math.hasOwnProperty('imul'), "Math should have a imul method"); |
| assert.isTrue(Math.hasOwnProperty('clz32'), "Math should have a clz32 method"); |
| |
| assert.isTrue(Math.log10.length === 1, "log10 method takes one argument"); |
| assert.isTrue(Math.log2.length === 1, "log2 method takes one argument"); |
| assert.isTrue(Math.log1p.length === 1, "log1p method takes one argument"); |
| assert.isTrue(Math.expm1.length === 1, "expm1 method takes one argument"); |
| assert.isTrue(Math.cosh.length === 1, "cosh method takes one argument"); |
| assert.isTrue(Math.sinh.length === 1, "sinh method takes one argument"); |
| assert.isTrue(Math.tanh.length === 1, "tanh method takes one argument"); |
| assert.isTrue(Math.acosh.length === 1, "acosh method takes one argument"); |
| assert.isTrue(Math.asinh.length === 1, "asinh method takes one argument"); |
| assert.isTrue(Math.atanh.length === 1, "atanh method takes one argument"); |
| assert.isTrue(Math.hypot.length === 2, "hypot method takes three arguments but the third is optional and spec says the length must be 2"); |
| assert.isTrue(Math.trunc.length === 1, "trunc method takes one argument"); |
| assert.isTrue(Math.sign.length === 1, "sign method takes one argument"); |
| assert.isTrue(Math.cbrt.length === 1, "cbrt method takes one argument"); |
| assert.isTrue(Math.imul.length === 2, "imul method takes two arguments"); |
| assert.isTrue(Math.clz32.length === 1, "clz32 method takes one argument"); |
| } |
| }, |
| { |
| name: "Math APIs all return NaN if called with no arguments or passed undefined for arguments", |
| body: function () { |
| assert.areEqual(NaN, Math.log10(), "log10 returns NaN given no arguments"); |
| assert.areEqual(NaN, Math.log2(), "log2 returns NaN given no arguments"); |
| assert.areEqual(NaN, Math.log1p(), "log1p returns NaN given no arguments"); |
| assert.areEqual(NaN, Math.expm1(), "expm1 returns NaN given no arguments"); |
| assert.areEqual(NaN, Math.cosh(), "cosh returns NaN given no arguments"); |
| assert.areEqual(NaN, Math.sinh(), "sinh returns NaN given no arguments"); |
| assert.areEqual(NaN, Math.tanh(), "tanh returns NaN given no arguments"); |
| assert.areEqual(NaN, Math.acosh(), "acosh returns NaN given no arguments"); |
| assert.areEqual(NaN, Math.asinh(), "asinh returns NaN given no arguments"); |
| assert.areEqual(NaN, Math.atanh(), "atanh returns NaN given no arguments"); |
| assert.areEqual( +0, Math.hypot(), "hypot returns +0 given no arguments"); |
| assert.areEqual(123, Math.hypot(123), "hypot returns abs(123) given only one argument"); |
| assert.areEqual(123, Math.hypot(-123), "hypot returns abs(-123) given only one argument"); |
| assert.areEqual(NaN, Math.trunc(), "trunc returns NaN given no arguments"); |
| assert.areEqual(NaN, Math.sign(), "sign returns NaN given no arguments"); |
| assert.areEqual(NaN, Math.cbrt(), "cbrt returns NaN given no arguments"); |
| // imul actually returns +0 since it converts its arguments via ToUint32 which converts undefined to 0 |
| assert.areEqual( +0, Math.imul(), "imul returns +0 given no arguments"); |
| assert.areEqual( +0, Math.imul(123), "imul returns +0 given too few arguments"); |
| |
| assert.areEqual(NaN, Math.log10(undefined), "log10 returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.log2(undefined), "log2 returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.log1p(undefined), "log1p returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.expm1(undefined), "expm1 returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.cosh(undefined), "cosh returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.sinh(undefined), "sinh returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.tanh(undefined), "tanh returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.acosh(undefined), "acosh returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.asinh(undefined), "asinh returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.atanh(undefined), "atanh returns NaN when passed undefined"); |
| /* |
| assert.areEqual(NaN, Math.hypot(undefined, undefined), "hypot returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.hypot(undefined, undefined, undefined), "hypot returns NaN when passed undefined"); |
| */ |
| assert.areEqual(NaN, Math.trunc(undefined), "trunc returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.sign(undefined), "sign returns NaN when passed undefined"); |
| assert.areEqual(NaN, Math.cbrt(undefined), "cbrt returns NaN when passed undefined"); |
| assert.areEqual( +0, Math.imul(undefined), "imul returns +0 when passed undefined"); |
| assert.areEqual( +0, Math.imul(undefined, undefined), "imul returns +0 when passed undefined"); |
| } |
| }, |
| { |
| name: "log10 computes the base 10 logarithm and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.log10, NaN, "if x is NaN, then the result of log10(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.log10, -1, "if x is less than 0, then the result of log10(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.log10, -500, "if x is less than 0, then the result of log10(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.log10, -Infinity, "if x is less than 0, then the result of log10(x) is NaN"); |
| assertFunctionExactlyEqual(-Infinity, Math.log10, +0, "if x is +0, then the result of log10(x) is -Infinity"); |
| assertFunctionExactlyEqual(-Infinity, Math.log10, -0, "if x is -0, then the result of log10(x) is -Infinity"); |
| assertFunctionExactlyEqual( +0, Math.log10, 1, "if x is 1, then the result of log10(x) is +0"); |
| assertFunctionExactlyEqual(+Infinity, Math.log10, +Infinity, "if x is +Infinity, then the result of log10(x) is +Infinity"); |
| |
| assertFunctionAlmostEqual( 1, Math.log10, 10, "log10(10) = 1"); |
| assertFunctionAlmostEqual( 2, Math.log10, 100, "log10(100) = 2"); |
| assertFunctionAlmostEqual( 6, Math.log10, 1000000, "log10(100) = 6"); |
| } |
| }, |
| { |
| name: "log2 computes the base 2 logarithm and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.log2, NaN, "if x is NaN, then the result of log2(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.log2, -1, "if x is less than 0, then the result of log2(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.log2, -500, "if x is less than 0, then the result of log2(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.log2, -Infinity, "if x is less than 0, then the result of log2(x) is NaN"); |
| assertFunctionExactlyEqual(-Infinity, Math.log2, +0, "if x is +0, then the result of log2(x) is -Infinity"); |
| assertFunctionExactlyEqual(-Infinity, Math.log2, -0, "if x is -0, then the result of log2(x) is -Infinity"); |
| assertFunctionExactlyEqual( +0, Math.log2, 1, "if x is 1, then the result of log2(x) is +0"); |
| assertFunctionExactlyEqual(+Infinity, Math.log2, +Infinity, "if x is +Infinity, then the result of log2(x) is +Infinity"); |
| |
| assertFunctionAlmostEqual( 1, Math.log2, 2, "log2(2) = 1"); |
| assertFunctionAlmostEqual( 2, Math.log2, 4, "log2(4) = 2"); |
| assertFunctionAlmostEqual( 6, Math.log2, 64, "log2(64) = 6"); |
| } |
| }, |
| { |
| name: "log1p computes the natural logarithm of 1 + x and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.log1p, NaN, "if x is NaN, then the result of log1p(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.log1p, -2, "if x is less than -1, then the result of log1p(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.log1p, -500, "if x is less than -1, then the result of log1p(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.log1p, -Infinity, "if x is less than -1, then the result of log1p(x) is NaN"); |
| assertFunctionExactlyEqual(-Infinity, Math.log1p, -1, "if x is -1, then the result of log1p(x) is -Infinity"); |
| assertFunctionExactlyEqual( +0, Math.log1p, +0, "if x is +0, then the result of log1p(x) is +0"); |
| assertFunctionExactlyEqual( -0, Math.log1p, -0, "if x is -0, then the result of log1p(x) is -0"); |
| assertFunctionExactlyEqual(+Infinity, Math.log1p, +Infinity, "if x is +Infinity, then the result of log1p(x) is +Infinity"); |
| |
| var e = Math.E; |
| var e2 = e * e; |
| var e6 = e2 * e2 * e2; |
| |
| assertFunctionAlmostEqual( 1, Math.log1p, e - 1, "log1p(e - 1) = 1"); |
| assertFunctionAlmostEqual( 2, Math.log1p, e2 - 1, "log1p(e^2 - 1) = 2"); |
| assertFunctionAlmostEqual( 6, Math.log1p, e6 - 1, "log1p(e^6 - 1) = 6"); |
| |
| // TODO: Figure out how to run these tests on machines with C99 APIs |
| /* |
| assertFunctionAlmostEqual( 1e-20, Math.log1p, 1e-20, "log1p(10^-20) = 10^-20"); |
| assertFunctionAlmostEqual( 1e-30, Math.log1p, 1e-30, "log1p(10^-30) = 10^-30"); |
| assertFunctionAlmostEqual( 1e-50, Math.log1p, 1e-50, "log1p(10^-50) = 10^-50"); |
| */ |
| } |
| }, |
| { |
| name: "expm1 computes the result of subtracting 1 from the exponential function and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.expm1, NaN, "if x is NaN, then the result of expm1(x) is NaN"); |
| assertFunctionExactlyEqual( +0, Math.expm1, +0, "if x is +0, then the result of expm1(x) is +0"); |
| assertFunctionExactlyEqual( -0, Math.expm1, -0, "if x is -0, then the result of expm1(x) is -0"); |
| assertFunctionExactlyEqual(+Infinity, Math.expm1, +Infinity, "if x is +Infinity, then the result of expm1(x) is +Infinity"); |
| assertFunctionExactlyEqual( -1, Math.expm1, -Infinity, "if x is -Infinity, then the result of expm1(x) is -1"); |
| |
| var e = Math.E; |
| var e2 = e * e; |
| var e6 = e2 * e2 * e2; |
| |
| assertFunctionAlmostEqual( e - 1, Math.expm1, 1, "expm1(1) = e - 1"); |
| assertFunctionAlmostEqual( e2 - 1, Math.expm1, 2, "expm1(2) = e^2 - 1"); |
| assertFunctionAlmostEqual( e6 - 1, Math.expm1, 6, "expm1(6) = e^6 - 1"); |
| |
| // TODO: Figure out how to run these tests on machines with C99 APIs |
| /* |
| assertFunctionAlmostEqual( 1e-20, Math.expm1, 1e-20, "expm1(10^-20) = 10^-20"); |
| assertFunctionAlmostEqual( 1e-30, Math.expm1, 1e-30, "expm1(10^-30) = 10^-30"); |
| assertFunctionAlmostEqual( 1e-50, Math.expm1, 1e-50, "expm1(10^-50) = 10^-50"); |
| */ |
| } |
| }, |
| { |
| name: "cosh computes the hyperbolic cosine and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.cosh, NaN, "if x is NaN, then the result of cosh(x) is NaN"); |
| assertFunctionExactlyEqual( 1, Math.cosh, +0, "if x is +0, then the result of cosh(x) is 1"); |
| assertFunctionExactlyEqual( 1, Math.cosh, -0, "if x is -0, then the result of cosh(x) is 1"); |
| assertFunctionExactlyEqual(+Infinity, Math.cosh, +Infinity, "if x is +Infinity, then the result of cosh(x) is +Infinity"); |
| assertFunctionExactlyEqual(+Infinity, Math.cosh, -Infinity, "if x is -Infinity, then the result of cosh(x) is +Infinity"); |
| |
| var e = Math.E; |
| var e2 = e * e; |
| var em2 = 1 / e2; |
| |
| var cosh1 = (e + 1/e) / 2; |
| var cosh2 = (e2 + em2) / 2; |
| |
| assertFunctionAlmostEqual( cosh1, Math.cosh, 1, "cosh(1) = (e + e^-1) / 2"); |
| assertFunctionAlmostEqual( cosh2, Math.cosh, 2, "cosh(2) = (e^2 + e^-2) / 2"); |
| } |
| }, |
| { |
| name: "sinh computes the hyperbolic sine and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.sinh, NaN, "if x is NaN, then the result of sinh(x) is NaN"); |
| assertFunctionExactlyEqual( +0, Math.sinh, +0, "if x is +0, then the result of sinh(x) is +0"); |
| assertFunctionExactlyEqual( -0, Math.sinh, -0, "if x is -0, then the result of sinh(x) is -0"); |
| assertFunctionExactlyEqual(+Infinity, Math.sinh, +Infinity, "if x is +Infinity, then the result of sinh(x) is +Infinity"); |
| assertFunctionExactlyEqual(-Infinity, Math.sinh, -Infinity, "if x is -Infinity, then the result of sinh(x) is -Infinity"); |
| |
| var e = Math.E; |
| var e2 = e * e; |
| var em2 = 1 / e2; |
| |
| var sinh1 = (e - 1/e) / 2; |
| var sinh2 = (e2 - em2) / 2; |
| |
| assertFunctionAlmostEqual( sinh1, Math.sinh, 1, "sinh(1) = (e - e^-1) / 2"); |
| assertFunctionAlmostEqual( sinh2, Math.sinh, 2, "sinh(2) = (e^2 - e^-2) / 2"); |
| } |
| }, |
| { |
| name: "tanh computes the hyperbolic tangent and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.tanh, NaN, "if x is NaN, then the result of tanh(x) is NaN"); |
| assertFunctionExactlyEqual( +0, Math.tanh, +0, "if x is +0, then the result of tanh(x) is +0"); |
| assertFunctionExactlyEqual( -0, Math.tanh, -0, "if x is -0, then the result of tanh(x) is -0"); |
| assertFunctionExactlyEqual( 1, Math.tanh, +Infinity, "if x is +Infinity, then the result of tanh(x) is 1"); |
| assertFunctionExactlyEqual( -1, Math.tanh, -Infinity, "if x is -Infinity, then the result of tanh(x) is -1"); |
| |
| var tanh1 = Math.sinh(1) / Math.cosh(1); |
| var tanh2 = Math.sinh(2) / Math.cosh(2); |
| |
| assertFunctionAlmostEqual( tanh1, Math.tanh, 1, "tanh(1) = sinh(1) / cosh(1)"); |
| assertFunctionAlmostEqual( tanh2, Math.tanh, 2, "tanh(2) = sinh(2) / cosh(2)"); |
| } |
| }, |
| { |
| name: "acosh computes the inverse hyperbolic cosine and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.acosh, NaN, "if x is NaN, then the result of acosh(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.acosh, 0.999, "if x is less than 1, then the result of acosh(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.acosh, 0.5, "if x is less than 1, then the result of acosh(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.acosh, 0, "if x is less than 1, then the result of acosh(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.acosh, -1, "if x is less than 1, then the result of acosh(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.acosh, -Infinity, "if x is less than 1, then the result of acosh(x) is NaN"); |
| assertFunctionExactlyEqual( +0, Math.acosh, 1, "if x is 1, then the result of acosh(x) is +0"); |
| assertFunctionExactlyEqual(+Infinity, Math.acosh, +Infinity, "if x is +Infinity, then the result of acosh(x) is +Infinity"); |
| |
| var acosh2 = Math.log(2 + Math.sqrt(3)); |
| var acosh3 = Math.log(3 + Math.sqrt(8)); |
| |
| assertFunctionAlmostEqual( acosh2, Math.acosh, 2, "acosh(2) = ln(2 + sqrt(3))"); |
| assertFunctionAlmostEqual( acosh3, Math.acosh, 3, "acosh(3) = ln(3 + sqrt(8))"); |
| } |
| }, |
| { |
| name: "asinh computes the inverse hyperbolic sine and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.asinh, NaN, "if x is NaN, then the result of asinh(x) is NaN"); |
| assertFunctionExactlyEqual( +0, Math.asinh, +0, "if x is +0, then the result of asinh(x) is +0"); |
| assertFunctionExactlyEqual( -0, Math.asinh, -0, "if x is -0, then the result of asinh(x) is -0"); |
| assertFunctionExactlyEqual(+Infinity, Math.asinh, +Infinity, "if x is +Infinity, then the result of asinh(x) is +Infinity"); |
| assertFunctionExactlyEqual(-Infinity, Math.asinh, -Infinity, "if x is -Infinity, then the result of asinh(x) is -Infinity"); |
| |
| var asinh1 = Math.log(1 + Math.SQRT2); |
| var asinh2 = Math.log(2 + Math.sqrt(5)); |
| |
| assertFunctionAlmostEqual( asinh1, Math.asinh, 1, "asinh(1) = ln(1 + sqrt(2))"); |
| assertFunctionAlmostEqual( asinh2, Math.asinh, 2, "asinh(2) = ln(2 + sqrt(5))"); |
| } |
| }, |
| { |
| name: "atanh computes the inverse hyperbolic tangent and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.atanh, NaN, "if x is NaN, then the result of atanh(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.atanh, -1.001, "if x is less than -1, then the result of atanh(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.atanh, -2, "if x is less than -1, then the result of atanh(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.atanh, -Infinity, "if x is less than -1, then the result of atanh(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.atanh, 1.001, "if x is greater than 1, then the result of atanh(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.atanh, 2, "if x is greater than 1, then the result of atanh(x) is NaN"); |
| assertFunctionExactlyEqual( NaN, Math.atanh, +Infinity, "if x is greater than 1, then the result of atanh(x) is NaN"); |
| assertFunctionExactlyEqual(-Infinity, Math.atanh, -1, "if x is -1, then the result of atanh(x) is -Infinity"); |
| assertFunctionExactlyEqual(+Infinity, Math.atanh, 1, "if x is 1, then the result of atanh(x) is +Infinity"); |
| assertFunctionExactlyEqual( +0, Math.atanh, +0, "if x is +0, then the result of atanh(x) is +0"); |
| assertFunctionExactlyEqual( -0, Math.atanh, -0, "if x is -0, then the result of atanh(x) is -0"); |
| |
| var atanh05 = Math.log(3) / 2; |
| var atanh025 = Math.log(5/3) / 2; |
| |
| assertFunctionAlmostEqual( atanh05, Math.atanh, 0.5, "atanh(0.5) = 1/2 * ln(1.5 / 0.5)"); |
| assertFunctionAlmostEqual( atanh025, Math.atanh, 0.25, "atanh(0.25) = 1/2 * ln(1.25 / 0.75)"); |
| } |
| }, |
| { |
| name: "hypot computes the square root of the sum of the squares of the arguments and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual2(+Infinity, Math.hypot, +Infinity, 0, "if any argument is +Infinity, then the result of hypot(x,y) is +Infinity"); |
| assertFunctionExactlyEqual2(+Infinity, Math.hypot, 0, +Infinity, "if any argument is +Infinity, then the result of hypot(x,y) is +Infinity"); |
| assertFunctionExactlyEqual2(+Infinity, Math.hypot, -Infinity, 0, "if any argument is -Infinity, then the result of hypot(x,y) is +Infinity"); |
| assertFunctionExactlyEqual2(+Infinity, Math.hypot, 0, -Infinity, "if any argument is -Infinity, then the result of hypot(x,y) is +Infinity"); |
| assertFunctionExactlyEqual2(+Infinity, Math.hypot, +Infinity, NaN, "if any argument is +Infinity, then the result of hypot(x,y) is +Infinity, even if another argument is NaN"); |
| assertFunctionExactlyEqual2(+Infinity, Math.hypot, NaN, +Infinity, "if any argument is +Infinity, then the result of hypot(x,y) is +Infinity, even if another argument is NaN"); |
| assertFunctionExactlyEqual2(+Infinity, Math.hypot, -Infinity, NaN, "if any argument is -Infinity, then the result of hypot(x,y) is +Infinity, even if another argument is NaN"); |
| assertFunctionExactlyEqual2(+Infinity, Math.hypot, NaN, -Infinity, "if any argument is -Infinity, then the result of hypot(x,y) is +Infinity, even if another argument is NaN"); |
| assertFunctionExactlyEqual2( NaN, Math.hypot, NaN, 0, "if no argument is +/- Infinity, and any argument is NaN, then the result of hypot(x,y) is NaN"); |
| assertFunctionExactlyEqual2( NaN, Math.hypot, 0, NaN, "if no argument is +/- Infinity, and any argument is NaN, then the result of hypot(x,y) is NaN"); |
| assertFunctionExactlyEqual2( +0, Math.hypot, 0, 0, "if all arguments are either +0 or -0, then the result of hypot(x,y) is +0"); |
| assertFunctionExactlyEqual2( +0, Math.hypot, -0, -0, "if all arguments are either +0 or -0, then the result of hypot(x,y) is +0"); |
| |
| assertFunctionExactlyEqual2( 1.4142135623730951e308, Math.hypot, 1e308, 1e308, "hypot(1e308, 1e308) = 1.414e308 and shouldn't cause NaN from premature overflow"); |
| assertFunctionExactlyEqual2(1.4142135623730951e-308, Math.hypot, 1e-308, 1e-308, "hypot(1e-308, 1e-308) = 1.414e-308 and shouldn't cause NaN from premature underflow"); |
| |
| assertFunctionAlmostEqual2( 5, Math.hypot, 3, 4, "hypot(3,4) = 5"); |
| |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, +Infinity, 0, 0, "if any argument is +Infinity, then the result of hypot(x,y,z) is +Infinity"); |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, 0, +Infinity, 0, "if any argument is +Infinity, then the result of hypot(x,y,z) is +Infinity"); |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, 0, 0, +Infinity, "if any argument is +Infinity, then the result of hypot(x,y,z) is +Infinity"); |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, -Infinity, 0, 0, "if any argument is -Infinity, then the result of hypot(x,y,z) is +Infinity"); |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, 0, -Infinity, 0, "if any argument is -Infinity, then the result of hypot(x,y,z) is +Infinity"); |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, 0, 0, -Infinity, "if any argument is -Infinity, then the result of hypot(x,y,z) is +Infinity"); |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, +Infinity, NaN, NaN, "if any argument is +Infinity, then the result of hypot(x,y,z) is +Infinity, even if another argument is NaN"); |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, NaN, +Infinity, NaN, "if any argument is +Infinity, then the result of hypot(x,y,z) is +Infinity, even if another argument is NaN"); |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, NaN, NaN, +Infinity, "if any argument is +Infinity, then the result of hypot(x,y,z) is +Infinity, even if another argument is NaN"); |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, -Infinity, NaN, NaN, "if any argument is -Infinity, then the result of hypot(x,y,z) is +Infinity, even if another argument is NaN"); |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, NaN, -Infinity, NaN, "if any argument is -Infinity, then the result of hypot(x,y,z) is +Infinity, even if another argument is NaN"); |
| assertFunctionExactlyEqual3(+Infinity, Math.hypot, NaN, NaN, -Infinity, "if any argument is -Infinity, then the result of hypot(x,y,z) is +Infinity, even if another argument is NaN"); |
| assertFunctionExactlyEqual3( NaN, Math.hypot, NaN, 0, 0, "if no argument is +/- Infinity, and any argument is NaN, then the result of hypot(x,y,z) is NaN"); |
| assertFunctionExactlyEqual3( NaN, Math.hypot, 0, NaN, 0, "if no argument is +/- Infinity, and any argument is NaN, then the result of hypot(x,y,z) is NaN"); |
| assertFunctionExactlyEqual3( NaN, Math.hypot, 0, 0, NaN, "if no argument is +/- Infinity, and any argument is NaN, then the result of hypot(x,y,z) is NaN"); |
| assertFunctionExactlyEqual3( +0, Math.hypot, 0, 0, 0, "if all arguments are either +0 or -0, then the result of hypot(x,y,z) is +0"); |
| assertFunctionExactlyEqual3( +0, Math.hypot, -0, -0, -0, "if all arguments are either +0 or -0, then the result of hypot(x,y,z) is +0"); |
| |
| assertFunctionExactlyEqual3(1.7320508075688772e+308, Math.hypot, 1e308, 1e308, 1e308, "hypot(1e308, 1e308, 1e308) = 1.732e308 and shouldn't cause NaN from premature overflow"); |
| assertFunctionExactlyEqual3(1.7320508075688772e-308, Math.hypot, 1e-308, 1e-308, 1e-308, "hypot(1e-308, 1e-308, 1e-308) = 1.732e-308 and shouldn't cause NaN from premature underflow"); |
| assertFunctionExactlyEqual3(1.4142135623730951e-308, Math.hypot, 0, 1e-308, 1e-308, "hypot(0, 1e-308, 1e-308) = 1.414e-308 and shouldn't cause NaN from premature underflow (testing NonZeroMin codepath)"); |
| assertFunctionExactlyEqual3(1.4142135623730951e-308, Math.hypot, 1e-308, 0, 1e-308, "hypot(1e-308, 0, 1e-308) = 1.414e-308 and shouldn't cause NaN from premature underflow (testing NonZeroMin codepath)"); |
| assertFunctionExactlyEqual3(1.4142135623730951e-308, Math.hypot, 1e-308, 1e-308, 0, "hypot(1e-308, 1e-308, 0) = 1.414e-308 and shouldn't cause NaN from premature underflow (testing NonZeroMin codepath)"); |
| assertFunctionExactlyEqual3( 1e-308, Math.hypot, 1e-308, 0, 0, "hypot(1e-308, 0, 0) = 1.414e-308 and shouldn't cause NaN from premature underflow (testing NonZeroMin codepath)"); |
| assertFunctionExactlyEqual3( 1e-308, Math.hypot, 0, 1e-308, 0, "hypot(0, 1e-308, 0) = 1.414e-308 and shouldn't cause NaN from premature underflow (testing NonZeroMin codepath)"); |
| assertFunctionExactlyEqual3( 1e-308, Math.hypot, 0, 0, 1e-308, "hypot(0, 0, 1e-308) = 1.414e-308 and shouldn't cause NaN from premature underflow (testing NonZeroMin codepath)"); |
| |
| assertFunctionAlmostEqual3( 7, Math.hypot, 2, 3, 6, "hypot(2,3,6) = 7"); |
| |
| assertFunctionExactlyEqual4( 1.7776388834631178e308, Math.hypot, 1e308, 1e308, 1e308, 4e307, "hypot(1e308, 1e308, 1e308, 4e307) = 1.777e308 and shouldn't cause NaN from premature overflow"); |
| assertFunctionExactlyEqual4( 2e-308, Math.hypot, 1e-308, 1e-308, 1e-308, 1e-308, "hypot(1e-308, 1e-308, 1e-308, 1e-308) = 2e-308 and shouldn't cause NaN from premature underflow"); |
| assertFunctionExactlyEqual4( 1.732050807568877e-308, Math.hypot, 0, 1e-308, 1e-308, 1e-308, "hypot(0, 1e-308, 1e-308, 1e-308) = 1.732e-308 and shouldn't cause NaN from premature underflow "); |
| assertFunctionExactlyEqual4( 1.4142135623730951e-308, Math.hypot, 1e-308, 0, 1e-308, 0, "hypot(1e-308, 0, 1e-308, 0) = 1.414e-308 and shouldn't cause NaN from premature underflow "); |
| assertFunctionExactlyEqual4( 1.4142135623730951e-308, Math.hypot, 1e-308, 1e-308, 0, 0, "hypot(1e-308, 1e-308, 0, 0) = 1.414e-308 and shouldn't cause NaN from premature underflow "); |
| assertFunctionExactlyEqual4( 1e-308, Math.hypot, 1e-308, 0, 0, 0, "hypot(1e-308, 0, 0) = 1.414e-308 and shouldn't cause NaN from premature underflow"); |
| assertFunctionExactlyEqual4( 1.414213562373095e-308, Math.hypot, 0, 1e-308, 0, 1e-308, "hypot(0, 1e-308, 0, 1e-308) = 1.414e-308 and shouldn't cause NaN from premature underflow"); |
| assertFunctionExactlyEqual4( 1.4142135623730951e+308, Math.hypot, 1e308, 0, 0, 1e308, "hypot(1e308, 0, 0, 1e308) = 1.414e+308 and shouldn't cause NaN from premature overflow"); |
| assertFunctionExactlyEqual4( +0, Math.hypot, -0, -0, -0, -0, "hypot(-0, -0, -0, -0) = 0 All zeros positive or negative result in zero"); |
| assertFunctionExactlyEqual4( +0, Math.hypot, 0, -0, 0, -0, "hypot(0, -0, 0, -0) = 0 All zeros positive or negative result in zero"); |
| assertFunctionExactlyEqual4( NaN, Math.hypot, 0, NaN, 1e-308, 0, "hypot(0, NaN, 0, 1e-308) = NaN"); |
| assertFunctionExactlyEqual4( Infinity, Math.hypot, 1e+308, NaN, 1e-308,Infinity, "hypot(1e+308, NaN, 1e-308, Infinity) = Infinity, If any argument is infinity result is infinity"); |
| assertFunctionExactlyEqual4( 1.0000014999988748e-305, Math.hypot, 1e-308, 1e-308, 1e-308, 1e-305, "hypot(1e-308, 1e-308, 1e-308, 1e-305) = 1e-305, and shouldn't cause NaN from premature overflow "); |
| assertFunctionExactlyEqual4( 1.4142135623730951e+308, Math.hypot, 1e-308, 1e+308, 1e-308, 1e+308, "hypot(1e+308, 1e+308, 1e-308, 1e+308) = 1.414e+308 , and shouldn't cause NaN from premature overflow"); |
| |
| assertFunctionExactlyEqual4( 13.950268814614288, Math.hypot, 3.2, -4.8, 9.7, 8.2, "hypot(3.2, -4.8, 9.7, 8.2) = 13.9502"); |
| assertFunctionExactlyEqual4( 25, Math.hypot, 2, 3, 6, 24, "hypot(2, 3, 6, 24) = 25"); |
| assertFunctionExactlyEqual4( 25, Math.hypot, 24, 2, 3, 6, "hypot(24, 2, 3, 6) = 25"); |
| assertFunctionExactlyEqual4( 25, Math.hypot, 2, 24, 3, 6, "hypot(2, 24, 3, 6) = 25"); |
| assertFunctionExactlyEqual4( 25, Math.hypot, 6, 3, 24, 2, "hypot(6, 3, 24, 2) = 25"); |
| |
| assertFunctionExactlyEqual7( 2.6457513110645905e+307, Math.hypot, 1e+307, 1e+307, 1e+307, 1e+307, 1e+307, 1e+307, 1e+307, "hypot(1e+307, ...) = 2.545e+307 and shouldn't cause NaN from premature overflow"); |
| assertFunctionExactlyEqual7( 2.6457513110645904e-308, Math.hypot, 1e-308, 1e-308, 1e-308, 1e-308, 1e-308, 1e-308, 1e-308, "hypot(1e-308, ...) = 2.645e-308, and shouldn't cause NaN from premature underflow"); |
| } |
| }, |
| { |
| name: "trunc computes the integral part of the argument by removing any fractional digits and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.trunc, NaN, "if x is NaN, then the result of trunc(x) is NaN"); |
| assertFunctionExactlyEqual( -0, Math.trunc, -0, "if x is -0, then the result of trunc(x) is -0"); |
| assertFunctionExactlyEqual( +0, Math.trunc, +0, "if x is +0, then the result of trunc(x) is +0"); |
| assertFunctionExactlyEqual(-Infinity, Math.trunc, -Infinity, "if x is -Infinity, then the result of trunc(x) is -Infinity"); |
| assertFunctionExactlyEqual(+Infinity, Math.trunc, +Infinity, "if x is +Infinity, then the result of trunc(x) is +Infinity"); |
| |
| assertFunctionExactlyEqual( +0, Math.trunc, 0.5, "trunc(0.5) = +0"); |
| assertFunctionExactlyEqual( -0, Math.trunc, -0.5, "trunc(-0.5) = -0"); |
| assertFunctionExactlyEqual( 3, Math.trunc, Math.PI, "trunc(pi) = 3"); |
| assertFunctionExactlyEqual( -3, Math.trunc, -Math.PI, "trunc(-pi) = -3"); |
| assertFunctionExactlyEqual( 123, Math.trunc, 123.456, "trunc(123.456) = 123"); |
| } |
| }, |
| { |
| name: "sign computes sign of the argument indicating whether it is positive, negative, or zero and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.sign, NaN, "if x is NaN, then the result of sign(x) is NaN"); |
| assertFunctionExactlyEqual( -0, Math.sign, -0, "if x is -0, then the result of sign(x) is -0"); |
| assertFunctionExactlyEqual( +0, Math.sign, +0, "if x is +0, then the result of sign(x) is +0"); |
| assertFunctionExactlyEqual( -1, Math.sign, -0.001, "if x is negative and not -0, then the result of sign(x) is -1"); |
| assertFunctionExactlyEqual( -1, Math.sign, -1, "if x is negative and not -0, then the result of sign(x) is -1"); |
| assertFunctionExactlyEqual( -1, Math.sign, -200, "if x is negative and not -0, then the result of sign(x) is -1"); |
| assertFunctionExactlyEqual( -1, Math.sign, -Infinity, "if x is negative and not -0, then the result of sign(x) is -1"); |
| assertFunctionExactlyEqual( 1, Math.sign, 0.001, "if x is positive and not +0, then the result of sign(x) is 1"); |
| assertFunctionExactlyEqual( 1, Math.sign, 1, "if x is positive and not +0, then the result of sign(x) is 1"); |
| assertFunctionExactlyEqual( 1, Math.sign, 200, "if x is positive and not +0, then the result of sign(x) is 1"); |
| assertFunctionExactlyEqual( 1, Math.sign, Infinity, "if x is positive and not +0, then the result of sign(x) is 1"); |
| } |
| }, |
| { |
| name: "cbrt computes the cube root and follows spec on special boundary values", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.cbrt, NaN, "if x is NaN, then the result of cbrt(x) is NaN"); |
| assertFunctionExactlyEqual( +0, Math.cbrt, +0, "if x is +0, then the result of cbrt(x) is +0"); |
| assertFunctionExactlyEqual( -0, Math.cbrt, -0, "if x is -0, then the result of cbrt(x) is -0"); |
| assertFunctionExactlyEqual(+Infinity, Math.cbrt, +Infinity, "if x is +Infinity, then the result of cbrt(x) is +Infinity"); |
| assertFunctionExactlyEqual(-Infinity, Math.cbrt, -Infinity, "if x is -Infinity, then the result of cbrt(x) is -Infinity"); |
| |
| assertFunctionAlmostEqual( 1, Math.cbrt, 1, "cbrt(1) = 1"); |
| assertFunctionAlmostEqual( -1, Math.cbrt, -1, "cbrt(-1) = -1"); |
| assertFunctionAlmostEqual( 2, Math.cbrt, 8, "cbrt(8) = 2"); |
| assertFunctionAlmostEqual( -2, Math.cbrt, -8, "cbrt(-8) = -2"); |
| assertFunctionAlmostEqual( 5, Math.cbrt, 125, "cbrt(125) = 5"); |
| assertFunctionAlmostEqual( -5, Math.cbrt, -125, "cbrt(-125) = -5"); |
| } |
| }, |
| { |
| name: "imul computes the multiplication of two unsigned 32 bit integers modulo 2^32", |
| body: function () { |
| function assertFunctionExactlyEqual2ForAllY(expected, fn, x, message) { |
| assertFunctionExactlyEqual2(expected, fn, x, NaN, message + " for all y (y === NaN)"); |
| assertFunctionExactlyEqual2(expected, fn, x, +Infinity, message + " for all y (y === +Infinity)"); |
| assertFunctionExactlyEqual2(expected, fn, x, -Infinity, message + " for all y (y === -Infinity)"); |
| assertFunctionExactlyEqual2(expected, fn, x, +0, message + " for all y (y === +0)"); |
| assertFunctionExactlyEqual2(expected, fn, x, -0, message + " for all y (y === -0)"); |
| assertFunctionExactlyEqual2(expected, fn, x, +0.5, message + " for all y (y === +0.5)"); |
| assertFunctionExactlyEqual2(expected, fn, x, -0.5, message + " for all y (y === -0.5)"); |
| assertFunctionExactlyEqual2(expected, fn, x, +1, message + " for all y (y === +1)"); |
| assertFunctionExactlyEqual2(expected, fn, x, -1, message + " for all y (y === -1)"); |
| assertFunctionExactlyEqual2(expected, fn, x, +1.5, message + " for all y (y === +1.5)"); |
| assertFunctionExactlyEqual2(expected, fn, x, -1.5, message + " for all y (y === -1.5)"); |
| assertFunctionExactlyEqual2(expected, fn, x, +50, message + " for all y (y === +50)"); |
| assertFunctionExactlyEqual2(expected, fn, x, -50, message + " for all y (y === -50)"); |
| assertFunctionExactlyEqual2(expected, fn, x, +12345.67, message + " for all y (y === +12345.67)"); |
| assertFunctionExactlyEqual2(expected, fn, x, -12345.67, message + " for all y (y === -12345.67)"); |
| } |
| |
| assertFunctionExactlyEqual2ForAllY( +0, Math.imul, NaN, "if x is NaN, then the result of imul(x,y) is +0"); |
| assertFunctionExactlyEqual2ForAllY( +0, Math.imul, +0, "if x is +0, then the result of imul(x,y) is +0"); |
| assertFunctionExactlyEqual2ForAllY( +0, Math.imul, -0, "if x is -0, then the result of imul(x,y) is +0"); |
| assertFunctionExactlyEqual2ForAllY( +0, Math.imul, +Infinity, "if x is +Infinity, then the result of imul(x,y) is +0"); |
| assertFunctionExactlyEqual2ForAllY( +0, Math.imul, -Infinity, "if x is -Infinity, then the result of imul(x,y) is +0"); |
| |
| assertFunctionExactlyEqual2( 0, Math.imul, 0, 0, "imul(0,0) is 0"); |
| assertFunctionExactlyEqual2( 0, Math.imul, 0, 1, "imul(0,0) is 0"); |
| assertFunctionExactlyEqual2( 0, Math.imul, 1, 0, "imul(0,0) is 0"); |
| assertFunctionExactlyEqual2( 1, Math.imul, 1, 1, "imul(0,0) is 0"); |
| assertFunctionExactlyEqual2( 6, Math.imul, 2, 3, "imul(0,0) is 0"); |
| assertFunctionExactlyEqual2( -8, Math.imul, 4, -2, "imul(0,0) is 0"); |
| assertFunctionExactlyEqual2( 1024, Math.imul, 32, 32, "imul(0,0) is 0"); |
| assertFunctionExactlyEqual2( 0, Math.imul, 65536, 65536, "imul(2^16,2^16) is 0 because imul is modulo 2^32"); |
| assertFunctionExactlyEqual2(-2147483648, Math.imul, 32768, 65536, "imul(2^15,2^16) is -2^31 because imul is modulo 2^32 and subtracts 2^31 if the value would be greater than or equal to 2^31"); |
| assertFunctionExactlyEqual2(-2147418112, Math.imul, 32769, 65536, "imul(2^15 + 1,2^16) is -2^31 + 65536 because imul is modulo 2^32 and subtracts 2^31 if the value would be greater than or equal to 2^31"); |
| } |
| }, |
| { |
| name: "clz returns the number of leading zero bits of the unsigned 32 bit integer representation of the this argument", |
| body: function () { |
| assertFunctionExactlyEqual(32, Math.clz32, 0x00000000, "32 leading zero bits in the uint32 value 0x00000000"); |
| assertFunctionExactlyEqual(31, Math.clz32, 0x00000001, "31 leading zero bits in the uint32 value 0x00000001"); |
| assertFunctionExactlyEqual(30, Math.clz32, 0x00000002, "30 leading zero bits in the uint32 value 0x00000002"); |
| assertFunctionExactlyEqual(29, Math.clz32, 0x00000004, "29 leading zero bits in the uint32 value 0x00000004"); |
| assertFunctionExactlyEqual(28, Math.clz32, 0x00000008, "28 leading zero bits in the uint32 value 0x00000008"); |
| assertFunctionExactlyEqual(27, Math.clz32, 0x00000010, "27 leading zero bits in the uint32 value 0x00000010"); |
| assertFunctionExactlyEqual(26, Math.clz32, 0x00000020, "26 leading zero bits in the uint32 value 0x00000020"); |
| assertFunctionExactlyEqual(25, Math.clz32, 0x00000040, "25 leading zero bits in the uint32 value 0x00000040"); |
| assertFunctionExactlyEqual(24, Math.clz32, 0x00000080, "24 leading zero bits in the uint32 value 0x00000080"); |
| assertFunctionExactlyEqual(23, Math.clz32, 0x00000100, "23 leading zero bits in the uint32 value 0x00000100"); |
| assertFunctionExactlyEqual(22, Math.clz32, 0x00000200, "22 leading zero bits in the uint32 value 0x00000200"); |
| assertFunctionExactlyEqual(21, Math.clz32, 0x00000400, "21 leading zero bits in the uint32 value 0x00000400"); |
| assertFunctionExactlyEqual(20, Math.clz32, 0x00000800, "20 leading zero bits in the uint32 value 0x00000800"); |
| assertFunctionExactlyEqual(19, Math.clz32, 0x00001000, "19 leading zero bits in the uint32 value 0x00001000"); |
| assertFunctionExactlyEqual(18, Math.clz32, 0x00002000, "18 leading zero bits in the uint32 value 0x00002000"); |
| assertFunctionExactlyEqual(17, Math.clz32, 0x00004000, "17 leading zero bits in the uint32 value 0x00004000"); |
| assertFunctionExactlyEqual(16, Math.clz32, 0x00008000, "16 leading zero bits in the uint32 value 0x00008000"); |
| assertFunctionExactlyEqual(15, Math.clz32, 0x00010000, "15 leading zero bits in the uint32 value 0x00010000"); |
| assertFunctionExactlyEqual(14, Math.clz32, 0x00020000, "14 leading zero bits in the uint32 value 0x00020000"); |
| assertFunctionExactlyEqual(13, Math.clz32, 0x00040000, "13 leading zero bits in the uint32 value 0x00040000"); |
| assertFunctionExactlyEqual(12, Math.clz32, 0x00080000, "12 leading zero bits in the uint32 value 0x00080000"); |
| assertFunctionExactlyEqual(11, Math.clz32, 0x00100000, "11 leading zero bits in the uint32 value 0x00100000"); |
| assertFunctionExactlyEqual(10, Math.clz32, 0x00200000, "10 leading zero bits in the uint32 value 0x00200000"); |
| assertFunctionExactlyEqual( 9, Math.clz32, 0x00400000, "9 leading zero bits in the uint32 value 0x00400000"); |
| assertFunctionExactlyEqual( 8, Math.clz32, 0x00800000, "8 leading zero bits in the uint32 value 0x00800000"); |
| assertFunctionExactlyEqual( 7, Math.clz32, 0x01000000, "7 leading zero bits in the uint32 value 0x01000000"); |
| assertFunctionExactlyEqual( 6, Math.clz32, 0x02000000, "6 leading zero bits in the uint32 value 0x02000000"); |
| assertFunctionExactlyEqual( 5, Math.clz32, 0x04000000, "5 leading zero bits in the uint32 value 0x04000000"); |
| assertFunctionExactlyEqual( 4, Math.clz32, 0x08000000, "4 leading zero bits in the uint32 value 0x08000000"); |
| assertFunctionExactlyEqual( 3, Math.clz32, 0x10000000, "3 leading zero bits in the uint32 value 0x10000000"); |
| assertFunctionExactlyEqual( 2, Math.clz32, 0x20000000, "2 leading zero bits in the uint32 value 0x20000000"); |
| assertFunctionExactlyEqual( 1, Math.clz32, 0x40000000, "1 leading zero bit in the uint32 value 0x40000000"); |
| assertFunctionExactlyEqual( 0, Math.clz32, 0x80000000, "0 leading zero bits in the uint32 value 0x80000000"); |
| |
| // quick random sampling to ensure values with more than one "one" bits still produce the correct result |
| assertFunctionExactlyEqual(28, Math.clz32, 0x0000000A, "28 leading zero bits in the uint32 value 0x0000000A, same as 0x00000008"); |
| assertFunctionExactlyEqual(17, Math.clz32, 0x00007ABC, "17 leading zero bits in the uint32 value 0x00007ABC, same as 0x00004000"); |
| assertFunctionExactlyEqual( 3, Math.clz32, 0x10380FE1, "3 leading zero bits in the uint32 value 0x10380FE1, same as 0x10000000"); |
| |
| // The argument is converted to a uint32 via the ToUint32 algorithm, so all objects work |
| assertFunctionExactlyEqual(32, Math.clz32, undefined, "Undefined converts to +0 therefore 32 leading zero bits"); |
| assertFunctionExactlyEqual(32, Math.clz32, "hello", "Non-number string converts to +0 therefore 32 leading zero bits"); |
| assertFunctionExactlyEqual( 2, Math.clz32, "0x20000000", "Number string converts to that number therefore however many leading zero bits"); |
| var o = { valueOf: function () { return 0x00800000; } }; |
| assertFunctionExactlyEqual( 8, Math.clz32, o, "Object with valueOf method converts to result of that method therefore however many leading zero bits"); |
| } |
| }, |
| { |
| name: "fround converts 64-bit float to 32-bit float and back to 64-bit float", |
| body: function () { |
| assertFunctionExactlyEqual( NaN, Math.fround, NaN, "if x is NaN, then the result of fround(x) is NaN"); |
| assertFunctionExactlyEqual(+Infinity, Math.fround, +Infinity, "if x is +Infinity, then the result of fround(x) is +Infinity"); |
| assertFunctionExactlyEqual(-Infinity, Math.fround, -Infinity, "if x is -Infinity, then the result of fround(x) is -Infinity"); |
| assertFunctionExactlyEqual( +0, Math.fround, +0, "if x is +0, then the result of fround(x) is +0"); |
| assertFunctionExactlyEqual( -0, Math.fround, -0, "if x is -0, then the result of fround(x) is -0"); |
| assertFunctionExactlyEqual( +1, Math.fround, +1, "if x is +1, then the result of fround(x) is +1"); |
| assertFunctionExactlyEqual( -1, Math.fround, -1, "if x is -1, then the result of fround(x) is -1"); |
| assertFunctionExactlyEqual( +2, Math.fround, +2, "if x is +2, then the result of fround(x) is +2"); |
| assertFunctionExactlyEqual( -2, Math.fround, -2, "if x is -2, then the result of fround(x) is -2"); |
| assertFunctionExactlyEqual( +5, Math.fround, +5, "if x is +5, then the result of fround(x) is +5"); |
| assertFunctionExactlyEqual( -5, Math.fround, -5, "if x is -5, then the result of fround(x) is -5"); |
| assertFunctionExactlyEqual( +100, Math.fround, +100, "if x is +100, then the result of fround(x) is +100"); |
| assertFunctionExactlyEqual( -100, Math.fround, -100, "if x is -100, then the result of fround(x) is -100"); |
| assertFunctionExactlyEqual( +0.5, Math.fround, +0.5, "if x is +0.5, then the result of fround(x) is +0.5"); |
| assertFunctionExactlyEqual( -0.5, Math.fround, -0.5, "if x is -0.5, then the result of fround(x) is -0.5"); |
| |
| let testcase = [ |
| // numbers between zero and one |
| [0.5995356650091708 , 0.5995356440544128 ], |
| [0.4388806028291583 , 0.43888059258461 ], |
| [0.05652953824028373 , 0.056529536843299866 ], |
| [0.8834999229293317 , 0.8834999203681946 ], |
| [0.19564732676371932 , 0.19564732909202576 ], |
| [0.04695801460184157 , 0.046958014369010925 ], |
| [0.995549641083926 , 0.9955496191978455 ], |
| [0.5965264535043389 , 0.5965264439582825 ], |
| [0.3384522853884846 , 0.3384522795677185 ], |
| [0.4793784348294139 , 0.47937843203544617 ], |
| |
| // large integers |
| [968719029287650 , 968719001976832 ], |
| [612872438100595 , 612872438677504 ], |
| [986007985043197 , 986007990173696 ], |
| [229849530517651 , 229849536921600 ], |
| [1069224778058320 , 1069224793473024 ], |
| [404824585745150 , 404824591958016 ], |
| [980853506006873 , 980853492547584 ], |
| [156784970534624 , 156784962568192 ], |
| [416562781028203 , 416562771132416 ], |
| [724128106542317 , 724128130662400 ], |
| |
| // arbitrary numbers |
| [6785.904748927644 , 6785.90478515625 ], |
| [5.585741676777502 , 5.5857415199279785 ], |
| [0.1787555584523126 , 0.17875555157661438 ], |
| [45167.42179931141 , 45167.421875 ], |
| [53.97847279046722 , 53.97847366333008 ], |
| [708731082.0651336 , 708731072 ], |
| [786033.2273395439 , 786033.25 ], |
| [134428002986767.81 , 134428005236736 ], |
| [10598756866706 , 10598756646912 ], |
| [2316.058639210134 , 2316.05859375 ], |
| ]; |
| for (let i=0; i < testcase.length; i++) { |
| assertFunctionExactlyEqual( testcase[i][1], Math.fround, testcase[i][0], "if x is "+testcase[i][0]+", then the result of fround(x) is "+testcase[i][1]); |
| } |
| |
| // Test against type specialization bugs |
| // -bgjit- -maxinterpretcount:1 -maxsimplejitruncount:2 |
| function fround_testsub() { |
| protoObj2.prop0 = Math.fround(1); |
| return protoObj2.prop0; |
| } |
| let obj2={}; |
| let protoObj2 = Object.create(obj2); |
| |
| fround_testsub(); |
| fround_testsub(); |
| fround_testsub(); // ok till this point |
| assert.areEqual( 1, fround_testsub(), "Math.fround() expects both input and output type specialized to float64") ; |
| } |
| }, |
| ]; |
| |
| testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" }); |
