function testUnitsEmpirically(element) {
var testDiv = document.createElement('div')
element.appendChild(testDiv)
for(var i=0; i<units.length; ++i) {
testDiv.style['font-size'] = '128' + units[i]
var expected = parseUnit(getComputedStyle(testDiv).getPropertyValue('font-size'))[0]/128
var actual = toPX(units[i], element)
t.ok(almostEqual(actual, expected, 0.005, almostEqual.FLT_EPSILON),
'testing: ' + units[i] + ' ' + actual + ' ~ ' + expected)
}
element.removeChild(testDiv)
}
module.exports = function (n, eps) {
n = norm(n);
var str = n + '';
//1e-10 etc
var e = str.indexOf('e-');
if (e >= 0) return parseInt(str.substring(e+2));
//imperfect ints, like 3.0000000000000004 or 1.9999999999999998
var remainder = Math.abs(n % 1);
var remStr = remainder + '';
if (almost(remainder, 1, eps) || almost(remainder, 0, eps)) return 0;
//usual floats like .0123
var d = remStr.indexOf('.') + 1;
if (d) return remStr.length - d;
//regular inte
return 0;
};
assert.almost = function (x, y) {
if (x && x.length != null && y && y.length != null) return x.every(function (xi, i) {
try {
assert.almost(xi, y[i]);
} catch (e) {
assert.fail(x, y, (x+'').slice(0,50) + '...\n≈\n' + (y+'').slice(0,50) + '...\n\nspecifically x[' + i + '] == ' + xi + ' ≈ ' + y[i], '≈')
return false;
}
return true;
});
var EPSILON = 1e-2;
if (!almost(x, y, EPSILON)) assert.fail(x, y,
x + ' ≈ ' + y, '≈');
return true;
};
var assert = require("assert")
var almostEqual = require("almost-equal")
var stepSimulator = require("../simulator.js")
var position = [[0, 1]]
var velocity = [[0, 1]]
var ground = [0, 1]
var dt = 0.1
var nstate = stepSimulator(position, velocity, ground, dt)
position = nstate.position
velocity = nstate.velocity
assert.ok(almostEqual(position[0][0], 0.0, almostEqual.FLT_EPSILON))
assert.ok(almostEqual(position[0][1], 0.9, almostEqual.FLT_EPSILON))
assert.ok(almostEqual(velocity[0][0], 0.0, almostEqual.FLT_EPSILON))
assert.ok(almostEqual(velocity[0][1],-1.0, almostEqual.FLT_EPSILON))
function eq(a, b) {
t.assert(almostEqual(a, b, EPSILON, EPSILON),"rnd/n=" + shape + ", i=" + i + " - got: " + a + ", expect: " + b)
}
function eq(ar, ai, br, bi, str) {
t.assert(almostEqual(ar, br, EPSILON, EPSILON) &&
almostEqual(ai, bi, EPSILON, EPSILON),
str + "/n=(" + n + "," + m + "), i=(" + i1 + "," + i2 + "), j=(" + j1 + "," + j2 + "), - got: " + ar + " + " + ai + "i, expect: " + br + " + " + bi + "i")
}
function eq(a, b, str) {
t.assert(almostEqual(a, b, EPSILON, EPSILON), str + "/n=" + n + ", i=" + i + " - got: " + a + ", expect: " + b)
}
assert.almostEqual = function (computed, expected, tol) {
tol = tol === undefined ? almostEqual.FLT_EPSILON : tol;
assert(isNumber(computed), 'Expected ' + computed + ' to be a number.');
assert(almostEqual(expected, computed, tol, tol), 'Expected ' + computed + ' to equal ' + expected + ' (± ' + tol + ')');
};
require("tap").test("distance-transform", function(t) {
//1D
var x = zeros([2])
x.set(0, 1)
dt(x)
t.equals(x.get(0), 0)
t.equals(x.get(1), 1)
ops.assigns(x, 0)
x.set(0, 1)
dt(x, 1)
t.equals(x.get(0), 0)
t.equals(x.get(1), 1)
ops.assigns(x, 0)
x.set(0, 1)
dt(x, Infinity)
t.equals(x.get(0), 0)
t.equals(x.get(1), 1)
ops.assigns(x, 0)
x.set(0, 1)
dt(x, 3)
t.equals(x.get(0), 0)
t.equals(x.get(1), 1)
//2D
x = zeros([2, 2])
x.set(0, 0, 1)
dt(x)
t.equals(x.get(1, 1), Math.sqrt(2.0))
ops.assigns(x, 0)
x.set(0, 0, 1)
dt(x, 1)
t.equals(x.get(1, 1), 2)
ops.assigns(x, 0)
x.set(0, 0, 1)
dt(x, Infinity)
t.equals(x.get(1, 1), 1)
ops.assigns(x, 0)
x.set(0, 0, 1)
dt(x, 3)
t.equals(x.get(1, 1), Math.pow(2, 1.0/3.0))
ops.assigns(x, 0)
x.set(1, 1, 1)
dt(x, 3)
t.equals(x.get(0, 0), Math.pow(2, 1.0/3.0))
//3D
x = zeros([2,2,2])
x.set(0, 0, 0, 1)
dt(x)
t.assert(almostEqual(x.get(1,1,1), Math.sqrt(3.0), almostEqual.FLT_EPSILON, almostEqual.FLT_EPSILON))
ops.assigns(x, 0)
x.set(0, 0, 0, 1)
dt(x, 1)
t.equals(x.get(1, 1, 1), 3)
ops.assigns(x, 0)
x.set(0, 0, 0, 1)
dt(x, Infinity)
t.equals(x.get(1, 1, 1), 1)
ops.assigns(x, 0)
x.set(0, 0, 0, 1)
dt(x, 3)
t.equals(x.get(1, 1, 1), Math.pow(3, 1.0/3.0))
//4D
x = zeros([2,2,2,2])
x.set(0, 0, 0, 0, 1)
dt(x)
t.equals(x.get(1,1,1,1), 2.0)
ops.assigns(x, 0)
x.set(0, 0, 0, 0, 1)
dt(x, 1)
t.equals(x.get(1, 1, 1, 1), 4)
ops.assigns(x, 0)
x.set(0, 0, 0, 0, 1)
dt(x, Infinity)
t.equals(x.get(1, 1, 1, 1), 1)
ops.assigns(x, 0)
x.set(0, 0, 0, 0, 1)
dt(x, 3)
t.equals(x.get(1, 1, 1, 1), Math.pow(4, 1.0/3.0))
t.end()
})
function assertAlmostEqual (t, computed, expected, tol) {
tol = tol === undefined ? almostEqual.FLT_EPSILON : tol;
t.ok(almostEqual(computed, expected, tol, tol, 'Expected ' + computed + ' to equal ' + expected + ' (±' + tol + ')'));
}
var assert = require("assert")
var almostEqual = require("almost-equal")
var stepSimulator = require("../simulator.js")
var position = [[0, 0.1]]
var velocity = [[1, 1.0]]
var ground = [0, 1]
var dt = 0.1
for(var t=0.0; t<1.9; t+=dt) {
var nstate = stepSimulator(position, velocity, ground, dt)
position = nstate.position
velocity = nstate.velocity
}
assert.ok(almostEqual(position[0][0], 0.1, almostEqual.FLT_EPSILON))
assert.ok(almostEqual(position[0][1], 0.0, almostEqual.FLT_EPSILON))
var almostEqual = require('almost-equal')
var tap = require('tap')
var s = require('.')
tap.equal(s.compile([2505, 5010]).operation, 'sum')
tap.equal(s.compile([2, 4, 6]).operation, 'sum')
tap.equal(s.compile([2, 4, 8]).operation, 'multiply')
tap.equal(s.compile([5010, 5009, 5008]).operation, 'sum')
tap.equal(s.compile([5010, 5011, 5012]).operation, 'sum')
tap.equal(s.compile([80, 40, 20, 10, 5, 2.5]).operation, 'multiply')
tap.equal(s.compile([5010]).operation, 'nothing')
tap.equal(s.compile([118, 119]).factor, 1)
tap.equal(s.compile([10, 119]).factor, 109)
tap.equal(s.compile([10, -100, 1000]).factor, -10)
tap.equal(s.compile([10, 1 / 10, 1 / 1000]).factor, 1 / 100)
tap.equal(s.compile([-2, 6, -18]).factor, -3)
tap.equal(s([1, 2, 3], 1), 4)
tap.equal(s([-2, 0, 2, 4], 2), 8)
tap.equal(s(['qwe', 'asd'], 2), 'asd')
tap.equal(s(['qwe', 'asd'], 7), 'qwe')
tap.equal(s([0, 77, 11, 18, -28], 7), 77)
tap.equal(s([-2, 6, -18], 1), 54)
tap.equal(s([-2, 6, -18], 2), -162)
tap.equal(s([-2, 6, -18], 3), 486)
tap.equal(s([-2, 6, -18], 4), -1458)
tap.equal(s([-2, 6, -18], 6), -13122)
tap.assert(almostEqual(s([10, 1 / 10, 1 / 1000], 3), 1 / 1000000000))
([value1, value2]) => almostEqual(value1, value2),