@woosh/meep-engine 2.110.13 → 2.110.15

package/src/core/math/copysign.spec.js

@@ -1,13 +0,0 @@
-import { copysign } from "./copysign.js";
-
-test('copysign', () => {
-    expect(copysign(1, 2)).toBe(1);
-    expect(copysign(2, 1)).toBe(2);
-
-    expect(copysign(2, -1)).toBe(-2);
-    expect(copysign(-2, 1)).toBe(2);
-    expect(copysign(-2, -1)).toBe(-2);
-
-    expect(copysign(3, 7)).toBe(3);
-    expect(copysign(3, -7)).toBe(-3);
-});

package/src/core/math/epsilonEquals.spec.js

@@ -1,17 +0,0 @@
-import { epsilonEquals } from "./epsilonEquals.js";
-
-test("basics", () => {
-
-    expect(epsilonEquals(0, 0, 0)).toBe(true);
-    expect(epsilonEquals(0, 1, 0)).toBe(false);
-    expect(epsilonEquals(1, 0, 0)).toBe(false);
-    expect(epsilonEquals(-1, 0, 0)).toBe(false);
-    expect(epsilonEquals(-1, 1, 0)).toBe(false);
-    expect(epsilonEquals(1, -1, 0)).toBe(false);
-
-    expect(epsilonEquals(1, 1.1, 0)).toBe(false);
-    expect(epsilonEquals(1, 1, 0.1)).toBe(true);
-    expect(epsilonEquals(1, 1.09, 0.1)).toBe(true);
-    expect(epsilonEquals(1, 1.11, 0.1)).toBe(false);
-
-});

package/src/core/math/factorial.spec.js

@@ -1,9 +0,0 @@
-import { factorial } from "./factorial.js";
-
-test("basics",()=>{
-
-    expect(factorial(1)).toBe(1);
-
-    expect(factorial(5)).toBe(120);
-
-});

package/src/core/math/fract.spec.js

@@ -1,11 +0,0 @@
-import { fract } from "./fract.js";
-
-test("correctness", () => {
-
-    expect(fract(0)).toBeCloseTo(0);
-    expect(fract(0.1)).toBeCloseTo(0.1);
-    expect(fract(-0.1)).toBeCloseTo(-0.1);
-    expect(fract(1.1)).toBeCloseTo(0.1);
-    expect(fract(-1.1)).toBeCloseTo(-0.1);
-
-});

package/src/core/math/hash/computeHashFloatArray.spec.js

@@ -1,11 +0,0 @@
-import { computeHashFloatArray } from "./computeHashFloatArray.js";
-
-test("computeHashFloatArray", () => {
-    expect(computeHashFloatArray([1, 2, 1.5])).toEqual(computeHashFloatArray([1, 2, 1.5]));
-
-    expect(computeHashFloatArray([1, 2, 1.5])).not.toEqual(computeHashFloatArray([1, 3, 1.5]));
-
-    expect(computeHashFloatArray([1, 2, 1.5])).not.toEqual(computeHashFloatArray([1, 2, 2.5]));
-
-    expect(computeHashFloatArray([1, 2, 3])).not.toEqual(computeHashFloatArray([1, 2, 1.5]));
-});

package/src/core/math/hash/computeObjectHash.spec.js

@@ -1,42 +0,0 @@
-import { computeObjectHash } from "./computeObjectHash.js";
-
-/**
- *
- * @param {number} hash
- */
-function validateHash(hash){
-    expect(typeof hash).toBe('number');
-    expect(hash).not.toBeNaN();
-    expect(Number.isFinite(hash)).toBe(true);
-    expect(Number.isInteger(hash)).toBe(true);
-}
-
-test('primitives produce valid hash',()=>{
-    validateHash( computeObjectHash(undefined));
-    validateHash( computeObjectHash(null));
-    validateHash( computeObjectHash(0));
-    validateHash( computeObjectHash(1));
-    validateHash( computeObjectHash(""));
-    validateHash( computeObjectHash("hello"));
-    validateHash( computeObjectHash(false));
-    validateHash( computeObjectHash(true));
-    validateHash( computeObjectHash({}));
-});
-
-test('nested object hash is stable',()=>{
-    const test_object = {
-        a:{
-            b:7
-        },
-        c: "hello"
-    };
-
-    expect(computeObjectHash(test_object)).toEqual(computeObjectHash(test_object));
-
-    expect(computeObjectHash(test_object)).not.toEqual(computeObjectHash({
-        a:{
-            b:5
-        },
-        c: "hello"
-    }));
-});

