@danielsimonjr/mathts-functions 0.2.2 → 0.2.4

package/dist/typed/interpolation.d.ts

@@ -0,0 +1,189 @@
+/**
+ * Interpolation Functions
+ *
+ * Provides polynomial and spline interpolation methods:
+ * - linearInterp: Linear interpolation between data points
+ * - lagrangeInterp: Lagrange polynomial interpolation
+ * - cubicSpline: Natural cubic spline (returns evaluation function)
+ * - hermiteInterp: Hermite interpolation with derivative data
+ * - pchipInterp: Piecewise Cubic Hermite Interpolating Polynomial (shape-preserving)
+ * - polyFit: Least-squares polynomial fitting
+ *
+ * These use plain exports since some return functions.
+ *
+ * The hot-loop tridiagonal solver used by `cubicSpline` is dispatched
+ * through `functions/src/wasm/interpolation/wasm-bridge.ts` when the
+ * knot count reaches the WASM_TRIDIAG_THRESHOLD (1024).
+ *
+ * @packageDocumentation
+ */
+import { WASM_INTERP_THRESHOLD } from '../wasm/interpolation/wasm-bridge.js';
+/**
+ * Linear interpolation between data points.
+ *
+ * Finds the interval containing x and linearly interpolates.
+ * Extrapolates linearly outside the data range.
+ *
+ * @param xs - Sorted x-coordinates (ascending)
+ * @param ys - Corresponding y-values
+ * @param x - Point to interpolate at
+ * @returns Interpolated value
+ *
+ * @example
+ * linearInterp([0, 1], [0, 1], 0.5) // => 0.5
+ * linearInterp([0, 1, 2], [0, 1, 4], 1.5) // => 2.5
+ */
+export declare function linearInterp(xs: number[], ys: number[], x: number): number;
+/**
+ * Lagrange polynomial interpolation.
+ *
+ * Computes the unique polynomial of degree n-1 passing through n data points,
+ * evaluated at x.
+ *
+ * When `xs.length >= WASM_INTERP_THRESHOLD` (256), the O(n²)
+ * divided-difference table is computed via the WASM kernel (Rust primary,
+ * AssemblyScript fallback) and the result is evaluated in Newton form.
+ * Below the threshold the classical direct Lagrange formula is used.
+ *
+ * @param xs - Distinct x-coordinates
+ * @param ys - Corresponding y-values
+ * @param x - Point to evaluate at
+ * @returns Interpolated value
+ *
+ * @example
+ * lagrangeInterp([0, 1, 2], [0, 1, 4], 1.5) // => 2.25
+ */
+export declare function lagrangeInterp(xs: number[], ys: number[], x: number): number;
+/**
+ * Newton's divided-difference polynomial interpolation.
+ *
+ * Evaluates the unique interpolating polynomial of degree n-1 at `x` using
+ * Newton's divided-difference representation.  Mathematically identical to
+ * Lagrange interpolation but computed via a different (and more numerically
+ * efficient) algorithm.
+ *
+ * When `xs.length >= WASM_INTERP_THRESHOLD` (256), the O(n²)
+ * divided-difference table is dispatched to the WASM kernel; otherwise the
+ * pure-JS path runs.
+ *
+ * @param xs - Distinct x-coordinates
+ * @param ys - Corresponding y-values
+ * @param x  - Point to evaluate at
+ * @returns Interpolated value
+ * @throws RangeError when any two xs are equal (degenerate / duplicate nodes)
+ *
+ * @example
+ * newtonInterp([0, 1, 2], [0, 1, 4], 1.5) // => 2.25
+ */
+export declare function newtonInterp(xs: number[], ys: number[], x: number): number;
+/**
+ * Re-export the WASM_INTERP_THRESHOLD constant for external consumers
+ * that need to know the dispatch boundary.
+ */
+export { WASM_INTERP_THRESHOLD };
+/**
+ * Natural cubic spline interpolation.
+ *
+ * Computes spline coefficients and returns a function that evaluates
+ * the spline at any point. Uses natural boundary conditions (second
+ * derivative = 0 at endpoints).
+ *
+ * @param xs - Sorted x-coordinates (ascending, at least 3 points)
+ * @param ys - Corresponding y-values
+ * @returns Evaluation function
+ *
+ * @example
+ * const spline = cubicSpline([0, 1, 2, 3], [0, 1, 4, 9]);
+ * spline(1.5) // => ~2.25
+ */
+export declare function cubicSpline(xs: number[], ys: number[]): (x: number) => number;
+/**
+ * Hermite interpolation using function values and derivatives.
+ *
+ * Constructs the unique polynomial that matches both function values
+ * and first derivatives at each data point.
+ *
+ * @param xs - Distinct x-coordinates
+ * @param ys - Function values at xs
+ * @param dys - Derivative values at xs
+ * @param x - Point to evaluate at
+ * @returns Interpolated value
+ *
+ * @example
+ * hermiteInterp([0, 1], [0, 1], [1, 1], 0.5) // => 0.5 (linear)
+ */
+export declare function hermiteInterp(xs: number[], ys: number[], dys: number[], x: number): number;
+/**
+ * Shape-preserving piecewise cubic Hermite interpolation (PCHIP).
+ *
+ * Unlike cubic splines, PCHIP preserves monotonicity and avoids overshoot.
+ * Uses Fritsch-Carlson method to compute slopes.
+ *
+ * @param xs - Sorted x-coordinates (ascending, at least 2 points)
+ * @param ys - Corresponding y-values
+ * @param x - Point to interpolate at
+ * @returns Interpolated value
+ *
+ * @example
+ * pchipInterp([0, 1, 2, 3], [0, 1, 4, 9], 1.5)
+ */
+export declare function pchipInterp(xs: number[], ys: number[], x: number): number;
+/**
+ * Least-squares polynomial fit.
+ *
+ * Fits a polynomial of given degree to data points using Vandermonde + QR.
+ * Returns coefficients [a0, a1, ..., a_degree] where p(x) = a0 + a1*x + ... + a_d*x^d.
+ *
+ * When xs.length >= WASM_POLY_FIT_THRESHOLD (1024), the hot-loop is dispatched
+ * to the WASM Rust backend (or AS fallback). Below the threshold, a normal-
+ * equation / Gaussian-elimination path runs in pure JS.
+ *
+ * @param xs - x-coordinates
+ * @param ys - y-values
+ * @param degree - Polynomial degree (must be < number of data points)
+ * @returns Array of coefficients [a0, a1, ..., a_degree]
+ *
+ * @example
+ * polyFit([0, 1, 2, 3], [0, 1, 4, 9], 2) // => ~[0, 0, 1] (x^2)
+ */
+export declare function polyFit(xs: number[], ys: number[], degree: number): number[];
+/**
+ * Fit a Chebyshev-series of given degree to data points.
+ *
+ * Returns coefficients [c0, c1, ..., c_degree] in the Chebyshev-T basis so
+ * that f(x) ≈ c0·T_0(x) + c1·T_1(x) + ... + c_d·T_d(x).
+ *
+ * When xs.length >= WASM_POLY_FIT_THRESHOLD, the QR solve is dispatched
+ * to WASM.  Below the threshold, a normal-equation JS path is used.
+ *
+ * @param xs - x-coordinates (ideally in [-1, 1] for numerical stability)
+ * @param ys - y-values
+ * @param degree - Chebyshev degree
+ * @returns Array of Chebyshev coefficients [c0, ..., c_degree]
+ *
+ * @example
+ * // T_2(x) = 2x² - 1: coefficients should be approx [-1, 0, 2] (wait — basis order)
+ * // T_0 = 1, T_1 = x, T_2 = 2x²-1 → recovery coefficients [0, 0, 1] for T_2 alone
+ * chebyshevFit(xs, ys, 2) // ys = T_2(xs): => ~[0, 0, 1]
+ */
+export declare function chebyshevFit(xs: number[], ys: number[], degree: number): number[];
+/**
+ * Fit a Legendre-series of given degree to data points.
+ *
+ * Returns coefficients [c0, c1, ..., c_degree] in the Legendre-P basis so
+ * that f(x) ≈ c0·P_0(x) + c1·P_1(x) + ... + c_d·P_d(x).
+ *
+ * When xs.length >= WASM_POLY_FIT_THRESHOLD, the QR solve is dispatched
+ * to WASM.  Below the threshold, a normal-equation JS path is used.
+ *
+ * @param xs - x-coordinates (ideally in [-1, 1] for numerical stability)
+ * @param ys - y-values
+ * @param degree - Legendre degree
+ * @returns Array of Legendre coefficients [c0, ..., c_degree]
+ *
+ * @example
+ * // P_2(x) = (3x² - 1)/2: recovery coefficients [0, 0, 1] for P_2 alone
+ * legendreFit(xs, ys, 2) // ys = P_2(xs): => ~[0, 0, 1]
+ */
+export declare function legendreFit(xs: number[], ys: number[], degree: number): number[];
+//# sourceMappingURL=interpolation.d.ts.map

