Source code
Revision control
Copy as Markdown
Other Tools
// Lowering provides a specialisation when the base operand is a constant which
// is a power of two.
load(libdir + "math.js");
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 ys = [${y}, ${y}];
var zs = [${z}, ${z}];
for (var i = 0; i < 1000; ++i) {
assertNear(${fn(x, "ys[i & 1]")}, 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]();
}
}
}
function* range(a, b, fn) {
for (var i = a; i <= b; ++i) {
yield fn(i);
}
}
// Only 2^i with |i| ∈ {1..8} currently triggers the optimisation, but also test
// the next power-of-two values, 1 and 0, and negative base-of-two values.
var values = [
...range(1, 10, i => 2 ** i),
1,
0,
...range(1, 4, i => -(2 ** i)),
];
for (var x of values) {
test(x, 0, 1);
test(x, 1, x);
test(x, 2, x * x);
// 0**(negative) is Infinity, 1**(negative) is 1.
if (Math.abs(x) > 1) {
test(x, -1076, 0);
}
// (negative)**(odd-negative) is -0.
if (x > 1) {
test(x, -1075, 0);
}
}