@woosh/meep-engine 2.135.0 → 2.138.0

package/src/core/geom/Vector4.d.ts

@@ -8,9 +8,11 @@
  *
  * Iterating through a Vector4 instance will yield its components (x, y, z, w) in the corresponding order.
  *
+ * Backed by a `Float64Array` of length 4, so instances are usable directly as typed-array views and indexed access `v[0]`..`v[3]` aliases `v.x`..`v.w`.
+ *
  * @implements Iterable<number>
  */
-export class Vector4 implements Iterable<number> {
+export class Vector4 extends Float64Array implements Iterable<number> {
     /**
      *
      * @param {Vector4} v0
@@ -19,6 +21,12 @@ export class Vector4 implements Iterable<number> {
      * @param {Vector4} result
      */
     static lerp(v0: Vector4, v1: Vector4, f: number, result: Vector4): void;
+    /**
+     * Ensure that built-in `TypedArray` methods (`map`, `slice`, `subarray`, ...) do not
+     * try to construct a `Vector4` via the buffer-form constructor.
+     * @returns {Float64ArrayConstructor}
+     */
+    static get [Symbol.species](): Float64ArrayConstructor;
     /**
      *
      * @param {number} [x=0]
@@ -29,26 +37,10 @@ export class Vector4 implements Iterable<number> {
      * @class
      */
     constructor(x?: number, y?: number, z?: number, w?: number);
-    /**
-     *
-     * @type {number}
-     */
-    x: number;
-    /**
-     *
-     * @type {number}
-     */
-    y: number;
-    /**
-     *
-     * @type {number}
-     */
-    z: number;
-    /**
-     *
-     * @type {number}
-     */
-    w: number;
+    0: number;
+    1: number;
+    2: number;
+    3: number;
     /**
      * Dispatched when the value changes
      * @readonly
@@ -59,42 +51,42 @@ export class Vector4 implements Iterable<number> {
      *
      * @param {number} v
      */
-    set 0(arg: number);
+    set x(arg: number);
     /**
      *
      * @returns {number}
      */
-    get 0(): number;
+    get x(): number;
     /**
      *
      * @param {number} v
      */
-    set 1(arg: number);
+    set y(arg: number);
     /**
      *
      * @returns {number}
      */
-    get 1(): number;
+    get y(): number;
     /**
      *
      * @param {number} v
      */
-    set 2(arg: number);
+    set z(arg: number);
     /**
      *
      * @returns {number}
      */
-    get 2(): number;
+    get z(): number;
     /**
      *
      * @param {number} v
      */
-    set 3(arg: number);
+    set w(arg: number);
     /**
      *
      * @returns {number}
      */
-    get 3(): number;
+    get w(): number;
     /**
      *
      * @param {number[]} array
@@ -239,7 +231,6 @@ export class Vector4 implements Iterable<number> {
      */
     readonly isVector4: boolean;
     fromArray: (array: number[], offset?: number) => void;
-    [Symbol.iterator](): Generator<number, void, unknown>;
 }
 export namespace Vector4 {
     let typeName: string;

package/src/core/geom/Vector4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Vector4.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector4.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;GAWG;AACH,yCAFwB,MAAM;IAgc1B;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,qBAEP,OAAO,QASjB;IA3cD;;;;;;;;OAQG;IACH,gBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,EAsChB;IA3BG;;;OAGG;IACH,GAFU,MAAM,CAEN;IACV;;;OAGG;IACH,GAFU,MAAM,CAEN;IACV;;;OAGG;IACH,GAFU,MAAM,CAEN;IACV;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,2FAA6B;IAWjC;;;OAGG;IACH,mBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,mBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,mBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,mBAEC;IAdD;;;OAGG;IACH,gBAEC;IAUD;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAShB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,iDAFa,OAAO,CAkCnB;IAED;;;OAGG;IACH,mCAMC;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAOnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAlBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoBnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,SAHW,UAAQ,OAAO,GACb,OAAO,CASnB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,EAAE,GAAC,YAAY,GACpB,OAAO,CASlB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,SAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,qCAuBC;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CASjB;IAED;;;;OAIG;IACH,gBAJW,OAAO,MACP,OAAO,mBAKjB;IAuGL,kBAnGe,MAAM,EAAE,UAmGE;IA1FrB;;OAEG;IACH,WAFa,MAAM,EAAE,CAQpB;IAED;;;;OAIG;IACH,mBAHW,MAAM,EAAE,UACR,MAAM,QAIhB;IAED;;;;;MAOC;IAED,0BAEC;IAED;;;OAGG;IACH,2CAKC;IAED;;;OAGG;IACH,6CAOC;IA4BL;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAE3B,mBArWe,MAAM,EAAE,WACR,MAAM,UAoWM;IAhCvB,sDAOC;CAiBJ;;kBAaS,MAAM"}
+{"version":3,"file":"Vector4.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector4.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;GAaG;AACH,8DAFwB,MAAM;IAib1B;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,qBAEP,OAAO,QASjB;IA9ZD;;;;OAIG;IACH,uDAEC;IArCD;;;;;;;;OAQG;IACH,gBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,EAuBhB;IAXG,UAAW;IACX,UAAW;IACX,UAAW;IACX,UAAW;IAEX;;;;OAIG;IACH,2FAA6B;IAoBjC;;;OAGG;IACH,mBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,mBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,mBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,mBAEC;IAdD;;;OAGG;IACH,gBAEC;IAUD;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAShB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,iDAFa,OAAO,CAkCnB;IAED;;;OAGG;IACH,mCAMC;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAOnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAlBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoBnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,SAHW,UAAQ,OAAO,GACb,OAAO,CASnB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,EAAE,GAAC,YAAY,GACpB,OAAO,CASlB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,SAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,qCAuBC;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CASjB;IAED;;;;OAIG;IACH,gBAJW,OAAO,MACP,OAAO,mBAKjB;IA8FL,kBA1Fe,MAAM,EAAE,UA0FE;IAjFrB;;OAEG;IACH,WAFa,MAAM,EAAE,CAQpB;IAED;;;;OAIG;IACH,mBAHW,MAAM,EAAE,UACR,MAAM,QAIhB;IAED;;;;;MAOC;IAED,0BAEC;IAED;;;OAGG;IACH,2CAKC;IAED;;;OAGG;IACH,6CAOC;IAmBL;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAE3B,mBA5Ve,MAAM,EAAE,WACR,MAAM,UA2VM;CAR1B;;kBAaS,MAAM"}

package/src/core/geom/Vector4.js

@@ -14,9 +14,11 @@ import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
  *
  * Iterating through a Vector4 instance will yield its components (x, y, z, w) in the corresponding order.
  *
+ * Backed by a `Float64Array` of length 4, so instances are usable directly as typed-array views and indexed access `v[0]`..`v[3]` aliases `v.x`..`v.w`.
+ *
  * @implements Iterable<number>
  */
-export class Vector4 {
+export class Vector4 extends Float64Array {
     /**
      *
      * @param {number} [x=0]
@@ -32,27 +34,12 @@ export class Vector4 {
         z = 0,
         w = 0
     ) {
+        super(4);
 
-        /**
-         *
-         * @type {number}
-         */
-        this.x = x;
-        /**
-         *
-         * @type {number}
-         */
-        this.y = y;
-        /**
-         *
-         * @type {number}
-         */
-        this.z = z;
-        /**
-         *
-         * @type {number}
-         */
-        this.w = w;
+        this[0] = x;
+        this[1] = y;
+        this[2] = z;
+        this[3] = w;
 
         /**
          * Dispatched when the value changes
@@ -62,68 +49,77 @@ export class Vector4 {
         this.onChanged = new Signal();
     }
 
+    /**
+     * Ensure that built-in `TypedArray` methods (`map`, `slice`, `subarray`, ...) do not
+     * try to construct a `Vector4` via the buffer-form constructor.
+     * @returns {Float64ArrayConstructor}
+     */
+    static get [Symbol.species]() {
+        return Float64Array;
+    }
+
     /**
      *
      * @returns {number}
      */
-    get 0() {
-        return this.x;
+    get x() {
+        return this[0];
     }
 
     /**
      *
      * @param {number} v
      */
-    set 0(v) {
-        this.x = v;
+    set x(v) {
+        this[0] = v;
     }
 
     /**
      *
      * @returns {number}
      */
-    get 1() {
-        return this.y;
+    get y() {
+        return this[1];
     }
 
     /**
      *
      * @param {number} v
      */
-    set 1(v) {
-        this.y = v;
+    set y(v) {
+        this[1] = v;
     }
 
     /**
      *
      * @returns {number}
      */
-    get 2() {
-        return this.z;
+    get z() {
+        return this[2];
     }
 
     /**
      *
      * @param {number} v
      */
-    set 2(v) {
-        this.z = v;
+    set z(v) {
+        this[2] = v;
     }
 
     /**
      *
      * @returns {number}
      */
-    get 3() {
-        return this.w;
+    get w() {
+        return this[3];
     }
 
     /**
      *
      * @param {number} v
      */
-    set 3(v) {
-        this.w = v;
+    set w(v) {
+        this[3] = v;
     }
 
     /**
@@ -146,10 +142,10 @@ export class Vector4 {
      * @param {number} offset
      */
     writeToArray(array, offset = 0) {
-        array[offset] = this.x;
-        array[offset + 1] = this.y;
-        array[offset + 2] = this.z;
-        array[offset + 3] = this.w;
+        array[offset] = this[0];
+        array[offset + 1] = this[1];
+        array[offset + 2] = this[2];
+        array[offset + 3] = this[3];
     }
 
     /**
@@ -171,17 +167,17 @@ export class Vector4 {
         assert.ok(!Number.isNaN(z), `Z must be a valid number, instead was NaN`);
         assert.ok(!Number.isNaN(w), `W must be a valid number, instead was NaN`);
 
-        const _x = this.x;
-        const _y = this.y;
-        const _z = this.z;
-        const _w = this.w;
+        const _x = this[0];
+        const _y = this[1];
+        const _z = this[2];
+        const _w = this[3];
 
         if (_x !== x || _y !== y || _z !== z || _w !== w) {
 
-            this.x = x;
-            this.y = y;
-            this.z = z;
-            this.w = w;
+            this[0] = x;
+            this[1] = y;
+            this[2] = z;
+            this[3] = w;
 
             if (this.onChanged.hasHandlers()) {
                 this.onChanged.send8(
@@ -199,11 +195,11 @@ export class Vector4 {
      * @param {Vector3} v3
      */
     multiplyVector3(v3) {
-        const x = this.x * v3.x;
-        const y = this.y * v3.y;
-        const z = this.z * v3.z;
+        const x = this[0] * v3.x;
+        const y = this[1] * v3.y;
+        const z = this[2] * v3.z;
 
-        this.set(x, y, z, this.w);
+        this.set(x, y, z, this[3]);
     }
 
     /**
@@ -215,7 +211,7 @@ export class Vector4 {
         assert.isNumber(value, 'value');
         assert.notNaN(value, 'value');
 
-        return this.set(this.x * value, this.y * value, this.z * value, this.w * value);
+        return this.set(this[0] * value, this[1] * value, this[2] * value, this[3] * value);
     }
 
     /**
@@ -245,10 +241,10 @@ export class Vector4 {
         d0, d1, d2, d3
     ) {
 
-        const _x = this.x;
-        const _y = this.y;
-        const _z = this.z;
-        const _w = this.w;
+        const _x = this[0];
+        const _y = this[1];
+        const _z = this[2];
+        const _w = this[3];
 
         const x = a0 * _x + b0 * _y + c0 * _z + d0 * _w;
         const y = a1 * _x + b1 * _y + c1 * _z + d1 * _w;
@@ -264,7 +260,7 @@ export class Vector4 {
      * @returns {number}
      */
     dot(other) {
-        return this.x * other.x + this.y * other.y + this.z * other.z + this.w * other.w;
+        return this[0] * other.x + this[1] * other.y + this[2] * other.z + this[3] * other.w;
     }
 
     /**
@@ -274,10 +270,10 @@ export class Vector4 {
      */
     add3(v3) {
         return this.set(
-            this.x + v3.x,
-            this.y + v3.y,
-            this.z + v3.z,
-            this.w
+            this[0] + v3.x,
+            this[1] + v3.y,
+            this[2] + v3.z,
+            this[3]
         );
     }
 
@@ -330,10 +326,10 @@ export class Vector4 {
      * @param {Quaternion} q
      */
     applyQuaternion(q) {
-        const x = this.x;
-        const y = this.y;
-        const z = this.z;
-        const w = this.w;
+        const x = this[0];
+        const y = this[1];
+        const z = this[2];
+        const w = this[3];
 
         const qx = q.x;
         const qy = q.y;
@@ -360,7 +356,7 @@ export class Vector4 {
      * @returns {boolean}
      */
     equals(vec4) {
-        return this.x === vec4.x && this.y === vec4.y && this.z === vec4.z && this.w === vec4.w;
+        return this[0] === vec4.x && this[1] === vec4.y && this[2] === vec4.z && this[3] === vec4.w;
     }
 
     /**
@@ -369,10 +365,10 @@ export class Vector4 {
      */
     hash() {
         return combine_hash(
-            computeHashFloat(this.x),
-            computeHashFloat(this.y),
-            computeHashFloat(this.z),
-            computeHashFloat(this.w)
+            computeHashFloat(this[0]),
+            computeHashFloat(this[1]),
+            computeHashFloat(this[2]),
+            computeHashFloat(this[3])
         );
     }
 
@@ -390,10 +386,10 @@ export class Vector4 {
      * @param {number[]} result
      */
     toArray(result) {
-        result[0] = this.x;
-        result[1] = this.y;
-        result[2] = this.z;
-        result[3] = this.w;
+        result[0] = this[0];
+        result[1] = this[1];
+        result[2] = this[2];
+        result[3] = this[3];
     }
 
     /**
@@ -418,10 +414,10 @@ export class Vector4 {
 
     toJSON() {
         return {
-            x: this.x,
-            y: this.y,
-            z: this.z,
-            w: this.w
+            x: this[0],
+            y: this[1],
+            z: this[2],
+            w: this[3]
         };
     }
 
@@ -434,10 +430,10 @@ export class Vector4 {
      * @param {BinaryBuffer} buffer
      */
     toBinaryBuffer(buffer) {
-        buffer.writeFloat64(this.x);
-        buffer.writeFloat64(this.y);
-        buffer.writeFloat64(this.z);
-        buffer.writeFloat64(this.w);
+        buffer.writeFloat64(this[0]);
+        buffer.writeFloat64(this[1]);
+        buffer.writeFloat64(this[2]);
+        buffer.writeFloat64(this[3]);
     }
 
     /**
@@ -453,15 +449,6 @@ export class Vector4 {
         this.set(x, y, z, w);
     }
 
-    * [Symbol.iterator]() {
-
-        yield this.x;
-        yield this.y;
-        yield this.z;
-        yield this.w;
-
-    }
-
     /**
      *
      * @param {Vector4} v0

package/src/core/geom/packing/computeBoundingSphereOfSpheres.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"computeBoundingSphereOfSpheres.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/packing/computeBoundingSphereOfSpheres.js"],"names":[],"mappings":"AAoBA;;;;;;;;;GASG;AACH,uDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,SACN,MAAM,cACN,MAAM,QAwDhB"}
+{"version":3,"file":"computeBoundingSphereOfSpheres.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/packing/computeBoundingSphereOfSpheres.js"],"names":[],"mappings":"AAyBA;;;;;;;;;GASG;AACH,uDANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,SACN,MAAM,cACN,MAAM,QAoEhB"}

package/src/core/geom/packing/computeBoundingSphereOfSpheres.js

@@ -18,6 +18,11 @@ function compute_point_distance(a, b, d) {
     return Math.sqrt(result);
 }
 
+const SCRATCH_DIMENSIONS = 4;
+
+const _scratch_center = new Float64Array(SCRATCH_DIMENSIONS);
+const _scratch_sphere = new Float64Array(SCRATCH_DIMENSIONS + 1);
+
 /**
  * Computes bounding sphere of a number of spheres
  * NOTE: implementation does not produce a very tight sphere, here is a good resource for a better implementation:
@@ -31,15 +36,27 @@ function compute_point_distance(a, b, d) {
 export function computeBoundingSphereOfSpheres(result, data, offset, count, dimensions) {
     assert.isArrayLike(result, 'result');
 
-    const center = new Float64Array(dimensions);
+    const sphere_component_count = dimensions + 1;
+
+    let center;
+    let sphere;
 
-    const sphere = new Float64Array(dimensions + 1);
+    if (dimensions <= SCRATCH_DIMENSIONS) {
+        // avoid allocation
+        center = _scratch_center;
+        sphere = _scratch_sphere;
+
+        center.fill(0);
+    } else {
+        center = new Float64Array(dimensions);
+        sphere = new Float64Array(sphere_component_count);
+    }
 
     for (let i = 0; i < count; i++) {
-        const sphere_offset = offset + i * dimensions;
+        const sphere_offset = offset + i * sphere_component_count;
 
         //read sphere
-        for (let j = 0; j < dimensions + 1; j++) {
+        for (let j = 0; j < sphere_component_count; j++) {
             sphere[j] = data[sphere_offset + j];
         }
 
@@ -58,10 +75,10 @@ export function computeBoundingSphereOfSpheres(result, data, offset, count, dime
 
     for (let i = 0; i < count; i++) {
         // compute squared distance from center to each sphere
-        const sphere_offset = offset + i * dimensions;
+        const sphere_offset = offset + i*sphere_component_count;
 
         //read sphere
-        for (let j = 0; j < dimensions + 1; j++) {
+        for (let j = 0; j < sphere_component_count; j++) {
             sphere[j] = data[sphere_offset + j];
         }
 

package/src/core/geom/packing/miniball/Miniball.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Miniball.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/miniball/Miniball.js"],"names":[],"mappings":"AAwBA;;;;;GAKG;AACH;IA8CI;;;;;OAKG;IACH,8BA4DC;IA9GD;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;;;;;;;OAUG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,iBAAa;IAEb;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAYR;;OAEG;IACH,YAAe;IAEf;;;;OAIG;IACH,eAA2B;IAI3B;;;OAGG;IACH,KAFU,MAAM,CAEU;IAM1B;;;;OAIG;IACH,iBAA4D;IAE5D;;;OAGG;IACH,aAFU,MAAM,EAAE,GAAC,YAAY,CAEkD;IAEjF;;;OAGG;IACH,eAFU,MAAM,EAAE,GAAC,YAAY,CAEwD;IAEvF;;;OAGG;IACH,SAFU,MAAM,EAAE,GAAC,YAAY,CAEsD;IAErF;;;;OAIG;IACH,kBAAgC;IAIpC;;;;;;;OAOG;IACH,WAFY,OAAO,CAIlB;IAED;;;;;;OAMG;IACH,UAFY,MAAM,CAIjB;IAED;;;;;;OAMG;IACH,UAFY,MAAM,EAAE,CAInB;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;OAMG;IACH,QAJY,MAAM,CAMjB;IAED;;;;;;;;OAQG;IACH,iBAkCC;IAED;;OAEG;IACH,yBAGC;IAED;;OAEG;IACH,qBAcC;IAED;;;;;;;;;;;OAWG;IACH,gBA4CC;IAED;;;;;;;;OAQG;IACH,kBAFY,OAAO,CA4BlB;IAED;;;;;;;;OAQG;IACH,yBA8DC;IAGD;;;OAGG;IACH,YAFY,MAAM,CA0BjB;CACJ;wBAzcuB,cAAc"}
+{"version":3,"file":"Miniball.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/miniball/Miniball.js"],"names":[],"mappings":"AAyBA;;;;;GAKG;AACH;IA8CI;;;;;OAKG;IACH,8BA4DC;IA9GD;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;;;;;;;;OAUG;IACH,wBAAoB;IAEpB;;;;OAIG;IACH,iBAAa;IAEb;;;OAGG;IACH,SAFU,MAAM,CAEJ;IAYR;;OAEG;IACH,YAAe;IAEf;;;;OAIG;IACH,eAA2B;IAI3B;;;OAGG;IACH,KAFU,MAAM,CAEU;IAM1B;;;;OAIG;IACH,iBAA4D;IAE5D;;;OAGG;IACH,aAFU,MAAM,EAAE,GAAC,YAAY,CAEkD;IAEjF;;;OAGG;IACH,eAFU,MAAM,EAAE,GAAC,YAAY,CAEwD;IAEvF;;;OAGG;IACH,SAFU,MAAM,EAAE,GAAC,YAAY,CAEsD;IAErF;;;;OAIG;IACH,kBAAgC;IAIpC;;;;;;;OAOG;IACH,WAFY,OAAO,CAIlB;IAED;;;;;;OAMG;IACH,UAFY,MAAM,CAIjB;IAED;;;;;;OAMG;IACH,UAFY,MAAM,EAAE,CAInB;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;OAMG;IACH,QAJY,MAAM,CAMjB;IAED;;;;;;;;OAQG;IACH,iBAkCC;IAED;;OAEG;IACH,yBAGC;IAED;;OAEG;IACH,qBAcC;IAED;;;;;;;;;;;OAWG;IACH,gBA4CC;IAED;;;;;;;;OAQG;IACH,kBAFY,OAAO,CA4BlB;IAED;;;;;;;;OAQG;IACH,yBAsDC;IAGD;;;OAGG;IACH,YAFY,MAAM,CA0BjB;CACJ;wBAjcuB,cAAc"}

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

@@ -8,6 +8,7 @@
 
 import { assert } from "../../../assert.js";
 import { sqr } from "../../../math/sqr.js";
+import { vector_dot } from "../../vec/vector_dot.js";
 import { Subspan } from "./Subspan.js";
 
 /**
@@ -405,23 +406,15 @@ export class Miniball {
                 centerToPoint[i] = pointSet.coord(j, i) - center[i];
             }
 
-            let dirPointProd = 0;
-
-            for (i = 0; i < dim; ++i) {
-                dirPointProd += centerToAff[i] * centerToPoint[i];
-            }
+            const dirPointProd = vector_dot(centerToAff, centerToPoint, dim);
 
             if ((distToAffSquare - dirPointProd) < distance_error) {
                 continue;
             }
 
-            let bound = 0;
-
-            for (i = 0; i < dim; ++i) {
-                bound += centerToPoint[i] * centerToPoint[i];
-            }
+            const bound_sq = vector_dot(centerToPoint, centerToPoint, dim);
 
-            bound = (squaredRadius - bound) / 2 / (distToAffSquare - dirPointProd);
+            const bound = (squaredRadius - bound_sq) / 2 / (distToAffSquare - dirPointProd);
 
             if (bound > 0 && bound < scale) {
                 //if (com.dreizak.miniball.highdim.Logging.log)

package/src/core/geom/packing/miniball/Subspan.d.ts

@@ -26,36 +26,31 @@ export class Subspan {
      */
     members: Int32Array;
     /**
-     * DxD square matrix, where D is number of dimensions
-     * @type {number[][]}
+     * @type {SquareMatrix}
      */
-    Q: number[][];
+    Q: SquareMatrix;
     /**
-     * DxD square matrix, where D is number of dimensions
-     * @type {number[][]}
+     * @type {SquareMatrix}
      */
-    R: number[][];
+    R: SquareMatrix;
     /**
      * D sized vector
-     * @type {number[]}
+     * @type {Float64Array}
      */
-    u: number[];
+    u: Float64Array;
     /**
      * D sized vector
-     * @type {number[]}
+     * @type {Float64Array}
      */
-    w: number[];
+    w: Float64Array;
     r: number;
     /**
-     * Givens C coefficient
-     * @type {number}
-     */
-    c: number;
-    /**
-     * Givens S coefficient
-     * @type {number}
+     * Givens rotation coefficients scratch: cs[0] = c, cs[1] = s.
+     * Holding this as an instance field avoids per-call allocation of a
+     * fresh 2-element array — see givens_rotation_coefficients's contract.
+     * @type {Float64Array}
      */
-    s: number;
+    cs: Float64Array;
     dimension(): number;
     /**
      * The size of the instance's set <i>M</i>, a number between 0 and `dim+1`.
@@ -116,27 +111,6 @@ export class Subspan {
      * @private
      */
     private origin;
-    /**
-     * Determine the Givens coefficients <i>(c,s)</i> satisfying
-     *
-     * <pre>
-     * c * a + s * b = +/- (a^2 + b^2) c * b - s * a = 0
-     * </pre>
-     *
-     * We don't care about the signs here, for efficiency, so make sure not to rely on them anywhere.
-     *
-     * <i>Source:</i> "Matrix Computations" (2nd edition) by Gene H. B. Golub & Charles F. B. Van Loan
-     * (Johns Hopkins University Press, 1989), p. 216.
-     *
-     * Note that the code of this class sometimes does not call this method but only mentions it in a
-     * comment. The reason for this is performance; Java does not allow an efficient way of returning
-     * a pair of doubles, so we sometimes manually "inline" `givens()` for the sake of
-     * performance.
-     * @param {number} a
-     * @param {number} b
-     * @private
-     */
-    private givens;
     /**
      * Appends the new column <i>u</i> (which is a member field of this instance) to the right of <i>A
      * = QR</i>, updating <i>Q</i> and <i>R</i>. It assumes <i>r</i> to still be the old value, i.e.,
@@ -213,4 +187,5 @@ export class Subspan {
     remove(index: number): void;
 }
 import { BitSet } from "../../../binary/BitSet.js";
+import { SquareMatrix } from "../../../math/matrix/SquareMatrix.js";
 //# sourceMappingURL=Subspan.d.ts.map

package/src/core/geom/packing/miniball/Subspan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Subspan.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/miniball/Subspan.js"],"names":[],"mappings":"AAUA;IACI;;;;;OAKG;IACH,iBAJW,MAAM,kBAEN,MAAM,EAuFhB;IAhFG;;OAEG;IACH,YAAU;IAEV;;;OAGG;IACH,YAFU,MAAM,CAE4B;IAE5C;;;OAGG;IACH,KAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,SAFU,UAAU,CAEkB;IAmBtC;;;OAGG;IACH,GAFU,MAAM,EAAE,EAAE,CAEV;IAEV;;;OAGG;IACH,GAFU,MAAM,EAAE,EAAE,CAEV;IAEV;;;OAGG;IACH,GAFU,MAAM,EAAE,CAEK;IACvB;;;OAGG;IACH,GAFU,MAAM,EAAE,CAEK;IAEvB,UAAU;IAEV;;;OAGG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,GAFU,MAAM,CAEN;IAOd,oBAEC;IAED;;;;;;OAMG;IACH,YAEC;IAED;;;;;;;;OAQG;IACH,kBAFa,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,aAFa,MAAM,CAIlB;IAED;;;;;;;;;;OAUG;IACH,eAJW,MAAM,GAEL,MAAM,CAIjB;IAED;;;;;;;;;;;OAWG;IACH,YAEC;IAED;;;;;OAKG;IACH,eAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAaC;IAED;;;;;;;;OAQG;IACH,qBA2BC;IAED;;;;;;;;OAQG;IACH,WAFW,MAAM,QAsBhB;IAED;;;;;;;;;;;OAWG;IACH,wBAJW,MAAM,EAAE,KACR,MAAM,EAAE,GACP,MAAM,CAuCjB;IAED;;;;OAIG;IACH,uBAFY,MAAM,CA8CjB;IAED;;;;;;;;;;;;OAYG;IACH,0BAHW,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,EAAE,GAAC,YAAY,QAuC/B;IAED;;;;;OAKG;IACH,yBAkCC;IAED;;;;;;;OAOG;IACH,8BA6CC;IAED;;;OAGG;IACH,cAFW,MAAM,QAsChB;CACJ;uBA7jBsB,2BAA2B"}
+{"version":3,"file":"Subspan.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/miniball/Subspan.js"],"names":[],"mappings":"AAgBA;IACI;;;;;OAKG;IACH,iBAJW,MAAM,kBAEN,MAAM,EAuEhB;IAhEG;;OAEG;IACH,YAAU;IAEV;;;OAGG;IACH,YAFU,MAAM,CAE4B;IAE5C;;;OAGG;IACH,KAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,SAFU,UAAU,CAEkB;IAQtC;;OAEG;IACH,GAFU,YAAY,CAEgC;IAGtD;;OAEG;IACH,GAFU,YAAY,CAEgC;IAEtD;;;OAGG;IACH,GAFU,YAAY,CAEQ;IAC9B;;;OAGG;IACH,GAFU,YAAY,CAEQ;IAE9B,UAAU;IAEV;;;;;OAKG;IACH,IAFU,YAAY,CAEO;IAOjC,oBAEC;IAED;;;;;;OAMG;IACH,YAEC;IAED;;;;;;;;OAQG;IACH,kBAFa,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,aAFa,MAAM,CAIlB;IAED;;;;;;;;;;OAUG;IACH,eAJW,MAAM,GAEL,MAAM,CAIjB;IAED;;;;;;;;;;;OAWG;IACH,YAEC;IAED;;;;;OAKG;IACH,eAEC;IAED;;;;;;;;OAQG;IACH,qBAyBC;IAED;;;;;;;;OAQG;IACH,WAFW,MAAM,QAsBhB;IAED;;;;;;;;;;;OAWG;IACH,wBAJW,MAAM,EAAE,KACR,MAAM,EAAE,GACP,MAAM,CA4BjB;IAED;;;;OAIG;IACH,uBAFY,MAAM,CA8CjB;IAED;;;;;;;;;;;;OAYG;IACH,0BAHW,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,EAAE,GAAC,YAAY,QAuC/B;IAED;;;;;OAKG;IACH,yBAkCC;IAED;;;;;;;OAOG;IACH,8BA4CC;IAED;;;OAGG;IACH,cAFW,MAAM,QA4ChB;CACJ;uBAxgBsB,2BAA2B;6BAErB,sCAAsC"}