@woosh/meep-engine 2.135.0 → 2.138.0

package/src/core/math/linalg/givens/givens_apply_rows.js

@@ -0,0 +1,28 @@
+/**
+ * Applies a Givens rotation (c, s) to two row vectors in place:
+ *
+ *     row_i' =  c * row_i + s * row_j
+ *     row_j' = -s * row_i + c * row_j
+ *
+ * Each row is treated as a length-n vector and rotated element-by-element.
+ *
+ * Accepts plain arrays or typed arrays. The two row arguments can be
+ * standalone arrays or subarray views into a larger flat matrix — useful
+ * for row-major QR/Hessenberg maintenance where the matrix is a single
+ * Float64Array and the caller hands in `M.subarray(i*n, (i+1)*n)` and
+ * `M.subarray(j*n, (j+1)*n)`.
+ *
+ * @param {Float64Array|number[]} row_i length >= n
+ * @param {Float64Array|number[]} row_j length >= n
+ * @param {number} c
+ * @param {number} s
+ * @param {number} n number of elements to rotate
+ */
+export function givens_apply_rows(row_i, row_j, c, s, n) {
+    for (let i = 0; i < n; ++i) {
+        const a = row_i[i];
+        const b = row_j[i];
+        row_i[i] = c * a + s * b;
+        row_j[i] = c * b - s * a;
+    }
+}

package/src/core/math/linalg/givens/givens_apply_rows_offset.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Applies a Givens rotation (c, s) to two length-n vectors stored in the
+ * same flat buffer at the given offsets. In-place:
+ *
+ *     v_i' =  c * v_i + s * v_j
+ *     v_j' = -s * v_i + c * v_j
+ *
+ * Naming reflects the original use case (rotating two rows of a matrix),
+ * but the helper is layout-agnostic: pass the offsets to two rows of a
+ * row-major matrix, or to two columns of a column-major matrix — anything
+ * where the pair of vectors lives in a single buffer.
+ *
+ * Avoids the header allocation that `.subarray(...)` would cost on every
+ * call when this is invoked inside a tight QR-update loop.
+ *
+ * @param {Float64Array|Float32Array|number[]} buf flat buffer holding both vectors
+ * @param {number} off_i starting offset of the first vector
+ * @param {number} off_j starting offset of the second vector
+ * @param {number} c
+ * @param {number} s
+ * @param {number} n number of elements to rotate
+ */
+export function givens_apply_rows_offset(buf: Float64Array | Float32Array | number[], off_i: number, off_j: number, c: number, s: number, n: number): void;
+//# sourceMappingURL=givens_apply_rows_offset.d.ts.map

package/src/core/math/linalg/givens/givens_apply_rows_offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"givens_apply_rows_offset.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/givens/givens_apply_rows_offset.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8CAPW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,SAClC,MAAM,SACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAShB"}

package/src/core/math/linalg/givens/givens_apply_rows_offset.js

@@ -0,0 +1,30 @@
+/**
+ * Applies a Givens rotation (c, s) to two length-n vectors stored in the
+ * same flat buffer at the given offsets. In-place:
+ *
+ *     v_i' =  c * v_i + s * v_j
+ *     v_j' = -s * v_i + c * v_j
+ *
+ * Naming reflects the original use case (rotating two rows of a matrix),
+ * but the helper is layout-agnostic: pass the offsets to two rows of a
+ * row-major matrix, or to two columns of a column-major matrix — anything
+ * where the pair of vectors lives in a single buffer.
+ *
+ * Avoids the header allocation that `.subarray(...)` would cost on every
+ * call when this is invoked inside a tight QR-update loop.
+ *
+ * @param {Float64Array|Float32Array|number[]} buf flat buffer holding both vectors
+ * @param {number} off_i starting offset of the first vector
+ * @param {number} off_j starting offset of the second vector
+ * @param {number} c
+ * @param {number} s
+ * @param {number} n number of elements to rotate
+ */
+export function givens_apply_rows_offset(buf, off_i, off_j, c, s, n) {
+    for (let i = 0; i < n; ++i) {
+        const a = buf[off_i + i];
+        const b = buf[off_j + i];
+        buf[off_i + i] = c * a + s * b;
+        buf[off_j + i] = c * b - s * a;
+    }
+}

