@danielsimonjr/mathts-matrix 0.7.1 → 0.7.3

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

@@ -0,0 +1,39 @@
+/**
+ * Rank-Revealing Pivoted QR Decomposition (Businger-Golub column pivoting)
+ *
+ * Computes `A[:, P] = Q · R` via Householder reflections, choosing at each
+ * step the remaining column of largest norm as the next pivot. This is the
+ * classical column-pivoted QR (LAPACK `dgeqp3`'s algorithm, simplified —
+ * exact remaining-column-norm recomputation rather than the cheaper
+ * downdating formula, since these matrices are small): it guarantees
+ * `|R[0,0]| ≥ |R[1,1]| ≥ … ≥ |R[k-1,k-1]|`, which makes `R`'s diagonal a
+ * reliable numerical-rank indicator — unlike the plain (unpivoted)
+ * Gram-Schmidt `qr()` in this directory, whose diagonal can be small for an
+ * early column purely by column order, not by rank deficiency.
+ *
+ * Reuses the Householder helpers in `./common.js` (already exercised by
+ * `svd.ts`/`schur.ts`) rather than re-deriving reflection algebra here.
+ */
+import { DenseMatrix } from '../types/DenseMatrix.js';
+export interface QRPivotedResult {
+    /** Orthonormal Q factor (m × k, k = min(m, n)). */
+    Q: DenseMatrix;
+    /** Upper-triangular R factor (k × n) with |diag(R)| non-increasing. */
+    R: DenseMatrix;
+    /** Column permutation: `P[j]` is the original column index now at position `j`, so `A[:, P] = Q · R`. */
+    P: number[];
+    /** Numerical rank: count of `i` with `|R[i,i]| > tolerance · |R[0,0]|`. */
+    rank: number;
+}
+export interface QRPivotedOptions {
+    /** Relative rank tolerance (default `1e-10`). */
+    tolerance?: number;
+}
+/**
+ * Compute the column-pivoted rank-revealing QR decomposition of `A`.
+ *
+ * @param A    - Input matrix (m × n).
+ * @param opts - Optional rank tolerance.
+ */
+export declare function qrPivoted(A: DenseMatrix, opts?: QRPivotedOptions): QRPivotedResult;
+//# sourceMappingURL=qr-pivoted.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"qr-pivoted.d.ts","sourceRoot":"","sources":["../../src/operations/qr-pivoted.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAGtD,MAAM,WAAW,eAAe;IAC9B,mDAAmD;IACnD,CAAC,EAAE,WAAW,CAAC;IACf,uEAAuE;IACvE,CAAC,EAAE,WAAW,CAAC;IACf,yGAAyG;IACzG,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,gBAAgB;IAC/B,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,gBAAgB,GAAG,eAAe,CA6GlF"}

package/dist/operations/qr.d.ts

@@ -0,0 +1,35 @@
+/**
+ * QR Decomposition (DenseMatrix primitive)
+ *
+ * Classical Gram-Schmidt with re-orthogonalisation. Adequate for the
+ * well-conditioned matrices that arise in the tensor wrappers + the
+ * `randomTensor` orthogonal-distribution code path. For pathological
+ * matrices the Householder QR implemented in `WASMBackend.qrDecompositionJS`
+ * is preferable, but Gram-Schmidt suffices for the current call sites.
+ *
+ * Two modes:
+ *   - 'reduced' (thin QR): Q is (m × k), R is (k × n), k = min(m, n).
+ *   - 'full'             : Q is (m × m), R is (m × n).
+ *
+ * In 'reduced' mode A = Q · R reconstructs A to within `1e-12`.
+ * Q's columns are orthonormal (Qᵀ · Q = I_k); R is upper-triangular.
+ */
+import { DenseMatrix } from '../types/DenseMatrix.js';
+export interface QRResult {
+    /** Orthonormal Q factor. Reduced: (m × k); full: (m × m). */
+    Q: DenseMatrix;
+    /** Upper-triangular R factor. Reduced: (k × n); full: (m × n). */
+    R: DenseMatrix;
+}
+export interface QROptions {
+    /** 'reduced' (default, thin QR) or 'full'. */
+    mode?: 'reduced' | 'full';
+}
+/**
+ * Compute the QR decomposition of `A` such that `A = Q · R`.
+ *
+ * @param A    - Input matrix (m × n, m ≥ 0, n ≥ 0).
+ * @param opts - Optional mode selector (`'reduced'` thin QR or `'full'` square Q).
+ */
+export declare function qr(A: DenseMatrix, opts?: QROptions): QRResult;
+//# sourceMappingURL=qr.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"qr.d.ts","sourceRoot":"","sources":["../../src/operations/qr.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAEtD,MAAM,WAAW,QAAQ;IACvB,6DAA6D;IAC7D,CAAC,EAAE,WAAW,CAAC;IACf,kEAAkE;IAClE,CAAC,EAAE,WAAW,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IACxB,8CAA8C;IAC9C,IAAI,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,SAAS,GAAG,QAAQ,CAqJ7D"}

