@woosh/meep-engine 2.134.4 → 2.135.0

package/src/core/geom/vec3/v3_rigid_align_paired_unit_vectors.js

@@ -0,0 +1,96 @@
+import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
+import { matrix_top_eigenvector_power_iteration } from "../../math/linalg/eigen/matrix_top_eigenvector_power_iteration.js";
+import { SquareMatrix } from "../../math/matrix/SquareMatrix.js"
+
+const scratch_horn_n = new SquareMatrix(4, BinaryDataType.Float64);
+
+/**
+ * Closed-form solution for the rotation that best aligns two sets of unit
+ * vectors, via Horn (1987) "Closed-form solution of absolute orientation using
+ * unit quaternions".
+ *
+ * Given paired unit vectors {a_i} and {b_i}, finds the unit quaternion q such
+ * that rotating each b_i by q minimizes Σ |a_i − R(q)·b_i|².
+ *
+ * The matrix N is built so that the eigenvector of its largest eigenvalue
+ * IS the optimal rotation quaternion (in scalar-last form, matching meep's
+ * `Quaternion`).
+ *
+ * Inputs are unit vectors so no centroid subtraction is needed — the rotation
+ * is recovered from the cross-correlations alone.
+ *
+ * @param {Float32Array|number[]} a_xyz Source vectors — Length: count*3, unit length per triple
+ * @param {Float32Array|number[]} b_xyz Target vectors — Length: count*3, unit length per triple
+ * @param {number} count
+ * @param {Float32Array|number[]} out_quaternion Length 4 (x, y, z, w)
+ * @returns {number} The maximum eigenvalue ≈ Σ a_i · R·b_i. For a perfect alignment this equals `count`.
+ */
+export function v3_rigid_align_paired_unit_vectors(a_xyz, b_xyz, count, out_quaternion) {
+
+    // Cross-correlation matrix S_ij = Σ b_i_component * a_j_component
+    // Note: S is built as Σ b ⊗ aᵀ (Horn 1987 convention) — the rotation
+    // recovered will take b onto a.
+    let Sxx = 0, Sxy = 0, Sxz = 0;
+    let Syx = 0, Syy = 0, Syz = 0;
+    let Szx = 0, Szy = 0, Szz = 0;
+
+    for (let i = 0; i < count; i++) {
+        const i3 = i * 3;
+        const ax = a_xyz[i3], ay = a_xyz[i3 + 1], az = a_xyz[i3 + 2];
+        const bx = b_xyz[i3], by = b_xyz[i3 + 1], bz = b_xyz[i3 + 2];
+
+        Sxx += bx * ax;
+        Sxy += bx * ay;
+        Sxz += bx * az;
+        Syx += by * ax;
+        Syy += by * ay;
+        Syz += by * az;
+        Szx += bz * ax;
+        Szy += bz * ay;
+        Szz += bz * az;
+    }
+
+    // Horn's 4x4 symmetric matrix N (scalar-last quaternion ordering: x, y, z, w).
+    //
+    // From the paper, ordered for scalar-FIRST quaternion (w, x, y, z):
+    //   N00 = Sxx + Syy + Szz       N01 = Syz - Szy            N02 = Szx - Sxz            N03 = Sxy - Syx
+    //   N11 = Sxx - Syy - Szz       N12 = Sxy + Syx            N13 = Szx + Sxz
+    //   N22 = -Sxx + Syy - Szz      N23 = Syz + Szy
+    //   N33 = -Sxx - Syy + Szz
+    //
+    // We rebind to (x, y, z, w):
+    //   row/col 0 = x, 1 = y, 2 = z, 3 = w
+    // i.e. swap original index 0 with 3 and shift others down.
+    const Nxx = Sxx - Syy - Szz;
+    const Nyy = -Sxx + Syy - Szz;
+    const Nzz = -Sxx - Syy + Szz;
+    const Nww = Sxx + Syy + Szz;
+    const Nxy = Sxy + Syx;
+    const Nxz = Szx + Sxz;
+    const Nxw = Syz - Szy;
+    const Nyz = Syz + Szy;
+    const Nyw = Szx - Sxz;
+    const Nzw = Sxy - Syx;
+
+    const N = scratch_horn_n;
+    const d = N.data;
+    // SquareMatrix is column-major: d[col * 4 + row]
+    d[0] = Nxx;
+    d[5] = Nyy;
+    d[10] = Nzz;
+    d[15] = Nww;
+    d[1] = Nxy;
+    d[4] = Nxy;
+    d[2] = Nxz;
+    d[8] = Nxz;
+    d[3] = Nxw;
+    d[12] = Nxw;
+    d[6] = Nyz;
+    d[9] = Nyz;
+    d[7] = Nyw;
+    d[13] = Nyw;
+    d[11] = Nzw;
+    d[14] = Nzw;
+
+    return matrix_top_eigenvector_power_iteration(N, out_quaternion);
+}

