@woosh/meep-engine 2.163.11 → 2.165.0

package/src/core/math/linalg/cg/cg_solve.js

@@ -0,0 +1,106 @@
+/**
+ * Module-static scratch vectors, grown on demand and reused across calls.
+ * The solver is therefore NOT re-entrant: `apply_A` must not itself call
+ * `cg_solve` (it may call lower-level matvecs freely).
+ */
+let _r = new Float64Array(0);
+let _p = new Float64Array(0);
+let _Ap = new Float64Array(0);
+
+/**
+ * Grow the module-static scratch vectors (`_r`, `_p`, `_Ap`) so each holds at
+ * least `n` entries. A no-op once they are large enough; existing contents are
+ * not preserved, since each `cg_solve` re-initializes them.
+ *
+ * @param {number} n required minimum length
+ */
+function ensure_scratch(n) {
+    if (_r.length < n) {
+        _r = new Float64Array(n);
+        _p = new Float64Array(n);
+        _Ap = new Float64Array(n);
+    }
+}
+
+/**
+ * Conjugate Gradient solve of `A x = b` for a symmetric positive-definite
+ * operator `A`, supplied as a matrix-free callback. This is the generic core
+ * shared by the cotangent-Laplacian harmonic solve and the LSCM normal
+ * equations (via {@link cg_solve_normal_equations}).
+ *
+ * `x` is both the initial guess and the output (warm-start it with a prior
+ * solution to cut iterations; zero-fill for a cold start). Convergence is the
+ * relative residual: the solve stops when `‖r‖ <= tolerance · ‖r0‖`.
+ *
+ * Determinism: reductions run in fixed index order with no wall-clock exit, so
+ * the result is bit-reproducible for a given `apply_A`.
+ *
+ * @param {Float64Array} x length n; initial guess in, solution out
+ * @param {(out: Float64Array, vec: Float64Array) => void} apply_A computes out = A·vec
+ *   over the first n entries
+ * @param {Float64Array} b right-hand side, length n
+ * @param {number} n system size
+ * @param {number} max_iterations hard cap on iterations
+ * @param {number} tolerance relative residual target in [0, 1]; 0 runs to max_iterations
+ * @returns {number} iterations performed
+ */
+export function cg_solve(x, apply_A, b, n, max_iterations, tolerance) {
+    ensure_scratch(n);
+
+    const r = _r;
+    const p = _p;
+    const Ap = _Ap;
+
+    apply_A(Ap, x);
+
+    let rs = 0;
+    for (let i = 0; i < n; i++) {
+        const ri = b[i] - Ap[i];
+        r[i] = ri;
+        p[i] = ri;
+        rs += ri * ri;
+    }
+
+    if (rs === 0) {
+        return 0;
+    }
+
+    const rs0 = rs;
+    const target = tolerance * tolerance * rs0;
+
+    for (let iter = 0; iter < max_iterations; iter++) {
+        apply_A(Ap, p);
+
+        let p_dot_Ap = 0;
+        for (let i = 0; i < n; i++) {
+            p_dot_Ap += p[i] * Ap[i];
+        }
+
+        if (p_dot_Ap === 0) {
+            return iter;
+        }
+
+        const alpha = rs / p_dot_Ap;
+
+        let rs_new = 0;
+        for (let i = 0; i < n; i++) {
+            x[i] += alpha * p[i];
+            const ri = r[i] - alpha * Ap[i];
+            r[i] = ri;
+            rs_new += ri * ri;
+        }
+
+        if (rs_new <= target) {
+            return iter + 1;
+        }
+
+        const beta = rs_new / rs;
+        for (let i = 0; i < n; i++) {
+            p[i] = r[i] + beta * p[i];
+        }
+
+        rs = rs_new;
+    }
+
+    return max_iterations;
+}

