@woosh/meep-engine 2.135.0 → 2.138.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"cubic_residual_times_derivative_accumulate.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/linalg/cubic_residual_times_derivative_accumulate.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wEALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAClC,MAAM,UACN,MAAM,QAoBhB"}

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

@@ -0,0 +1,43 @@
+/**
+ * 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, coeffs, base, offset) {
+    const a0 = coeffs[base] - offset;
+    const a1 = coeffs[base + 1];
+    const a2 = coeffs[base + 2];
+    const a3 = coeffs[base + 3];
+
+    // p'(t) coefficients: e0 + e1*t + e2*t^2 = a1 + 2*a2*t + 3*a3*t^2
+    const e0 = a1;
+    const e1 = 2 * a2;
+    const e2 = 3 * a3;
+
+    // (a0 + a1 t + a2 t² + a3 t³) · (e0 + e1 t + e2 t²) accumulated coefficient by coefficient
+    out_quintic[0] += a0 * e0;
+    out_quintic[1] += a0 * e1 + a1 * e0;
+    out_quintic[2] += a0 * e2 + a1 * e1 + a2 * e0;
+    out_quintic[3] += a1 * e2 + a2 * e1 + a3 * e0;
+    out_quintic[4] += a2 * e2 + a3 * e1;
+    out_quintic[5] += a3 * e2;
+}

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

@@ -1,9 +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
+ * @param {SquareMatrix} mat column-major; modified in place
  * @return {T}
  */
 export function matrix_eigenvalues_in_place<T>(out: T, mat: SquareMatrix): T;

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

@@ -1 +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"}
+{"version":3,"file":"matrix_eigenvalues_in_place.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_eigenvalues_in_place.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,6EASC"}

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

