@woosh/meep-engine 2.60.1 → 2.61.0

package/src/core/geom/packing/miniball/Miniball.js

@@ -6,23 +6,15 @@
  */
 
 
-import { Quality } from "./Quality.js";
-import { Subspan } from "./Subspan.js";
+import {assert} from "../../../assert.js";
+import {sqr} from "../../../math/sqr.js";
+import {Subspan} from "./Subspan.js";
 
 /**
- * Create a zero-filled array of fixed size
- * @param {number} n
- * @returns {number[]}
+ * Small number
+ * @type {number}
  */
-function ndArray(n) {
-    const result = new Array(n);
-
-    for (let i = 0; i < n; i++) {
-        result[i] = 0;
-    }
-
-    return result;
-}
+const Epsilon = 1.0E-14;
 
 /**
  * Limit to how many iterations algorithm is allowed to perform, this is to cover poorly converging cases
@@ -32,24 +24,32 @@ const MAX_ITERATIONS = 10000;
 
 /**
  * Computes the miniball of the given point set.
- *
- * Notice that the point set `pts` is assumed to be immutable during the computation. That
- * is, if you add, remove, or change points in the point set, you have to create a new instance of
- * {@link Miniball}.
- *
- * @param {PointSet} pts
- * the point set
  * @class
  */