package/src/core/math/linalg/cg/cg_solve_normal_equations.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Least-squares solve of the overdetermined (or square) system `A x ≈ b` via
+ * the normal equations `AᵀA x = Aᵀb`, using {@link cg_solve} on the
+ * matrix-free operator `x ↦ Aᵀ(A x)`. `AᵀA` is symmetric positive
+ * semi-definite, and positive-definite when `A` has full column rank — which is
+ * the case for the LSCM conformal system once two vertices are pinned.
+ *
+ * The normal-equations operator squares the condition number of `A`, so this is
+ * appropriate for the well-conditioned, modest-size per-chart systems of UV
+ * parameterization; it is not a general-purpose least-squares routine for
+ * ill-conditioned problems.
+ *
+ * @param {Float64Array} x length A.cols; initial guess in, solution out
+ * @param {import("../sparse/SparseMatrixCSR.js").SparseMatrixCSR} A
+ * @param {Float64Array} b right-hand side, length A.rows
+ * @param {number} max_iterations
+ * @param {number} tolerance relative residual target for the normal equations
+ * @returns {number} iterations performed
+ */
+export function cg_solve_normal_equations(x: Float64Array, A: import("../sparse/SparseMatrixCSR.js").SparseMatrixCSR, b: Float64Array, max_iterations: number, tolerance: number): number;
+//# sourceMappingURL=cg_solve_normal_equations.d.ts.map

package/src/core/math/linalg/cg/cg_solve_normal_equations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cg_solve_normal_equations.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/cg/cg_solve_normal_equations.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;GAkBG;AACH,6CAPW,YAAY,KACZ,OAAO,8BAA8B,EAAE,eAAe,KACtD,YAAY,kBACZ,MAAM,aACN,MAAM,GACJ,MAAM,CA8BlB"}

package/src/core/math/linalg/cg/cg_solve_normal_equations.js

