@woosh/meep-engine 2.33.20 → 2.33.24

package/core/geom/random/randomPointInSphere.js

@@ -4,9 +4,10 @@ import { PI2 } from "../../math/MathUtils.js";
  *
  * @see based on python code suggested here: https://stackoverflow.com/questions/5408276/sampling-uniformly-distributed-random-points-inside-a-spherical-volume
  * @param {function} random
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  */
-export function randomPointInSphere(random, result) {
+export function randomPointInSphere(random, result, result_offset) {
     const phi = PI2 * random();
 
     const cosTheta = random() * 2 - 1;
@@ -27,5 +28,7 @@ export function randomPointInSphere(random, result) {
     const z = r * cosTheta;
 
     //write the result
-    result.set(x, y, z);
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 }

package/core/geom/random/randomPointOnBox.js

@@ -1,9 +1,10 @@
 /**
  *
  * @param {function} random
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  */
-export function randomPointOnBox(random, result) {
+export function randomPointOnBox(random, result, result_offset) {
     //pick a side
     const side = random();
 
@@ -29,5 +30,8 @@ export function randomPointOnBox(random, result) {
         z = fixedAxis;
     }
 
-    result.set(x, y, z);
+    //write the result
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 }

package/core/geom/random/randomPointOnSphere.js

@@ -2,9 +2,10 @@
  *
  * @see based on python code suggested here: https://stackoverflow.com/questions/5408276/sampling-uniformly-distributed-random-points-inside-a-spherical-volume
  * @param {function} random
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  */
-export function randomPointOnSphere(random, result) {
+export function randomPointOnSphere(random, result, result_offset) {
     const phi = Math.PI * 2 * random();
 
     const cosTheta = random() * 2 - 1;
@@ -23,5 +24,7 @@ export function randomPointOnSphere(random, result) {
     const z = r * cosTheta;
 
     //write the result
-    result.set(x, y, z);
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 }

package/core/geom/v3_angle_between.js

@@ -0,0 +1,31 @@
+import { v3_dot } from "./v3_dot.js";
+import { v3_length } from "./v3_length.js";
+import { clamp } from "../math/clamp.js";
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_angle_between(x0, y0, z0, x1, y1, z1) {
+    const d = v3_dot(x0, y0, z0, x1, y1, z1);
+
+    const magnitude_0 = v3_length(x0, y0, z0);
+    const magnitude_1 = v3_length(x1, y1, z1);
+
+    const l = magnitude_0 * magnitude_1;
+
+    if (l === 0) {
+        // collective magnitude is 0, provide arbitrary angle
+        return 0;
+    }
+
+    const theta = clamp(d / l, -1, 1);
+
+    return Math.acos(theta);
+}

package/core/geom/v3_distance.js

@@ -0,0 +1,16 @@
+import { v3_distance_sqr } from "./v3_distance_sqr.js";
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_distance(x0, y0, z0, x1, y1, z1) {
+
+    return Math.sqrt(v3_distance_sqr(x0, y0, z0, x1, y1, z1));
+}

package/core/geom/v3_distance_sqr.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_distance_sqr(x0, y0, z0, x1, y1, z1) {
+    const x = x0 - x1;
+    const y = y0 - y1;
+    const z = z0 - z1;
+
+    return x * x + y * y + z * z;
+}

package/core/geom/v3_dot.js

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @returns {number}
+ */
+export function v3_dot(x0, y0, z0, x1, y1, z1) {
+    return (x0 * x1 + y0 * y1 + z0 * z1);
+}

package/core/geom/v3_length.js

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
+export function v3_length(x, y, z) {
+    return Math.hypot(x, y, z);
+}

package/core/geom/v3_length_sqr.js

@@ -0,0 +1,10 @@
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {number}
+ */
+export function v3_length_sqr(x, y, z) {
+    return x * x + y * y + z * z;
+}

package/core/geom/v3_lerp.js

@@ -0,0 +1,21 @@
+import { lerp } from "../math/lerp.js";
+
+/**
+ *
+ * @param {Vector3} result
+ * @param {number} a_x
+ * @param {number} a_y
+ * @param {number} a_z
+ * @param {number} b_x
+ * @param {number} b_y
+ * @param {number} b_z
+ * @param {number} fraction
+ */
+export function v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction) {
+
+    const x = lerp(a_x, b_x, fraction);
+    const y = lerp(a_y, b_y, fraction);
+    const z = lerp(a_z, b_z, fraction);
+
+    result.set(x, y, z);
+}

package/core/geom/v3_slerp.js

@@ -0,0 +1,48 @@
+import { v3_dot } from "./v3_dot.js";
+import { v3_lerp } from "./v3_lerp.js";
+
+/**
+ * Spherical linear interpolation
+ * @see https://en.wikipedia.org/wiki/Slerp
+ * @param {Vector3} result
+ * @param {number} a_x
+ * @param {number} a_y
+ * @param {number} a_z
+ * @param {number} b_x
+ * @param {number} b_y
+ * @param {number} b_z
+ * @param {number} fraction
+ */
+export function v3_slerp(
+    result,
+    a_x, a_y, a_z,
+    b_x, b_y, b_z,
+    fraction
+) {
+    const dot = v3_dot(
+        a_x, a_y, a_z,
+        b_x, b_y, b_z
+    );
+
+    if (dot >= 1 || dot <= -1) {
+        // avoid division by 0, both vectors are pointing in the same direction, use lerp instead
+        v3_lerp(result, a_x, a_y, a_z, b_x, b_y, b_z, fraction);
+        return;
+    }
+
+    // compute angle between two vectors
+    const theta = Math.acos(dot);
+
+    const sin_theta = Math.sin(theta);
+
+    const inv_sin_theta = 1 / sin_theta;
+
+    const scale_0 = Math.sin((1 - fraction) * theta) * inv_sin_theta;
+    const scale_1 = Math.sin((fraction) * theta) * inv_sin_theta;
+
+    const x = a_x * scale_0 + b_x * scale_1;
+    const y = a_y * scale_0 + b_y * scale_1;
+    const z = a_z * scale_0 + b_z * scale_1;
+
+    result.set(x, y, z);
+}

package/core/graph/graph_k_means_cluster.js

@@ -1,10 +1,10 @@
 //
 import { seededRandom } from "../math/random/seededRandom.js";
-import { randomIntegerBetween } from "../math/MathUtils.js";
 import { SquareMatrix } from "./SquareMatrix.js";
 import { DataType } from "../collection/table/DataType.js";
 import { BitSet } from "../binary/BitSet.js";
 import FastBinaryHeap from "../../engine/navigation/grid/FastBinaryHeap.js";
+import { randomIntegerBetween } from "../math/random/randomIntegerBetween.js";
 
 /**
  * @template N

package/core/math/MathUtils.js

@@ -4,8 +4,6 @@
  */
 
 import { assert } from "../assert.js";
-import { computeStringHash } from "../primitives/strings/computeStringHash.js";
-import { max2 } from "./max2.js";
 import { min2 } from "./min2.js";
 
 /**
@@ -29,105 +27,6 @@ export function makeSequenceLoop(sequence) {
     }
 }
 
-/**
- * Performs a probabilistic rounding where a fraction is rounded up or down with probability equal to the fraction
- * @param {number} number
- * @param {function} random
- * @returns {int}
- */
-export function roundFair(number, random) {
-    const mantissa = number % 1;
-    const roll = random();
-    if (roll < mantissa) {
-        return Math.ceil(number);
-    } else {
-        return Math.floor(number);
-    }
-}
-
-/**
- * Returns a random number within a normal distribution (Bell/Gaussian curve)
- * @param {int} [quality=6] controls number of "die rolls" used to approximate curve, more rolls - better approximation but higher cost of computation
- * @param {function():number} random
- * @returns {number} value between 0 and 1 with normal weight at 0.5
- */
-export function randomGaussian(random, quality = 6) {
-    let s = 0;
-
-    for (let i = 0; i < quality; i++) {
-        s += random();
-    }
-
-    return s / quality;
-}
-
-/**
- * @template T
- * @param {function} random
- * @param {T[]} array
- * @returns {T}
- */
-export function randomFromArray(random, array) {
-    assert.isArray(array, 'array');
-    assert.typeOf(random, 'function', 'random');
-
-    const length = array.length;
-
-    const i = min2(length - 1, Math.floor(random() * length));
-
-    return array[i];
-}
-
-/**
- *
- * @param {function} random
- * @param {number} min
- * @param {number} max
- * @returns {number}
- */
-export function randomFloatBetween(random, min, max) {
-    const span = max - min;
-
-    const roll = random();
-
-    return roll * span + min;
-}
-
-/**
- * Inclusive random between two boundaries, result is integer
- * @param {function} random
- * @param {number} min lower boundary, must be an integer
- * @param {number} max upper boundary, must be an integer
- * @returns {number}
- */
-export function randomIntegerBetween(random, min, max) {
-    const span = max - min;
-
-    const roll = random();
-
-    return Math.round(roll * span) + min;
-}
-
-/**
- *
- * @param {function():number} random returns a number between 0 and 1
- * @param {number} min
- * @param {number} max
- * @returns {function():number} returns number between min and max
- */
-export function makeRangedRandom(random, min, max) {
-
-    if (min === 0 && max === 1) {
-        //input already returns values in correct range
-        return random;
-    }
-
-    const scale = max - min;
-    return function () {
-        return random() * scale + min;
-    };
-}
-
 /**
  * Compute lowest positive integer divisor of a given "product" value
  * @param {number} product
@@ -243,148 +142,6 @@ function bezierCurve(t, p0, p1, p2, p3) {
 }
 
 
-/**
- *
- * @param {number} v
- * @returns {number}
- */
-export function computeHashFloat(v) {
-    //we break the number up into fractional and whole parts
-    const fraction = v % 1;
-
-    const whole = v | 0;
-
-    //fractional part is scaled up into int32 range, this inexact method, as it will produce 0 hash for values below a certain threshold
-    const fractionHash = fraction * 1367130550;
-
-    //take XOR of both parts
-    return fractionHash ^ whole;
-}
-
-/**
- *
- * @param {number[]|Float32Array|Float64Array} values
- * @param {number} min
- * @param {number} max
- */
-export function computeHashFloatArray(values, min, max) {
-    const dataLength = values.length;
-
-    const dataRange = max - min;
-
-    /*
-     hash min and max
-     */
-    const minHash = computeHashFloat(min);
-    const maxHash = computeHashFloat(min);
-
-    let hash = ((minHash << 5) - minHash) + maxHash;
-
-    for (let i = 0; i < dataLength; i++) {
-        const singleValue = values[i];
-        //normalize value
-        const valueNormalized = (singleValue - min) / dataRange;
-        //scale value to integer range
-        const integerValue = valueNormalized * 4294967295;
-
-        hash = ((hash << 5) - hash) + integerValue;
-        hash |= 0; // Convert to 32bit integer
-    }
-
-    return hash;
-}
-
-/**
- * @template T
- * @param {T[]} array
- * @param {function(T):number} elementHashFunction
- */
-export function computeHashArray(array, elementHashFunction) {
-
-    const numArguments = array.length;
-    let hash = numArguments;
-
-    for (let i = 0; i < numArguments; i++) {
-
-        const singleValue = array[i];
-
-        const elementHash = elementHashFunction(singleValue);
-
-        hash = ((hash << 5) - hash) + elementHash;
-        hash |= 0; // Convert to 32bit integer
-    }
-
-    return hash;
-}
-
-/**
- * Computes hash on integer values
- * @param {...number} value
- * @returns {number}
- */
-export function computeHashIntegerArray(value) {
-    let hash = 0;
-    const numArguments = arguments.length;
-    for (let i = 0; i < numArguments; i++) {
-        const singleValue = arguments[i];
-        hash = ((hash << 5) - hash) + singleValue;
-        hash |= 0; // Convert to 32bit integer
-    }
-    return hash;
-}
-
-/**
- * Recursively computes object hash
- * @param {Object} value
- * @param {number} [depth=3] Maximum recursion depth
- * @returns {number}
- */
-export function computeObjectHash(value, depth = 3) {
-    if (value === undefined) {
-        return 1;
-    }
-
-    if (value === null) {
-        return 2;
-    }
-
-    let hash = 0;
-
-    for (let p in value) {
-
-        hash = ((hash << 5) - hash) + computeStringHash(p);
-
-        const pValue = value[p];
-
-        const pType = typeof pValue;
-
-        let pHash;
-        if (pType === "string") {
-            pHash = computeStringHash(pValue);
-        } else if (pType === "number") {
-            pHash = computeHashFloat(pValue);
-        } else if (pType === "boolean") {
-            pHash = pValue ? 1 : 0;
-        } else if (pType === "object") {
-
-            if (depth <= 0) {
-                pHash = 3;
-            } else {
-                pHash = computeObjectHash(pValue, depth - 1);
-            }
-
-        } else {
-            pHash = 0;
-        }
-
-        hash = ((hash << 5) - hash) + pHash;
-
-        hash |= 0; // Convert to 32bit integer
-    }
-
-    return hash;
-}
-
 /**
  *
  * @param {number} a
@@ -410,54 +167,6 @@ export function computeGreatestCommonDivisor(a, b) {
     return result;
 }
 
-/**
- * Exclusive test, boundaries are not included in positive test
- * @param {Number} value
- * @param {Number} v0
- * @param {Number} v1
- * @returns {boolean}
- */
-export function isValueBetween(value, v0, v1) {
-    return (v0 > value && value > v1) || (v1 > value && value > v0);
-}
-
-/**
- * Inclusive test, boundaries are included in positive test
- * @param {Number} value
- * @param {Number} v0
- * @param {Number} v1
- * @returns {boolean}
- */
-export function isValueBetweenInclusive(value, v0, v1) {
-    return (v0 >= value && value >= v1) || (v1 >= value && value >= v0);
-}
-
-
-/**
- * Return solutions for quadratic
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @returns {number[]|null}
- */
-export function solveQuadratic(a, b, c) {
-    let sol = null;
-    if (Math.abs(a) < 1e-6) {
-        if (Math.abs(b) < 1e-6) {
-            sol = Math.abs(c) < 1e-6 ? [0, 0] : null;
-        } else {
-            sol = [-c / b, -c / b];
-        }
-    } else {
-        let disc = b * b - 4 * a * c;
-        if (disc >= 0) {
-            disc = Math.sqrt(disc);
-            a = 2 * a;
-            sol = [(-b - disc) / a, (-b + disc) / a];
-        }
-    }
-    return sol;
-}
 
 /**
  *
@@ -492,60 +201,6 @@ export function epsilonEquals(a, b, tolerance) {
     return Math.abs(a - b) <= tolerance;
 }
 
-/**
- * Returns true if two 1D lines intersect, touch is treated as intersection
- * Parameters are assumed to be ordered, a1 >= a0, b1 >= b0
- * @param {Number} a0
- * @param {Number} a1
- * @param {Number} b0
- * @param {Number} b1
- * @returns {boolean}
- */
-export function intersects1D(a0, a1, b0, b1) {
-    assert.equal(typeof a0, "number");
-    assert.equal(typeof a1, "number");
-    assert.equal(typeof b0, "number");
-    assert.equal(typeof b1, "number");
-
-    return a1 >= b0 && b1 >= a0;
-}
-
-/**
- * Returns true if two 1D lines overlap, touch is not considered overlap
- * Parameters are assumed to be ordered, a1 > a0, b1 > b0
- * @param {Number} a0
- * @param {Number} a1
- * @param {Number} b0
- * @param {Number} b1
- * @returns {boolean}
- */
-export function overlap1D(a0, a1, b0, b1) {
-    assert.equal(typeof a0, "number");
-    assert.equal(typeof a1, "number");
-    assert.equal(typeof b0, "number");
-    assert.equal(typeof b1, "number");
-
-    return a1 > b0 && b1 > a0;
-}
-
-/**
- * Returns a number representing overlap distance between two 1D line segments.
- * Positive number indicates overlap, negative number indicates that segments do not overlap; 0 indicates that segments are touching.
- * @param {Number} a0
- * @param {Number} a1
- * @param {Number} b0
- * @param {Number} b1
- * @returns {number}
- */
-export function separation1D(a0, a1, b0, b1) {
-    assert.equal(typeof a0, "number");
-    assert.equal(typeof a1, "number");
-    assert.equal(typeof b0, "number");
-    assert.equal(typeof b1, "number");
-
-    return min2(a1, b1) - max2(a0, b0);
-}
-
 /**
  * Assuming the input is an N-dimension vector, normalizes the vector to magnitude of 1
  * @param {number[]|Float32Array} result
@@ -590,12 +245,3 @@ export const PI_HALF = Math.PI / 2;
  */
 export const EPSILON = 0.000001;
 
-/**
- *
- * @param {number} sigma
- * @param {number} v
- * @returns {number}
- */
-export function gaussian(sigma, v) {
-    return Math.exp(-(v * v) / (2 * sigma * sigma));
-}

package/core/math/MathUtils.spec.js

@@ -2,12 +2,18 @@ import { clamp } from "./clamp.js";
 import { copysign } from "./copysign.js";
 import { inverseLerp } from "./inverseLerp.js";
 import { lerp } from "./lerp.js";
-import { computeHashFloat, computeHashFloatArray, computeWholeDivisorLow, cubicCurve, isValueBetween, isValueBetweenInclusive, makeCubicCurve, overlap1D, quadraticCurve, solveQuadratic } from "./MathUtils.js";
+import { computeWholeDivisorLow, cubicCurve, makeCubicCurve, quadraticCurve } from "./MathUtils.js";
 import { max2 } from "./max2.js";
 import { max3 } from "./max3.js";
 import { min2 } from "./min2.js";
 import { min3 } from "./min3.js";
 import { sign } from "./sign.js";
+import { isValueBetween } from "./isValueBetween.js";
+import { isValueBetweenInclusive } from "./isValueBetweenInclusive.js";
+import { solveQuadratic } from "./solveQuadratic.js";
+import { overlap1D } from "./overlap1D.js";
+import { computeHashFloat } from "./hash/computeHashFloat.js";
+import { computeHashFloatArray } from "./hash/computeHashFloatArray.js";
 
 test('min2', () => {
     expect(min2(0, 0)).toBe(0);

package/core/math/gaussian.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number} sigma
+ * @param {number} v
+ * @returns {number}
+ */
+export function gaussian(sigma, v) {
+    return Math.exp(-(v * v) / (2 * sigma * sigma));
+}

package/core/math/hash/computeHashFloat.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+export function computeHashFloat(v) {
+    //we break the number up into fractional and whole parts
+    const fraction = v % 1;
+
+    const whole = v | 0;
+
+    //fractional part is scaled up into int32 range, this inexact method, as it will produce 0 hash for values below a certain threshold
+    const fractionHash = fraction * 1367130550;
+
+    //take XOR of both parts
+    return fractionHash ^ whole;
+}