@@ -5,9 +5,10 @@ import { matrix_qr_in_place } from "./matrix_qr_in_place.js";
 /**
  * list of eigen values square matrix (allow non-symmetric)
  * NOTE: Modifies input matrix
+ *
  * @template T extends ArrayLike<number>
  * @param {T} out
- * @param {SquareMatrix} mat
+ * @param {SquareMatrix} mat column-major; modified in place
  * @return {T}
  */
 export function matrix_eigenvalues_in_place(out, mat) {

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

@@ -1,9 +1,15 @@
 /**
- * NxN matrix Householder reduction
- * Return subfunction to upper Hessenberg matrix by Householder transformation
+ * NxN matrix Householder reduction to upper Hessenberg form via similarity
+ * transformations. After this routine, `a[c*n + r] == 0` for every `r > c+1`
+ * — i.e. only the main diagonal and the first sub-diagonal carry nonzeros
+ * below the diagonal.
+ *
+ * Inner loops are arranged so the hot accesses stream one column at a time
+ * (contiguous in column-major).
+ *
  * @see http://www-in.aut.ac.jp/~minemura/pub/Csimu/C/QRmethod.html
- * @param {number[]} a
+ * @param {number[]|Float64Array} a Square matrix, column-major flat layout (a[j*n + i] = row i, col j); modified in place
  * @param {number} n
  */
-export function matrix_householder_in_place(a: number[], n: number): void;
+export function matrix_householder_in_place(a: number[] | Float64Array, n: number): void;
 //# sourceMappingURL=matrix_householder_in_place.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"matrix_householder_in_place.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_householder_in_place.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,+CAHW,MAAM,EAAE,GAAC,YAAY,KACrB,MAAM,QA4GhB"}

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

@@ -1,98 +1,122 @@
-const EPSILON = 1e-10;
-
-/**
- * NxN matrix Householder reduction
- * Return subfunction to upper Hessenberg matrix by Householder transformation
- * @see http://www-in.aut.ac.jp/~minemura/pub/Csimu/C/QRmethod.html
- * @param {number[]} a
- * @param {number} n
- */
-export function matrix_householder_in_place(a, n) {
-    const u = new Float64Array(n);
-    const d = new Float64Array(n);
-    const ds = new Float64Array(n);
-
-    let i, j, k;
-    let sum;
-
-    for (k = 0; k <= n - 3; k++) {
-
-        for (i = 0; i <= k; i++) {
-            u[i] = 0;
-        }
-
-        for (i = k + 1; i < n; i++) {
-            u[i] = a[n * i + k];
-        }
-
-        // Build transformation matrix H
-        sum = 0.0;
-
-        for (i = k + 1; i < n; i++) {
-            sum = sum + u[i] * u[i];
-        }
-
-        if (sum < EPSILON * EPSILON) {
-            // sub-column already zero — nothing to reduce at this k
-            continue;
-        }
-
-        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;
-
-        const v_norm = Math.sqrt(2.0 * sigma * u[k + 1]);
-
-        for (i = k + 1; i < n; i++) {
-            u[i] /= v_norm;
-        }
-
-        // Similarity transformation
-        for (i = 0; i < n; i++) {
-            d[i] = 0.0;
-            ds[i] = 0.0;
-            for (j = k + 1; j <= n - 1; j++) {
-                const u_j = u[j];
-
-                d[i] += a[n * i + j] * u_j;
-                ds[i] += a[n * j + i] * u_j;
-            }
-        }
-
-        let ud = 0.0;
-        let uds = 0.0;
-
-        for (i = k + 1; i < n; i++) {
-            const u_i = u[i];
-
-            ud += u_i * d[i];
-            uds += u_i * ds[i];
-        }
-
-        for (i = 0; i < n; i++) {
-            const u_i = u[i];
-
-            d[i] = 2.0 * (d[i] - ud * u_i);
-            ds[i] = 2.0 * (ds[i] - uds * u_i);
-        }
-
-        for (i = 0; i < n; i++) {
-            const u_i = u[i];
-            const d_i = d[i];
-
-            const n_i = n * i;
-
-            for (j = 0; j < n; j++) {
-                a[n_i + j] -= u_i * ds[j] + d_i * u[j];
-            }
-        }
-    }
-}
+const EPSILON = 1e-10;
+
+/**
+ * NxN matrix Householder reduction to upper Hessenberg form via similarity
+ * transformations. After this routine, `a[c*n + r] == 0` for every `r > c+1`
+ * — i.e. only the main diagonal and the first sub-diagonal carry nonzeros
+ * below the diagonal.
+ *
+ * Inner loops are arranged so the hot accesses stream one column at a time
+ * (contiguous in column-major).
+ *
+ * @see http://www-in.aut.ac.jp/~minemura/pub/Csimu/C/QRmethod.html
+ * @param {number[]|Float64Array} a Square matrix, column-major flat layout (a[j*n + i] = row i, col j); modified in place
+ * @param {number} n
+ */
+export function matrix_householder_in_place(a, n) {
+    const u = new Float64Array(n);
+    const d = new Float64Array(n);
+    const ds = new Float64Array(n);
+
+    let i, j, k;
+    let sum;
+
+    for (k = 0; k <= n - 3; k++) {
+
+        const kOff = k * n;
+
+        for (i = 0; i <= k; i++) {
+            u[i] = 0;
+        }
+
+        // Read the sub-diagonal of column k. With column-major storage, this
+        // is contiguous in memory.
+        for (i = k + 1; i < n; i++) {
+            u[i] = a[kOff + i];
+        }
+
+        // Build transformation vector
+        sum = 0.0;
+
+        for (i = k + 1; i < n; i++) {
+            sum = sum + u[i] * u[i];
+        }
+
+        if (sum < EPSILON * EPSILON) {
+            // sub-column already zero — nothing to reduce at this k
+            continue;
+        }
+
+        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;
+
+        const v_norm = Math.sqrt(2.0 * sigma * u[k + 1]);
+
+        for (i = k + 1; i < n; i++) {
+            u[i] /= v_norm;
+        }
+
+        // Similarity transformation A := (I - 2uuᵀ) A (I - 2uuᵀ).
+        // Compute d = A u (matrix-vector with column-major: outer over j,
+        // inner over i streams one column at a time).
+        for (i = 0; i < n; i++) {
+            d[i] = 0.0;
+        }
+        for (j = k + 1; j < n; j++) {
+            const u_j = u[j];
+            const jOff = j * n;
+            for (i = 0; i < n; i++) {
+                d[i] += a[jOff + i] * u_j;
+            }
+        }
+
+        // Compute ds = Aᵀ u. In column-major, row i of Aᵀ is column i of A,
+        // which is contiguous starting at i*n. So the inner loop streams one
+        // column.
+        for (i = 0; i < n; i++) {
+            let s = 0.0;
+            const iOff = i * n;
+            for (j = k + 1; j < n; j++) {
+                s += a[iOff + j] * u[j];
+            }
+            ds[i] = s;
+        }
+
+        let ud = 0.0;
+        let uds = 0.0;
+
+        for (i = k + 1; i < n; i++) {
+            const u_i = u[i];
+
+            ud += u_i * d[i];
+            uds += u_i * ds[i];
+        }
+
+        for (i = 0; i < n; i++) {
+            const u_i = u[i];
+
+            d[i] = 2.0 * (d[i] - ud * u_i);
+            ds[i] = 2.0 * (ds[i] - uds * u_i);
+        }
+
+        // Outer-product update A -= u·dsᵀ + d·uᵀ. Walk one column j at a time
+        // (inner i is contiguous within column j).
+        for (j = 0; j < n; j++) {
+            const u_j = u[j];
+            const ds_j = ds[j];
+            const jOff = j * n;
+            for (i = 0; i < n; i++) {
+                a[jOff + i] -= u[i] * ds_j + d[i] * u_j;
+            }
+        }
+    }
+}

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

@@ -8,8 +8,8 @@
  * 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[]|Float64Array} a Square matrix, column-major flat layout (a[j*n + i] = row i, col j); modified in place (R is left on the upper triangle)
  * @param {number} n size of the matrix in single dimension
  */