package/src/core/math/hash/murmur3_32.spec.js

@@ -1,8 +0,0 @@
-import { murmur3_32 } from "./murmur3_32.js";
-
-test("hashing [0] with 0 seed", () => {
-    const hash = murmur3_32(new Uint32Array([0]), 0);
-    expect(typeof hash).toBe("number");
-    expect(Number.isInteger(hash)).toBe(true);
-    expect(hash).not.toBeNaN();
-});

package/src/core/math/hash/squirrel3.spec.js

@@ -1,16 +0,0 @@
-import { squirrel3 } from "./squirrel3.js";
-
-function expect_integer(v) {
-
-    expect(typeof v).toBe("number");
-    expect(Number.isInteger(v)).toBe(true);
-    expect(v).not.toBeNaN();
-}
-
-test("sanity check", () => {
-    expect_integer(squirrel3(0));
-    expect_integer(squirrel3(1));
-    expect_integer(squirrel3(-1));
-
-    expect(squirrel3(0)).not.toEqual(squirrel3(1));
-});

package/src/core/math/iabs.spec.js

@@ -1,9 +0,0 @@
-import { iabs } from "./iabs.js";
-
-test("basics", () => {
-    expect(iabs(0)).toBe(0);
-    expect(iabs(1)).toBe(1);
-    expect(iabs(1023)).toBe(1023);
-    expect(iabs(-1)).toBe(1);
-    expect(iabs(-1023)).toBe(1023);
-});

package/src/core/math/interval/NumericInterval.spec.js

@@ -1,89 +0,0 @@
-import { NumericInterval } from "./NumericInterval.js";
-
-test("constructor parameters propagation", () => {
-    const sut = new NumericInterval(-3, 7);
-
-    expect(sut.min).toBe(-3);
-    expect(sut.max).toBe(7);
-});
-
-test("set works correctly", () => {
-    const sut = new NumericInterval(0, 0);
-
-    sut.set(-3, 7);
-
-    expect(sut.min).toBe(-3);
-    expect(sut.max).toBe(7);
-
-    sut.set(-1, 7);
-
-    expect(sut.min).toBe(-1);
-    expect(sut.max).toBe(7);
-
-    sut.set(-1, 11);
-
-    expect(sut.min).toBe(-1);
-    expect(sut.max).toBe(11);
-});
-
-test("multiplyScalar", () => {
-    const sut = new NumericInterval(-3, 7);
-
-    sut.multiplyScalar(1);
-
-    expect(sut.min).toBe(-3);
-    expect(sut.max).toBe(7);
-
-    sut.multiplyScalar(2);
-
-    expect(sut.min).toBe(-6);
-    expect(sut.max).toBe(14);
-
-    sut.multiplyScalar(-2);
-
-    expect(sut.min).toBe(-28);
-    expect(sut.max).toBe(12);
-});
-
-test("isZero", () => {
-    const sut = new NumericInterval(-3, 7);
-
-    expect(sut.isZero()).toBe(false);
-
-    sut.set(0, 1);
-
-    expect(sut.isZero()).toBe(false);
-
-    sut.set(-1, 0);
-
-    expect(sut.isZero()).toBe(false);
-
-    sut.set(0, 0);
-
-    expect(sut.isZero()).toBe(true);
-});
-
-test("normalizeValue", () => {
-    const sut = new NumericInterval(-1, 1);
-
-    expect(sut.normalizeValue(-1)).toBe(0);
-    expect(sut.normalizeValue(1)).toBe(1);
-    expect(sut.normalizeValue(0)).toBeCloseTo(0.5);
-});
-
-test("sampleRandom", () => {
-    const sut = new NumericInterval(-3, 7);
-
-    expect(sut.sampleRandom(() => 0)).toBe(-3);
-    expect(sut.sampleRandom(() => 1)).toBe(7);
-    expect(sut.sampleRandom(() => 0.5)).toBeCloseTo(2);
-});
-
-test("computeAverage", () => {
-    expect(new NumericInterval(0, 0).computeAverage()).toBe(0);
-    expect(new NumericInterval(1, 1).computeAverage()).toBe(1);
-    expect(new NumericInterval(-1, -1).computeAverage()).toBe(-1);
-
-    expect(new NumericInterval(3, 7).computeAverage()).toBe(5);
-    expect(new NumericInterval(3.1, 7.1).computeAverage()).toBe(5.1);
-});

package/src/core/math/interval/isValueBetween.spec.js

