@woosh/meep-engine 2.135.0 → 2.138.0

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

@@ -7,6 +7,12 @@
 
 import { assert } from "../../../assert.js";
 import { BitSet } from "../../../binary/BitSet.js";
+import { BinaryDataType } from "../../../binary/type/BinaryDataType.js";
+import { SquareMatrix } from "../../../math/matrix/SquareMatrix.js";
+import { vector_dot_offset } from "../../vec/vector_dot_offset.js";
+import { vector_axpy_offset } from "../../vec/vector_axpy_offset.js";
+import { givens_rotation_coefficients } from "../../../math/linalg/givens/givens_rotation_coefficients.js";
+import { givens_apply_rows_offset } from "../../../math/linalg/givens/givens_apply_rows_offset.js";
 
 export class Subspan {
     /**
@@ -44,58 +50,42 @@ export class Subspan {
         this.members = new Int32Array(dim + 1);
 
 
-        const Q = new Array(dim);
-        const R = new Array(dim);
-
-        for (let i = 0; i < dim; i++) {
-            Q[i] = new Array(dim);
-            R[i] = new Array(dim);
-        }
-
-        // initialize Q vector
-        for (let i = 0; i < dim; i++) {
-            for (let j = 0; j < dim; j++) {
-                // set diagonal to 1
-                Q[j][i] = (i === j) ? 1.0 : 0.0;
-            }
-        }
-
+        // Q and R are dim x dim, column-major (per SquareMatrix). The k-th
+        // column lives contiguously at offsets [k*dim, (k+1)*dim). Inner
+        // loops index the flat .data buffer directly with offset arithmetic
+        // rather than going through subarray views — see vector_dot_offset
+        // and friends.
         /**
-         * DxD square matrix, where D is number of dimensions
-         * @type {number[][]}
+         * @type {SquareMatrix}
          */
-        this.Q = Q;
+        this.Q = new SquareMatrix(dim, BinaryDataType.Float64);
+        this.Q.eye();
 
         /**
-         * DxD square matrix, where D is number of dimensions
-         * @type {number[][]}
+         * @type {SquareMatrix}
          */
-        this.R = R;
+        this.R = new SquareMatrix(dim, BinaryDataType.Float64);
 
         /**
          * D sized vector
-         * @type {number[]}
+         * @type {Float64Array}
          */
-        this.u = new Array(dim);
+        this.u = new Float64Array(dim);
         /**
          * D sized vector
-         * @type {number[]}
+         * @type {Float64Array}
          */
-        this.w = new Array(dim);
+        this.w = new Float64Array(dim);
 
         this.r = 0;
 
         /**
-         * Givens C 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}
          */
-        this.c = 0;
-
-        /**
-         * Givens S coefficient
-         * @type {number}
-         */
-        this.s = 0;
+        this.cs = new Float64Array(2);
 
 
         this.membership.set(k, true);
@@ -183,41 +173,6 @@ export class Subspan {
         return this.members[this.r];
     }
 
-    /**
-     * 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
-     */
-    givens(a, b) {
-        if (b === 0.0) {
-            this.c = 1.0;
-            this.s = 0.0;
-        } else if (Math.abs(b) > Math.abs(a)) {
-            const t = a / b;
-            this.s = 1 / Math.sqrt(1 + t * t);
-            this.c = this.s * t;
-        } else {
-            const t = b / a;
-            this.c = 1 / Math.sqrt(1 + t * t);
-            this.s = this.c * t;
-        }
-    }
-
     /**
      * 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.,
@@ -228,30 +183,28 @@ export class Subspan {
      * @private
      */
     appendColumn() {
-        const R = this.R;
-        const Q = this.Q;
-
         const dim = this.dim;
 
+        const u = this.u;
+        const Q = this.Q.data;
+        const R = this.R.data;
+        const cs = this.cs;
+
+        const rOff = this.r * dim;
+
         for (let i = 0; i < dim; ++i) {
-            R[this.r][i] = 0;
-            for (let k = 0; k < dim; ++k) {
-                R[this.r][i] += Q[i][k] * this.u[k];
-            }
+            R[rOff + i] = vector_dot_offset(Q, i * dim, u, 0, dim);
         }
 
         for (let j = dim - 1; j > this.r; --j) {
 
-            this.givens(R[this.r][j - 1], R[this.r][j]);
-            R[this.r][j - 1] = this.c * R[this.r][j - 1] + this.s * R[this.r][j];
+            givens_rotation_coefficients(R[rOff + j - 1], R[rOff + j], cs);
+            const c = cs[0];
+            const s = cs[1];
 
-            for (let i = 0; i < dim; ++i) {
-                let a = Q[j - 1][i];
-                let b = Q[j][i];
-                Q[j - 1][i] = this.c * a + this.s * b;
-                Q[j][i] = this.c * b - this.s * a;
-            }
+            R[rOff + j - 1] = c * R[rOff + j - 1] + s * R[rOff + j];
 
+            givens_apply_rows_offset(Q, (j - 1) * dim, j * dim, c, s, dim);
         }
 
     }
@@ -310,32 +263,21 @@ export class Subspan {
             w[i] = S.coord(o, i) - p[i];
         }
 
-        const Q = this.Q;
+        const Q = this.Q.data;
 
         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] * QJ[i];