package/dist/typed/interpolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpolation.d.ts","sourceRoot":"","sources":["../../src/typed/interpolation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,EAGL,qBAAqB,EACtB,MAAM,sCAAsC,CAAC;AAY9C;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAmB1E;AA8BD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CA+B5E;AAMD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAiB1E;AAED;;;GAGG;AACH,OAAO,EAAE,qBAAqB,EAAE,CAAC;AAMjC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAsF7E;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAmC1F;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAsEzE;AA8BD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAsE5E;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAqEjF;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAqEhF"}

package/dist/typed/logical.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Typed Logical Functions
+ *
+ * Polymorphic logical operations using typed-function for runtime dispatch.
+ * Supports number, bigint, BigNumber, and Complex types.
+ *
+ * Truthiness rules (a value is FALSY if):
+ *   - number:    === 0 or NaN
+ *   - bigint:    === 0n
+ *   - BigNumber: .isZero() || .isNaN()
+ *   - Complex:   re === 0 && im === 0
+ *   - any:       JS-falsy (null, undefined, '', false, 0, 0n, NaN)
+ *
+ * These match the mathjs `and`/`or`/`xor`/`not` semantics exactly.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Logical `not`. Flips the boolean value of a given parameter.
+ *
+ * @example
+ * ```typescript
+ * not(2)      // false
+ * not(0)      // true
+ * not(true)   // false
+ * ```
+ */
+export declare const not: import("typed-function").TypedFunction;
+/**
+ * Logical `and`. Returns true when both inputs are truthy (non-zero/non-empty).
+ *
+ * @example
+ * ```typescript
+ * and(1, 2)   // true
+ * and(0, 2)   // false
+ * and(1, 2, 3) // true  (variadic)
+ * ```
+ */
+export declare const and: import("typed-function").TypedFunction;
+/**
+ * Logical `or`. Returns true when at least one input is truthy.
+ *
+ * @example
+ * ```typescript
+ * or(0, 2)    // true
+ * or(0, 0)    // false
+ * or(0, 0, 1) // true  (variadic)
+ * ```
+ */
+export declare const or: import("typed-function").TypedFunction;
+/**
+ * Logical `xor`. Returns true when exactly one input is truthy.
+ *
+ * @example
+ * ```typescript
+ * xor(1, 0)   // true
+ * xor(1, 2)   // false
+ * xor(1, 0, 0) // true  (variadic: odd number of truthy values)
+ * ```
+ */
+export declare const xor: import("typed-function").TypedFunction;
+/**
+ * Nullish coalescing operator (??).
+ * Returns `b` when `a` is `null` or `undefined`, otherwise returns `a`.
+ *
+ * Unlike `or`, a value of `0`, `false`, or `''` is NOT considered nullish.
+ *
+ * @example
+ * ```typescript
+ * nullish(null, 5)        // 5
+ * nullish(undefined, 5)  // 5
+ * nullish(0, 5)          // 0   (not nullish!)
+ * nullish(false, 5)      // false
+ * ```
+ */
+export declare const nullish: import("typed-function").TypedFunction;
+/**
+ * All typed logical functions.
+ */
+export declare const typedLogical: {
+    not: import("typed-function").TypedFunction;
+    and: import("typed-function").TypedFunction;
+    or: import("typed-function").TypedFunction;
+    xor: import("typed-function").TypedFunction;
+    nullish: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=logical.d.ts.map

package/dist/typed/logical.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logical.d.ts","sourceRoot":"","sources":["../../src/typed/logical.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAgCH;;;;;;;;;GASG;AACH,eAAO,MAAM,GAAG,wCAUd,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,GAAG,wCAmBd,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,EAAE,wCAmBb,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,GAAG,wCAwBd,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,OAAO,wCAmBlB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;CAMxB,CAAC"}

package/dist/typed/matrix-ops.d.ts

@@ -0,0 +1,303 @@
+/**
+ * Typed Matrix Operations
+ *
+ * Advanced matrix operations including characteristic polynomial,
+ * row reduction (RREF), Cholesky decomposition, Hessenberg form,
+ * matrix power/log, polar decomposition, and Jordan form.
+ *
+ * All functions operate on number[][] (nested arrays) for consistency
+ * with the rest of the typed functions layer. SVD and eigendecomposition
+ * are delegated to @danielsimonjr/mathts-matrix when needed.
+ *
+ * @packageDocumentation
+ */
+type f64 = number;
+type i32 = number;
+/**
+ * Compute the characteristic polynomial of a square matrix.
+ *
+ * Returns coefficients of det(A - lambda*I) in ascending power order:
+ * [c0, c1, ..., cn] represents c0 + c1*lambda + ... + cn*lambda^n.
+ *
+ * Uses the Faddeev-LeVerrier algorithm which computes the coefficients
+ * from traces of successive matrix powers, achieving O(n^4) complexity.
+ *
+ * @param A - Square matrix (n x n)
+ * @returns Coefficient array of length n+1 (ascending power order)
+ *
+ * @example
+ * // Matrix [[2,1],[1,2]] has char poly lambda^2 - 4*lambda + 3
+ * characteristicPolynomial([[2,1],[1,2]]) // => [3, -4, 1]
+ */
+export declare function characteristicPolynomial(A: number[][]): Promise<number[]>;
+/**
+ * Compute the reduced row echelon form (RREF) of a matrix.
+ *
+ * Uses Gauss-Jordan elimination with partial pivoting for numerical
+ * stability. The result has leading 1s in each pivot column and zeros
+ * in all other entries of pivot columns.
+ *
+ * @param A - Matrix (m x n), not modified in place
+ * @param tol - Tolerance for zero detection (default 1e-10)
+ * @returns RREF matrix (m x n)
+ *
+ * @example
+ * rowReduce([[1,2,3],[4,5,6],[7,8,9]])
+ * // => [[1,0,-1],[0,1,2],[0,0,0]]
+ */
+export declare function rowReduce(A: number[][], tol?: f64): number[][];
+/**
+ * Compute the rank of a matrix using RREF.
+ *
+ * The rank is the number of nonzero rows in the reduced row echelon form,
+ * which equals the number of pivot columns.
+ *
+ * @param A - Matrix (m x n)
+ * @param tol - Tolerance for zero detection (default 1e-10)
+ * @returns Rank (number of linearly independent rows/columns)
+ *
+ * @example
+ * matrixRank([[1,2],[2,4]]) // => 1
+ * matrixRank([[1,0],[0,1]]) // => 2
+ */
+export declare function matrixRank(A: number[][], tol?: f64): i32;
+/**
+ * Result of Cholesky decomposition.
+ */
+export interface CholeskyResult {
+    /** Lower triangular matrix L such that A = L * L^T */
+    L: number[][];
+}
+/**
+ * Cholesky decomposition of a symmetric positive-definite matrix.
+ *
+ * Decomposes A = L * L^T where L is lower triangular with positive
+ * diagonal entries. The matrix must be symmetric and positive definite,
+ * otherwise an error is thrown.
+ *
+ * @param A - Symmetric positive-definite matrix (n x n)
+ * @returns Object with L (lower triangular factor)
+ * @throws Error if matrix is not symmetric or not positive definite
+ *
+ * @example
+ * cholesky([[4,2],[2,3]])
+ * // => { L: [[2,0],[1, Math.sqrt(2)]] }
+ */
+export declare function cholesky(A: number[][]): CholeskyResult;
+/**
+ * Result of Hessenberg reduction.
+ */
+export interface HessenbergResult {
+    /** Upper Hessenberg matrix H */
+    H: number[][];
+    /** Orthogonal transformation matrix Q such that A = Q * H * Q^T */
+    Q: number[][];
+}
+/**
+ * Reduce a square matrix to upper Hessenberg form using Householder reflections.
+ *
+ * Computes Q and H such that A = Q * H * Q^T, where H is upper Hessenberg
+ * (zero below the first subdiagonal) and Q is orthogonal.
+ *
+ * @param A - Square matrix (n x n)
+ * @returns Object with H (Hessenberg) and Q (orthogonal)
+ *
+ * @example
+ * const { H, Q } = hessenbergForm([[1,2,3],[4,5,6],[7,8,9]]);
+ * // H is upper Hessenberg, Q is orthogonal, A = Q * H * Q^T
+ */
+export declare function hessenbergForm(A: number[][]): HessenbergResult;
+/**
+ * Compute a matrix raised to an integer or fractional power.
+ *
+ * For non-negative integers: uses binary exponentiation (repeated squaring).
+ * For p = -1: computes the matrix inverse via Gauss-Jordan elimination.
+ * For negative integers: computes inverse then raises to |p|.
+ * For fractional p: uses eigendecomposition A = V * diag(lambda) * V^{-1},
+ * then A^p = V * diag(lambda^p) * V^{-1}.
+ *
+ * @param A - Square matrix (n x n)
+ * @param p - Exponent (integer or fractional)
+ * @returns A^p as an n x n matrix
+ *
+ * @example
+ * matrixPower([[1,1],[0,1]], 3) // => [[1,3],[0,1]]
+ * matrixPower([[4,0],[0,9]], 0.5) // => [[2,0],[0,3]]
+ */
+export declare function matrixPower(A: number[][], p: f64): Promise<number[][]>;
+/**
+ * Compute the matrix logarithm.
+ *
+ * For matrices near the identity, uses the Padé approximant of log(I + X)
+ * with inverse scaling and squaring. For general matrices, uses eigendecomposition:
+ * log(A) = V * diag(log(lambda_i)) * V^{-1}.
+ *
+ * @param A - Square matrix with positive real eigenvalues
+ * @returns log(A) as an n x n matrix
+ *
+ * @example
+ * // log(exp([[0,1],[0,0]])) should recover [[0,1],[0,0]]
+ * matrixLog([[1,1],[0,1]]) // => [[0,1],[0,0]]
+ */
+export declare function matrixLog(A: number[][]): Promise<number[][]>;
+/**
+ * Result of polar decomposition.
+ */
+export interface PolarResult {
+    /** Unitary factor U (orthogonal for real matrices) */
+    U: number[][];
+    /** Positive semi-definite factor P */
+    P: number[][];
+}
+/**
+ * Compute the polar decomposition A = U * P.
+ *
+ * U is unitary (orthogonal for real matrices) and P is symmetric positive
+ * semi-definite. Computed via SVD: if A = W*S*V^T, then U = W*V^T and P = V*S*V^T.
+ *
+ * @param A - Square matrix (n x n)
+ * @returns Object with U (unitary) and P (positive semi-definite)
+ *
+ * @example
+ * const { U, P } = polarDecomposition([[1,0],[0,2]]);
+ * // U is identity (or close), P = [[1,0],[0,2]]
+ */
+export declare function polarDecomposition(A: number[][]): Promise<PolarResult>;
+/**
+ * Result of Jordan decomposition.
+ */
+export interface JordanResult {
+    /** Jordan normal form matrix J */
+    J: number[][];
+    /** Transformation matrix P such that A = P * J * P^{-1} */
+    P: number[][];
+}
+/**
+ * Compute the Jordan normal form of a square matrix.
+ *
+ * For matrices with distinct eigenvalues, this is simply the diagonal
+ * matrix of eigenvalues. For repeated eigenvalues, Jordan blocks are
+ * formed by analyzing the null spaces of (A - lambda*I)^k.
+ *
+ * Note: This implementation works best for matrices with real eigenvalues
+ * and reasonably well-conditioned eigenvectors. For matrices with complex
+ * eigenvalues, only the real parts are used.
+ *
+ * @param A - Square matrix (n x n)
+ * @returns Object with J (Jordan form) and P (transformation matrix)
+ *
+ * @example
+ * // Diagonal matrix with distinct eigenvalues
+ * jordanForm([[2,0],[0,3]]) // => { J: [[2,0],[0,3]], P: ... }
+ */
+export declare function jordanForm(A: number[][]): Promise<JordanResult>;
+/**
+ * Compute the Moore-Penrose pseudoinverse of a DenseMatrix (Option A — Slice 4.2 primitive).
+ *
+ * Delegates to the DenseMatrix-based `matrixPinv` from `@danielsimonjr/mathts-matrix`,
+ * which uses full SVD with `rcond · max(S)` singular-value thresholding.
+ *
+ * @example
+ * const A = DenseMatrix.fromArray([[1,2],[3,4],[5,6]]);
+ * const Ap = pinv(A);           // shape 2x3
+ * const Ap2 = pinv(A, { rcond: 1e-6 });
+ */
+export declare const pinv: import("typed-function").TypedFunction;
+/**
+ * Compute the condition number of a matrix (ratio σ_max / σ_min via SVD).
+ *
+ * Returns `Infinity` for singular or rank-deficient matrices.
+ *
+ * @example
+ * cond([[1,0],[0,2]])  // => 2
+ * cond([[1,2],[2,4]])  // => Infinity
+ */
+export declare const cond: import("typed-function").TypedFunction;
+/**
+ * Compute the spectral norm (2-norm) of a matrix — the largest singular value.
+ *
+ * @example
+ * norm2([[3,0],[0,2]])  // => 3
+ */
+export declare const norm2: import("typed-function").TypedFunction;
+/**
+ * Compute the Frobenius norm of a matrix — `sqrt(sum(A_ij²))`.
+ *
+ * @example
+ * normFro([[1,0],[0,1]])  // => sqrt(2) ≈ 1.414
+ */
+export declare const normFro: import("typed-function").TypedFunction;
+/**
+ * Compute a rank-k approximation of a matrix using truncated SVD.
+ *
+ * Returns the best rank-k approximation in the Frobenius-norm sense:
+ * `A_k = U[:, :k] * diag(S[:k]) * V[:, :k]^T`.
+ *
+ * @example
+ * lowRankApprox([[1,2],[3,4],[5,6]], 1)
+ */
+export declare const lowRankApprox: import("typed-function").TypedFunction;
+/**
+ * Return the singular values of a matrix in descending order.
+ *
+ * The result has length `min(m, n)` and all values are non-negative.
+ *
+ * @example
+ * singularValues([[3,0],[0,2]])  // => [3, 2]
+ */
+export declare const singularValues: import("typed-function").TypedFunction;
+/**
+ * Compute the matrix exponential via Padé-13 scaling-and-squaring.
+ *
+ * Dispatches on `DenseMatrix` (returns `DenseMatrix`) or `Array` (number[][],
+ * wraps in DenseMatrix, returns number[][]).
+ *
+ * Algorithm: Higham (2005) "The scaling and squaring method for the matrix
+ * exponential revisited." Accurate to near machine precision for general real
+ * matrices.
+ *
+ * @example
+ * matrixExpm(DenseMatrix.zeros(3, 3))          // => identity DenseMatrix
+ * matrixExpm([[0,0],[0,0]])                     // => [[1,0],[0,1]]
+ * matrixExpm([[1,0],[0,1]])                     // => [[e,0],[0,e]]
+ */
+export declare const matrixExpm: import("typed-function").TypedFunction;
+/**
+ * Compute the principal matrix logarithm via inverse scaling-and-squaring
+ * with 16-point Gauss-Legendre quadrature for log(I + X).
+ *
+ * Dispatches on `DenseMatrix` (returns `DenseMatrix`) or `Array` (returns
+ * number[][]). Throws for matrices with non-positive or complex eigenvalues.
+ *
+ * Slice 5.9a limitations:
+ *   - Non-positive eigenvalues: throws (principal log undefined).
+ *   - Complex eigenvalues: throws.
+ *   - Full Schur-based algorithm for non-diagonalisable A: Slice 5.9b.
+ *
+ * @example
+ * matrixLogm(DenseMatrix.eye(3))               // => zero DenseMatrix
+ * matrixLogm([[Math.E,0],[0,Math.E]])           // => [[1,0],[0,1]]
+ */
+export declare const matrixLogm: import("typed-function").TypedFunction;
+/**
+ * Compute the principal square root of a matrix.
+ *
+ * For symmetric positive semi-definite A: uses Newton iteration (robust for
+ * all non-negative eigenvalue cases). For general diagonalisable A: Newton
+ * iteration falling back to eigendecomposition.
+ *
+ * Dispatches on `DenseMatrix` (returns `DenseMatrix`) or `Array` (returns
+ * number[][]). Throws for matrices with negative or complex eigenvalues.
+ *
+ * Slice 5.9a limitations:
+ *   - Negative eigenvalues: throws (complex sqrt not supported).
+ *   - Complex eigenvalues: throws.
+ *   - Full Schur-based Björck-Hammarling: Slice 5.9b.
+ *
+ * @example
+ * matrixSqrtm(DenseMatrix.fromArray([[4,0],[0,9]]))  // => [[2,0],[0,3]] DenseMatrix
+ * matrixSqrtm([[4,0],[0,9]])                          // => [[2,0],[0,3]]
+ */
+export declare const matrixSqrtm: import("typed-function").TypedFunction;
+export {};
+//# sourceMappingURL=matrix-ops.d.ts.map

package/dist/typed/matrix-ops.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix-ops.d.ts","sourceRoot":"","sources":["../../src/typed/matrix-ops.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA2BH,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,GAAG,GAAG,MAAM,CAAC;AAgGlB;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,wBAAwB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAyB/E;AAMD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,GAAE,GAAW,GAAG,MAAM,EAAE,EAAE,CAqDrE;AAMD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,GAAG,GAAE,GAAW,GAAG,GAAG,CAc/D;AAMD;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,sDAAsD;IACtD,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;CACf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,cAAc,CAmCtD;AAMD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gCAAgC;IAChC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACd,mEAAmE;IACnE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;CACf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,gBAAgB,CAuE9D;AAMD;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAwB5E;AA8FD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAMlE;AAqJD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,sDAAsD;IACtD,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACd,sCAAsC;IACtC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;CACf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,WAAW,CAAC,CAiB5E;AAMD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,kCAAkC;IAClC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACd,2DAA2D;IAC3D,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAwErE;AA+MD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,IAAI,wCAIf,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,IAAI,wCAEf,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,KAAK,wCAEhB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,OAAO,wCAElB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,wCAExB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,wCAEzB,CAAC;AAMH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,wCAQrB,CAAC;AAMH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,wCAQrB,CAAC;AAMH;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,WAAW,wCAQtB,CAAC"}