@@ -1,11 +0,0 @@
-import { isValueBetween } from "./isValueBetween.js";
-
-test("isValueBetween", () => {
-    expect(isValueBetween(0, 1, 2)).toBe(false);
-});
-
-test("isValueBetween negative limits", () => {
-    expect(isValueBetween(1, -1, 2)).toBe(true);
-
-    expect(isValueBetween(1, 2, -1)).toBe(true);
-});

package/src/core/math/interval/isValueBetweenInclusive.spec.js

@@ -1,16 +0,0 @@
-import { isValueBetweenInclusive } from "./isValueBetweenInclusive.js";
-
-
-test("isValueBetweenInclusive", () => {
-    expect(isValueBetweenInclusive(1, 1, 2)).toBe(true);
-
-    expect(isValueBetweenInclusive(2, 1, 2)).toBe(true);
-
-    expect(isValueBetweenInclusive(1.5, 1, 2)).toBe(true);
-
-    expect(isValueBetweenInclusive(0.5, 1, 2)).toBe(false);
-
-    expect(isValueBetweenInclusive(3, 1, 2)).toBe(false);
-});
-
-

package/src/core/math/interval/overlap1D.spec.js

@@ -1,10 +0,0 @@
-import { overlap1D } from "./overlap1D.js";
-
-test('overlap1D', () => {
-    expect(overlap1D(0, 0, 0, 0)).toBe(false);
-    expect(overlap1D(-3, -1, -2, -0.5)).toBe(true);
-    expect(overlap1D(-1, 2, 1, 1)).toBe(true);
-    expect(overlap1D(1, 1, -1, 2)).toBe(true);
-
-    expect(overlap1D(1, 2, 2, 3)).toBe(false);
-});

package/src/core/math/inverseLerp.spec.js

@@ -1,13 +0,0 @@
-import { inverseLerp } from "./inverseLerp.js";
-
-test('inverseLerp', () => {
-    expect(inverseLerp(0, 5, 0.5)).toBe(0.1);
-
-    expect(inverseLerp(-5, 5, 0)).toBe(0.5);
-
-    expect(inverseLerp(0, 0, 0)).toBe(0);
-
-    expect(inverseLerp(1, 2, 1)).toBe(0);
-
-    expect(inverseLerp(1, 2, 2)).toBe(1);
-});

package/src/core/math/isPowerOfTwo.spec.js

@@ -1,9 +0,0 @@
-import { isPowerOfTwo } from "./isPowerOrTwo.js";
-
-test("correctness", () => {
-    expect(isPowerOfTwo(1)).toBe(true);
-    expect(isPowerOfTwo(2)).toBe(true);
-    expect(isPowerOfTwo(3)).toBe(false);
-    expect(isPowerOfTwo(4)).toBe(true);
-    expect(isPowerOfTwo(5)).toBe(false);
-});

package/src/core/math/isqrt.spec.js

@@ -1,9 +0,0 @@
-import { isqrt } from "./isqrt.js";
-
-test('1', () => {
-    expect(isqrt(1)).toBe(1);
-});
-
-test('4', () => {
-    expect(isqrt(4)).toBe(2);
-});

package/src/core/math/lerp.spec.js

@@ -1,15 +0,0 @@
-import { lerp } from "./lerp.js";
-
-test('lerp', () => {
-    expect(lerp(0, 5, 0.1)).toBe(0.5);
-
-    expect(lerp(-5, 5, 0.5)).toBe(0);
-
-    expect(lerp(0, 0, 0)).toBe(0);
-
-    expect(lerp(0, 0, 1)).toBe(0);
-
-    expect(lerp(1, 2, 0)).toBe(1);
-
-    expect(lerp(1, 2, 1)).toBe(2);
-});

package/src/core/math/linalg/solve_linear_system.spec.js

@@ -1,70 +0,0 @@
-import { solve_linear_system } from "./solve_linear_system.js";
-
-test("3 variables", () => {
-
-    /*
-
-    x + y + z = 6
-    2x - y - x = -3
-    3y - 2z = 0
-
-     */
-    const x = [6, -3, 0];
-
-    expect(solve_linear_system(
-        [
-            1, 1, 1,
-            2, -1, -1,
-            0, 3, -2
-        ],
-        x,
-        3
-    )).toBe(true);
-
-    expect(x).toEqual([1, 2, 3])
-
-});
-
-test("2 variables", () => {
-
-    /*
-
-    2x + 7y = 34
-    5x - 4y = -1
-
-     */
-    const x = [34, -1];
-
-    expect(solve_linear_system(
-        [
-            2,7,
-            5,-4
-        ],
-        x,
-        2
-    )).toBe(true);
-
-    expect(x).toEqual([3,4])
-
-});
-
-test("1 variable", () => {
-
-    /*
-
-    2x = -42
-
-     */
-    const x = [-42];
-
-    expect(solve_linear_system(
-        [
-            2
-        ],
-        x,
-        1
-    )).toBe(true);
-
-    expect(x).toEqual([-21])
-
-});