-            }
-
-            for (let i = 0; i < dim; ++i) {
-                w[i] -= scale * QJ[i];
-            }
+            const qOff = j * dim;
 
-        }
+            const scale = vector_dot_offset(w, 0, Q, qOff, dim);
 
-        let sl = 0;
+            vector_axpy_offset(w, 0, -scale, Q, qOff, dim);
 
-        for (let i = 0; i < dim; ++i) {
-            sl += w[i] * w[i];
         }
 
-        return sl;
+        return vector_dot_offset(w, 0, w, 0, dim);
     }
 
     /**
@@ -413,32 +355,32 @@ export class Subspan {
         }
 
         const w = this.w;
-        const Q = this.Q;
+        const Q = this.Q.data;
 
         for (let i = 0; i < dim; ++i) {
-            w[i] = 0;
-            for (let k = 0; k < dim; ++k) {
-                w[i] += Q[i][k] * u[k];
-            }
+            w[i] = vector_dot_offset(Q, i * dim, u, 0, dim);
         }
 
         let origin_lambda = 1;
 
-        const R = this.R;
+        const R = this.R.data;
+        const r = this.r;
+
+        for (let j = r - 1; j >= 0; --j) {
 
-        for (let j = this.r - 1; j >= 0; --j) {
+            const jjOff = j * dim;
 
-            for (let k = j + 1; k < this.r; ++k) {
-                w[j] -= lambdas[k] * R[k][j];
+            for (let k = j + 1; k < r; ++k) {
+                w[j] -= lambdas[k] * R[k * dim + j];
             }
 
-            const lj = w[j] / R[j][j];
+            const lj = w[j] / R[jjOff + j];
 
             lambdas[j] = lj;
             origin_lambda -= lj;
         }
 
-        lambdas[this.r] = origin_lambda;
+        lambdas[r] = origin_lambda;
     }
 
     /**
@@ -451,34 +393,34 @@ export class Subspan {
 
         let cursor = pos;
 
-        const R = this.R;
-        const Q = this.Q;
+        const R = this.R.data;
+        const Q = this.Q.data;
 
         const dim = this.dim;
+        const cs = this.cs;
+        const r = this.r;
 
-        for (; cursor < this.r; ++cursor) {
-
-            this.givens(R[cursor][cursor], R[cursor][cursor + 1]);
-            R[cursor][cursor] = this.c * R[cursor][cursor] + this.s * R[cursor][cursor + 1];
+        for (; cursor < r; ++cursor) {
 
-            for (let j = cursor + 1; j < this.r; ++j) {
+            const cOff = cursor * dim;
 
-                const a = R[j][cursor];
-                const b = R[j][cursor + 1];
+            givens_rotation_coefficients(R[cOff + cursor], R[cOff + cursor + 1], cs);
+            const c = cs[0];
+            const s = cs[1];
 
-                R[j][cursor] = this.c * a + this.s * b;
-                R[j][cursor + 1] = this.c * b - this.s * a;
-            }
+            R[cOff + cursor] = c * R[cOff + cursor] + s * R[cOff + cursor + 1];
 
-            for (let i = 0; i < dim; ++i) {
+            for (let j = cursor + 1; j < r; ++j) {
 
-                const a = Q[cursor][i];
-                const b = Q[cursor + 1][i];
+                const jOff = j * dim;
+                const a = R[jOff + cursor];
+                const b = R[jOff + cursor + 1];
 
-                Q[cursor][i] = this.c * a + this.s * b;
-                Q[cursor + 1][i] = this.c * b - this.s * a;
+                R[jOff + cursor] = c * a + s * b;
+                R[jOff + cursor + 1] = c * b - s * a;
             }
 
+            givens_apply_rows_offset(Q, cOff, cOff + dim, c, s, dim);
         }
 
     }
@@ -497,42 +439,41 @@ export class Subspan {
         const w = this.w;
         const u = this.u;
 
-        const Q = this.Q;
-        const R = this.R;
+        const Q = this.Q.data;
+        const R = this.R.data;
+        const cs = this.cs;
+        const r = this.r;
 
         for (let i = 0; i < dim; ++i) {
-            w[i] = 0;
-
-            for (let k = 0; k < dim; ++k) {
-                w[i] += Q[i][k] * u[k];
-            }
+            w[i] = vector_dot_offset(Q, i * dim, u, 0, dim);
         }
 
         for (let k = dim - 1; k > 0; --k) {
 
-            this.givens(w[k - 1], w[k]);
-            w[k - 1] = this.c * w[k - 1] + this.s * w[k];
-            R[k - 1][k] = -this.s * R[k - 1][k - 1];
-            R[k - 1][k - 1] *= this.c;
+            givens_rotation_coefficients(w[k - 1], w[k], cs);
+            const c = cs[0];
+            const s = cs[1];
 
-            for (let j = k; j < this.r; ++j) {
-                const a = R[j][k - 1];
-                const b = R[j][k];
-                R[j][k - 1] = this.c * a + this.s * b;
-                R[j][k] = this.c * b - this.s * a;
-            }
+            w[k - 1] = c * w[k - 1] + s * w[k];
 
-            for (let i = 0; i < dim; ++i) {
-                const a = Q[k - 1][i];
-                const b = Q[k][i];
-                Q[k - 1][i] = this.c * a + this.s * b;
-                Q[k][i] = this.c * b - this.s * a;
+            const prevOff = (k - 1) * dim;
+            R[prevOff + k] = -s * R[prevOff + k - 1];
+            R[prevOff + k - 1] *= c;
+
+            for (let j = k; j < r; ++j) {
+                const jOff = j * dim;
+                const a = R[jOff + k - 1];
+                const b = R[jOff + k];
+                R[jOff + k - 1] = c * a + s * b;
+                R[jOff + k] = c * b - s * a;
             }
 
+            givens_apply_rows_offset(Q, prevOff, prevOff + dim, c, s, dim);
         }
 
-        for (let j = 0; j < this.r; ++j) {
-            R[j][0] += w[0];
+        const w0 = w[0];
+        for (let j = 0; j < r; ++j) {
+            R[j * dim] += w0;
         }
 
         this.hessenberg_clear(0);
@@ -562,19 +503,25 @@ export class Subspan {
 
             this.special_rank_1_update();
         } else {
-            const R = this.R;
-
-            const dummy = R[index];
+            const R = this.R.data;
+            const dim = this.dim;
 
             const members = this.members;
 
+            // Shift the column block [index+1 .. r-1] down by one position.
+            // Each column is `dim` contiguous floats in column-major storage,
+            // so the whole shift is a single copyWithin call.
+            const dstOff = index * dim;
+            const srcOff = (index + 1) * dim;
+            const endOff = this.r * dim;
+            R.copyWithin(dstOff, srcOff, endOff);
+
             for (let j = index + 1; j < this.r; ++j) {
-                R[j - 1] = R[j];
                 members[j - 1] = members[j];
             }
 
             members[this.r - 1] = members[this.r];
-            R[--this.r] = dummy;
+            --this.r;
 
             this.hessenberg_clear(index);
         }

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

@@ -1 +1 @@
-{"version":3,"file":"miniball_compute_quality.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/miniball/miniball_compute_quality.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,8DAFY,OAAO,CAuDlB;wBA9DqB,cAAc"}
+{"version":3,"file":"miniball_compute_quality.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/miniball/miniball_compute_quality.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH,8DAFY,OAAO,CAmDlB;wBA3DqB,cAAc"}

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

@@ -1,5 +1,5 @@
-import {sqr} from "../../../math/sqr.js";
 import {Quality} from "./Quality.js";
+import {vector_dot} from "../../vec/vector_dot.js";
 
 /**
  * Verifies that the computed ball is indeed the miniball.
@@ -36,11 +36,7 @@ export function miniball_compute_quality(miniball) {
             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]);
-        }
+        const sqDist = vector_dot(miniball.centerToPoint, miniball.centerToPoint, dimension_count);
 
         ball_error = Math.sqrt(sqDist) - miniball.radius();
 

package/src/core/geom/vec/vector_axpy.d.ts

@@ -0,0 +1,12 @@
+/**
+ * N-dimensional AXPY (BLAS-style): in-place adds `alpha * x` into `y`.
+ *
+ *     y[i] += alpha * x[i]   for i in [0, n)
+ *
+ * @param {number[]|Float32Array|Float64Array} y receives the in-place update
+ * @param {number} alpha
+ * @param {number[]|Float32Array|Float64Array} x
+ * @param {number} n number of elements
+ */
+export function vector_axpy(y: number[] | Float32Array | Float64Array, alpha: number, x: number[] | Float32Array | Float64Array, n: number): void;
+//# sourceMappingURL=vector_axpy.d.ts.map