package/src/core/math/linalg/givens/givens_rotation_coefficients.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Computes the Givens rotation coefficients (c, s) such that
+ *
+ *     [  c  s ] [ a ]   [ r ]
+ *     [ -s  c ] [ b ] = [ 0 ]
+ *
+ * with c^2 + s^2 = 1 (so the matrix is a proper rotation).
+ *
+ * Signs are not pinned down — `r` may be either +sqrt(a^2 + b^2) or its
+ * negation depending on the branch taken. Callers that care about the sign
+ * of `r` must apply the rotation explicitly and read the rotated value.
+ *
+ * Writes c to out[0] and s to out[1]. Designed to take an out-param rather
+ * than return an object: returning a freshly-allocated {c, s} pair would
+ * cost an allocation per call, which matters when this is invoked inside a
+ * tight QR-update loop.
+ *
+ * Source: Golub & Van Loan, Matrix Computations 2nd ed., p. 216.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {Float64Array|number[]} out length >= 2; receives [c, s]
+ */
+export function givens_rotation_coefficients(a: number, b: number, out: Float64Array | number[]): void;
+//# sourceMappingURL=givens_rotation_coefficients.d.ts.map

package/src/core/math/linalg/givens/givens_rotation_coefficients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"givens_rotation_coefficients.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/givens/givens_rotation_coefficients.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,gDAJW,MAAM,KACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,QAiB/B"}

package/src/core/math/linalg/givens/givens_rotation_coefficients.js

@@ -0,0 +1,39 @@
+/**
+ * Computes the Givens rotation coefficients (c, s) such that
+ *
+ *     [  c  s ] [ a ]   [ r ]
+ *     [ -s  c ] [ b ] = [ 0 ]
+ *
+ * with c^2 + s^2 = 1 (so the matrix is a proper rotation).
+ *
+ * Signs are not pinned down — `r` may be either +sqrt(a^2 + b^2) or its
+ * negation depending on the branch taken. Callers that care about the sign
+ * of `r` must apply the rotation explicitly and read the rotated value.
+ *
+ * Writes c to out[0] and s to out[1]. Designed to take an out-param rather
+ * than return an object: returning a freshly-allocated {c, s} pair would
+ * cost an allocation per call, which matters when this is invoked inside a
+ * tight QR-update loop.
+ *
+ * Source: Golub & Van Loan, Matrix Computations 2nd ed., p. 216.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {Float64Array|number[]} out length >= 2; receives [c, s]
+ */
+export function givens_rotation_coefficients(a, b, out) {
+    if (b === 0.0) {
+        out[0] = 1.0;
+        out[1] = 0.0;
+    } else if (Math.abs(b) > Math.abs(a)) {
+        const t = a / b;
+        const s = 1 / Math.sqrt(1 + t * t);
+        out[0] = s * t;
+        out[1] = s;
+    } else {
+        const t = b / a;
+        const c = 1 / Math.sqrt(1 + t * t);
+        out[0] = c;
+        out[1] = c * t;
+    }
+}

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

@@ -4,7 +4,7 @@
  * Output factorization LU is in matrix A.
  * If error is found, method returns false.
  *
- * @param {number[]} A Square matrix, will be modified
+ * @param {number[]} A Square matrix, column-major flat layout (A[j*size + i] = element at row i, col j); modified in place to hold the LU factorization
  * @param {number[]|Uint32Array} index will be written to
  * @param {number} size Size of the matrix ( 4x4 matrix has size 4 )
  * @returns {boolean} true if factorization succeeded, false otherwise

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

@@ -1 +1 @@
-{"version":3,"file":"lu_factor_linear_system.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/lu_factor_linear_system.js"],"names":[],"mappings":"AAYA;;;;;;;;;;GAUG;AACH,2CALW,MAAM,EAAE,SACR,MAAM,EAAE,GAAC,WAAW,QACpB,MAAM,GACJ,OAAO,CA+FnB"}
+{"version":3,"file":"lu_factor_linear_system.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/lu_factor_linear_system.js"],"names":[],"mappings":"AAYA;;;;;;;;;;GAUG;AACH,2CALW,MAAM,EAAE,SACR,MAAM,EAAE,GAAC,WAAW,QACpB,MAAM,GACJ,OAAO,CAsFnB"}

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