-class Miniball {
+export class Miniball {
     /**
+     * Notice that the point set `points` is assumed to be immutable during the computation.
+     * That is, if you add, remove, or change points in the point set, you have to create a new instance of {@link Miniball}.
      *
-     * @param {PointSet} pts
+     * @param {PointSet} points the point set
      */
-    constructor(pts) {
+    constructor(points) {
+        assert.defined(points, 'points');
+
         this.iteration = 0;
         this.distToAff = 0;
         this.distToAffSquare = 0;
+        /**
+         *
+         * The squared radius of the miniball.
+         *
+         * This is equivalent to `radius() * radius()`.
+         *
+         * Precondition: `!isEmpty()`
+         *
+         * @type {number}
+         * @private
+         */
         this.__squaredRadius = 0;
         this.__radius = 0;
         this.stopper = 0;
@@ -57,40 +57,46 @@ class Miniball {
         /**
          * @type {PointSet}
          */
-        this.S = pts;
+        this.S = points;
 
         this.__size = this.S.size();
 
+        const dimension_count = this.S.dimension();
+
         /**
          * Number of dimensions (2 for 2d, 3 for 3d etc.)
          * @type {Number}
          */
-        this.dim = this.S.dimension();
+        this.dim = dimension_count;
+
+
+        // pre-allocated continuous chunk of memory to make execution faster by reducing cache miss rate
+        const buffer = new ArrayBuffer(8 * (dimension_count * 4 + 1));
 
         /**
          *
-         * @type {number[]}
+         * @type {number[]|Float64Array}
          * @private
          */
-        this.__center = ndArray(this.dim);
+        this.__center = new Float64Array(buffer, 0, dimension_count);
 
         /**
          *
-         * @type {number[]}
+         * @type {number[]|Float64Array}
          */
-        this.centerToAff = ndArray(this.dim);
+        this.centerToAff = new Float64Array(buffer, 8 * dimension_count, dimension_count);
 
         /**
          *
-         * @type {number[]}
+         * @type {number[]|Float64Array}
          */
-        this.centerToPoint = ndArray(this.dim);
+        this.centerToPoint = new Float64Array(buffer, 8 * 2 * dimension_count, dimension_count);
 
         /**
          *
-         * @type {number[]}
+         * @type {number[]|Float64Array}
          */
-        this.lambdas = ndArray(this.dim + 1);
+        this.lambdas = new Float64Array(buffer, 8 * 3 * dimension_count, dimension_count + 1);
 
         /**
          *
@@ -102,7 +108,7 @@ class Miniball {
     }
 
     /**
-     * Whether or not the miniball is the empty set, equivalently, whether `points.size() == 0`
+     * Whether the miniball is the empty set, equivalently, whether `points.size() == 0`
      * was true when this miniball instance was constructed.
      *
      * Notice that the miniball of a point set <i>S</i> is empty if and only if <i>S={}</i>.
@@ -125,27 +131,22 @@ class Miniball {
     }
 
     /**
-     * The squared radius of the miniball.
-     *
-     * This is equivalent to `radius() * radius()`.
+     * The Euclidean coordinates of the center of the miniball.
      *
      * Precondition: `!isEmpty()`
      *
-     * @return {number} the squared radius of the miniball
+     * @return {number[]} an array holding the coordinates of the center of the miniball
      */
-    squaredRadius() {
-        return this.__squaredRadius;
+    center() {
+        return this.__center;
     }
 
     /**
-     * The Euclidean coordinates of the center of the miniball.
-     *
-     * Precondition: `!isEmpty()`
      *
-     * @return {number[]} an array holding the coordinates of the center of the miniball
+     * @returns {Subspan}
      */
-    center() {
-        return this.__center;
+    get support() {
+        return this.__support;
     }
 
     /**
@@ -159,20 +160,6 @@ class Miniball {
         return this.__size;
     }
 
-    /**
-     * TODO
-     *
-     * @return {*}
-     */
-    support() {
-        throw new Error("Not implemented yet.");
-    }
-
-    /*private*/
-    static sqr(x) {
-        return x * x;
-    }
-
     /**
      * Sets up the search ball with an arbitrary point of <i>S</i> as center and with exactly one of
      * the points farthest from center in the support. So the current ball contains all points of
@@ -205,7 +192,7 @@ class Miniball {
             let dist = 0;
 
             for (i = 0; i < dim; ++i) {
-                dist += Miniball.sqr(pointSet.coord(j, i) - center[i]);
+                dist += sqr(pointSet.coord(j, i) - center[i]);
             }
 
             if (dist >= this.__squaredRadius) {
@@ -226,13 +213,19 @@ class Miniball {
 
     /*private*/
     updateRadius() {
-        let any = this.__support.anyMember();
+        const any = this.__support.anyMember();
         this.__squaredRadius = 0;
-        for (let i = 0; i < this.dim; ++i)
-            this.__squaredRadius += Miniball.sqr(this.S.coord(any, i) - this.__center[i]);
+
+        const dim = this.dim;
+
+        const center = this.__center;
+        const points = this.S;
+
+        for (let i = 0; i < dim; ++i) {
+            this.__squaredRadius += sqr(points.coord(any, i) - center[i]);
+        }
+
         this.__radius = Math.sqrt(this.__squaredRadius);
-        //if (com.dreizak.miniball.highdim.Logging.log)
-        //    com.dreizak.miniball.highdim.Logging.debug("current radius = " + this.__radius);
     }
 
     /**
@@ -253,18 +246,15 @@ class Miniball {
         const centerToAff = this.centerToAff;
 
         for (this.iteration = 0; this.iteration < MAX_ITERATIONS; this.iteration++) {
-            //if (com.dreizak.miniball.highdim.Logging.log) {
-            //    com.dreizak.miniball.highdim.Logging.debug("Iteration " + this.iteration);
-            //    com.dreizak.miniball.highdim.Logging.debug(this.__support.size() + " points on the boundary");
-            //}
+
             this.computeDistToAff();
+
             while (
-                this.distToAff <= Miniball.Eps * this.__radius
+                this.distToAff <= Epsilon * this.__radius
                 || support.size() === dim + 1
                 ) {
                 if (!this.successfulDrop()) {
-                    //if (com.dreizak.miniball.highdim.Logging.log)
-                    //    com.dreizak.miniball.highdim.Logging.info("Done");
+                    // done
                     return;
                 }
                 this.computeDistToAff();
@@ -376,7 +366,7 @@ class Miniball {
                 dirPointProd += centerToAff[i] * centerToPoint[i];
             }
 
-            if ((this.distToAffSquare - dirPointProd) < (Miniball.Eps * this.__radius * this.distToAff)) {
+            if ((this.distToAffSquare - dirPointProd) < (Epsilon * this.__radius * this.distToAff)) {
                 continue;
             }
 
@@ -400,43 +390,9 @@ class Miniball {
         return scale;
     }
 
-    /**
-     * Verifies that the computed ball is indeed the miniball.
-     *
-     * This method should be called for testing purposes only; it may not be very efficient.
-     * @return {Quality}
-     */
-    verify() {
-        let min_lambda = 1;
-        let max_overlength = 0;
-        let min_underlength = 0;
-        let ball_error;
-        let qr_error = this.__support.representationError();
-        this.__support.findAffineCoefficients(this.__center, this.lambdas);
-        for (let k = 0; k < this.__support.size(); ++k)
-            if (this.lambdas[k] <= min_lambda)
-                min_lambda = this.lambdas[k];
-
-        for (let k = 0; k < this.S.size(); ++k) {
-            for (let i = 0; i < this.dim; ++i)
-                this.centerToPoint[i] = this.S.coord(k, i) - this.__center[i];
-            let sqDist = 0;
-            for (let i = 0; i < this.dim; ++i)
-                sqDist += Miniball.sqr(this.centerToPoint[i]);
-            ball_error = Math.sqrt(sqDist) - this.__radius;
-            if (ball_error > max_overlength)
-                max_overlength = ball_error;
-            if (this.__support.isMember(k))
-                if (ball_error < min_underlength)
-                    min_underlength = ball_error;
-        }
-
-        return new Quality(qr_error, min_lambda, max_overlength / this.__radius, Math.abs(min_underlength / this.__radius), this.iteration, this.__support.size());
-    }
 
     /**
-     * Outputs information about the miniball; this includes the quality information provided by
-     * {@link #verify()} (and as a consequence, {@link #toString()} is expensive to call).
+     * Outputs information about the miniball
      * @return {string}
      */
     toString() {
@@ -451,14 +407,9 @@ class Miniball {
                     s += (", ");
             }
 
-            s += `), radius=${this.__radius}, squaredRadius=${this.__squaredRadius}, quality=${this.verify()}`;
+            s += `), radius=${this.__radius}, squaredRadius=${this.__squaredRadius}`;
         }
         s += "]";
         return s;
     }
-}
-
-Miniball.Eps = 1.0E-14;
-
-
-export { Miniball };
+}

package/src/core/geom/packing/miniball/Miniball.spec.js

@@ -1,5 +1,5 @@
-import { Miniball } from "./Miniball.js";
-import { PointSet } from "./PointSet.js";
+import {Miniball} from "./Miniball.js";
+import {PointSet} from "./PointSet.js";
 
 
 test("empty point set in 1d", () => {
@@ -12,7 +12,7 @@ test("single point in 1d", () => {
 
     const miniball = new Miniball(new PointSet(1, 1, [7]));
 
-    expect(miniball.center()).toEqual([7]);
+    expect(Array.from(miniball.center())).toEqual([7]);
     expect(miniball.radius()).toEqual(0);
 
 });

package/src/core/geom/packing/miniball/Subspan.js

@@ -5,7 +5,7 @@
  * @generated Generated from Java with JSweet 2.2.0-SNAPSHOT - http://www.jsweet.org
  */
 
-import { BitSet } from "../../../binary/BitSet.js";
+import {BitSet} from "../../../binary/BitSet.js";
 
 export class Subspan {
     /**
@@ -305,32 +305,38 @@ export class Subspan {
      *
      * Complexity: O(dim^2)
      *
-     * @param {Array} p
-     * Euclidean coordinates of point <i>p</i>
-     * @param {Array} w
-     * the squared length of <i>w</i>
-     * @return {number}
+     * @param {number[]} p
+     * @param {number[]} w Euclidean coordinates of point <i>p</i>
+     * @return {number} the squared length of <i>w</i>
      */
     shortestVectorToSpan(p, w) {
-        let o = this.origin();
+        const o = this.origin();
 
         const dim = this.dim;
 
         const S = this.S;
+
         for (let i = 0; i < dim; ++i) {
             w[i] = S.coord(o, i) - p[i];
         }
 
         const Q = this.Q;
 
-        for (let j = 0; j < this.r; ++j) {
+        const r = this.r;
+
+        for (let j = 0; j < r; ++j) {
             let scale = 0;
+
+            const QJ = Q[j];
+
             for (let i = 0; i < dim; ++i) {
-                scale += w[i] * Q[j][i];
+                scale += w[i] * QJ[i];
             }
+
             for (let i = 0; i < dim; ++i) {
-                w[i] -= scale * Q[j][i];
+                w[i] -= scale * QJ[i];
             }
+
         }
 
         let sl = 0;
@@ -348,37 +354,44 @@ export class Subspan {
      * @return {number}
      */
     representationError() {
-        let lambdas = (s => {
-            let a = [];
-            while (s-- > 0)
-                a.push(0);
-            return a;
-        })(this.size());
-        let pt = (s => {
-            let a = [];
-            while (s-- > 0)
-                a.push(0);
-            return a;
-        })(this.dim);
+
+        const size = this.size();
+
+        const lambdas = new Float64Array(size);
+
+        const dim = this.dim;
+
+        const pt = new Float64Array(dim);
+
         let max = 0;
-        let error;
-        for (let j = 0; j < this.size(); ++j) {
-            for (let i = 0; i < this.dim; ++i)
+
+        for (let j = 0; j < size; ++j) {
+            for (let i = 0; i < dim; ++i) {
                 pt[i] = this.S.coord(this.globalIndex(j), i);
+            }
+
             this.findAffineCoefficients(pt, lambdas);
-            error = Math.abs(lambdas[j] - 1.0);
-            if (error > max)
+
+            let error = Math.abs(lambdas[j] - 1.0);
+
+            if (error > max) {
                 max = error;
+            }
+
             for (let i = 0; i < j; ++i) {
-                error = Math.abs(lambdas[i] - 0.0);
-                if (error > max)
+                error = Math.abs(lambdas[i]);
+                if (error > max) {
                     max = error;
+                }
             }
 
-            for (let i = j + 1; i < this.size(); ++i) {
-                error = Math.abs(lambdas[i] - 0.0);
-                if (error > max)
+            // skip over lambdas[j]
+
+            for (let i = j + 1; i < size; ++i) {
+                error = Math.abs(lambdas[i]);
+                if (error > max) {
                     max = error;
+                }
             }
 
         }
@@ -396,8 +409,8 @@ export class Subspan {
      * Complexity: O(dim^2)
      *
      * Preconditions: c lies in the affine hull aff(M) and size() > 0.
-     * @param {Array} p
-     * @param {Array} lambdas
+     * @param {number[]|Float64Array} p
+     * @param {number[]|Float64Array} lambdas
      */
     findAffineCoefficients(p, lambdas) {
         let o = this.origin();

package/src/core/geom/packing/miniball/miniball_compute_quality.js

@@ -0,0 +1,64 @@
+import {sqr} from "../../../math/sqr.js";
+import {Quality} from "./Quality.js";
+
+/**
+ * Verifies that the computed ball is indeed the miniball.
+ *
+ * This method should be called for testing purposes only; it may not be very efficient.
+ * @param {Miniball} miniball
+ * @return {Quality}
+ */
+export function miniball_compute_quality(miniball) {
+    const support = miniball.support;
+    const points = miniball.S;
+    const center = miniball.center();
+    const dimension_count = miniball.dim;
+
+
+    let min_lambda = 1;
+    let max_overlength = 0;
+    let min_underlength = 0;
+    let ball_error;
+
+    let qr_error = support.representationError();
+
+    support.findAffineCoefficients(center, miniball.lambdas);
+
+    for (let k = 0; k < support.size(); ++k) {
+        if (miniball.lambdas[k] <= min_lambda) {
+            min_lambda = miniball.lambdas[k];
+        }
+    }
+
+    for (let k = 0; k < points.size(); ++k) {
+
+        for (let i = 0; i < dimension_count; ++i) {
+            miniball.centerToPoint[i] = points.coord(k, i) - center[i];
+        }
+
+        let sqDist = 0;
+
+        for (let i = 0; i < dimension_count; ++i) {
+            sqDist += sqr(miniball.centerToPoint[i]);
+        }
+
+        ball_error = Math.sqrt(sqDist) - miniball.radius();
+
+        if (ball_error > max_overlength) {
+            max_overlength = ball_error;
+        }
+
+        if (support.isMember(k) && ball_error < min_underlength) {
+            min_underlength = ball_error;
+        }
+    }
+
+    return new Quality(
+        qr_error,
+        min_lambda,
+        max_overlength / miniball.radius(),
+        Math.abs(min_underlength / miniball.radius()),
+        miniball.iteration,
+        support.size()
+    );
+}

package/src/core/math/bessel_3.js

@@ -1,6 +1,7 @@
 /**
  * Kaiser Bessel Function of third kind
  * NOTE: this is an approximation, if input value is sufficiently large - results will be way off
+ * This is a Tylor series approximation
  * @see https://www.shadertoy.com/view/wlf3RH
  * @returns {number}
  * @param {number} x

package/src/core/math/random/randomBytes.js

@@ -1,7 +1,7 @@
-import { randomUint8 } from "./randomUint8.js";
+import {randomUint8} from "./randomUint8.js";
 
 /**
- *
+ * Fill array with random byte values (0..255 integers)
  * @param {Uint8Array} result
  * @param {number} result_offset
  * @param {function():number} random

package/src/core/math/sqr.js

@@ -0,0 +1,8 @@
+/**
+ * Square input (x^2)
+ * @param {number} x
+ * @returns {number}
+ */
+export function sqr(x) {
+    return x * x;
+}

package/src/core/model/node-graph/Connection.js

@@ -1,7 +1,7 @@
-import { assert } from "../../assert.js";
-import { noop } from "../../function/Functions.js";
-import { objectKeyByValue } from "../object/objectKeyByValue.js";
-import { PortDirection } from "./node/PortDirection.js";
+import {assert} from "../../assert.js";
+import {noop} from "../../function/Functions.js";
+import {objectKeyByValue} from "../object/objectKeyByValue.js";
+import {PortDirection} from "./node/PortDirection.js";
 
 /**
  *
@@ -10,25 +10,23 @@ import { PortDirection } from "./node/PortDirection.js";
 let id_counter = 0;
 
 export class Connection {
-    constructor() {
-        /**
-         * @readonly
-         * @type {number}
-         */
-        this.id = id_counter++;
-
-        /**
-         *
-         * @type {NodeInstancePortReference}
-         */
-        this.source = null;
-
-        /**
-         *
-         * @type {NodeInstancePortReference}
-         */
-        this.target = null;
-    }
+    /**
+     * @readonly
+     * @type {number}
+     */
+    id = id_counter++;
+
+    /**
+     *
+     * @type {NodeInstancePortReference}
+     */
+    source = null;
+
+    /**
+     *
+     * @type {NodeInstancePortReference}
+     */
+    target = null;
 
     /**
      *

package/src/core/model/node-graph/DataType.js

@@ -1,19 +1,18 @@
-import { assert } from "../../assert.js";
+import {assert} from "../../assert.js";
 
 export class DataType {
-    constructor() {
-        /**
-         *
-         * @type {number}
-         */
-        this.id = 0;
-
-        /**
-         * Name is not guaranteed to be unique, it is intended mainly for debug purposes
-         * @type {string}
-         */
-        this.name = "";
-    }
+
+    /**
+     * Unique integer identifier
+     * @type {number}
+     */
+    id = 0;
+
+    /**
+     * Name is not guaranteed to be unique, it is intended mainly for debug purposes
+     * @type {string}
+     */
+    name = "";
 
     toString() {
         return `DataType{ id=${this.id}, name='${this.name}' }`;
@@ -37,10 +36,10 @@ export class DataType {
     }
 
     toJSON() {
-        return { ...this };
+        return {...this};
     }
 
-    fromJSON({ id, name }) {
+    fromJSON({id, name}) {
         assert.isNonNegativeInteger(id, 'id');
         assert.isString(name, 'name');
 
@@ -53,7 +52,7 @@ export class DataType {
      * @param {*} j
      * @returns {DataType}
      */
-    static fromJSON(j){
+    static fromJSON(j) {
         const r = new DataType();
 
         r.fromJSON(j);