package/src/core/geom/vec/vector_axpy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector_axpy.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec/vector_axpy.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,+BALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,QAMhB"}

package/src/core/geom/vec/vector_axpy.js

@@ -0,0 +1,15 @@
+/**
+ * N-dimensional AXPY (BLAS-style): in-place adds `alpha * x` into `y`.
+ *
+ *     y[i] += alpha * x[i]   for i in [0, n)
+ *
+ * @param {number[]|Float32Array|Float64Array} y receives the in-place update
+ * @param {number} alpha
+ * @param {number[]|Float32Array|Float64Array} x
+ * @param {number} n number of elements
+ */
+export function vector_axpy(y, alpha, x, n) {
+    for (let i = 0; i < n; ++i) {
+        y[i] += alpha * x[i];
+    }
+}

package/src/core/geom/vec/vector_axpy_offset.d.ts

@@ -0,0 +1,17 @@
+/**
+ * N-dimensional AXPY over offset slices of two flat buffers.
+ *
+ *     y[yOff + i] += alpha * x[xOff + i]   for i in [0, n)
+ *
+ * Use when the operands are columns/rows of a flat matrix; passing offsets
+ * avoids per-call `.subarray(...)` header allocation.
+ *
+ * @param {number[]|Float32Array|Float64Array} y receives in-place update
+ * @param {number} yOff starting index into y
+ * @param {number} alpha
+ * @param {number[]|Float32Array|Float64Array} x
+ * @param {number} xOff starting index into x
+ * @param {number} n number of elements
+ */
+export function vector_axpy_offset(y: number[] | Float32Array | Float64Array, yOff: number, alpha: number, x: number[] | Float32Array | Float64Array, xOff: number, n: number): void;
+//# sourceMappingURL=vector_axpy_offset.d.ts.map