package/dist/operations/schur.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Schur Decomposition — Francis QR with double shifts (Slice 6.1)
+ *
+ * Computes the real Schur decomposition A = Q · T · Q^T where:
+ *   - Q is orthogonal (Q^T · Q = I)
+ *   - T is quasi-upper-triangular (real Schur form): diagonal blocks are
+ *     1×1 (real eigenvalue) or 2×2 (complex-conjugate eigenvalue pair)
+ *
+ * Algorithm: Householder reduction to upper Hessenberg form followed by
+ * Francis double-shift implicit QR iteration (Golub & Van Loan §7.5).
+ *
+ * References:
+ *   Golub & Van Loan (2013) "Matrix Computations," 4th ed., §7.5.
+ *   Higham (2008) "Functions of Matrices: Theory and Computation," §1.
+ */
+import { DenseMatrix } from '../types/DenseMatrix.js';
+export interface SchurResult {
+    /** Orthogonal factor Q (Q^T · Q = I, Q · Q^T = I). */
+    Q: DenseMatrix;
+    /** Quasi-upper-triangular Schur form T (real Schur form). */
+    T: DenseMatrix;
+}
+export interface SchurOptions {
+    /** Maximum QR iterations (default: 1000). */
+    maxIterations?: number;
+    /** Deflation tolerance (default: 1e-12). */
+    tolerance?: number;
+}
+/**
+ * Compute the real Schur decomposition of a square matrix:
+ *   A = Q · T · Q^T
+ *
+ * T is quasi-upper-triangular (real Schur form): 1×1 diagonal blocks for
+ * real eigenvalues and 2×2 blocks for complex-conjugate pairs. Q is
+ * orthogonal.
+ *
+ * For matrices with all real eigenvalues, T is upper triangular with
+ * eigenvalues on the diagonal. For matrices with complex-conjugate eigenvalue
+ * pairs, the corresponding 2×2 diagonal block has the form
+ *   [[a, b], [-b, a]]  (approximately)
+ * and the complex pair is  a ± bi.
+ *
+ * @param A - Square DenseMatrix (n × n, real entries).
+ * @param opts - Optional algorithm parameters.
+ * @returns { Q, T } satisfying Q · T · Q^T ≈ A.
+ * @throws Error if A is not square.
+ */
+export declare function matrixSchur(A: DenseMatrix, opts?: SchurOptions): SchurResult;
+/**
+ * Low-level Schur decomposition on a 2-D number array.
+ * Returns mutable H and Q arrays suitable for further in-place operations.
+ * @internal
+ */
+export declare function schurInternal(A: number[][], maxIterations?: number, tolerance?: number): {
+    H: number[][];
+    Q: number[][];
+};
+//# sourceMappingURL=schur.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schur.d.ts","sourceRoot":"","sources":["../../src/operations/schur.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAqVtD,MAAM,WAAW,WAAW;IAC1B,sDAAsD;IACtD,CAAC,EAAE,WAAW,CAAC;IACf,6DAA6D;IAC7D,CAAC,EAAE,WAAW,CAAC;CAChB;AAED,MAAM,WAAW,YAAY;IAC3B,6CAA6C;IAC7C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4CAA4C;IAC5C,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,WAAW,CA+B5E;AAMD;;;;GAIG;AACH,wBAAgB,aAAa,CAC3B,CAAC,EAAE,MAAM,EAAE,EAAE,EACb,aAAa,SAAO,EACpB,SAAS,SAAQ,GAChB;IAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;CAAE,CAElC"}

