@woosh/meep-engine 2.135.0 → 2.138.0

package/src/core/math/linalg/polynomial_complex_roots_aberth_ehrlich.js

@@ -1,4 +1,6 @@
 import { assert } from "../../assert.js";
+import { complex_horner_eval } from "../complex/complex_horner_eval.js";
+import { polynomial_root_bound_cauchy } from "./polynomial_root_bound_cauchy.js";
 
 /*
  Find all roots of a univariate polynomial in the complex plane via
@@ -21,43 +23,10 @@ import { assert } from "../../assert.js";
 const MAX_SUPPORTED_DEGREE = 64;
 
 const ABERTH_MAX_ITERATIONS = 80;
-const ABERTH_CONVERGENCE_TOLERANCE = 1e-14;
+const ABERTH_CONVERGENCE_TOLERANCE_SQR = 1e-28;
 
 const _DERIV = new Float64Array(MAX_SUPPORTED_DEGREE);
-const _P_EVAL = new Float64Array(2);
-const _DP_EVAL = new Float64Array(2);
-
-/**
- * Horner evaluation of polynomial p(z) at a complex z = (zr, zi).
- * Writes [p(z).re, p(z).im] into `out`.
- */
-function poly_eval_complex(coeffs, degree, zr, zi, out) {
-    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;
-    }
-
-    out[0] = pr;
-    out[1] = pi;
-}
-
-/**
- * Cauchy bound: every root z of `coeffs` satisfies |z| ≤ this value.
- */
-function cauchy_root_magnitude_bound(coeffs, degree) {
-    const lead = Math.abs(coeffs[degree]);
-    let m = 0;
-    for (let i = 0; i < degree; i++) {
-        const a = Math.abs(coeffs[i]);
-        if (a > m) m = a;
-    }
-    return 1 + m / lead;
-}
+const scratch_v2 = new Float64Array(2);
 
 /**
  * Find all complex roots of a univariate polynomial via Aberth–Ehrlich.
@@ -75,10 +44,16 @@ function cauchy_root_magnitude_bound(coeffs, degree) {
  * @param {Float64Array|number[]} roots_re real parts, length ≥ offset + degree
  * @param {Float64Array|number[]} roots_im imaginary parts, length ≥ offset + degree
  * @param {number} offset
+ * @param {number} [max_iterations=80] outer iteration cap. Lower values
+ *   trade worst-case convergence accuracy for speed; the per-iteration
+ *   convergence check still fires early in the common case. A low cap
+ *   (~24-32) is appropriate for well-conditioned low-degree polynomials
+ *   where Aberth typically converges in 15-25 iterations.
  */
 export function polynomial_complex_roots_aberth_ehrlich(
     coeffs, degree,
-    roots_re, roots_im, offset
+    roots_re, roots_im, offset,
+    max_iterations = ABERTH_MAX_ITERATIONS
 ) {
     assert.greaterThanOrEqual(degree, 1, 'degree');
     assert.greaterThanOrEqual(MAX_SUPPORTED_DEGREE, degree, 'degree exceeds MAX_SUPPORTED_DEGREE');
@@ -89,36 +64,42 @@ export function polynomial_complex_roots_aberth_ehrlich(
         _DERIV[i] = (i + 1) * coeffs[i + 1];
     }
 
-    const radius = cauchy_root_magnitude_bound(coeffs, degree);
+    const radius = polynomial_root_bound_cauchy(coeffs, degree);
 
     // Initial points around a circle, with a small phase offset to avoid
     // landing exactly on a real root at iteration zero.
     const phase_offset = 0.5;
     const two_pi_over_n = (2 * Math.PI) / degree;
+
     for (let k = 0; k < degree; k++) {
         const angle = k * two_pi_over_n + phase_offset;
         roots_re[offset + k] = radius * Math.cos(angle);
         roots_im[offset + k] = radius * Math.sin(angle);
     }
 
-    for (let iter = 0; iter < ABERTH_MAX_ITERATIONS; iter++) {
+    for (let iter = 0; iter < max_iterations; iter++) {
         let max_correction_sq = 0;
 
         for (let k = 0; k < degree; k++) {
             const zr = roots_re[offset + k];
             const zi = roots_im[offset + k];
 
-            poly_eval_complex(coeffs, degree, zr, zi, _P_EVAL);
-            const pr = _P_EVAL[0];
-            const pi = _P_EVAL[1];
+            complex_horner_eval(scratch_v2, coeffs, degree, zr, zi);
+            const pr = scratch_v2[0];
+            const pi = scratch_v2[1];
 
-            poly_eval_complex(_DERIV, degree - 1, zr, zi, _DP_EVAL);
-            const dpr = _DP_EVAL[0];
-            const dpi = _DP_EVAL[1];
+            complex_horner_eval(scratch_v2, _DERIV, degree - 1, zr, zi);
+            const dpr = scratch_v2[0];
+            const dpi = scratch_v2[1];
 
             // w = p / p'
             const dp_norm_sq = dpr * dpr + dpi * dpi;
-            if (dp_norm_sq === 0) continue;
+
+            if (dp_norm_sq === 0) {
+                // division by 0 guard
+                continue;
+            }
+
             const inv_dp_sq = 1 / dp_norm_sq;
             const wr = (pr * dpr + pi * dpi) * inv_dp_sq;
             const wi = (pi * dpr - pr * dpi) * inv_dp_sq;
@@ -126,11 +107,18 @@ export function polynomial_complex_roots_aberth_ehrlich(
             // S = Σ_{j≠k} 1/(z_k − z_j) in complex
             let sr = 0, si = 0;
             for (let j = 0; j < degree; j++) {
-                if (j === k) continue;
+
+                if (j === k) {
+                    continue;
+                }
+
                 const dr = zr - roots_re[offset + j];
                 const di = zi - roots_im[offset + j];
                 const denom_sq = dr * dr + di * di;
-                if (denom_sq === 0) continue;
+
+                if (denom_sq === 0) {
+                    continue;
+                }
                 const inv_d_sq = 1 / denom_sq;
                 sr += dr * inv_d_sq;
                 si += -di * inv_d_sq;
@@ -139,10 +127,17 @@ export function polynomial_complex_roots_aberth_ehrlich(
             // correction = w / (1 − w·S)
             const ws_r = wr * sr - wi * si;
             const ws_i = wr * si + wi * sr;
+
             const denom_r = 1 - ws_r;
             const denom_i = -ws_i;
+
             const denom_sq2 = denom_r * denom_r + denom_i * denom_i;
-            if (denom_sq2 === 0) continue;
+
+            if (denom_sq2 === 0){
+                // division by 0 guard
+                continue;
+            }
+
             const inv_denom_sq2 = 1 / denom_sq2;
             const corr_r = (wr * denom_r + wi * denom_i) * inv_denom_sq2;
             const corr_i = (wi * denom_r - wr * denom_i) * inv_denom_sq2;
@@ -151,10 +146,13 @@ export function polynomial_complex_roots_aberth_ehrlich(
             roots_im[offset + k] = zi - corr_i;
 
             const corr_sq = corr_r * corr_r + corr_i * corr_i;
-            if (corr_sq > max_correction_sq) max_correction_sq = corr_sq;
+
+            if (corr_sq > max_correction_sq){
+                max_correction_sq = corr_sq;
+            }
         }
 
-        if (max_correction_sq < ABERTH_CONVERGENCE_TOLERANCE * ABERTH_CONVERGENCE_TOLERANCE) {
+        if (max_correction_sq < ABERTH_CONVERGENCE_TOLERANCE_SQR) {
             break;
         }
     }

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

@@ -0,0 +1,15 @@
+/**
+ * Evaluates p'(x), the first derivative of the cubic stored at
+ * coeffs[base..base+3]:
+ *
+ *   p'(x) = coeffs[base+1]
+ *         + 2 * coeffs[base+2] * x
+ *         + 3 * coeffs[base+3] * x^2
+ *
+ * @param {number[]|Float32Array|Float64Array} coeffs
+ * @param {number} base index of the constant term (coefficient of x^0)
+ * @param {number} x
+ * @returns {number}
+ */
+export function polynomial_cubic_derivative_eval(coeffs: number[] | Float32Array | Float64Array, base: number, x: number): number;
+//# sourceMappingURL=polynomial_cubic_derivative_eval.d.ts.map

package/src/core/math/linalg/polynomial_cubic_derivative_eval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomial_cubic_derivative_eval.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_cubic_derivative_eval.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,yDALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB"}

package/src/core/math/linalg/polynomial_cubic_derivative_eval.js

@@ -0,0 +1,16 @@
+/**
+ * Evaluates p'(x), the first derivative of the cubic stored at
+ * coeffs[base..base+3]:
+ *
+ *   p'(x) = coeffs[base+1]
+ *         + 2 * coeffs[base+2] * x
+ *         + 3 * coeffs[base+3] * x^2
+ *
+ * @param {number[]|Float32Array|Float64Array} coeffs
+ * @param {number} base index of the constant term (coefficient of x^0)
+ * @param {number} x
+ * @returns {number}
+ */
+export function polynomial_cubic_derivative_eval(coeffs, base, x) {
+    return coeffs[base + 1] + x * (2 * coeffs[base + 2] + x * 3 * coeffs[base + 3]);
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Horner evaluation of a cubic polynomial stored at coeffs[base..base+3]:
+ *
+ *   p(x) = coeffs[base]
+ *        + coeffs[base+1] * x
+ *        + coeffs[base+2] * x^2
+ *        + coeffs[base+3] * x^3
+ *
+ * The `base` offset lets callers pack many cubics into one flat buffer
+ * (e.g. one cubic per dimension at base = 4*d).
+ *
+ * @param {number[]|Float32Array|Float64Array} coeffs
+ * @param {number} base index of the constant term (coefficient of x^0)
+ * @param {number} x
+ * @returns {number}
+ */
+export function polynomial_cubic_horner_eval(coeffs: number[] | Float32Array | Float64Array, base: number, x: number): number;
+//# sourceMappingURL=polynomial_cubic_horner_eval.d.ts.map

package/src/core/math/linalg/polynomial_cubic_horner_eval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomial_cubic_horner_eval.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_cubic_horner_eval.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,qDALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB"}

package/src/core/math/linalg/polynomial_cubic_horner_eval.js

@@ -0,0 +1,19 @@
+/**
+ * Horner evaluation of a cubic polynomial stored at coeffs[base..base+3]:
+ *
+ *   p(x) = coeffs[base]
+ *        + coeffs[base+1] * x
+ *        + coeffs[base+2] * x^2
+ *        + coeffs[base+3] * x^3
+ *
+ * The `base` offset lets callers pack many cubics into one flat buffer
+ * (e.g. one cubic per dimension at base = 4*d).
+ *
+ * @param {number[]|Float32Array|Float64Array} coeffs
+ * @param {number} base index of the constant term (coefficient of x^0)
+ * @param {number} x
+ * @returns {number}
+ */
+export function polynomial_cubic_horner_eval(coeffs, base, x) {
+    return coeffs[base] + x * (coeffs[base + 1] + x * (coeffs[base + 2] + x * coeffs[base + 3]));
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Evaluates p''(x), the second derivative of the cubic stored at
+ * coeffs[base..base+3]:
+ *
+ *   p''(x) = 2 * coeffs[base+2] + 6 * coeffs[base+3] * x
+ *
+ * @param {number[]|Float32Array|Float64Array} coeffs
+ * @param {number} base index of the constant term (coefficient of x^0)
+ * @param {number} x
+ * @returns {number}
+ */
+export function polynomial_cubic_second_derivative_eval(coeffs: number[] | Float32Array | Float64Array, base: number, x: number): number;
+//# sourceMappingURL=polynomial_cubic_second_derivative_eval.d.ts.map

package/src/core/math/linalg/polynomial_cubic_second_derivative_eval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomial_cubic_second_derivative_eval.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_cubic_second_derivative_eval.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,gEALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB"}

package/src/core/math/linalg/polynomial_cubic_second_derivative_eval.js

@@ -0,0 +1,14 @@
+/**
+ * Evaluates p''(x), the second derivative of the cubic stored at
+ * coeffs[base..base+3]:
+ *
+ *   p''(x) = 2 * coeffs[base+2] + 6 * coeffs[base+3] * x
+ *
+ * @param {number[]|Float32Array|Float64Array} coeffs
+ * @param {number} base index of the constant term (coefficient of x^0)
+ * @param {number} x
+ * @returns {number}
+ */
+export function polynomial_cubic_second_derivative_eval(coeffs, base, x) {
+    return 2 * coeffs[base + 2] + 6 * coeffs[base + 3] * x;
+}

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

@@ -0,0 +1,21 @@
+/**
+ * Multiplies two polynomials given in coefficient-array form.
+ *
+ *   out(x) = a(x) * b(x)
+ *
+ * Coefficient layout: index i is the coefficient of x^i (ascending). The
+ * result has length `a_len + b_len - 1`. The first `out_len` entries of
+ * `out` are written; entries beyond that are not touched.
+ *
+ * `out` must not alias `a` or `b` — the routine writes into `out` while it
+ * still reads from the inputs.
+ *
+ * @param {number[]|Float64Array|Float32Array} out destination, length >= a_len + b_len - 1
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number} a_len number of coefficients in a
+ * @param {number[]|Float64Array|Float32Array} b
+ * @param {number} b_len number of coefficients in b
+ * @returns {number} number of coefficients written into `out` (a_len + b_len - 1)
+ */
+export function polynomial_multiply(out: number[] | Float64Array | Float32Array, a: number[] | Float64Array | Float32Array, a_len: number, b: number[] | Float64Array | Float32Array, b_len: number): number;
+//# sourceMappingURL=polynomial_multiply.d.ts.map

package/src/core/math/linalg/polynomial_multiply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomial_multiply.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_multiply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,GACJ,MAAM,CAuBlB"}

package/src/core/math/linalg/polynomial_multiply.js

@@ -0,0 +1,41 @@
+/**
+ * Multiplies two polynomials given in coefficient-array form.
+ *
+ *   out(x) = a(x) * b(x)
+ *
+ * Coefficient layout: index i is the coefficient of x^i (ascending). The
+ * result has length `a_len + b_len - 1`. The first `out_len` entries of
+ * `out` are written; entries beyond that are not touched.
+ *
+ * `out` must not alias `a` or `b` — the routine writes into `out` while it
+ * still reads from the inputs.
+ *
+ * @param {number[]|Float64Array|Float32Array} out destination, length >= a_len + b_len - 1
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number} a_len number of coefficients in a
+ * @param {number[]|Float64Array|Float32Array} b
+ * @param {number} b_len number of coefficients in b
+ * @returns {number} number of coefficients written into `out` (a_len + b_len - 1)
+ */
+export function polynomial_multiply(out, a, a_len, b, b_len) {
+    const out_len = a_len + b_len - 1;
+
+    for (let i = 0; i < out_len; i++) {
+        out[i] = 0;
+    }
+
+    for (let i = 0; i < a_len; i++) {
+        const ai = a[i];
+
+        if (ai === 0) {
+            // short-circuit, 0*X == 0
+            continue;
+        }
+
+        for (let j = 0; j < b_len; j++) {
+            out[i + j] += ai * b[j];
+        }
+    }
+
+    return out_len;
+}

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

@@ -9,7 +9,12 @@
  * @param {number} hi
  * @param {Float64Array|number[]} out
  * @param {number} out_offset
+ * @param {number} [aberth_max_iterations] optional outer-iteration cap for the
+ *   Aberth root finder used at degree ≥ 3. Defaults to the routine's own
+ *   internal cap (80). Lower the cap when the caller knows the polynomial is
+ *   well-conditioned and convergence is typically quick — e.g. degree-5
+ *   well-behaved polys converge in 15-25 iterations.
  * @returns {number} number of roots written
  */
-export function polynomial_real_roots_in_interval(coeffs: Float64Array | number[], degree: number, lo: number, hi: number, out: Float64Array | number[], out_offset: number): number;
+export function polynomial_real_roots_in_interval(coeffs: Float64Array | number[], degree: number, lo: number, hi: number, out: Float64Array | number[], out_offset: number, aberth_max_iterations?: number): number;
 //# sourceMappingURL=polynomial_real_roots_in_interval.d.ts.map

package/src/core/math/linalg/polynomial_real_roots_in_interval.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polynomial_real_roots_in_interval.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_real_roots_in_interval.js"],"names":[],"mappings":"AAsGA;;;;;;;;;;;;GAYG;AACH,0DARW,YAAY,GAAC,MAAM,EAAE,UACrB,MAAM,MACN,MAAM,MACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,GACJ,MAAM,CAsFlB"}
+{"version":3,"file":"polynomial_real_roots_in_interval.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_real_roots_in_interval.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;;;;GAiBG;AACH,0DAbW,YAAY,GAAC,MAAM,EAAE,UACrB,MAAM,MACN,MAAM,MACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,0BACN,MAAM,GAKJ,MAAM,CAqGlB"}

package/src/core/math/linalg/polynomial_real_roots_in_interval.js

@@ -1,6 +1,7 @@
 import { assert } from "../../assert.js";
 import { solveQuadratic } from "../solveQuadratic.js";
 import { polynomial_complex_roots_aberth_ehrlich } from "./polynomial_complex_roots_aberth_ehrlich.js";
+import { polynomial_root_bound_cauchy } from "./polynomial_root_bound_cauchy.js";
 
 /*
  Find all real roots of a univariate polynomial that lie inside a closed interval [lo, hi].
@@ -58,16 +59,6 @@ function max_abs_coefficient(coeffs, degree) {
     return m;
 }
 
-function root_scale_estimate(coeffs, degree) {
-    const lead = Math.abs(coeffs[degree]);
-    let m = 0;
-    for (let i = 0; i < degree; i++) {
-        const a = Math.abs(coeffs[i]);
-        if (a > m) m = a;
-    }
-    return 1 + m / lead;
-}
-
 function newton_polish_real(coeffs, degree, x_init) {
     let x = x_init;
 
@@ -111,13 +102,19 @@ function insert_sorted_unique(roots, count, value, dedupe_tolerance) {
  * @param {number} hi
  * @param {Float64Array|number[]} out
  * @param {number} out_offset
+ * @param {number} [aberth_max_iterations] optional outer-iteration cap for the
+ *   Aberth root finder used at degree ≥ 3. Defaults to the routine's own
+ *   internal cap (80). Lower the cap when the caller knows the polynomial is
+ *   well-conditioned and convergence is typically quick — e.g. degree-5
+ *   well-behaved polys converge in 15-25 iterations.
  * @returns {number} number of roots written
  */
 export function polynomial_real_roots_in_interval(
     coeffs,
     degree,
     lo, hi,
-    out, out_offset
+    out, out_offset,
+    aberth_max_iterations
 ) {
     assert.isNonNegativeInteger(degree, 'degree');
     assert.isNonNegativeInteger(out_offset, 'out_offset');
@@ -147,14 +144,17 @@ export function polynomial_real_roots_in_interval(
     if (effective_degree === 2) {
         const root_count = solveQuadratic(SCRATCH_QUADRATIC, 0, coeffs[2], coeffs[1], coeffs[0]);
         let written = 0;
+
         for (let i = 0; i < root_count; i++) {
             const r = SCRATCH_QUADRATIC[i];
+
             if (r >= lo && r <= hi) {
                 if (written === 0 || Math.abs(out[out_offset + written - 1] - r) > 0) {
                     out[out_offset + written] = r;
                     written++;
                 }
             }
+
         }
         return written;
     }
@@ -163,10 +163,11 @@ export function polynomial_real_roots_in_interval(
 
     polynomial_complex_roots_aberth_ehrlich(
         SCRATCH_COEFF, effective_degree,
-        SCRATCH_ROOTS_RE, SCRATCH_ROOTS_IM, 0
+        SCRATCH_ROOTS_RE, SCRATCH_ROOTS_IM, 0,
+        aberth_max_iterations
     );
 
-    const root_scale = root_scale_estimate(SCRATCH_COEFF, effective_degree);
+    const root_scale = polynomial_root_bound_cauchy(SCRATCH_COEFF, effective_degree);
     const imag_threshold = IMAG_PART_REAL_THRESHOLD * Math.max(1, root_scale);
     const residual_tolerance = NEWTON_RELATIVE_RESIDUAL_TOLERANCE * coeff_norm;
     const dedupe_tolerance = DEDUPE_RELATIVE_TOLERANCE * Math.max(1, Math.max(Math.abs(lo), Math.abs(hi)));
@@ -177,17 +178,27 @@ export function polynomial_real_roots_in_interval(
         const re = SCRATCH_ROOTS_RE[i];
         const im = SCRATCH_ROOTS_IM[i];
 
-        if (!Number.isFinite(re) || !Number.isFinite(im)) continue;
+        if (!Number.isFinite(re) || !Number.isFinite(im)){
+            continue;
+        }
 
-        if (Math.abs(im) > imag_threshold) continue;
+        if (Math.abs(im) > imag_threshold){
+            continue;
+        }
 
         const polished = newton_polish_real(SCRATCH_COEFF, effective_degree, re);
-        if (!Number.isFinite(polished)) continue;
+        if (!Number.isFinite(polished)){
+            continue;
+        }
 
         poly_eval_with_derivative(SCRATCH_COEFF, effective_degree, polished, SCRATCH_EVAL);
-        if (Math.abs(SCRATCH_EVAL[0]) > residual_tolerance) continue;
+        if (Math.abs(SCRATCH_EVAL[0]) > residual_tolerance){
+            continue;
+        }
 
-        if (polished < lo || polished > hi) continue;
+        if (polished < lo || polished > hi){
+            continue;
+        }
 
         unique_count = insert_sorted_unique(SCRATCH_OUT_REAL, unique_count, polished, dedupe_tolerance);
     }

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

@@ -0,0 +1,17 @@
+/**
+ * Cauchy's bound on the magnitude of polynomial roots.
+ *
+ * For a polynomial `p(x) = c[0] + c[1]·x + ... + c[degree]·x^degree` with
+ * `c[degree] ≠ 0`, every (real or complex) root `z` satisfies
+ *
+ *   |z| ≤ 1 + max(|c[0]|, |c[1]|, ..., |c[degree − 1]|) / |c[degree]|
+ *
+ * The bound is loose for general polynomials but cheap to compute and serves
+ * as a good initial radius for iterative root-finders such as Aberth–Ehrlich.
+ *
+ * @param {number[]|Float32Array|Float64Array} coeffs ascending-power, length ≥ degree + 1
+ * @param {number} degree polynomial degree, ≥ 1; the leading coefficient `coeffs[degree]` must be nonzero
+ * @returns {number}
+ */
+export function polynomial_root_bound_cauchy(coeffs: number[] | Float32Array | Float64Array, degree: number): number;
+//# sourceMappingURL=polynomial_root_bound_cauchy.d.ts.map

package/src/core/math/linalg/polynomial_root_bound_cauchy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomial_root_bound_cauchy.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_root_bound_cauchy.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,qDAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,GACJ,MAAM,CAgBlB"}

package/src/core/math/linalg/polynomial_root_bound_cauchy.js

@@ -0,0 +1,30 @@
+/**
+ * Cauchy's bound on the magnitude of polynomial roots.
+ *
+ * For a polynomial `p(x) = c[0] + c[1]·x + ... + c[degree]·x^degree` with
+ * `c[degree] ≠ 0`, every (real or complex) root `z` satisfies
+ *
+ *   |z| ≤ 1 + max(|c[0]|, |c[1]|, ..., |c[degree − 1]|) / |c[degree]|
+ *
+ * The bound is loose for general polynomials but cheap to compute and serves
+ * as a good initial radius for iterative root-finders such as Aberth–Ehrlich.
+ *
+ * @param {number[]|Float32Array|Float64Array} coeffs ascending-power, length ≥ degree + 1
+ * @param {number} degree polynomial degree, ≥ 1; the leading coefficient `coeffs[degree]` must be nonzero
+ * @returns {number}
+ */
+export function polynomial_root_bound_cauchy(coeffs, degree) {
+    const lead = Math.abs(coeffs[degree]);
+
+    let m = 0;
+
+    for (let i = 0; i < degree; i++) {
+        const a = Math.abs(coeffs[i]);
+
+        if (a > m) {
+            m = a;
+        }
+    }
+
+    return 1 + m / lead;
+}

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

@@ -0,0 +1,14 @@
+/**
+ * Scales polynomial `target` in place by a scalar.
+ *
+ *   target(x) := scalar * target(x)
+ *
+ * Coefficient layout: index i is the coefficient of x^i (ascending). Only
+ * the first `target_len` coefficients are touched.
+ *
+ * @param {number[]|Float64Array|Float32Array} target modified in place
+ * @param {number} target_len number of coefficients to scale
+ * @param {number} scalar
+ */
+export function polynomial_scale_into(target: number[] | Float64Array | Float32Array, target_len: number, scalar: number): void;
+//# sourceMappingURL=polynomial_scale_into.d.ts.map

package/src/core/math/linalg/polynomial_scale_into.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomial_scale_into.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_scale_into.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,8CAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,UACN,MAAM,QAMhB"}

package/src/core/math/linalg/polynomial_scale_into.js

@@ -0,0 +1,17 @@
+/**
+ * Scales polynomial `target` in place by a scalar.
+ *
+ *   target(x) := scalar * target(x)
+ *
+ * Coefficient layout: index i is the coefficient of x^i (ascending). Only
+ * the first `target_len` coefficients are touched.
+ *
+ * @param {number[]|Float64Array|Float32Array} target modified in place
+ * @param {number} target_len number of coefficients to scale
+ * @param {number} scalar
+ */
+export function polynomial_scale_into(target, target_len, scalar) {
+    for (let i = 0; i < target_len; i++) {
+        target[i] *= scalar;
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Subtracts polynomial `a` from `target` in place.
+ *
+ *   target(x) := target(x) - a(x)
+ *
+ * Coefficient layout: index i is the coefficient of x^i (ascending). If
+ * `a_len > target_len`, the excess coefficients in `target` at indices
+ * [target_len, a_len) are first cleared to zero, so the returned length
+ * (max of the two input lengths) reflects valid coefficients.
+ *
+ * @param {number[]|Float64Array|Float32Array} target receives the difference, length >= max(target_len, a_len)
+ * @param {number} target_len current number of coefficients in target
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number} a_len number of coefficients in a
+ * @returns {number} new logical length of target = max(target_len, a_len)
+ */
+export function polynomial_sub_into(target: number[] | Float64Array | Float32Array, target_len: number, a: number[] | Float64Array | Float32Array, a_len: number): number;
+//# sourceMappingURL=polynomial_sub_into.d.ts.map

package/src/core/math/linalg/polynomial_sub_into.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polynomial_sub_into.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_sub_into.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,4CANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,KACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,GACJ,MAAM,CAclB"}

package/src/core/math/linalg/polynomial_sub_into.js

@@ -0,0 +1,29 @@
+/**
+ * Subtracts polynomial `a` from `target` in place.
+ *
+ *   target(x) := target(x) - a(x)
+ *
+ * Coefficient layout: index i is the coefficient of x^i (ascending). If
+ * `a_len > target_len`, the excess coefficients in `target` at indices
+ * [target_len, a_len) are first cleared to zero, so the returned length
+ * (max of the two input lengths) reflects valid coefficients.
+ *
+ * @param {number[]|Float64Array|Float32Array} target receives the difference, length >= max(target_len, a_len)
+ * @param {number} target_len current number of coefficients in target
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number} a_len number of coefficients in a
+ * @returns {number} new logical length of target = max(target_len, a_len)
+ */
+export function polynomial_sub_into(target, target_len, a, a_len) {
+    const n = a_len > target_len ? a_len : target_len;
+
+    for (let i = target_len; i < n; i++) {
+        target[i] = 0;
+    }
+
+    for (let i = 0; i < a_len; i++) {
+        target[i] -= a[i];
+    }
+
+    return n;
+}

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

@@ -5,7 +5,7 @@
  *
  * @see https://github.com/Kitware/VTK/blob/af928016f4041ad8a6a193d032355b909721fc95/Common/Core/vtkMath.cxx
  *
- * @param {number[]|Float32Array|Float64Array} A Matrix of coefficients
+ * @param {number[]|Float32Array|Float64Array} A Matrix of coefficients, column-major flat layout (A[j*size + i] = element at row i, col j)
  * @param {number[]|Float32Array|Float64Array} x Vector of right-hand constants for each equation, resulting solution for variables will also be written here
  * @param {number} size size of the system. Size 1 means a single variable and a single equation, 2 means a 2 variable equation system etc
  * @returns {boolean} true if solution found, false if factorization fails

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

@@ -13,7 +13,7 @@ const scratch = new Uint32Array(SCRATCH_SIZE);
  *
  * @see https://github.com/Kitware/VTK/blob/af928016f4041ad8a6a193d032355b909721fc95/Common/Core/vtkMath.cxx
  *
- * @param {number[]|Float32Array|Float64Array} A Matrix of coefficients
+ * @param {number[]|Float32Array|Float64Array} A Matrix of coefficients, column-major flat layout (A[j*size + i] = element at row i, col j)
  * @param {number[]|Float32Array|Float64Array} x Vector of right-hand constants for each equation, resulting solution for variables will also be written here
  * @param {number} size size of the system. Size 1 means a single variable and a single equation, 2 means a 2 variable equation system etc
  * @returns {boolean} true if solution found, false if factorization fails