-export function matrix_qr_in_place(a: number[], n: number): void;
+export function matrix_qr_in_place(a: number[] | Float64Array, n: number): void;
 //# sourceMappingURL=matrix_qr_in_place.d.ts.map

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

@@ -1 +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"}
+{"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,GAAC,YAAY,KACrB,MAAM,QAkIhB"}

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

@@ -1,124 +1,144 @@
-const EPSILON = 1e-10;
-
-/**
- * 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, n) {
-    const q = new Float64Array(n * n);
-    const w = new Float64Array(n);
-
-    let mu, wa, sinx, cosx, sum1, sum2;
-    let m = n;
-
-    let i, j, k;
-
-    while (m > 1) {
-        const a10_index = n * (m - 1) + m - 2;
-
-        const a10 = a[a10_index];
-
-        //   Convergence test
-        if (Math.abs(a10) < EPSILON) {
-            m = m - 1;
-            continue;
-        }
-
-        //   Origin movement mu (compute Wilkinson's shift)
-        const a00 = a[n * (m - 2) + m - 2];
-        const a01 = a[n * (m - 2) + m - 1];
-        const a11 = a[n * (m - 1) + m - 1];
-
-        sum1 = a00 + a11;
-        sum2 = a00 * a11 - a01 * a10;
-
-        wa = sum1 * sum1 - 4.0 * sum2;
-        if (wa < 0.0) {
-            wa = 0.0;
-        } else {
-            wa = Math.sqrt(wa);
-        }
-
-        const lam1 = 0.5 * (sum1 + wa);
-        const lam2 = sum2 / lam1;
-
-        if (Math.abs(a11 - lam1) < Math.abs(a11 - lam2)) {
-            mu = a11 - lam1;
-        } else {
-            mu = a11 - lam2;
-        }
-
-        for (i = 0; i < m; i++) {
-            a[n * i + i] -= mu;
-        }
-
-        //   QR decomposition, A becomes R
-        for (i = 0; i < m * m; i++) {
-            q[i] = 0.0;
-        }
-        for (i = 0; i < m; i++) {
-            q[m * i + i] = 1.0;
-        }
-
-        for (i = 0; i < m - 1; i++) {
-            sum1 = Math.sqrt(a[n * i + i] * a[n * i + i] + a[n * i + n + i] * a[n * i + n + i]);
-
-            if (Math.abs(sum1) < EPSILON) {
-                sinx = 0.0;
-                cosx = 0.0;
-            } else {
-                sinx = a[n * i + n + i] / sum1;
-                cosx = a[n * i + i] / sum1;
-            }
-
-            for (j = i + 1; j < m; j++) {
-                sum2 = a[n * i + j] * cosx + a[n * i + n + j] * sinx;
-                a[n * i + n + j] = -a[n * i + j] * sinx + a[n * i + n + j] * cosx;
-                a[n * i + j] = sum2;
-            }
-
-            a[n * i + n + i] = 0.0;
-            a[n * i + i] = sum1;
-
-            for (j = 0; j < m; j++) {
-                const m_j = m * j;
-
-                sum2 = q[m_j + i] * cosx + q[m_j + i + 1] * sinx;
-                q[m_j + i + 1] = -q[m_j + i] * sinx + q[m_j + i + 1] * cosx;
-                q[m_j + i] = sum2;
-            }
-
-        }
-
-        for (i = 0; i < m; i++) {
-            const n_i = n * i;
-
-            for (j = i; j < m; j++) {
-                w[j] = a[n_i + j];
-            }
-
-            for (j = 0; j < m; j++) {
-                sum1 = 0.0;
-
-                for (k = i; k < m; k++) {
-                    sum1 += w[k] * q[m * k + j];
-                }
-
-                a[n_i + j] = sum1;
-            }
-        }
-
-        for (i = 0; i < m; i++) {
-            a[n * i + i] += mu;
-        }
-    }
-}
+const EPSILON = 1e-10;
+
+/**
+ * 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[]|Float64Array} a Square matrix, column-major flat layout (a[j*n + i] = row i, col j); modified in place (R is left on the upper triangle)
+ * @param {number} n size of the matrix in single dimension
+ */
+export function matrix_qr_in_place(a, n) {
+    const q = new Float64Array(n * n);
+    const w = new Float64Array(n);
+
+    let mu, wa, sinx, cosx, sum1, sum2;
+    let m = n;
+
+    let i, j, k;
+
+    while (m > 1) {
+        // a[m-1, m-2] in column-major: (m-2)*n + (m-1)
+        const a10_index = (m - 2) * n + (m - 1);
+
+        const a10 = a[a10_index];
+
+        //   Convergence test
+        if (Math.abs(a10) < EPSILON) {
+            m = m - 1;
+            continue;
+        }
+
+        //   Origin movement mu (compute Wilkinson's shift)
+        const a00 = a[(m - 2) * n + (m - 2)];
+        const a01 = a[(m - 1) * n + (m - 2)];
+        const a11 = a[(m - 1) * n + (m - 1)];
+
+        sum1 = a00 + a11;
+        sum2 = a00 * a11 - a01 * a10;
+
+        wa = sum1 * sum1 - 4.0 * sum2;
+        if (wa < 0.0) {
+            wa = 0.0;
+        } else {
+            wa = Math.sqrt(wa);
+        }
+
+        const lam1 = 0.5 * (sum1 + wa);
+        const lam2 = sum2 / lam1;
+
+        if (Math.abs(a11 - lam1) < Math.abs(a11 - lam2)) {
+            mu = a11 - lam1;
+        } else {
+            mu = a11 - lam2;
+        }
+
+        // Subtract mu from diagonal
+        for (i = 0; i < m; i++) {
+            a[i * n + i] -= mu;
+        }
+
+        //   QR decomposition, A becomes R
+        for (i = 0; i < m * m; i++) {
+            q[i] = 0.0;
+        }
+        for (i = 0; i < m; i++) {
+            q[i * m + i] = 1.0;
+        }
+
+        for (i = 0; i < m - 1; i++) {
+            // diagonal a[i, i] at i*n + i; sub-diagonal a[i+1, i] at i*n + (i+1)
+            const diag = a[i * n + i];
+            const subdiag = a[i * n + i + 1];
+
+            sum1 = Math.sqrt(diag * diag + subdiag * subdiag);
+
+            if (Math.abs(sum1) < EPSILON) {
+                sinx = 0.0;
+                cosx = 0.0;
+            } else {
+                sinx = subdiag / sum1;
+                cosx = diag / sum1;
+            }
+
+            // Rotate rows i and i+1 of A for columns j > i. In column-major,
+            // those two row entries within column j live at adjacent offsets
+            // (j*n + i, j*n + i+1) — contiguous within each column.
+            for (j = i + 1; j < m; j++) {
+                const jOff = j * n;
+                const a_ij = a[jOff + i];
+                const a_i1j = a[jOff + i + 1];
+                sum2 = a_ij * cosx + a_i1j * sinx;
+                a[jOff + i + 1] = -a_ij * sinx + a_i1j * cosx;
+                a[jOff + i] = sum2;
+            }
+
+            a[i * n + i + 1] = 0.0;
+            a[i * n + i] = sum1;
+
+            // Accumulate the rotation into Q. In the original (row-major) the
+            // inner loop walked j over rows of q, touching (q[j, i], q[j, i+1])
+            // — which is two columns of q. In column-major those columns are
+            // contiguous: i*m..i*m+m-1 and (i+1)*m..(i+1)*m+m-1.
+            const qiOff = i * m;
+            const qi1Off = (i + 1) * m;
+            for (j = 0; j < m; j++) {
+                const q_ji = q[qiOff + j];
+                const q_ji1 = q[qi1Off + j];
+                sum2 = q_ji * cosx + q_ji1 * sinx;
+                q[qi1Off + j] = -q_ji * sinx + q_ji1 * cosx;
+                q[qiOff + j] = sum2;
+            }
+        }
+
+        // A := R * Q. Cache row i of R into w (since R is upper-triangular
+        // we only need k >= i), then compute the new row i of A. With
+        // column-major a, reading row i is strided — accept it; m is small.
+        for (i = 0; i < m; i++) {
+            for (j = i; j < m; j++) {
+                w[j] = a[j * n + i];
+            }
+
+            for (j = 0; j < m; j++) {
+                sum1 = 0.0;
+
+                const qjOff = j * m;
+                for (k = i; k < m; k++) {
+                    sum1 += w[k] * q[qjOff + k];
+                }
+
+                a[j * n + i] = sum1;
+            }
+        }
+
+        // Add mu back to diagonal
+        for (i = 0; i < m; i++) {
+            a[i * n + i] += mu;
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+/**
+ * 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: Float64Array | number[], row_j: Float64Array | number[], c: number, s: number, n: number): void;
+//# sourceMappingURL=givens_apply_rows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"givens_apply_rows.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/givens/givens_apply_rows.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,yCANW,YAAY,GAAC,MAAM,EAAE,SACrB,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,KACN,MAAM,KACN,MAAM,QAShB"}