package/src/core/math/max.spec.js

@@ -1,25 +0,0 @@
-import { max2 } from "./max2.js";
-
-test("0,0", () => {
-    expect(max2(0, 0)).toBe(0);
-});
-
-test("0,1", () => {
-    expect(max2(0, 1)).toBe(1);
-});
-
-test("1,0", () => {
-    expect(max2(1, 0)).toBe(1);
-});
-
-test("-1,0", () => {
-    expect(max2(-1, 0)).toBe(0);
-});
-
-test("0,-1", () => {
-    expect(max2(0, -1)).toBe(0);
-});
-
-test("Infinity,-Infinity", () => {
-    expect(max2(Infinity, -Infinity)).toBe(Infinity);
-});

package/src/core/math/max2.spec.js

@@ -1,13 +0,0 @@
-import { max2 } from "./max2.js";
-
-test('max2', () => {
-    expect(max2(0, 0)).toBe(0);
-
-    expect(max2(2, 1)).toBe(2);
-
-    expect(max2(1, 2)).toBe(2);
-
-    expect(max2(-1, 1)).toBe(1);
-
-    expect(max2(1, -1)).toBe(1);
-});

package/src/core/math/max3.spec.js

@@ -1,29 +0,0 @@
-import { max3 } from "./max3.js";
-
-test("max3", () => {
-    expect(max3(0, 0, 0)).toBe(0);
-
-    expect(max3(-1, -3, 1)).toBe(1);
-
-    expect(max3(-3, -1, 1)).toBe(1);
-
-    expect(max3(-3, 1, -1)).toBe(1);
-
-    expect(max3(-1, 1, -3)).toBe(1);
-
-    expect(max3(1, -1, -3)).toBe(1);
-
-    expect(max3(1, -3, -1)).toBe(1);
-
-    expect(max3(-3, 1, 1)).toBe(1);
-
-    expect(max3(3, 1, 1)).toBe(3);
-
-    expect(max3(3, 3, -1)).toBe(3);
-
-    expect(max3(3, 3, 4)).toBe(4);
-
-    expect(max3(3, 0, 3)).toBe(3);
-
-    expect(max3(3, 4, 3)).toBe(4);
-});

package/src/core/math/min2.spec.js

@@ -1,37 +0,0 @@
-import { min2 } from "./min2.js";
-
-test("0,0", () => {
-    expect(min2(0, 0)).toBe(0);
-});
-
-test("0,1", () => {
-    expect(min2(0, 1)).toBe(0);
-});
-
-test("1,0", () => {
-    expect(min2(1, 0)).toBe(0);
-});
-
-test("-1,0", () => {
-    expect(min2(-1, 0)).toBe(-1);
-});
-
-test("0,-1", () => {
-    expect(min2(0, -1)).toBe(-1);
-});
-
-test("Infinity,-Infinity", () => {
-    expect(min2(Infinity, -Infinity)).toBe(-Infinity);
-});
-
-test('min2', () => {
-    expect(min2(0, 0)).toBe(0);
-
-    expect(min2(2, 1)).toBe(1);
-
-    expect(min2(1, 2)).toBe(1);
-
-    expect(min2(-1, 1)).toBe(-1);
-
-    expect(min2(1, -1)).toBe(-1);
-});

package/src/core/math/min3.spec.js

@@ -1,29 +0,0 @@
-import { min3 } from "./min3.js";
-
-test("min3", () => {
-    expect(min3(0,0,0)).toBe(0);
-
-    expect(min3(-1, -3, 1)).toBe(-3);
-
-    expect(min3(-3, -1, 1)).toBe(-3);
-
-    expect(min3(-1, 1, -3)).toBe(-3);
-
-    expect(min3(1, -3, -1)).toBe(-3);
-
-    expect(min3(-3, 1, -1)).toBe(-3);
-
-    expect(min3(1, -1, -3)).toBe(-3);
-
-    expect(min3(-3, 1, 1)).toBe(-3);
-
-    expect(min3(2, 1, 1)).toBe(1);
-
-    expect(min3(3, 3, -1)).toBe(-1);
-
-    expect(min3(3, 3, 4)).toBe(3);
-
-    expect(min3(3, 0, 3)).toBe(0);
-
-    expect(min3(3, 4, 3)).toBe(3);
-});