package/dist/operations/sqrtm.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Matrix Square Root — Hybrid approach (Slices 5.9a + 6.1)
+ *
+ * Computes the principal square root of a square matrix.
+ *
+ * Algorithm selection:
+ *   1. For symmetric positive semi-definite matrices: symmetric eigendecomposition
+ *      with Gram-Schmidt re-orthogonalisation (handles repeated eigenvalues).
+ *   2. For general matrices: Björck-Hammarling Schur-based algorithm
+ *      (Higham 2008, Algorithm 6.3):
+ *        a. Schur decompose: A = Q · T · Q^T.
+ *        b. Compute upper-triangular U with U^2 = T via back-substitution.
+ *        c. Rotate back: sqrtm(A) = Q · U · Q^T.
+ *      Falls back to Newton iteration for diagonalisable matrices when the
+ *      Schur path is unsuitable (e.g. negative eigenvalues in 1×1 blocks).
+ *
+ * References:
+ *   - Higham (2008) "Functions of Matrices" §6 (Algorithm 6.3).
+ *   - Björck & Hammarling (1983) "A Schur method for the square root of a matrix."
+ */
+import { DenseMatrix } from '../types/DenseMatrix.js';
+export interface SqrtmOptions {
+    /**
+     * Force the symmetric-eigendecomposition path even for non-SPD matrices.
+     * By default, symmetry is auto-detected.
+     */
+    assumeSymmetric?: boolean;
+}
+/**
+ * Compute the principal square root of a square DenseMatrix.
+ *
+ * For symmetric positive semi-definite A:
+ *   Uses symmetric eigendecomposition with Gram-Schmidt re-orthogonalisation.
+ *
+ * For general diagonalisable A with non-negative eigenvalues:
+ *   Uses Newton iteration Y_{k+1} = (Y_k + A * Y_k^{-1}) / 2, falling back
+ *   to the eig-based formula if Newton fails to converge.
+ *
+ * Slice 5.9a limitations:
+ *   - Matrices with negative real eigenvalues: throws.
+ *   - Matrices with complex eigenvalues: throws.
+ *   - Non-diagonalisable (defective) matrices: Newton may fail + eig fallback
+ *     may also fail. Full Schur-based Björck-Hammarling deferred to Slice 5.9b.
+ *
+ * @param A    - Square DenseMatrix (n × n).
+ * @param opts - Optional flags.
+ * @returns sqrtm(A), the principal square root.
+ * @throws Error for matrices with negative or complex eigenvalues.
+ *
+ * @example
+ * // sqrtm(I) = I
+ * matrixSqrtm(DenseMatrix.eye(3))  // => identity 3×3
+ *
+ * @example
+ * // sqrtm(4*I) = 2*I
+ * const A = DenseMatrix.fromArray([[4,0],[0,4]]);
+ * matrixSqrtm(A)  // => [[2,0],[0,2]]
+ *
+ * @example
+ * // Round-trip: sqrtm(A)^2 ≈ A
+ * const S = DenseMatrix.fromArray([[4,2],[2,3]]);
+ * const R = matrixSqrtm(S);
+ * // R * R ≈ S  (to machine precision for SPD matrices)
+ */
+export declare function matrixSqrtm(A: DenseMatrix, opts?: SqrtmOptions): DenseMatrix;
+/**
+ * Newton iteration square root (exported for logm.ts internal use).
+ * Y_{k+1} = (Y_k + A * Y_k^{-1}) / 2, starting from Y_0 = I.
+ *
+ * This is a robust complement to sqrtmGeneral for matrices near the identity
+ * and is used internally by matrixLogm's inverse-scaling phase.
+ *
+ * @internal
+ */
+export declare function matrixSqrtNewtonInternal(A: number[][]): number[][];
+//# sourceMappingURL=sqrtm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sqrtm.d.ts","sourceRoot":"","sources":["../../src/operations/sqrtm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAuatD,MAAM,WAAW,YAAY;IAC3B;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,WAAW,CAqC5E;AAUD;;;;;;;;GAQG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAsBlE"}

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