@@ -1,117 +1,108 @@
-import { assert } from "../../assert.js";
-
-/**
- * Error bound during calculations, must be something reasonably large to avoid floating point rounding errors
- * @type {number}
- */
-const SMALL_NUMBER = 1e-12;
-
-const SCRATCH_SIZE = 16;
-// avoid allocation for smaller systems by using a scratch
-const scratch = new Float64Array(SCRATCH_SIZE);
-
-/**
- * Factor linear equations Ax = b using LU decomposition A = LU where L is lower triangular matrix and U is upper triangular matrix.
- * Input is square matrix A, integer array of pivot indices index[0->n-1], and size of square matrix n.
- * Output factorization LU is in matrix A.
- * If error is found, method returns false.
- *
- * @param {number[]} A Square matrix, will be modified
- * @param {number[]|Uint32Array} index will be written to
- * @param {number} size Size of the matrix ( 4x4 matrix has size 4 )
- * @returns {boolean} true if factorization succeeded, false otherwise
- */
-export function lu_factor_linear_system(A, index, size) {
-    assert.isNonNegativeInteger(size,'size');
-
-    // double scratch[10];
-    // double* scale = (size < 10 ? scratch : new double[size]);
-    //
-    // int i, j, k;
-    // int maxI = 0;
-    // double largest, temp1, temp2, sum;
-    //
-    // // Manage number of output warnings
-    // static int numWarns = 0;
-    //
-    // //
-
-    let i, j, k;
-    let maxI = 0;
-    let largest, temp1, temp2, sum;
-
-    const scale = size <= SCRATCH_SIZE ? scratch : new Float64Array(size);
-
-    // Loop over rows to get implicit scaling information
-    //
-    for (i = 0; i < size; ++i) {
-        for (largest = 0.0, j = 0; j < size; ++j) {
-            if ((temp2 = Math.abs(A[i * size + j])) > largest) {
-                largest = temp2;
-            }
-        }
-
-        if (largest === 0.0) {
-            // Unable to factor linear system
-
-            return false;
-        }
-        scale[i] = 1.0 / largest;
-    }
-    //
-    // Loop over all columns using Crout's method
-    //
-    for (j = 0; j < size; ++j) {
-        for (i = 0; i < j; ++i) {
-            sum = A[i * size + j];
-            for (k = 0; k < i; ++k) {
-                sum -= A[i * size + k] * A[k * size + j];
-            }
-            A[i * size + j] = sum;
-        }
-        //
-        // Begin search for largest pivot element
-        //
-        for (largest = 0.0, i = j; i < size; ++i) {
-            sum = A[i * size + j];
-            for (k = 0; k < j; ++k) {
-                sum -= A[i * size + k] * A[k * size + j];
-            }
-            A[i * size + j] = sum;
-
-            if ((temp1 = scale[i] * Math.abs(sum)) >= largest) {
-                largest = temp1;
-                maxI = i;
-            }
-        }
-        //
-        // Check for row interchange
-        //
-        if (j !== maxI) {
-            for (k = 0; k < size; ++k) {
-                temp1 = A[maxI * size + k];
-                A[maxI * size + k] = A[j * size + k];
-                A[j * size + k] = temp1;
-            }
-            scale[maxI] = scale[j];
-        }
-        //
-        // Divide by pivot element and perform elimination
-        //
-        index[j] = maxI;
-
-        if (Math.abs(A[j * size + j]) <= SMALL_NUMBER) {
-            // Unable to factor linear system
-            return false;
-        }
-
-        if (j !== (size - 1)) {
-            temp1 = 1.0 / A[j * size + j];
-            for (i = j + 1; i < size; ++i) {
-                A[i * size + j] *= temp1;
-            }
-        }
-    }
-
-    return true;
-}
+import { assert } from "../../assert.js";
+
+/**
+ * Error bound during calculations, must be something reasonably large to avoid floating point rounding errors
+ * @type {number}
+ */
+const SMALL_NUMBER = 1e-12;
+
+const SCRATCH_SIZE = 16;
+// avoid allocation for smaller systems by using a scratch
+const scratch = new Float64Array(SCRATCH_SIZE);
+
+/**
+ * Factor linear equations Ax = b using LU decomposition A = LU where L is lower triangular matrix and U is upper triangular matrix.
+ * Input is square matrix A, integer array of pivot indices index[0->n-1], and size of square matrix n.
+ * Output factorization LU is in matrix A.
+ * If error is found, method returns false.
+ *
+ * @param {number[]} A Square matrix, column-major flat layout (A[j*size + i] = element at row i, col j); modified in place to hold the LU factorization
+ * @param {number[]|Uint32Array} index will be written to
+ * @param {number} size Size of the matrix ( 4x4 matrix has size 4 )
+ * @returns {boolean} true if factorization succeeded, false otherwise
+ */
+export function lu_factor_linear_system(A, index, size) {
+    assert.isNonNegativeInteger(size,'size');
+
+    let i, j, k;
+    let maxI = 0;
+    let largest, temp1, temp2, sum;
+
+    const scale = size <= SCRATCH_SIZE ? scratch : new Float64Array(size);
+
+    // Loop over rows to get implicit scaling information
+    //
+    for (i = 0; i < size; ++i) {
+        for (largest = 0.0, j = 0; j < size; ++j) {
+            if ((temp2 = Math.abs(A[j * size + i])) > largest) {
+                largest = temp2;
+            }
+        }
+
+        if (largest === 0.0) {
+            // Unable to factor linear system
+
+            return false;
+        }
+        scale[i] = 1.0 / largest;
+    }
+    //
+    // Loop over all columns using Crout's method
+    //
+    for (j = 0; j < size; ++j) {
+        const jOff = j * size;
+
+        for (i = 0; i < j; ++i) {
+            sum = A[jOff + i];
+            for (k = 0; k < i; ++k) {
+                sum -= A[k * size + i] * A[jOff + k];
+            }
+            A[jOff + i] = sum;
+        }
+        //
+        // Begin search for largest pivot element
+        //
+        for (largest = 0.0, i = j; i < size; ++i) {
+            sum = A[jOff + i];
+            for (k = 0; k < j; ++k) {
+                sum -= A[k * size + i] * A[jOff + k];
+            }
+            A[jOff + i] = sum;
+
+            if ((temp1 = scale[i] * Math.abs(sum)) >= largest) {
+                largest = temp1;
+                maxI = i;
+            }
+        }
+        //
+        // Check for row interchange
+        //
+        if (j !== maxI) {
+            for (k = 0; k < size; ++k) {
+                const kOff = k * size;
+                temp1 = A[kOff + maxI];
+                A[kOff + maxI] = A[kOff + j];
+                A[kOff + j] = temp1;
+            }
+            scale[maxI] = scale[j];
+        }
+        //
+        // Divide by pivot element and perform elimination
+        //
+        index[j] = maxI;
+
+        if (Math.abs(A[jOff + j]) <= SMALL_NUMBER) {
+            // Unable to factor linear system
+            return false;
+        }
+
+        if (j !== (size - 1)) {
+            temp1 = 1.0 / A[jOff + j];
+            for (i = j + 1; i < size; ++i) {
+                A[jOff + i] *= temp1;
+            }
+        }
+    }
+
+    return true;
+}

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