package/src/core/geom/vec/vector_axpy_offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector_axpy_offset.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec/vector_axpy_offset.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,sCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,SACN,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,KACN,MAAM,QAMhB"}

package/src/core/geom/vec/vector_axpy_offset.js

@@ -0,0 +1,20 @@
+/**
+ * N-dimensional AXPY over offset slices of two flat buffers.
+ *
+ *     y[yOff + i] += alpha * x[xOff + i]   for i in [0, n)
+ *
+ * Use when the operands are columns/rows of a flat matrix; passing offsets
+ * avoids per-call `.subarray(...)` header allocation.
+ *
+ * @param {number[]|Float32Array|Float64Array} y receives in-place update
+ * @param {number} yOff starting index into y
+ * @param {number} alpha
+ * @param {number[]|Float32Array|Float64Array} x
+ * @param {number} xOff starting index into x
+ * @param {number} n number of elements
+ */
+export function vector_axpy_offset(y, yOff, alpha, x, xOff, n) {
+    for (let i = 0; i < n; ++i) {
+        y[yOff + i] += alpha * x[xOff + i];
+    }
+}

package/src/core/geom/vec/vector_dot_offset.d.ts

@@ -0,0 +1,18 @@
+/**
+ * N-dimensional dot product over offset slices of two flat buffers.
+ *
+ *     sum_{i=0..n-1} a[aOff + i] * b[bOff + i]
+ *
+ * Use when the operands are columns/rows of a flat matrix laid out in a
+ * single typed array — passing the buffer plus an offset avoids the header
+ * allocation that `.subarray(...)` would incur on every call.
+ *
+ * @param {number[]|Float32Array|Float64Array} a
+ * @param {number} aOff starting index into a
+ * @param {number[]|Float32Array|Float64Array} b
+ * @param {number} bOff starting index into b
+ * @param {number} n number of elements
+ * @return {number}
+ */
+export function vector_dot_offset(a: number[] | Float32Array | Float64Array, aOff: number, b: number[] | Float32Array | Float64Array, bOff: number, n: number): number;
+//# sourceMappingURL=vector_dot_offset.d.ts.map