@@ -0,0 +1,23 @@
+/**
+ * `svdWasm` — thin wrapper kept for API compatibility (consumed by `tensor` and `linalg`).
+ *
+ * The WASM SVD path was RETIRED and REMOVED (2026-07-01): the AssemblyScript one-sided
+ * Jacobi kernel was scalar + async and measured 0.4–0.7× of the pure-JS Golub-Reinsch
+ * {@link svd}, worsening with size — see `tools/benchmarks/decomp-audit`. It now delegates
+ * to the JS `svd`, truncated to the **thin / economy** form (`U` is `m×k`, `V` is `n×k`,
+ * `k = min(m, n)`) so the result shape is unchanged. The `async` signature is retained so
+ * existing callers (which `await`) are unaffected.
+ *
+ * @packageDocumentation
+ */
+import { type SVDResult, type SVDOptions } from './svd.js';
+/**
+ * Thin SVD. Delegates to the JS {@link svd} and truncates to the economy form
+ * (WASM path retired — see file header).
+ *
+ * @param matrix - Input matrix (m x n) as a row-major 2D array
+ * @param options - SVD options; `rankTolerance` controls the rank estimate
+ * @returns thin SVD `{ U (m x k), S (k), V (n x k), rank }`
+ */
+export declare function svdWasm(matrix: number[][], options?: SVDOptions): Promise<SVDResult>;
+//# sourceMappingURL=svd-wasm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"svd-wasm.d.ts","sourceRoot":"","sources":["../../src/operations/svd-wasm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAO,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,MAAM,UAAU,CAAC;AAsBhE;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,CAS1F"}

package/dist/operations/svd.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Singular Value Decomposition (SVD)
+ *
+ * Implements SVD using Golub-Reinsch bidiagonalization and implicit QR.
+ * A = U * S * V^T where:
+ *   - U: m x m orthogonal matrix (left singular vectors)
+ *   - S: m x n diagonal matrix (singular values)
+ *   - V: n x n orthogonal matrix (right singular vectors)
+ */
+/**
+ * Result of SVD decomposition
+ */
+export interface SVDResult {
+    /** Left singular vectors (m x m) */
+    U: number[][];
+    /** Singular values (min(m,n) values) */
+    S: number[];
+    /** Right singular vectors (n x n) */
+    V: number[][];
+    /** Rank estimate */
+    rank: number;
+}
+/**
+ * Options for SVD computation
+ */
+export interface SVDOptions {
+    /** Maximum number of iterations */
+    maxIterations?: number;
+    /** Convergence tolerance */
+    tolerance?: number;
+    /**
+     * Complete the thin factor to a square orthonormal basis (U → m×m for tall
+     * inputs, V → n×n for wide ones), numpy `full_matrices=True` style, so the
+     * rectangular-Σ reconstruction `A = U·Σ·Vᵀ` holds. Default `false` = thin
+     * factors (the library's long-standing behavior; the option was previously
+     * accepted but ignored — B-4).
+     */
+    fullMatrices?: boolean;
+    /** Threshold for rank determination */
+    rankTolerance?: number;
+}
+export declare function svd(matrix: number[][] | Float64Array, options?: SVDOptions): SVDResult;
+/**
+ * Compute only singular values (faster than full SVD)
+ */
+export declare function singularValues(matrix: number[][] | Float64Array, options?: Omit<SVDOptions, 'fullMatrices'>): number[];
+/**
+ * Compute the pseudoinverse (Moore-Penrose inverse) using SVD
+ */
+export declare function pinv(matrix: number[][], options?: SVDOptions): number[][];
+/**
+ * Low-rank approximation using SVD
+ * Keeps only the top r singular values
+ */
+export declare function lowRankApprox(matrix: number[][], r: number, options?: SVDOptions): number[][];
+/**
+ * Compute condition number using SVD
+ */
+export declare function cond(matrix: number[][], options?: SVDOptions): number;
+/**
+ * Compute matrix norm using SVD
+ * Returns the spectral norm (largest singular value)
+ */
+export declare function norm2(matrix: number[][], options?: SVDOptions): number;
+/**
+ * Compute Frobenius norm using SVD
+ * Equals sqrt(sum of squared singular values)
+ */
+export declare function normFro(matrix: number[][]): number;
+//# sourceMappingURL=svd.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"svd.d.ts","sourceRoot":"","sources":["../../src/operations/svd.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAUH;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,oCAAoC;IACpC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACd,wCAAwC;IACxC,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,qCAAqC;IACrC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACd,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,mCAAmC;IACnC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4BAA4B;IAC5B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,uCAAuC;IACvC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAuVD,wBAAgB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,YAAY,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,CA0K1F;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,YAAY,EACjC,OAAO,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,cAAc,CAAC,GACzC,MAAM,EAAE,CAEV;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,EAAE,CAmCzE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM,EAAE,EAAE,CAqB7F;AAED;;GAEG;AACH,wBAAgB,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM,CAQrE;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM,CAGtE;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,CAQlD"}