@@ -5,7 +5,7 @@
  * Note that A=LU and index[] are generated from method LUFactorLinearSystem.
  * Also, solution vector is written directly over input load vector.
  *
- * @param {number[]} A Square matrix (flattened)
+ * @param {number[]} A Square matrix, column-major flat layout (pre-factored LU as produced by lu_factor_linear_system)
  * @param {number[]|Uint32Array} index
  * @param {number[]} x Load vector
  * @param {number} size matrix size ( 4x4 matrix has size 4)

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

@@ -1,53 +1,53 @@
-import { assert } from "../../assert.js";
-
-/**
- * Assumes the system is factorized already. Use {@link lu_factor_linear_system} before if it isn't
- * Solve linear equations Ax = b using LU decomposition A = LU where L is lower triangular matrix and U is upper triangular matrix.
- * Input is factored matrix A=LU, integer array of pivot indices index[0->n-1], load vector x[0->n-1], and size of square matrix n.
- * Note that A=LU and index[] are generated from method LUFactorLinearSystem.
- * Also, solution vector is written directly over input load vector.
- *
- * @param {number[]} A Square matrix (flattened)
- * @param {number[]|Uint32Array} index
- * @param {number[]} x Load vector
- * @param {number} size matrix size ( 4x4 matrix has size 4)
- */
-export function lu_solve_linear_system(A, index, x, size) {
-    assert.isNonNegativeInteger(size, 'size');
-
-    let i = 0, j, ii = -1;
-
-    let sum;
-
-    // Proceed with forward and back-substitution for L and U matrices.
-
-    // First, forward substitution.
-    for (; i < size; ++i) {
-        const idx = index[i];
-        sum = x[idx];
-        x[idx] = x[i];
-
-        if (ii >= 0) {
-
-            for (j = ii; j <= i - 1; ++j) {
-                sum -= A[i * size + j] * x[j];
-            }
-
-        } else if (sum !== 0.0) {
-            ii = i;
-        }
-
-        x[i] = sum;
-    }
-
-    // Now, back substitution
-    for (i = size - 1; i >= 0; i--) {
-        sum = x[i];
-
-        for (j = i + 1; j < size; ++j) {
-            sum -= A[i * size + j] * x[j];
-        }
-
-        x[i] = sum / A[i * size + i];
-    }
-}
+import { assert } from "../../assert.js";
+
+/**
+ * Assumes the system is factorized already. Use {@link lu_factor_linear_system} before if it isn't
+ * Solve linear equations Ax = b using LU decomposition A = LU where L is lower triangular matrix and U is upper triangular matrix.
+ * Input is factored matrix A=LU, integer array of pivot indices index[0->n-1], load vector x[0->n-1], and size of square matrix n.
+ * Note that A=LU and index[] are generated from method LUFactorLinearSystem.
+ * Also, solution vector is written directly over input load vector.
+ *
+ * @param {number[]} A Square matrix, column-major flat layout (pre-factored LU as produced by lu_factor_linear_system)
+ * @param {number[]|Uint32Array} index
+ * @param {number[]} x Load vector
+ * @param {number} size matrix size ( 4x4 matrix has size 4)
+ */
+export function lu_solve_linear_system(A, index, x, size) {
+    assert.isNonNegativeInteger(size, 'size');
+
+    let i = 0, j, ii = -1;
+
+    let sum;
+
+    // Proceed with forward and back-substitution for L and U matrices.
+
+    // First, forward substitution.
+    for (; i < size; ++i) {
+        const idx = index[i];
+        sum = x[idx];
+        x[idx] = x[i];
+
+        if (ii >= 0) {
+
+            for (j = ii; j <= i - 1; ++j) {
+                sum -= A[j * size + i] * x[j];
+            }
+
+        } else if (sum !== 0.0) {
+            ii = i;
+        }
+
+        x[i] = sum;
+    }
+
+    // Now, back substitution
+    for (i = size - 1; i >= 0; i--) {
+        sum = x[i];
+
+        for (j = i + 1; j < size; ++j) {
+            sum -= A[j * size + i] * x[j];
+        }
+
+        x[i] = sum / A[i * size + i];
+    }
+}

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