package/src/core/geom/vec/vector_dot_offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector_dot_offset.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec/vector_dot_offset.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,qCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,KACN,MAAM,GACL,MAAM,CAUjB"}

package/src/core/geom/vec/vector_dot_offset.js

@@ -0,0 +1,25 @@
+/**
+ * N-dimensional dot product over offset slices of two flat buffers.
+ *
+ *     sum_{i=0..n-1} a[aOff + i] * b[bOff + i]
+ *
+ * Use when the operands are columns/rows of a flat matrix laid out in a
+ * single typed array — passing the buffer plus an offset avoids the header
+ * allocation that `.subarray(...)` would incur on every call.
+ *
+ * @param {number[]|Float32Array|Float64Array} a
+ * @param {number} aOff starting index into a
+ * @param {number[]|Float32Array|Float64Array} b
+ * @param {number} bOff starting index into b
+ * @param {number} n number of elements
+ * @return {number}
+ */
+export function vector_dot_offset(a, aOff, b, bOff, n) {
+    let result = 0;
+
+    for (let i = 0; i < n; i++) {
+        result += a[aOff + i] * b[bOff + i];
+    }
+
+    return result;
+}

package/src/core/math/complex/complex_horner_eval.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Evaluate a univariate polynomial with real coefficients at a complex point,
+ * via Horner's method.
+ *
+ *   p(z) = coeffs[0] + coeffs[1] · z + ... + coeffs[degree] · z^degree
+ *
+ * The result is written into `result` as `[Re(p(z)), Im(p(z))]`.
+ *
+ * @param {number[]|Float32Array|Float64Array} result 2-element output buffer
+ * @param {number[]|Float32Array|Float64Array} coeffs ascending-power, length ≥ degree + 1
+ * @param {number} degree polynomial degree, ≥ 0
+ * @param {number} zr real part of z
+ * @param {number} zi imaginary part of z
+ */
+export function complex_horner_eval(result: number[] | Float32Array | Float64Array, coeffs: number[] | Float32Array | Float64Array, degree: number, zr: number, zi: number): void;
+//# sourceMappingURL=complex_horner_eval.d.ts.map

package/src/core/math/complex/complex_horner_eval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complex_horner_eval.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_horner_eval.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,4CANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,MACN,MAAM,MACN,MAAM,QAkBhB"}

package/src/core/math/complex/complex_horner_eval.js