@@ -0,0 +1,59 @@
+import { spm_matvec } from "../sparse/spm_matvec.js";
+import { spm_matvec_transpose } from "../sparse/spm_matvec_transpose.js";
+import { cg_solve } from "./cg_solve.js";
+
+/**
+ * Module-static scratch for the intermediate `A x` (length rows) reused across
+ * calls. Like {@link cg_solve}, this is not re-entrant.
+ */
+let _Ax = new Float64Array(0);
+let _Atb = new Float64Array(0);
+
+/**
+ * Least-squares solve of the overdetermined (or square) system `A x ≈ b` via
+ * the normal equations `AᵀA x = Aᵀb`, using {@link cg_solve} on the
+ * matrix-free operator `x ↦ Aᵀ(A x)`. `AᵀA` is symmetric positive
+ * semi-definite, and positive-definite when `A` has full column rank — which is
+ * the case for the LSCM conformal system once two vertices are pinned.
+ *
+ * The normal-equations operator squares the condition number of `A`, so this is
+ * appropriate for the well-conditioned, modest-size per-chart systems of UV
+ * parameterization; it is not a general-purpose least-squares routine for
+ * ill-conditioned problems.
+ *
+ * @param {Float64Array} x length A.cols; initial guess in, solution out
+ * @param {import("../sparse/SparseMatrixCSR.js").SparseMatrixCSR} A
+ * @param {Float64Array} b right-hand side, length A.rows
+ * @param {number} max_iterations
+ * @param {number} tolerance relative residual target for the normal equations
+ * @returns {number} iterations performed
+ */
+export function cg_solve_normal_equations(x, A, b, max_iterations, tolerance) {
+    const rows = A.rows;
+    const cols = A.cols;
+
+    if (_Ax.length < rows) {
+        _Ax = new Float64Array(rows);
+    }
+    if (_Atb.length < cols) {
+        _Atb = new Float64Array(cols);
+    }
+
+    const Ax = _Ax;
+
+    // Right-hand side of the normal equations.
+    spm_matvec_transpose(_Atb, A, b);
+
+    /**
+     * Matrix-free normal-equations operator: `out = Aᵀ(A·vec)`.
+     *
+     * @param {Float64Array} out length A.cols; overwritten with AᵀA·vec
+     * @param {Float64Array} vec length A.cols
+     */
+    const apply_normal = (out, vec) => {
+        spm_matvec(Ax, A, vec);
+        spm_matvec_transpose(out, A, Ax);
+    };
+
+    return cg_solve(x, apply_normal, _Atb, cols, max_iterations, tolerance);
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Eigendecomposition of a symmetric 3x3 matrix via cyclic Jacobi rotations.
+ *
+ * Only the upper triangle of `m` is read (the matrix is assumed symmetric);
+ * the input is not modified. Eigenpairs are emitted sorted by **ascending
+ * eigenvalue**, so index 0 is the smallest — convenient for proxy-plane fits,
+ * where the plane normal is the eigenvector of the smallest variance.
+ *
+ * Eigenvector sign is arbitrary (an eigenvector and its negation are both
+ * valid); callers that need a consistent orientation must fix the sign
+ * themselves.
+ *
+ * @param {Float64Array|Float32Array|number[]} out_values length >= 3, eigenvalues ascending
+ * @param {Float64Array|Float32Array|number[]} out_vectors length >= 9, eigenvector k
+ *   in out_vectors[k*3 .. k*3 + 2] (column-major: contiguous per eigenvector)
+ * @param {Float64Array|Float32Array|number[]} m symmetric 3x3, row-major (index = row*3 + col)
+ */
+export function matrix_symmetric_3x3_eigen(out_values: Float64Array | Float32Array | number[], out_vectors: Float64Array | Float32Array | number[], m: Float64Array | Float32Array | number[]): void;
+//# sourceMappingURL=matrix_symmetric_3x3_eigen.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"matrix_symmetric_3x3_eigen.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_symmetric_3x3_eigen.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;;;;;GAgBG;AACH,uDALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,eAClC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAElC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,QAuC5C"}

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

@@ -0,0 +1,117 @@
+/**
+ * Maximum number of cyclic Jacobi sweeps. A symmetric 3x3 reaches full double
+ * precision in ~5-6 sweeps (Jacobi converges quadratically); 50 is a generous
+ * cap that the relative-off-diagonal early-out almost always beats.
+ * @type {number}
+ */
+const MAX_SWEEPS = 50;
+
+/**
+ * One Jacobi rotation in the (p, q) plane that zeroes the off-diagonal entry
+ * a[p][q]. `a` and `v` are 3x3 matrices stored row-major (index = row*3 + col).
+ * `a` is the symmetric working matrix; `v` accumulates the rotations so its
+ * columns become the eigenvectors.
+ *
+ * @param {number[]} a symmetric 3x3, mutated in place
+ * @param {number[]} v 3x3 rotation accumulator, mutated in place
+ * @param {number} p
+ * @param {number} q
+ */
+function jacobi_rotate(a, v, p, q) {
+    const apq = a[p * 3 + q];
+
+    if (apq === 0) {
+        return;
+    }
+
+    const app = a[p * 3 + p];
+    const aqq = a[q * 3 + q];
+
+    // tan of the rotation angle (Numerical Recipes form, |angle| <= pi/4).
+    const theta = (aqq - app) / (2 * apq);
+    const t = (theta >= 0)
+        ? 1 / (theta + Math.sqrt(theta * theta + 1))
+        : -1 / (-theta + Math.sqrt(theta * theta + 1));
+    const c = 1 / Math.sqrt(t * t + 1);
+    const s = t * c;
+
+    // The third (untouched) index.
+    const r = 3 - p - q;
+    const arp = a[r * 3 + p];
+    const arq = a[r * 3 + q];
+
+    a[p * 3 + p] = app - t * apq;
+    a[q * 3 + q] = aqq + t * apq;
+    a[p * 3 + q] = 0;
+    a[q * 3 + p] = 0;
+
+    const new_rp = c * arp - s * arq;
+    const new_rq = s * arp + c * arq;
+    a[r * 3 + p] = new_rp;
+    a[p * 3 + r] = new_rp;
+    a[r * 3 + q] = new_rq;
+    a[q * 3 + r] = new_rq;
+
+    for (let row = 0; row < 3; row++) {
+        const vrp = v[row * 3 + p];
+        const vrq = v[row * 3 + q];
+        v[row * 3 + p] = c * vrp - s * vrq;
+        v[row * 3 + q] = s * vrp + c * vrq;
+    }
+}
+
+/**
+ * Eigendecomposition of a symmetric 3x3 matrix via cyclic Jacobi rotations.
+ *
+ * Only the upper triangle of `m` is read (the matrix is assumed symmetric);
+ * the input is not modified. Eigenpairs are emitted sorted by **ascending
+ * eigenvalue**, so index 0 is the smallest — convenient for proxy-plane fits,
+ * where the plane normal is the eigenvector of the smallest variance.
+ *
+ * Eigenvector sign is arbitrary (an eigenvector and its negation are both
+ * valid); callers that need a consistent orientation must fix the sign
+ * themselves.
+ *
+ * @param {Float64Array|Float32Array|number[]} out_values length >= 3, eigenvalues ascending
+ * @param {Float64Array|Float32Array|number[]} out_vectors length >= 9, eigenvector k
+ *   in out_vectors[k*3 .. k*3 + 2] (column-major: contiguous per eigenvector)
+ * @param {Float64Array|Float32Array|number[]} m symmetric 3x3, row-major (index = row*3 + col)
+ */
+export function matrix_symmetric_3x3_eigen(out_values, out_vectors, m) {
+    const a = [
+        m[0], m[1], m[2],
+        m[1], m[4], m[5],
+        m[2], m[5], m[8],
+    ];
+    const v = [
+        1, 0, 0,
+        0, 1, 0,
+        0, 0, 1,
+    ];
+
+    for (let sweep = 0; sweep < MAX_SWEEPS; sweep++) {
+        const scale = Math.abs(a[0]) + Math.abs(a[4]) + Math.abs(a[8]);
+        const off = Math.abs(a[1]) + Math.abs(a[2]) + Math.abs(a[5]);
+
+        if (off <= 1e-18 * scale) {
+            break;
+        }
+
+        jacobi_rotate(a, v, 0, 1);
+        jacobi_rotate(a, v, 0, 2);
+        jacobi_rotate(a, v, 1, 2);
+    }
+
+    // Eigenvalues live on the diagonal; eigenvector k is column k of V.
+    const eig = [a[0], a[4], a[8]];
+    const order = [0, 1, 2];
+    order.sort((i, j) => eig[i] - eig[j]);
+
+    for (let k = 0; k < 3; k++) {
+        const col = order[k];
+        out_values[k] = eig[col];
+        out_vectors[k * 3 + 0] = v[0 * 3 + col];
+        out_vectors[k * 3 + 1] = v[1 * 3 + col];
+        out_vectors[k * 3 + 2] = v[2 * 3 + col];
+    }
+}

package/src/core/math/linalg/sparse/SparseMatrixCSR.d.ts

@@ -0,0 +1,50 @@
+/**
+ * An `m x n` sparse matrix in Compressed Sparse Row form.
+ *
+ * The three parallel arrays follow the standard CSR convention:
+ *   - `row_ptr[r]`   = start of row r's entries in `col_idx`/`values`
+ *   - `row_ptr[r+1]` = end (exclusive); `row_ptr[rows]` = nnz
+ *   - `col_idx[k]`   = column of entry k
+ *   - `values[k]`    = value of entry k
+ *
+ * Entries within a row are NOT required to be sorted by column, and duplicate
+ * (row, col) entries are permitted: matrix-vector products sum over a row, so
+ * duplicates simply accumulate — which is exactly what finite-element style
+ * assembly (many small per-element contributions to the same cell) wants. This
+ * is why {@link SparseMatrixCSR.from_triplets} performs no de-duplication pass.
+ *
+ * Fields are exposed directly (not via accessors) so hot matvec loops can run
+ * `for (let k = row_ptr[r]; k < row_ptr[r+1]; k++)` without closure overhead,
+ * mirroring {@link CSRGraph}.
+ */
+export class SparseMatrixCSR {
+    /**
+     * Build a CSR matrix from a triplet (coordinate) list. The triplet arrays
+     * are parallel; `count` entries are read. Duplicate (row, col) triplets are
+     * kept and will sum during matvec.
+     *
+     * @param {number} rows
+     * @param {number} cols
+     * @param {Uint32Array|number[]} triplet_rows
+     * @param {Uint32Array|number[]} triplet_cols
+     * @param {Float64Array|number[]} triplet_values
+     * @param {number} count number of triplets to read
+     * @returns {SparseMatrixCSR}
+     */
+    static from_triplets(rows: number, cols: number, triplet_rows: Uint32Array | number[], triplet_cols: Uint32Array | number[], triplet_values: Float64Array | number[], count: number): SparseMatrixCSR;
+    /**
+     * @param {number} rows
+     * @param {number} cols
+     * @param {Uint32Array} row_ptr length rows + 1
+     * @param {Uint32Array} col_idx length nnz
+     * @param {Float64Array} values length nnz
+     */
+    constructor(rows: number, cols: number, row_ptr: Uint32Array, col_idx: Uint32Array, values: Float64Array);
+    rows: number;
+    cols: number;
+    row_ptr: Uint32Array;
+    col_idx: Uint32Array;
+    values: Float64Array;
+    nnz: number;
+}
+//# sourceMappingURL=SparseMatrixCSR.d.ts.map

package/src/core/math/linalg/sparse/SparseMatrixCSR.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SparseMatrixCSR.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/sparse/SparseMatrixCSR.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAiBI;;;;;;;;;;;;OAYG;IACH,2BARW,MAAM,QACN,MAAM,gBACN,WAAW,GAAC,MAAM,EAAE,gBACpB,WAAW,GAAC,MAAM,EAAE,kBACpB,YAAY,GAAC,MAAM,EAAE,SACrB,MAAM,GACJ,eAAe,CAqC3B;IAhED;;;;;;OAMG;IACH,kBANW,MAAM,QACN,MAAM,WACN,WAAW,WACX,WAAW,UACX,YAAY,EAStB;IANG,aAAgB;IAChB,aAAgB;IAChB,qBAAsB;IACtB,qBAAsB;IACtB,qBAAoB;IACpB,YAAwB;CAoD/B"}

package/src/core/math/linalg/sparse/SparseMatrixCSR.js

@@ -0,0 +1,88 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * An `m x n` sparse matrix in Compressed Sparse Row form.
+ *
+ * The three parallel arrays follow the standard CSR convention:
+ *   - `row_ptr[r]`   = start of row r's entries in `col_idx`/`values`
+ *   - `row_ptr[r+1]` = end (exclusive); `row_ptr[rows]` = nnz
+ *   - `col_idx[k]`   = column of entry k
+ *   - `values[k]`    = value of entry k
+ *
+ * Entries within a row are NOT required to be sorted by column, and duplicate
+ * (row, col) entries are permitted: matrix-vector products sum over a row, so
+ * duplicates simply accumulate — which is exactly what finite-element style
+ * assembly (many small per-element contributions to the same cell) wants. This
+ * is why {@link SparseMatrixCSR.from_triplets} performs no de-duplication pass.
+ *
+ * Fields are exposed directly (not via accessors) so hot matvec loops can run
+ * `for (let k = row_ptr[r]; k < row_ptr[r+1]; k++)` without closure overhead,
+ * mirroring {@link CSRGraph}.
+ */
+export class SparseMatrixCSR {
+    /**
+     * @param {number} rows
+     * @param {number} cols
+     * @param {Uint32Array} row_ptr length rows + 1
+     * @param {Uint32Array} col_idx length nnz
+     * @param {Float64Array} values length nnz
+     */
+    constructor(rows, cols, row_ptr, col_idx, values) {
+        this.rows = rows;
+        this.cols = cols;
+        this.row_ptr = row_ptr;
+        this.col_idx = col_idx;
+        this.values = values;
+        this.nnz = values.length;
+    }
+
+    /**
+     * Build a CSR matrix from a triplet (coordinate) list. The triplet arrays
+     * are parallel; `count` entries are read. Duplicate (row, col) triplets are
+     * kept and will sum during matvec.
+     *
+     * @param {number} rows
+     * @param {number} cols
+     * @param {Uint32Array|number[]} triplet_rows
+     * @param {Uint32Array|number[]} triplet_cols
+     * @param {Float64Array|number[]} triplet_values
+     * @param {number} count number of triplets to read
+     * @returns {SparseMatrixCSR}
+     */
+    static from_triplets(rows, cols, triplet_rows, triplet_cols, triplet_values, count) {
+        assert.isNonNegativeInteger(rows, "rows");
+        assert.isNonNegativeInteger(cols, "cols");
+        assert.isNonNegativeInteger(count, "count");
+
+        const row_ptr = new Uint32Array(rows + 1);
+
+        // Counting sort by row. First tally each row's entry count into the
+        // shifted slot row_ptr[r + 1].
+        for (let i = 0; i < count; i++) {
+            const r = triplet_rows[i];
+            assert.ok(r < rows, "triplet row in range");
+            row_ptr[r + 1]++;
+        }
+
+        // Prefix-sum into row start offsets.
+        for (let r = 0; r < rows; r++) {
+            row_ptr[r + 1] += row_ptr[r];
+        }
+
+        const col_idx = new Uint32Array(count);
+        const values = new Float64Array(count);
+
+        // Scatter using a per-row write cursor seeded from the row starts.
+        const cursor = row_ptr.slice(0, rows);
+        for (let i = 0; i < count; i++) {
+            const r = triplet_rows[i];
+            const c = triplet_cols[i];
+            assert.ok(c < cols, "triplet col in range");
+            const dst = cursor[r]++;
+            col_idx[dst] = c;
+            values[dst] = triplet_values[i];
+        }
+
+        return new SparseMatrixCSR(rows, cols, row_ptr, col_idx, values);
+    }
+}

package/src/core/math/linalg/sparse/spm_matvec.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Sparse matrix-vector product: `out = A * x`.
+ *
+ * @param {Float64Array} out length >= A.rows; overwritten
+ * @param {import("./SparseMatrixCSR.js").SparseMatrixCSR} A
+ * @param {Float64Array} x length >= A.cols
+ */
+export function spm_matvec(out: Float64Array, A: import("./SparseMatrixCSR.js").SparseMatrixCSR, x: Float64Array): void;
+//# sourceMappingURL=spm_matvec.d.ts.map

package/src/core/math/linalg/sparse/spm_matvec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spm_matvec.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/sparse/spm_matvec.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,gCAJW,YAAY,KACZ,OAAO,sBAAsB,EAAE,eAAe,KAC9C,YAAY,QAgBtB"}

package/src/core/math/linalg/sparse/spm_matvec.js

@@ -0,0 +1,22 @@
+/**
+ * Sparse matrix-vector product: `out = A * x`.
+ *
+ * @param {Float64Array} out length >= A.rows; overwritten
+ * @param {import("./SparseMatrixCSR.js").SparseMatrixCSR} A
+ * @param {Float64Array} x length >= A.cols
+ */
+export function spm_matvec(out, A, x) {
+    const rows = A.rows;
+    const row_ptr = A.row_ptr;
+    const col_idx = A.col_idx;
+    const values = A.values;
+
+    for (let r = 0; r < rows; r++) {
+        const end = row_ptr[r + 1];
+        let sum = 0;
+        for (let k = row_ptr[r]; k < end; k++) {
+            sum += values[k] * x[col_idx[k]];
+        }
+        out[r] = sum;
+    }
+}

package/src/core/math/linalg/sparse/spm_matvec_transpose.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Transposed sparse matrix-vector product: `out = Aᵀ * x`.
+ *
+ * Walks A row-major and scatters each entry's contribution into the output
+ * column slot, so no explicit transpose of A is materialized.
+ *
+ * @param {Float64Array} out length >= A.cols; overwritten
+ * @param {import("./SparseMatrixCSR.js").SparseMatrixCSR} A
+ * @param {Float64Array} x length >= A.rows
+ */
+export function spm_matvec_transpose(out: Float64Array, A: import("./SparseMatrixCSR.js").SparseMatrixCSR, x: Float64Array): void;
+//# sourceMappingURL=spm_matvec_transpose.d.ts.map

package/src/core/math/linalg/sparse/spm_matvec_transpose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spm_matvec_transpose.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/sparse/spm_matvec_transpose.js"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,0CAJW,YAAY,KACZ,OAAO,sBAAsB,EAAE,eAAe,KAC9C,YAAY,QAoBtB"}

package/src/core/math/linalg/sparse/spm_matvec_transpose.js

@@ -0,0 +1,29 @@
+/**
+ * Transposed sparse matrix-vector product: `out = Aᵀ * x`.
+ *
+ * Walks A row-major and scatters each entry's contribution into the output
+ * column slot, so no explicit transpose of A is materialized.
+ *
+ * @param {Float64Array} out length >= A.cols; overwritten
+ * @param {import("./SparseMatrixCSR.js").SparseMatrixCSR} A
+ * @param {Float64Array} x length >= A.rows
+ */
+export function spm_matvec_transpose(out, A, x) {
+    const rows = A.rows;
+    const cols = A.cols;
+    const row_ptr = A.row_ptr;
+    const col_idx = A.col_idx;
+    const values = A.values;
+
+    for (let c = 0; c < cols; c++) {
+        out[c] = 0;
+    }
+
+    for (let r = 0; r < rows; r++) {
+        const xr = x[r];
+        const end = row_ptr[r + 1];
+        for (let k = row_ptr[r]; k < end; k++) {
+            out[col_idx[k]] += values[k] * xr;
+        }
+    }
+}