package/src/core/graph/layout/box/BoxLayouter.js

@@ -22,11 +22,11 @@ function evaluateEdgeCost(edge) {
     const second = edge.target;
 
     //compute center points
-    const x0 = first.midX();
-    const y0 = first.midY();
+    const x0 = first.centerX;
+    const y0 = first.centerY;
 
-    const x1 = second.midX();
-    const y1 = second.midY();
+    const x1 = second.centerX;
+    const y1 = second.centerY;
 
     return Vector2._distance(x0, y0, x1, y1);
 }
@@ -63,7 +63,7 @@ function evaluateLayout(boxes, edges) {
     const footprint = computeBoundingBox(boxes);
 
     //overall size of the layout plays a role
-    const totalArea = footprint.getHeight() * footprint.getWidth();
+    const totalArea = footprint.height * footprint.width;
 
     const totalConnectionLength = edges.reduce(function (sum, edge) {
         return sum + evaluateEdgeCost(edge);
@@ -177,8 +177,8 @@ function applyPull(edges, strength) {
         const first = edge.source;
         const second = edge.target;
 
-        d.set(second.midX(), second.midY());
-        d._sub(first.midX(), first.midY());
+        d.set(second.centerX, second.centerY);
+        d._sub(first.centerX, first.centerY);
 
         d.multiplyScalar(strength);
 

package/src/core/graph/layout/box/position_box_next_to_box.js

@@ -31,13 +31,13 @@ function compute_initial_placement(
 
     const targetCenter = target.getCenter();
 
-    const targetH = target.getHeight();
-    const targetW = target.getWidth();
+    const targetH = target.height;
+    const targetW = target.width;
 
     const targetDiagonal = Math.sqrt(targetH * targetH + targetW * targetW);
 
-    const boxWidth = box.getWidth();
-    const boxHeight = box.getHeight();
+    const boxWidth = box.width;
+    const boxHeight = box.height;
 
     const boxWidth_2 = boxWidth / 2;
     const boxHeight_2 = boxHeight / 2;
@@ -120,8 +120,8 @@ function compute_initial_placement(
 
         let score = 0;
 
-        const availableWidth = availableSpace.getWidth();
-        const availableHeight = availableSpace.getHeight();
+        const availableWidth = availableSpace.width;
+        const availableHeight = availableSpace.height;
 
         const spareWidth = availableWidth - boxWidth;
         const spareHeight = availableHeight - boxHeight;

package/src/core/math/computeWholeDivisorLow.js

@@ -1,33 +1,33 @@
-import { assert } from "../assert.js";
-
-/**
- * Compute the largest positive integer divisor of a given "product" value
- * @param {number} product
- * @param {number} limit
- * @returns {number}
- */
-export function computeWholeDivisorLow(product, limit) {
-
-    assert.isNumber(product, 'product');
-    assert.isInteger(product, 'product');
-
-    assert.isNumber(limit, 'limit');
-    assert.isInteger(limit, 'limit');
-
-    assert.isFiniteNumber(limit,'limit');
-    assert.isFiniteNumber(product,'product');
-
-    let i = limit;
-
-    while (i > 1) {
-
-        if (product % i === 0) {
-            break;
-        }
-
-        i--;
-
-    }
-
-    return i;
-}
+import { assert } from "../assert.js";
+
+/**
+ * Compute the largest positive integer divisor of a given "product" value
+ * @param {number} product
+ * @param {number} limit
+ * @returns {number}
+ */
+export function computeWholeDivisorLow(product, limit) {
+
+    assert.isNumber(product, 'product');
+    assert.isInteger(product, 'product');
+
+    assert.isNumber(limit, 'limit');
+    assert.isInteger(limit, 'limit');
+
+    assert.isFinite(limit,'limit');
+    assert.isFinite(product,'product');
+
+    let i = limit;
+
+    while (i > 1) {
+
+        if (product % i === 0) {
+            break;
+        }
+
+        i--;
+
+    }
+
+    return i;
+}

package/src/core/math/linalg/eigen/eigen_values_find_spectral_gap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eigen_values_find_spectral_gap.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/eigen_values_find_spectral_gap.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,uDAHW,MAAM,EAAE,GACN,MAAM,CAoBlB"}

package/src/core/math/linalg/eigen/matrix_eigenvalues_in_place.d.ts

@@ -0,0 +1,10 @@
+/**
+ * list of eigen values square matrix (allow non-symmetric)
+ * NOTE: Modifies input matrix
+ * @template T extends ArrayLike<number>
+ * @param {T} out
+ * @param {SquareMatrix} mat
+ * @return {T}
+ */
+export function matrix_eigenvalues_in_place<T>(out: T, mat: SquareMatrix): T;
+//# sourceMappingURL=matrix_eigenvalues_in_place.d.ts.map

package/src/core/math/linalg/eigen/matrix_eigenvalues_in_place.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix_eigenvalues_in_place.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_eigenvalues_in_place.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,6EASC"}

package/src/core/{graph → math/linalg}/eigen/matrix_eigenvalues_in_place.js

@@ -3,19 +3,20 @@ import { matrix_qr_in_place } from "./matrix_qr_in_place.js";
 
 
 /**
- * list of eigen values square matrix (allow non symmetric)
+ * list of eigen values square matrix (allow non-symmetric)
  * NOTE: Modifies input matrix
+ * @template T extends ArrayLike<number>
+ * @param {T} out
  * @param {SquareMatrix} mat
- * @return {number[]}
+ * @return {T}
  */
-export function matrix_eigenvalues_in_place(mat) {
+export function matrix_eigenvalues_in_place(out, mat) {
     const n = mat.size;
+
     matrix_householder_in_place(mat.data, n);
     matrix_qr_in_place(mat.data, n);
 
-    const result = new Float32Array(n);
-
-    mat.readDiagonal(result);
+    mat.readDiagonal(out);
 
-    return result;
+    return out;
 }

package/src/core/math/linalg/eigen/matrix_householder_in_place.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix_householder_in_place.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_householder_in_place.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,+CAHW,MAAM,EAAE,KACR,MAAM,QA0FhB"}

package/src/core/{graph → math/linalg}/eigen/matrix_householder_in_place.js

@@ -32,14 +32,20 @@ export function matrix_householder_in_place(a, n) {
             sum = sum + u[i] * u[i];
         }
 
-        const u_k_1 = u[k + 1];
-
-        const u_k_1_abs = Math.abs(u_k_1);
-        if (u_k_1_abs < EPSILON) {
+        if (sum < EPSILON * EPSILON) {
+            // sub-column already zero — nothing to reduce at this k
             continue;
         }
 
-        const sigma = Math.sqrt(sum) * u_k_1 / u_k_1_abs;
+        const u_k_1 = u[k + 1];
+        const u_k_1_abs = Math.abs(u_k_1);
+
+        // sigma = sign(u[k+1]) · ‖u‖. When u[k+1] = 0 the sign is arbitrary
+        // (entries below are still nonzero by the `sum` check above), so pick
+        // +‖u‖.
+        const sigma = u_k_1_abs < EPSILON
+            ? Math.sqrt(sum)
+            : Math.sqrt(sum) * u_k_1 / u_k_1_abs;
 
         u[k + 1] += sigma;
 

package/src/core/math/linalg/eigen/matrix_qr_in_place.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Perform QR factorization in-place.
+ * Subfunction that analyzes eigenvalues by QR decomposition.
+ *
+ * Single-shift Wilkinson iteration: deflates the trailing subdiagonal one row
+ * at a time as it converges. A complex eigenvalue pair leaves a 2×2 trailing
+ * block whose inner subdiagonal does not vanish, and this routine will spin
+ * on it indefinitely — only safe today for matrices with all-real eigenvalues.
+ *
+ * @see http://www-in.aut.ac.jp/~minemura/pub/Csimu/C/QRmethod.html
+ * @param {number[]} a Square matrix
+ * @param {number} n size of the matrix in single dimension
+ */
+export function matrix_qr_in_place(a: number[], n: number): void;
+//# sourceMappingURL=matrix_qr_in_place.d.ts.map

package/src/core/math/linalg/eigen/matrix_qr_in_place.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix_qr_in_place.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_qr_in_place.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,sCAHW,MAAM,EAAE,KACR,MAAM,QA8GhB"}

package/src/core/{graph → math/linalg}/eigen/matrix_qr_in_place.js

@@ -1,8 +1,14 @@
 const EPSILON = 1e-10;
 
 /**
- * Perform QR factorization in-place
- * Subfunction that analyzes eigenvalues by QR decomposition
+ * Perform QR factorization in-place.
+ * Subfunction that analyzes eigenvalues by QR decomposition.
+ *
+ * Single-shift Wilkinson iteration: deflates the trailing subdiagonal one row
+ * at a time as it converges. A complex eigenvalue pair leaves a 2×2 trailing
+ * block whose inner subdiagonal does not vanish, and this routine will spin
+ * on it indefinitely — only safe today for matrices with all-real eigenvalues.
+ *
  * @see http://www-in.aut.ac.jp/~minemura/pub/Csimu/C/QRmethod.html
  * @param {number[]} a Square matrix
  * @param {number} n size of the matrix in single dimension

package/src/core/math/linalg/eigen/matrix_top_eigenvector_power_iteration.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Find the eigenvector corresponding to the largest-magnitude eigenvalue of a
+ * symmetric square matrix using power iteration.
+ *
+ * Designed for small symmetric matrices where the dominant eigenvalue is
+ * well-separated from the rest (Horn's quaternion method on a 4x4, PCA on a
+ * 3x3 covariance, etc.). Unsuitable when the top two eigenvalues have nearly
+ * equal magnitude — convergence stalls in that regime.
+ *
+ * @param {SquareMatrix} matrix Symmetric, column-major as per SquareMatrix
+ * @param {number[]|Float32Array|Float64Array} out Eigenvector is written here, length >= matrix.size
+ * @param {number} [max_iterations=64]
+ * @param {number} [tolerance=1e-8] Convergence stops when ||v_next - v|| < tolerance
+ * @returns {number} The Rayleigh quotient (estimated eigenvalue)
+ */
+export function matrix_top_eigenvector_power_iteration(matrix: SquareMatrix, out: number[] | Float32Array | Float64Array, max_iterations?: number, tolerance?: number): number;
+//# sourceMappingURL=matrix_top_eigenvector_power_iteration.d.ts.map

package/src/core/math/linalg/eigen/matrix_top_eigenvector_power_iteration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix_top_eigenvector_power_iteration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_top_eigenvector_power_iteration.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;GAcG;AACH,kFALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,cACN,MAAM,GACJ,MAAM,CAoFlB"}

package/src/core/math/linalg/eigen/matrix_top_eigenvector_power_iteration.js

@@ -0,0 +1,107 @@
+import { assert } from "@woosh/meep-engine/src/core/assert.js";
+
+let scratch_next = new Float64Array(16);
+
+function ensure_scratch(n) {
+    if (scratch_next.length < n) scratch_next = new Float64Array(n);
+    return scratch_next;
+}
+
+/**
+ * Find the eigenvector corresponding to the largest-magnitude eigenvalue of a
+ * symmetric square matrix using power iteration.
+ *
+ * Designed for small symmetric matrices where the dominant eigenvalue is
+ * well-separated from the rest (Horn's quaternion method on a 4x4, PCA on a
+ * 3x3 covariance, etc.). Unsuitable when the top two eigenvalues have nearly
+ * equal magnitude — convergence stalls in that regime.
+ *
+ * @param {SquareMatrix} matrix Symmetric, column-major as per SquareMatrix
+ * @param {number[]|Float32Array|Float64Array} out Eigenvector is written here, length >= matrix.size
+ * @param {number} [max_iterations=64]
+ * @param {number} [tolerance=1e-8] Convergence stops when ||v_next - v|| < tolerance
+ * @returns {number} The Rayleigh quotient (estimated eigenvalue)
+ */
+export function matrix_top_eigenvector_power_iteration(
+    matrix,
+    out,
+    max_iterations = 64,
+    tolerance = 1e-8
+) {
+    assert.defined(matrix, "matrix");
+    assert.defined(out, "out");
+
+    const n = matrix.size;
+    const data = matrix.data;
+
+    // Deterministic asymmetric initial vector. A uniform init (e.g. 1/√n in
+    // every slot) can be orthogonal to the dominant eigenvector when the matrix
+    // has block structure, stalling iteration on a sub-dominant eigenvalue.
+    // Irrational-component cosines avoid this for any reasonable n.
+    let init_norm_sq = 0;
+    for (let i = 0; i < n; i++) {
+        const v = Math.cos(i * 1.7 + 0.3);
+        out[i] = v;
+        init_norm_sq += v * v;
+    }
+    const init_inv = 1 / Math.sqrt(init_norm_sq);
+    for (let i = 0; i < n; i++) out[i] *= init_inv;
+
+    const next = ensure_scratch(n);
+    let eigenvalue = 0;
+
+    for (let iter = 0; iter < max_iterations; iter++) {
+        // next = matrix * out
+        // Column-major: data[col * n + row] is element at (row, col)
+        for (let row = 0; row < n; row++) {
+            let sum = 0;
+            for (let col = 0; col < n; col++) {
+                sum += data[col * n + row] * out[col];
+            }
+            next[row] = sum;
+        }
+
+        // Rayleigh quotient = out . next  (since out is unit length and matrix is symmetric)
+        let rayleigh = 0;
+        for (let i = 0; i < n; i++) {
+            rayleigh += out[i] * next[i];
+        }
+
+        // Normalize next
+        let length_sqr = 0;
+        for (let i = 0; i < n; i++) {
+            length_sqr += next[i] * next[i];
+        }
+
+        if (length_sqr === 0) {
+            // Degenerate input — bail out, leave `out` as-is
+            return 0;
+        }
+
+        const inv_length = 1 / Math.sqrt(length_sqr);
+
+        // Sign-align next with out so we can measure convergence by raw difference.
+        // (Power iteration has a sign ambiguity per step when eigenvalue is negative.)
+        let dot = 0;
+        for (let i = 0; i < n; i++) {
+            dot += next[i] * out[i];
+        }
+        const sign = dot < 0 ? -inv_length : inv_length;
+
+        let delta_sqr = 0;
+        for (let i = 0; i < n; i++) {
+            const v = next[i] * sign;
+            const d = v - out[i];
+            delta_sqr += d * d;
+            out[i] = v;
+        }
+
+        eigenvalue = rayleigh;
+
+        if (delta_sqr < tolerance * tolerance) {
+            break;
+        }
+    }
+
+    return eigenvalue;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Find all complex roots of a univariate polynomial via Aberth–Ehrlich.
+ *
+ * The polynomial is given in ascending-power coefficient form:
+ *   p(x) = coeffs[0] + coeffs[1]·x + … + coeffs[degree]·x^degree
+ * The leading coefficient `coeffs[degree]` must be nonzero.
+ *
+ * Exactly `degree` complex numbers are written into `roots_re`/`roots_im` at
+ * index `offset`, `offset + 1`, …, `offset + degree - 1`. The order they
+ * appear in is not specified.
+ *
+ * @param {Float64Array|number[]} coeffs ascending-power, length ≥ degree + 1
+ * @param {number} degree polynomial degree, ≥ 1, ≤ 64
+ * @param {Float64Array|number[]} roots_re real parts, length ≥ offset + degree
+ * @param {Float64Array|number[]} roots_im imaginary parts, length ≥ offset + degree
+ * @param {number} offset
+ */
+export function polynomial_complex_roots_aberth_ehrlich(coeffs: Float64Array | number[], degree: number, roots_re: Float64Array | number[], roots_im: Float64Array | number[], offset: number): void;
+//# sourceMappingURL=polynomial_complex_roots_aberth_ehrlich.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polynomial_complex_roots_aberth_ehrlich.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_complex_roots_aberth_ehrlich.js"],"names":[],"mappings":"AA6DA;;;;;;;;;;;;;;;;GAgBG;AACH,gEANW,YAAY,GAAC,MAAM,EAAE,UACrB,MAAM,YACN,YAAY,GAAC,MAAM,EAAE,YACrB,YAAY,GAAC,MAAM,EAAE,UACrB,MAAM,QAoFhB"}

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

@@ -0,0 +1,161 @@
+import { assert } from "../../assert.js";
+
+/*
+ Find all roots of a univariate polynomial in the complex plane via
+ Aberth–Ehrlich simultaneous iteration. Real and complex roots are isolated
+ together; the caller separates real ones by inspecting the imaginary parts.
+
+ Reference: Aberth (1973), "Iteration methods for finding all zeros of a
+ polynomial simultaneously", Math. Comp. 27.
+
+ The iteration is
+
+   z_k ← z_k − w_k / (1 − w_k · Σ_{j≠k} 1/(z_k − z_j))
+
+ with w_k = p(z_k) / p'(z_k). Initial points are placed on a circle of radius
+ = Cauchy bound, with a fixed phase offset so an initial guess never lands
+ exactly on a real root (which would make the pairwise sum singular at step
+ zero). Convergence is quadratic once close.
+*/
+
+const MAX_SUPPORTED_DEGREE = 64;
+
+const ABERTH_MAX_ITERATIONS = 80;
+const ABERTH_CONVERGENCE_TOLERANCE = 1e-14;
+
+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;
+}
+
+/**
+ * Find all complex roots of a univariate polynomial via Aberth–Ehrlich.
+ *
+ * The polynomial is given in ascending-power coefficient form:
+ *   p(x) = coeffs[0] + coeffs[1]·x + … + coeffs[degree]·x^degree
+ * The leading coefficient `coeffs[degree]` must be nonzero.
+ *
+ * Exactly `degree` complex numbers are written into `roots_re`/`roots_im` at
+ * index `offset`, `offset + 1`, …, `offset + degree - 1`. The order they
+ * appear in is not specified.
+ *
+ * @param {Float64Array|number[]} coeffs ascending-power, length ≥ degree + 1
+ * @param {number} degree polynomial degree, ≥ 1, ≤ 64
+ * @param {Float64Array|number[]} roots_re real parts, length ≥ offset + degree
+ * @param {Float64Array|number[]} roots_im imaginary parts, length ≥ offset + degree
+ * @param {number} offset
+ */
+export function polynomial_complex_roots_aberth_ehrlich(
+    coeffs, degree,
+    roots_re, roots_im, offset
+) {
+    assert.greaterThanOrEqual(degree, 1, 'degree');
+    assert.greaterThanOrEqual(MAX_SUPPORTED_DEGREE, degree, 'degree exceeds MAX_SUPPORTED_DEGREE');
+    assert.isNonNegativeInteger(offset, 'offset');
+
+    // derivative: _DERIV[i] = (i + 1) * coeffs[i + 1], i = 0 .. degree - 1
+    for (let i = 0; i < degree; i++) {
+        _DERIV[i] = (i + 1) * coeffs[i + 1];
+    }
+
+    const radius = cauchy_root_magnitude_bound(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++) {
+        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];
+
+            poly_eval_complex(_DERIV, degree - 1, zr, zi, _DP_EVAL);
+            const dpr = _DP_EVAL[0];
+            const dpi = _DP_EVAL[1];
+
+            // w = p / p'
+            const dp_norm_sq = dpr * dpr + dpi * dpi;
+            if (dp_norm_sq === 0) 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;
+
+            // 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;
+                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;
+                const inv_d_sq = 1 / denom_sq;
+                sr += dr * inv_d_sq;
+                si += -di * inv_d_sq;
+            }
+
+            // 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;
+            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;
+
+            roots_re[offset + k] = zr - corr_r;
+            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 (max_correction_sq < ABERTH_CONVERGENCE_TOLERANCE * ABERTH_CONVERGENCE_TOLERANCE) {
+            break;
+        }
+    }
+}