@@ -0,0 +1,31 @@
+/**
+ * Evaluate a univariate polynomial with real coefficients at a complex point,
+ * via Horner's method.
+ *
+ *   p(z) = coeffs[0] + coeffs[1] · z + ... + coeffs[degree] · z^degree
+ *
+ * The result is written into `result` as `[Re(p(z)), Im(p(z))]`.
+ *
+ * @param {number[]|Float32Array|Float64Array} result 2-element output buffer
+ * @param {number[]|Float32Array|Float64Array} coeffs ascending-power, length ≥ degree + 1
+ * @param {number} degree polynomial degree, ≥ 0
+ * @param {number} zr real part of z
+ * @param {number} zi imaginary part of z
+ */
+export function complex_horner_eval(result, coeffs, degree, zr, zi) {
+    let pr = coeffs[degree];
+    let pi = 0;
+
+    for (let i = degree - 1; i >= 0; i--) {
+
+        const new_pr = pr * zr - pi * zi + coeffs[i];
+        const new_pi = pr * zi + pi * zr;
+
+        pr = new_pr;
+        pi = new_pi;
+
+    }
+
+    result[0] = pr;
+    result[1] = pi;
+}

package/src/core/math/fabsf.d.ts

@@ -1,7 +1,6 @@
 /**
  * Float ABS, from standard C lib
- * @param {Number} val
- * @returns {number}
+ * @deprecated use Math.abs directly instead
  */
-export function fabsf(val: number): number;
+export const fabsf: (x: number) => number;
 //# sourceMappingURL=fabsf.d.ts.map

package/src/core/math/fabsf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fabsf.d.ts","sourceRoot":"","sources":["../../../../src/core/math/fabsf.js"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,oCAFa,MAAM,CAIlB"}
+{"version":3,"file":"fabsf.d.ts","sourceRoot":"","sources":["../../../../src/core/math/fabsf.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,0CAA6B"}

package/src/core/math/fabsf.js

@@ -1,8 +1,6 @@
 /**
  * Float ABS, from standard C lib
- * @param {Number} val
- * @returns {number}
+ * @deprecated use Math.abs directly instead
  */
-export function fabsf(val) {
-    return val >= 0 ? val : -val;
-}
+export const fabsf = Math.abs
+

package/src/core/math/linalg/cubic_residual_times_derivative_accumulate.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Accumulates the quintic `(p(t) - offset) * p'(t)` into `out_quintic`,
+ * where `p` is the cubic stored at `coeffs[base..base+3]`:
+ *
+ *   p(t)   = coeffs[base] + coeffs[base+1]·t + coeffs[base+2]·t² + coeffs[base+3]·t³
+ *   p'(t)  = coeffs[base+1] + 2·coeffs[base+2]·t + 3·coeffs[base+3]·t²
+ *
+ * Up to a constant factor of 2, the accumulated polynomial is the derivative
+ * of `(p(t) - offset)²`. Summed across "dimensions" (multiple calls with
+ * different `(base, offset)` pairs), the resulting quintic's real roots in
+ * [0, 1] are the candidate parameter values where the squared distance from
+ * the cubic curve `t → (p_0(t), p_1(t), ...)` to a fixed point
+ * `(offset_0, offset_1, ...)` is stationary. The factor of 2 is dropped
+ * because it does not affect root locations.
+ *
+ * `out_quintic` must have length ≥ 6. Entries are read-modify-written; the
+ * caller is responsible for zeroing the buffer before the first call in a
+ * given accumulation.
+ *
+ * @param {number[]|Float64Array|Float32Array} out_quintic length ≥ 6; receives the running sum
+ * @param {number[]|Float64Array|Float32Array} coeffs cubic coefficients laid out at base..base+3
+ * @param {number} base index of the constant term of the cubic in `coeffs`
+ * @param {number} offset value to subtract from the constant term before forming (p - offset)·p'
+ */
+export function cubic_residual_times_derivative_accumulate(out_quintic: number[] | Float64Array | Float32Array, coeffs: number[] | Float64Array | Float32Array, base: number, offset: number): void;
+//# sourceMappingURL=cubic_residual_times_derivative_accumulate.d.ts.map