package/src/core/math/newton_solver_1d.spec.js

@@ -1,9 +0,0 @@
-import { newton_solver_1d } from "./newton_solver_1d.js";
-
-test("solve for line", () => {
-    expect(newton_solver_1d((x) => x * 2 + 5, 1))
-        .toBeCloseTo(-2.5);
-
-    expect(newton_solver_1d((x) => -x * 7 - 3, 1))
-        .toBeCloseTo(-0.429);
-});

package/src/core/math/nextOdd.spec.js

@@ -1,9 +0,0 @@
-import { nextOdd } from "./nextOdd.js";
-
-test("basics", () => {
-
-    expect(nextOdd(0)).toBe(1);
-    expect(nextOdd(1)).toBe(1);
-    expect(nextOdd(-1)).toBe(-1);
-
-});

package/src/core/math/noise/create_simplex_noise_2d.spec.js

@@ -1,21 +0,0 @@
-import { create_simplex_noise_2d } from "./create_simplex_noise_2d.js";
-
-test("sample 10 points in 0..1 range", () => {
-    const noise2d = create_simplex_noise_2d(() => 0);
-
-    const COUNT = 10;
-    for (let i = 0; i < COUNT; i++) {
-        const u = i / (COUNT - 1);
-        for (let j = 0; j < COUNT; j++) {
-            const v = j / (COUNT - 1);
-
-            const value = noise2d(u, v);
-
-            expect(typeof value).toBe('number');
-            expect(value).not.toBeNaN();
-
-            expect(value).toBeGreaterThanOrEqual(-1);
-            expect(value).toBeLessThanOrEqual(1);
-        }
-    }
-});

package/src/core/math/noise/sdnoise.spec.js

@@ -1,87 +0,0 @@
-import { sdnoise1, sdnoise2, sdnoise3, sdnoise4 } from "./sdnoise.js";
-
-describe("sdnoise1", () => {
-    test("sanity", () => {
-        const derivatives = [];
-
-        const value = sdnoise1(derivatives, 0);
-
-        expect(typeof value).toBe("number");
-        expect(value).not.toBeNaN();
-
-        expect(derivatives.length).toEqual(1);
-
-        expect(typeof derivatives[0]).toBe("number");
-        expect(derivatives[0]).not.toBeNaN();
-
-    });
-});
-
-describe("sdnoise2", () => {
-    test("sanity", () => {
-        const derivatives = [];
-
-        const value = sdnoise2(derivatives, 0, 0);
-
-        expect(typeof value).toBe("number");
-        expect(value).not.toBeNaN();
-
-        expect(derivatives.length).toEqual(2);
-
-        expect(typeof derivatives[0]).toBe("number");
-        expect(derivatives[0]).not.toBeNaN();
-
-        expect(typeof derivatives[1]).toBe("number");
-        expect(derivatives[1]).not.toBeNaN();
-
-    });
-});
-
-describe("sdnoise3", () => {
-    test("sanity", () => {
-        const derivatives = [];
-
-        const value = sdnoise3(derivatives, 0, 0, 0);
-
-        expect(typeof value).toBe("number");
-        expect(value).not.toBeNaN();
-
-        expect(derivatives.length).toEqual(3);
-
-        expect(typeof derivatives[0]).toBe("number");
-        expect(derivatives[0]).not.toBeNaN();
-
-        expect(typeof derivatives[1]).toBe("number");
-        expect(derivatives[1]).not.toBeNaN();
-
-        expect(typeof derivatives[2]).toBe("number");
-        expect(derivatives[2]).not.toBeNaN();
-
-    });
-});
-
-describe("sdnoise4", () => {
-    test("sanity", () => {
-        const derivatives = [];
-
-        const value = sdnoise4(derivatives, 0, 0, 0, 0);
-
-        expect(typeof value).toBe("number");
-        expect(value).not.toBeNaN();
-
-        expect(derivatives.length).toEqual(4);
-
-        expect(typeof derivatives[0]).toBe("number");
-        expect(derivatives[0]).not.toBeNaN();
-
-        expect(typeof derivatives[1]).toBe("number");
-        expect(derivatives[1]).not.toBeNaN();
-
-        expect(typeof derivatives[2]).toBe("number");
-        expect(derivatives[2]).not.toBeNaN();
-
-        expect(typeof derivatives[3]).toBe("number");
-        expect(derivatives[3]).not.toBeNaN();
-
-    });
-});