package/dist/parallel-matrix.d.ts

@@ -0,0 +1,223 @@
+/**
+ * Parallel-First Matrix Operations
+ *
+ * AssemblyScript-friendly TypeScript implementations with typed-function
+ * integration and workerpool parallel execution via @danielsimonjr/mathts-parallel.
+ *
+ * These operations use Float64Array flat row-major format for efficient
+ * parallel processing through the ComputePool worker infrastructure.
+ *
+ * Following the parallel-first philosophy per CLAUDE.md:
+ * - Use workers for ALL matrix operations (matmul, transpose, etc.)
+ * - Use workers for ALL element-wise operations on matrices
+ * - Only fall back to sequential for trivial scalar operations
+ *
+ * @packageDocumentation
+ */
+import type { TypedFunction } from '@danielsimonjr/mathts-core';
+/**
+ * Create a matrix from various input types - parallel-first
+ */
+export declare const parallelMatrix: TypedFunction;
+/**
+ * Create an identity matrix
+ */
+export declare const parallelIdentity: TypedFunction;
+/**
+ * Create a matrix of zeros
+ */
+export declare const parallelZeros: TypedFunction;
+/**
+ * Create a matrix of ones
+ */
+export declare const parallelOnes: TypedFunction;
+/**
+ * Create a diagonal matrix
+ */
+export declare const parallelDiag: TypedFunction;
+/**
+ * Create a random matrix
+ */
+export declare const parallelRandom: TypedFunction;
+/**
+ * Parallel matrix addition with typed-function dispatch
+ */
+export declare const parallelMatrixAdd: TypedFunction;
+/**
+ * Parallel matrix subtraction with typed-function dispatch
+ */
+export declare const parallelMatrixSubtract: TypedFunction;
+/**
+ * Parallel matrix multiplication (matmul) with typed-function dispatch
+ */
+export declare const parallelMatrixMultiply: TypedFunction;
+/**
+ * Element-wise multiplication (Hadamard product) - parallel execution
+ */
+export declare const parallelDotMultiply: TypedFunction;
+/**
+ * Parallel matrix division
+ */
+export declare const parallelMatrixDivide: TypedFunction;
+/**
+ * Matrix negation - parallel execution
+ */
+export declare const parallelUnaryMinus: TypedFunction;
+/**
+ * Matrix transpose - parallel execution
+ */
+export declare const parallelMatrixTranspose: TypedFunction;
+/**
+ * Parallel sum of all elements
+ */
+export declare const parallelMatrixSum: TypedFunction;
+/**
+ * Parallel mean of all elements
+ */
+export declare const parallelMatrixMean: TypedFunction;
+/**
+ * Parallel minimum element
+ */
+export declare const parallelMatrixMin: TypedFunction;
+/**
+ * Parallel maximum element
+ */
+export declare const parallelMatrixMax: TypedFunction;
+/**
+ * Parallel variance computation
+ */
+export declare const parallelMatrixVariance: TypedFunction;
+/**
+ * Parallel standard deviation
+ */
+export declare const parallelMatrixStd: TypedFunction;
+/**
+ * Parallel Frobenius norm
+ */
+export declare const parallelMatrixNorm: TypedFunction;
+/**
+ * Parallel dot product
+ */
+export declare const parallelMatrixDot: TypedFunction;
+/**
+ * Matrix trace (sum of diagonal elements)
+ */
+export declare const parallelMatrixTrace: TypedFunction;
+/**
+ * Parallel Euclidean distance
+ */
+export declare const parallelMatrixDistance: TypedFunction;
+/**
+ * Parallel element-wise absolute value
+ */
+export declare const parallelMatrixAbs: TypedFunction;
+/**
+ * Parallel element-wise square root
+ */
+export declare const parallelMatrixSqrt: TypedFunction;
+/**
+ * Parallel element-wise square
+ */
+export declare const parallelMatrixSquare: TypedFunction;
+/**
+ * Parallel element-wise exponential
+ */
+export declare const parallelMatrixExp: TypedFunction;
+/**
+ * Parallel element-wise natural logarithm
+ */
+export declare const parallelMatrixLog: TypedFunction;
+/**
+ * Parallel element-wise sine
+ */
+export declare const parallelMatrixSin: TypedFunction;
+/**
+ * Parallel element-wise cosine
+ */
+export declare const parallelMatrixCos: TypedFunction;
+/**
+ * Parallel element-wise tangent
+ */
+export declare const parallelMatrixTan: TypedFunction;
+/**
+ * Get matrix dimensions
+ */
+export declare const parallelMatrixSize: TypedFunction;
+/**
+ * Get element at position
+ */
+export declare const parallelMatrixSubset: TypedFunction;
+/**
+ * Get row from matrix
+ */
+export declare const parallelMatrixRow: TypedFunction;
+/**
+ * Get column from matrix
+ */
+export declare const parallelMatrixColumn: TypedFunction;
+/**
+ * Get diagonal from matrix
+ */
+export declare const parallelMatrixDiagonal: TypedFunction;
+/**
+ * Parallel matrix-vector multiplication
+ */
+export declare const parallelMatrixMatvec: TypedFunction;
+/**
+ * Parallel outer product
+ */
+export declare const parallelMatrixOuter: TypedFunction;
+/**
+ * Parallel histogram computation
+ */
+export declare const parallelMatrixHistogram: TypedFunction;
+export declare const parallelMatrixOperations: {
+    matrix: TypedFunction;
+    identity: TypedFunction;
+    zeros: TypedFunction;
+    ones: TypedFunction;
+    diag: TypedFunction;
+    random: TypedFunction;
+    add: TypedFunction;
+    subtract: TypedFunction;
+    multiply: TypedFunction;
+    dotMultiply: TypedFunction;
+    divide: TypedFunction;
+    unaryMinus: TypedFunction;
+    transpose: TypedFunction;
+    sum: TypedFunction;
+    mean: TypedFunction;
+    min: TypedFunction;
+    max: TypedFunction;
+    variance: TypedFunction;
+    std: TypedFunction;
+    norm: TypedFunction;
+    dot: TypedFunction;
+    trace: TypedFunction;
+    distance: TypedFunction;
+    abs: TypedFunction;
+    sqrt: TypedFunction;
+    square: TypedFunction;
+    exp: TypedFunction;
+    log: TypedFunction;
+    sin: TypedFunction;
+    cos: TypedFunction;
+    tan: TypedFunction;
+    size: TypedFunction;
+    subset: TypedFunction;
+    row: TypedFunction;
+    column: TypedFunction;
+    diagonal: TypedFunction;
+    matvec: TypedFunction;
+    outer: TypedFunction;
+    histogram: TypedFunction;
+};
+/**
+ * Initialize parallel matrix operations
+ */
+export declare function initializeParallelMatrix(): Promise<void>;
+/**
+ * Terminate parallel matrix operations pool
+ */
+export declare function terminateParallelMatrix(): Promise<void>;
+//# sourceMappingURL=parallel-matrix.d.ts.map

package/dist/parallel-matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallel-matrix.d.ts","sourceRoot":"","sources":["../src/parallel-matrix.ts"],"names":[],"mappings":"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"}

package/dist/{resolve-DDCEWHWX.js → resolve-2SX6WJ6R.js}

@@ -1,4 +1,4 @@
-import "./chunk-4VMDO6W2.js";
+import "./chunk-PNKVD2UK.js";
 
 // src/backends/wasm/resolve.ts
 import { resolvePackagedWasm, defaultWasmLocation } from "@danielsimonjr/mathts-core/internal";