@@ -0,0 +1,18 @@
+/**
+ * Adds polynomial `a` into `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 sum, 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_add_into(target: number[] | Float64Array | Float32Array, target_len: number, a: number[] | Float64Array | Float32Array, a_len: number): number;
+//# sourceMappingURL=polynomial_add_into.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polynomial_add_into.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_add_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_add_into.js

@@ -0,0 +1,29 @@
+/**
+ * Adds polynomial `a` into `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 sum, 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_add_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/polynomial_complex_roots_aberth_ehrlich.d.ts

@@ -14,6 +14,11 @@
  * @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: Float64Array | number[], degree: number, roots_re: Float64Array | number[], roots_im: Float64Array | number[], offset: number): void;
+export function polynomial_complex_roots_aberth_ehrlich(coeffs: Float64Array | number[], degree: number, roots_re: Float64Array | number[], roots_im: Float64Array | number[], offset: number, max_iterations?: number): void;
 //# sourceMappingURL=polynomial_complex_roots_aberth_ehrlich.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"polynomial_complex_roots_aberth_ehrlich.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/polynomial_complex_roots_aberth_ehrlich.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gEAXW,YAAY,GAAC,MAAM,EAAE,UACrB,MAAM,YACN,YAAY,GAAC,MAAM,EAAE,YACrB,YAAY,GAAC,MAAM,EAAE,UACrB,MAAM,mBACN,MAAM,QAgHhB"}