pow-constant-power.js

Enable keyboard shortcuts

// Ion provides specialisations when Math.pow() resp. the **-operator is used

// with a constant power of one of [-0.5, 0.5, 1, 2, 3, 4].

function test(x, y, z) {

    function pow(x, y) { return `Math.pow(${x}, ${y})` };

    function exp(x, y) { return `((${x}) ** ${y})` };

    function make(fn, x, y, z) {

        return Function(`

            // Load from array to prevent constant-folding.

            // (Ion is currently not smart enough to realise that both array

            // values are the same.)

            var xs = [${x}, ${x}];

            var zs = [${z}, ${z}];

            for (var i = 0; i < 1000; ++i) {

                assertEq(${fn("xs[i & 1]", y)}, zs[i & 1]);

`);

    function double(v) {

        // NB: numberToDouble() always returns a double value.

        return `numberToDouble(${v})`;

    function addTests(fn) {

        tests.push(make(fn, x, y, z));

        tests.push(make(fn, x, double(y), z));

        tests.push(make(fn, double(x), y, z));

        tests.push(make(fn, double(x), double(y), z));

    var tests = [];

    addTests(pow);

    addTests(exp);

    for (var i = 0; i < tests.length; ++i) {

        for (var j = 0; j < 2; ++j) {

            tests[i]();

// Make sure the tests below test int32 and double return values.

// Math.pow(x, -0.5)

test( 1, -0.5, 1);

test(16, -0.5, 0.25);

// Math.pow(x, 0.5)

test(16, 0.5, 4);

test( 2, 0.5, Math.SQRT2);

// Math.pow(x, 1)

test(5,   1, 5);

test(0.5, 1, 0.5);

// Math.pow(x, 2)

test(5,   2, 25);

test(0.5, 2, 0.25);

// Math.pow(x, 3)

test(5,   3, 125);

test(0.5, 3, 0.125);

// Math.pow(x, 3)

test(5,   4, 625);

test(0.5, 4, 0.0625);