@danielsimonjr/mathts-matrix 0.7.0 → 0.7.2

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,cAAc,kBAAkB,CAAC;AAGjC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,uBAAuB,CAAC;AAGtC,cAAc,uBAAuB,CAAC;AAItC,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   __esm,
   __export,
   __toCommonJS
-} from "./chunk-4VMDO6W2.js";
+} from "./chunk-PNKVD2UK.js";
 
 // src/types/Matrix.ts
 function isMatrix(value) {
@@ -2499,7 +2499,7 @@ var WASMBackend = class {
    */
   async resolveAsWasmPath() {
     const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
-    const { resolvePackagedWasm, defaultWasmLocation } = await import("./resolve-DDCEWHWX.js");
+    const { resolvePackagedWasm, defaultWasmLocation } = await import("./resolve-2SX6WJ6R.js");
     if (isNode) {
       const found = await resolvePackagedWasm(import.meta.url, "mathts-as.wasm");
       if (found) return found;
@@ -2525,7 +2525,7 @@ var WASMBackend = class {
       Date
     };
     const isNode = typeof process !== "undefined" && process.versions?.node !== void 0;
-    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-LIWCCDIJ.js");
+    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-IBNQNHXP.js");
     let instance;
     if (isNode) {
       const fs = await import("fs");
@@ -4289,7 +4289,7 @@ var WasmLoader = class _WasmLoader {
     if (this.compiledModule) return;
     const path = wasmPath || await this.getDefaultWasmPath();
     const startTime = performance.now();
-    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-LIWCCDIJ.js");
+    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-IBNQNHXP.js");
     if (this.isNode) {
       const fs = await import("fs");
       const { promisify } = await import("util");
@@ -4350,20 +4350,20 @@ var WasmLoader = class _WasmLoader {
   async getDefaultWasmPath() {
     const wasmFile = "mathts-as.wasm";
     if (this.isNode) {
-      const { resolvePackagedWasm } = await import("./resolve-DDCEWHWX.js");
+      const { resolvePackagedWasm } = await import("./resolve-2SX6WJ6R.js");
       const found = await resolvePackagedWasm(import.meta.url, wasmFile);
       if (found) return found;
-      const { defaultWasmLocation: defaultWasmLocation2 } = await import("./resolve-DDCEWHWX.js");
+      const { defaultWasmLocation: defaultWasmLocation2 } = await import("./resolve-2SX6WJ6R.js");
       return defaultWasmLocation2(import.meta.url, wasmFile);
     }
-    const { defaultWasmLocation } = await import("./resolve-DDCEWHWX.js");
+    const { defaultWasmLocation } = await import("./resolve-2SX6WJ6R.js");
     return defaultWasmLocation(import.meta.url, wasmFile, { browser: true });
   }
   async loadNodeWasm(path, totalStart) {
     const fs = await import("fs");
     const { promisify } = await import("util");
     const readFile = promisify(fs.readFile);
-    const { verifyWasmIntegrity } = await import("./integrity-LIWCCDIJ.js");
+    const { verifyWasmIntegrity } = await import("./integrity-IBNQNHXP.js");
     const readStart = performance.now();
     const buffer = await readFile(path);
     const readEnd = performance.now();
@@ -4384,7 +4384,7 @@ var WasmLoader = class _WasmLoader {
     return instance.exports;
   }
   async loadBrowserWasm(path, totalStart) {
-    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-LIWCCDIJ.js");
+    const { loadWasmManifest, verifyWasmIntegrity } = await import("./integrity-IBNQNHXP.js");
     const manifest = await loadWasmManifest(path);
     if (!manifest && typeof WebAssembly.instantiateStreaming === "function") {
       const instStart2 = performance.now();

package/dist/{integrity-LIWCCDIJ.js → integrity-IBNQNHXP.js}

@@ -1,4 +1,4 @@
-import "./chunk-4VMDO6W2.js";
+import "./chunk-PNKVD2UK.js";
 
 // src/backends/wasm/integrity.ts
 import {

package/dist/operations/cholesky.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Cholesky Decomposition (DenseMatrix primitive)
+ *
+ * Right-looking algorithm. Factorises a symmetric positive-definite (SPD)
+ * matrix A into A = L · Lᵀ where L is lower-triangular.
+ *
+ * Usage:
+ *   const { L } = cholesky(A);
+ *   // A ≈ L · L^T  (to floating-point precision)
+ */
+import { DenseMatrix } from '../types/DenseMatrix.js';
+export interface CholeskyResult {
+    /** Lower-triangular Cholesky factor L such that A = L · Lᵀ. */
+    L: DenseMatrix;
+}
+/**
+ * Compute the Cholesky decomposition of the symmetric positive-definite
+ * `DenseMatrix` A such that A = L · Lᵀ.
+ *
+ * @throws {Error} if `A` is not square.
+ * @throws {Error} if `A` is not positive definite (non-positive diagonal pivot).
+ */
+export declare function cholesky(A: DenseMatrix): CholeskyResult;
+//# sourceMappingURL=cholesky.d.ts.map

package/dist/operations/cholesky.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cholesky.d.ts","sourceRoot":"","sources":["../../src/operations/cholesky.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,MAAM,WAAW,cAAc;IAC7B,+DAA+D;IAC/D,CAAC,EAAE,WAAW,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,WAAW,GAAG,cAAc,CA+BvD"}

package/dist/operations/common.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Shared decomposition helpers (number[][] dense algebra)
+ *
+ * Canonical home for small matrix utilities that were previously duplicated
+ * across the decomposition modules (eig, svd, schur, expm, logm, sqrtm). All
+ * functions operate on plain 2-D `number[][]` arrays and are behavior-identical
+ * to the per-file copies they replace.
+ *
+ * NOTE on `householder`: the degenerate "x is a negative multiple of e_1"
+ * branch returns a parameterized `beta`. eig/svd use `beta = -2` (the default);
+ * schur deliberately uses `beta = 2` (H = I − 2·e_1·e_1ᵀ = diag(−1, 1, …, 1)).
+ * This intentional divergence is preserved by passing the desired value.
+ */
+/** Create an n × n identity matrix. */
+export declare function eye(n: number): number[][];
+/** Clone a matrix (deep copy of rows). */
+export declare function cloneMatrix(A: number[][]): number[][];
+/** Transpose a matrix. */
+export declare function transpose(A: number[][]): number[][];
+/**
+ * Check if a matrix is symmetric to within tolerance.
+ * Returns true for empty matrices; false for non-square matrices.
+ */
+export declare function isSymmetric(matrix: number[][], tolerance?: number): boolean;
+/** Matrix multiply C = A × B. */
+export declare function matMul(A: number[][], B: number[][]): number[][];
+/** Matrix addition A + B (square inputs). */
+export declare function matAdd(A: number[][], B: number[][]): number[][];
+/** Matrix subtraction A − B (square inputs). */
+export declare function matSub(A: number[][], B: number[][]): number[][];
+/** Scalar multiply: c · A. */
+export declare function matScale(A: number[][], c: number): number[][];
+/** Infinity-norm proxy (max absolute entry). */
+export declare function normInf(A: number[][]): number;
+/** 1-norm of a matrix (max column sum of absolute values). */
+export declare function norm1(A: number[][]): number;
+/**
+ * Compute the Householder reflection vector for a column.
+ *
+ * For the degenerate case where `x` is a negative multiple of e_1
+ * (`sigma === 0 && x[0] < 0`), the returned `beta` is `degenerateBeta`:
+ *   - eig / svd use the default `-2`.
+ *   - schur passes `2` (its deliberate divergence — see module header).
+ */
+export declare function householder(x: number[], degenerateBeta?: number): {
+    v: number[];
+    beta: number;
+};
+/**
+ * Apply Householder reflection from the left: H = I − beta·v·vᵀ, computing
+ * H·A in-place over columns [startCol, A[0].length) and rows starting at
+ * `startRow` for `v.length` rows.
+ */
+export declare function applyHouseholderLeft(A: number[][], v: number[], beta: number, startRow: number, startCol: number): void;
+/**
+ * Apply Householder reflection from the right: H = I − beta·v·vᵀ, computing
+ * A·H in-place over rows [startRow, A.length) and columns starting at
+ * `startCol` for `v.length` columns.
+ */
+export declare function applyHouseholderRight(A: number[][], v: number[], beta: number, startRow: number, startCol: number): void;
+//# sourceMappingURL=common.d.ts.map

package/dist/operations/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../src/operations/common.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH,uCAAuC;AACvC,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAIzC;AAED,0CAA0C;AAC1C,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAErD;AAED,0BAA0B;AAC1B,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAInD;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,SAAS,GAAE,MAAc,GAAG,OAAO,CAalF;AAMD,iCAAiC;AACjC,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAa/D;AAED,6CAA6C;AAC7C,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAK/D;AAED,gDAAgD;AAChD,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAK/D;AAED,8BAA8B;AAC9B,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAE7D;AAED,gDAAgD;AAChD,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,CAI7C;AAED,8DAA8D;AAC9D,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,CAU3C;AAMD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,CAAC,EAAE,MAAM,EAAE,EACX,cAAc,GAAE,MAAW,GAC1B;IAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CA4B/B;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,CAAC,EAAE,MAAM,EAAE,EAAE,EACb,CAAC,EAAE,MAAM,EAAE,EACX,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,IAAI,CAcN;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,MAAM,EAAE,EAAE,EACb,CAAC,EAAE,MAAM,EAAE,EACX,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf,IAAI,CAcN"}

package/dist/operations/condest.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Condition-number ESTIMATE (Hager/Higham 1-norm power-iteration estimator)
+ *
+ * Estimates `‖A‖₁ · ‖A⁻¹‖₁` without ever forming `A⁻¹` explicitly — Hager's
+ * algorithm (Hager 1984; Higham 1988's practical refinement) needs only the
+ * ability to apply `A⁻¹` and `A⁻ᵀ` to a vector, which is done here via the
+ * existing `lu()` primitive's triangular factors (forward/back substitution,
+ * O(n²) per application vs. O(n³) to form `A⁻¹` or run the SVD-based exact
+ * `cond()` in `svd.ts`). The result is an ESTIMATE — typically a lower bound
+ * on the true `‖A⁻¹‖₁`, usually within a small constant factor — not the
+ * exact value.
+ */
+import { DenseMatrix } from '../types/DenseMatrix.js';
+/**
+ * Estimate the 1-norm condition number `‖A‖₁ · ‖A⁻¹‖₁` of a square matrix.
+ *
+ * This is an ESTIMATE (Hager/Higham power iteration), not the exact
+ * condition number that `cond()` (in `svd.ts`) computes via a full SVD —
+ * `condest` is O(n²)-per-iteration and avoids forming `A⁻¹`, at the cost of
+ * being a (typically close) lower-bound estimate rather than an exact value.
+ *
+ * @param A - Square input matrix.
+ * @param p - Only the 1-norm (`p = 1`, the default) is currently implemented.
+ * @throws {Error} if `A` is not square, or `p !== 1`.
+ */
+export declare function condest(A: DenseMatrix, p?: number): number;
+//# sourceMappingURL=condest.d.ts.map

package/dist/operations/condest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"condest.d.ts","sourceRoot":"","sources":["../../src/operations/condest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAuGtD;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,GAAE,MAAU,GAAG,MAAM,CAuC7D"}

package/dist/operations/eig-wasm.d.ts

@@ -0,0 +1,35 @@
+/**
+ * `eigWasm` / `eigvalsWasm` / `spectralRadiusWasm` — thin wrappers kept for API
+ * compatibility (consumed by `tensor` and `linalg`).
+ *
+ * The WASM eig path was RETIRED and REMOVED (2026-07-01): the AssemblyScript Jacobi
+ * (symmetric) / Hessenberg+Francis (general) kernels were scalar + async and measured
+ * 0.2–0.7× of the pure-JS path, worsening with size (~5× slower at 128²) — see
+ * `tools/benchmarks/decomp-audit`. Since a genuinely fast version would be a from-scratch
+ * SIMD implementation (not the removed scalar code), these now simply delegate to the
+ * synchronous JS `eig` / `eigvals` / `powerIteration`. The `async` signature is retained so
+ * existing callers (which `await`) are unaffected.
+ *
+ * @packageDocumentation
+ */
+import { type EigResult, type EigOptions } from './eig.js';
+/**
+ * Eigendecomposition. Delegates to the JS {@link eig} (WASM path retired — see file header).
+ */
+export declare function eigWasm(matrix: number[][], options?: EigOptions): Promise<EigResult>;
+/**
+ * Eigenvalues only. Delegates to the JS {@link eigvals} (WASM path retired).
+ */
+export declare function eigvalsWasm(matrix: number[][], options?: Omit<EigOptions, 'computeVectors'>): Promise<Array<{
+    re: number;
+    im: number;
+}>>;
+/**
+ * Spectral radius (|largest eigenvalue|). Delegates to the JS {@link powerIteration}
+ * (WASM path retired).
+ */
+export declare function spectralRadiusWasm(matrix: number[][], options?: {
+    maxIterations?: number;
+    tolerance?: number;
+}): Promise<number>;
+//# sourceMappingURL=eig-wasm.d.ts.map

package/dist/operations/eig-wasm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eig-wasm.d.ts","sourceRoot":"","sources":["../../src/operations/eig-wasm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAgC,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAEzF;;GAEG;AACH,wBAAsB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAW1F;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,gBAAgB,CAAC,GAC3C,OAAO,CAAC,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAE5C;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,OAAO,CAAC,EAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GACvD,OAAO,CAAC,MAAM,CAAC,CAGjB"}

package/dist/operations/eig.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Eigenvalue and Eigenvector Decomposition
+ *
+ * Implements eigenvalue computation using QR algorithm and
+ * eigenvector extraction using inverse iteration.
+ */
+/**
+ * Result of eigenvalue decomposition
+ */
+export interface EigResult {
+    /** Eigenvalues (may be complex for non-symmetric matrices) */
+    values: Array<{
+        re: number;
+        im: number;
+    }>;
+    /**
+     * Eigenvectors as columns (each column is an eigenvector). For a real
+     * eigenvalue this is the full (real) eigenvector, unit-normalised. For a
+     * complex-conjugate eigenvalue pair this holds the REAL PART of the
+     * corresponding complex eigenvector — see {@link vectorsIm} for the
+     * imaginary part.
+     */
+    vectors: number[][];
+    /**
+     * Imaginary parts of the eigenvector columns (same shape as {@link vectors}).
+     * All-zero for real eigenvalues. For a complex-conjugate eigenvalue pair at
+     * indices `j`/`j+1`, the full complex eigenvectors are
+     * `vectors[j] + i*vectorsIm[j]` (for `values[j]`) and
+     * `vectors[j+1] - i*vectorsIm[j] === vectors[j+1] + i*vectorsIm[j+1]` (for
+     * the conjugate `values[j+1]`), each unit-normalised by the complex 2-norm
+     * `sqrt(sum(re_i^2 + im_i^2))`.
+     */
+    vectorsIm: number[][];
+    /** Whether the matrix was symmetric */
+    isSymmetric: boolean;
+}
+/**
+ * Options for eigenvalue computation
+ */
+export interface EigOptions {
+    /** Maximum number of QR iterations */
+    maxIterations?: number;
+    /** Convergence tolerance */
+    tolerance?: number;
+    /** Whether to compute eigenvectors */
+    computeVectors?: boolean;
+}
+/**
+ * Compute eigenvalues and eigenvectors of a square matrix
+ * Uses QR algorithm with implicit shifts
+ *
+ * @param matrix - Square matrix (n x n)
+ * @param options - Computation options
+ * @returns Eigenvalues and eigenvectors
+ */
+export declare function eig(matrix: number[][] | Float64Array, options?: EigOptions): EigResult;
+/**
+ * Compute only eigenvalues (faster, no eigenvector computation)
+ */
+export declare function eigvals(matrix: number[][] | Float64Array, options?: Omit<EigOptions, 'computeVectors'>): Array<{
+    re: number;
+    im: number;
+}>;
+/**
+ * Power iteration for dominant eigenvalue
+ * Faster than full eigendecomposition when only largest eigenvalue needed
+ */
+export declare function powerIteration(matrix: number[][], options?: {
+    maxIterations?: number;
+    tolerance?: number;
+}): {
+    value: number;
+    vector: number[];
+};
+//# sourceMappingURL=eig.d.ts.map

package/dist/operations/eig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eig.d.ts","sourceRoot":"","sources":["../../src/operations/eig.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,8DAA8D;IAC9D,MAAM,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC1C;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IACpB;;;;;;;;OAQG;IACH,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,uCAAuC;IACvC,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,sCAAsC;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4BAA4B;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sCAAsC;IACtC,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AA+hBD;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,YAAY,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,CAiD1F;AAED;;GAEG;AACH,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,YAAY,EACjC,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,gBAAgB,CAAC,GAC3C,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAEnC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,OAAO,GAAE;IAAE,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAC3D;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAsCrC"}

package/dist/operations/expm.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Matrix Exponential — Scaling-and-Squaring with Padé-13 Approximant
+ *
+ * Implements Algorithm 10.20 from:
+ *   Higham, N. J. (2005). "The scaling and squaring method for the matrix
+ *   exponential revisited." SIAM J. Matrix Anal. Appl., 26(4), 1179–1193.
+ *
+ * Algorithm:
+ *   1. Compute s = max(0, ceil(log2(||A||_1 / θ_13))) where θ_13 ≈ 5.372.
+ *   2. Scale: B = A / 2^s.
+ *   3. Compute the [13/13] Padé approximant R(B) = (U + V)^{-1} * (-U + V).
+ *   4. Square s times: expm(A) = R(B)^(2^s).
+ *
+ * Works for any real square DenseMatrix. For large ||A||, uses scaling to
+ * stay within the Padé approximant's accuracy radius.
+ */
+import { DenseMatrix } from '../types/DenseMatrix.js';
+export interface ExpmOptions {
+    /**
+     * When true, return the result as a DenseMatrix.
+     * When false (default), work directly on the internal number[][] and
+     * return as DenseMatrix anyway — this option is reserved for future use.
+     */
+    _reserved?: never;
+}
+/**
+ * Compute the matrix exponential of a square DenseMatrix.
+ *
+ * Uses the Padé-13 scaling-and-squaring algorithm (Higham 2005).
+ * Accurate to near machine precision for general real matrices.
+ *
+ * @param A - Square DenseMatrix (n × n).
+ * @returns expm(A) as a DenseMatrix (n × n).
+ * @throws Error if A is not square.
+ *
+ * @example
+ * // expm(0) = I
+ * matrixExpm(DenseMatrix.zeros(3, 3)) // => identity 3×3
+ *
+ * @example
+ * // expm(t*I) = e^t * I
+ * const tI = DenseMatrix.fromArray([[2,0],[0,2]]);
+ * matrixExpm(tI) // => [[e^2, 0], [0, e^2]]
+ */
+export declare function matrixExpm(A: DenseMatrix): DenseMatrix;
+//# sourceMappingURL=expm.d.ts.map

package/dist/operations/expm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expm.d.ts","sourceRoot":"","sources":["../../src/operations/expm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAmHtD,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,WAAW,GAAG,WAAW,CA+BtD"}

package/dist/operations/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Matrix Operations
+ *
+ * Exports all matrix decomposition and computation operations.
+ */
+export { eig, eigvals, powerIteration, type EigResult, type EigOptions } from './eig.js';
+export { svd, singularValues, pinv, lowRankApprox, cond, norm2, normFro, type SVDResult, type SVDOptions, } from './svd.js';
+export { eigWasm, eigvalsWasm, spectralRadiusWasm } from './eig-wasm.js';
+export { svdWasm } from './svd-wasm.js';
+export { pinv as matrixPinv, type PinvOptions } from './pinv.js';
+export { qr, type QRResult, type QROptions } from './qr.js';
+export { lu, luSolve, type LUResult } from './lu.js';
+export { cholesky, type CholeskyResult } from './cholesky.js';
+export { matrixExpm, type ExpmOptions } from './expm.js';
+export { matrixLogm, type LogmOptions } from './logm.js';
+export { matrixSqrtm, type SqrtmOptions } from './sqrtm.js';
+export { matrixSchur, type SchurResult, type SchurOptions } from './schur.js';
+export { qrPivoted, type QRPivotedResult, type QRPivotedOptions } from './qr-pivoted.js';
+export { lq, rq, ql, type LQResult, type RQResult, type QLResult } from './qr-family.js';
+export { condest } from './condest.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/operations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/operations/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,cAAc,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAGzF,OAAO,EACL,GAAG,EACH,cAAc,EACd,IAAI,EACJ,aAAa,EACb,IAAI,EACJ,KAAK,EACL,OAAO,EACP,KAAK,SAAS,EACd,KAAK,UAAU,GAChB,MAAM,UAAU,CAAC;AAGlB,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAGzE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAIxC,OAAO,EAAE,IAAI,IAAI,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAGjE,OAAO,EAAE,EAAE,EAAE,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,SAAS,CAAC;AAG5D,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGrD,OAAO,EAAE,QAAQ,EAAE,KAAK,cAAc,EAAE,MAAM,eAAe,CAAC;AAG9D,OAAO,EAAE,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAGzD,OAAO,EAAE,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,WAAW,CAAC;AAGzD,OAAO,EAAE,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAG5D,OAAO,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,MAAM,YAAY,CAAC;AAG9E,OAAO,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,KAAK,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGzF,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,KAAK,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAGzF,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC"}

package/dist/operations/logm.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Matrix Logarithm — Schur-Padé inverse scaling-and-squaring (Slices 5.9a + 6.1)
+ *
+ * Implements the Schur-Padé algorithm based on:
+ *   Higham (2008) "Functions of Matrices: Theory and Computation," Chapter 11
+ *   (Algorithm 11.10).
+ *
+ * Algorithm (general Schur-based path, Slice 6.1):
+ *   1. Schur decompose: A = Q · T · Q^T.
+ *   2. Repeatedly take matrix square roots of T (Björck recurrence on upper-
+ *      triangular matrices) until ||T^{1/2^k} - I||_1 < 0.25.
+ *   3. Evaluate log(I + X) via 16-point Gauss-Legendre quadrature.
+ *   4. Scale back by 2^k; rotate by Q: logm(A) = Q · (2^k · log(T^{1/2^k})) · Q^T.
+ *
+ * For the eig-based fallback (diagonalisable matrices with positive real
+ * eigenvalues): logm(A) = V · diag(log(λ)) · V^{-1}.
+ */
+import { DenseMatrix } from '../types/DenseMatrix.js';
+export interface LogmOptions {
+    /**
+     * Tolerance for the "near-identity" test.
+     * Default: 0.25 (||M - I||_1 < tol triggers Padé path).
+     */
+    nearIdentityTol?: number;
+}
+/**
+ * Compute the principal matrix logarithm of a square DenseMatrix.
+ *
+ * Algorithm (Slice 5.9a — inverse scaling-and-squaring + Padé quadrature):
+ *   1. Repeatedly take matrix square roots until ||M - I||_1 < nearIdentityTol.
+ *   2. Evaluate log(I + X) = X * ∫₀¹ (I + tX)^{-1} dt via 7-pt Gauss-Legendre.
+ *   3. Scale back: logm(A) = 2^k * log(A^{1/2^k}).
+ *
+ * Falls back to eigendecomposition if the square-root sequence diverges
+ * (i.e., if the matrix has no non-positive eigenvalues and is diagonalisable).
+ *
+ * Limitations (deferred to Slice 5.9b):
+ *   - Matrices with non-positive real eigenvalues: principal log is undefined.
+ *   - Matrices with complex eigenvalues: throws.
+ *   - Non-diagonalisable (defective) matrices: eig-fallback also throws.
+ *   - Full Schur-based inverse-scaling-and-squaring for general non-normal
+ *     matrices.
+ *
+ * @param A - Square DenseMatrix with positive real eigenvalues.
+ * @returns logm(A) as a DenseMatrix.
+ * @throws Error for matrices with non-positive or complex eigenvalues.
+ *
+ * @example
+ * // logm(I) = 0
+ * matrixLogm(DenseMatrix.eye(3)) // => zero matrix
+ *
+ * @example
+ * // Round-trip: expm(logm(A)) ≈ A
+ * const A = DenseMatrix.fromArray([[4, 1], [0, 9]]);
+ * const logA = matrixLogm(A);
+ * // expm(logA) ≈ A  (to machine precision for diagonalisable A)
+ */
+export declare function matrixLogm(A: DenseMatrix, opts?: LogmOptions): DenseMatrix;
+//# sourceMappingURL=logm.d.ts.map

package/dist/operations/logm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logm.d.ts","sourceRoot":"","sources":["../../src/operations/logm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAiXtD,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,WAAW,CAyD1E"}

package/dist/operations/lu.d.ts

@@ -0,0 +1,51 @@
+/**
+ * LU Decomposition (DenseMatrix primitive)
+ *
+ * Doolittle's algorithm with partial (row) pivoting. Factorises a square
+ * matrix A into P · A = L · U where:
+ *   - L is unit lower-triangular (1s on the diagonal).
+ *   - U is upper-triangular.
+ *   - P is returned as a row-permutation array: P[i] is the original-row
+ *     index now at position i after pivoting.
+ *
+ * Usage:
+ *   const { L, U, P } = lu(A);
+ *   // P[i] gives the original row moved to position i, so P · A = L · U.
+ */
+import { DenseMatrix } from '../types/DenseMatrix.js';
+export interface LUResult {
+    /** Unit lower-triangular factor L. */
+    L: DenseMatrix;
+    /** Upper-triangular factor U. */
+    U: DenseMatrix;
+    /** Row permutation array of length n. P[i] is the original-row index now at position i. */
+    P: number[];
+}
+/**
+ * Perform LU decomposition with partial pivoting on a square `DenseMatrix`.
+ *
+ * Implements Doolittle's algorithm in compact form: the working array stores
+ * L below the diagonal (unit diagonal implicit) and U on and above it.
+ *
+ * @throws {Error} if `A` is not square.
+ * @throws {Error} if `A` is singular (zero pivot encountered).
+ */
+export declare function lu(A: DenseMatrix): LUResult;
+/**
+ * Solve the dense linear system `A · x = b` using a precomputed LU factorisation
+ * (from {@link lu}), where `P · A = L · U`.
+ *
+ * Applies the row permutation to `b` (`(P·b)[i] = b[P[i]]`), forward-substitutes
+ * the unit-lower-triangular `L`, then back-substitutes the upper-triangular `U`.
+ * Each call is O(n²), so factor **once** with `lu()` and call `luSolve` repeatedly
+ * to solve many right-hand sides against the same matrix — the pattern the stiff
+ * Rosenbrock/RODAS ODE steps use (the iteration matrix is solved against 3–6
+ * successive RHS per step).
+ *
+ * @param fac An `LUResult` produced by {@link lu}.
+ * @param b   Right-hand side vector of length `n` (`number[]` or `Float64Array`).
+ * @returns   The solution vector `x` as a `number[]` of length `n`.
+ * @throws {Error} if `b.length` does not equal the factor dimension `n`.
+ */
+export declare function luSolve(fac: LUResult, b: ArrayLike<number>): number[];
+//# sourceMappingURL=lu.d.ts.map

package/dist/operations/lu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lu.d.ts","sourceRoot":"","sources":["../../src/operations/lu.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,MAAM,WAAW,QAAQ;IACvB,sCAAsC;IACtC,CAAC,EAAE,WAAW,CAAC;IACf,iCAAiC;IACjC,CAAC,EAAE,WAAW,CAAC;IACf,2FAA2F;IAC3F,CAAC,EAAE,MAAM,EAAE,CAAC;CACb;AAED;;;;;;;;GAQG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,WAAW,GAAG,QAAQ,CAuE3C;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,QAAQ,EAAE,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,MAAM,EAAE,CA2BrE"}

package/dist/operations/pinv.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Moore-Penrose Pseudoinverse (DenseMatrix primitive)
+ *
+ * Computes the pseudoinverse A⁺ of a DenseMatrix A via full SVD with
+ * rcond·max(S) singular-value thresholding.
+ *
+ * Algorithm:
+ *   1. Full SVD:   A = U · diag(S) · Vᵀ   (A is m×n)
+ *      U: m×m orthogonal, V: n×n orthogonal, S: min(m,n) values (descending).
+ *   2. Threshold:  s_inv_i = 1/s_i  if  s_i > rcond·max(S),  else 0.
+ *   3. Build:      A⁺ = V · diag(s_inv) · Uᵀ   (shape: n×m).
+ *
+ * Satisfies all four Moore-Penrose identities within numerical precision:
+ *   A · A⁺ · A  = A
+ *   A⁺ · A · A⁺ = A⁺
+ *   (A · A⁺)ᵀ   = A · A⁺
+ *   (A⁺ · A)ᵀ   = A⁺ · A
+ */
+import { DenseMatrix } from '../types/DenseMatrix.js';
+export interface PinvOptions {
+    /**
+     * Relative condition threshold for singular-value truncation.
+     * A singular value s_i is treated as zero when s_i ≤ rcond · max(S).
+     * Default: 1e-10.
+     */
+    rcond?: number;
+}
+/**
+ * Compute the Moore-Penrose pseudoinverse of a DenseMatrix.
+ *
+ * @param A    - Input matrix (m × n).
+ * @param opts - Optional rcond threshold (default 1e-10).
+ * @returns    A⁺, the pseudoinverse of A (n × m).
+ */
+export declare function pinv(A: DenseMatrix, opts?: PinvOptions): DenseMatrix;
+//# sourceMappingURL=pinv.d.ts.map

package/dist/operations/pinv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pinv.d.ts","sourceRoot":"","sources":["../../src/operations/pinv.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAGtD,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;GAMG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,WAAW,CAoCpE"}

package/dist/operations/qr-family.d.ts

@@ -0,0 +1,52 @@
+/**
+ * QR-family decompositions: LQ, RQ, QL
+ *
+ * Each is derived from the existing Gram-Schmidt `qr()` primitive in this
+ * directory via the standard flip/transpose reductions (Golub & Van Loan,
+ * *Matrix Computations*, §5.2):
+ *
+ *   - **LQ** (`A = L·Q`, L lower-triangular): `qr(Aᵀ)` transposed — no flips
+ *     needed. If `Aᵀ = Q₁·R₁` then `A = R₁ᵀ·Q₁ᵀ`, so `L = R₁ᵀ`, `Q = Q₁ᵀ`.
+ *   - **RQ** (`A = R·Q`, R upper-triangular): reverse `A`'s row order,
+ *     transpose, run `qr()`, then un-flip the resulting factors.
+ *   - **QL** (`A = Q·L`, L lower-triangular): reverse `A`'s column order,
+ *     run `qr()`, then un-flip the resulting factors.
+ *
+ * All three share `qr()`'s reduced-QR convention: for an m×n input the thin
+ * factor pairing is (m×k, k×n) with k = min(m, n).
+ */
+import { DenseMatrix } from '../types/DenseMatrix.js';
+export interface LQResult {
+    /** Lower-triangular (trapezoidal) factor. m × k, k = min(m, n). */
+    L: DenseMatrix;
+    /** Orthonormal-row factor (Q · Qᵀ = I). k × n. */
+    Q: DenseMatrix;
+}
+export interface RQResult {
+    /** Upper-triangular (trapezoidal) factor. m × k, k = min(m, n). */
+    R: DenseMatrix;
+    /** Orthonormal-row factor (Q · Qᵀ = I). k × n. */
+    Q: DenseMatrix;
+}
+export interface QLResult {
+    /** Orthonormal-column factor (Qᵀ · Q = I). m × k, k = min(m, n). */
+    Q: DenseMatrix;
+    /** Lower-triangular (trapezoidal) factor. k × n. */
+    L: DenseMatrix;
+}
+/**
+ * LQ decomposition: `A = L · Q` with `L` lower-triangular and `Q` having
+ * orthonormal rows (`Q · Qᵀ = I`).
+ */
+export declare function lq(A: DenseMatrix): LQResult;
+/**
+ * RQ decomposition: `A = R · Q` with `R` upper-triangular and `Q` having
+ * orthonormal rows (`Q · Qᵀ = I`).
+ */
+export declare function rq(A: DenseMatrix): RQResult;
+/**
+ * QL decomposition: `A = Q · L` with `Q` having orthonormal columns
+ * (`Qᵀ · Q = I`) and `L` lower-triangular.
+ */
+export declare function ql(A: DenseMatrix): QLResult;
+//# sourceMappingURL=qr-family.d.ts.map

package/dist/operations/qr-family.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qr-family.d.ts","sourceRoot":"","sources":["../../src/operations/qr-family.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAGtD,MAAM,WAAW,QAAQ;IACvB,mEAAmE;IACnE,CAAC,EAAE,WAAW,CAAC;IACf,kDAAkD;IAClD,CAAC,EAAE,WAAW,CAAC;CAChB;AAED,MAAM,WAAW,QAAQ;IACvB,mEAAmE;IACnE,CAAC,EAAE,WAAW,CAAC;IACf,kDAAkD;IAClD,CAAC,EAAE,WAAW,CAAC;CAChB;AAED,MAAM,WAAW,QAAQ;IACvB,oEAAoE;IACpE,CAAC,EAAE,WAAW,CAAC;IACf,oDAAoD;IACpD,CAAC,EAAE,WAAW,CAAC;CAChB;AA8BD;;;GAGG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,WAAW,GAAG,QAAQ,CAG3C;AAED;;;GAGG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,WAAW,GAAG,QAAQ,CAM3C;AAED;;;GAGG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,WAAW,GAAG,QAAQ,CAM3C"}