@danielsimonjr/mathts-functions 0.34.0 → 0.36.0

package/dist/numeric/control-equations.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Control-theory matrix equations — `dlyap`/`care`/`dare`.
+ *
+ * These solve the algebraic matrix equations that underlie LQR (linear-
+ * quadratic regulator) and Kalman-filter design:
+ *
+ *   - {@link dlyap} — discrete Lyapunov equation `A X Aᵀ − X + Q = 0`, solved
+ *     directly via the Kronecker-product linear system
+ *     `(I − A⊗A) vec(X) = vec(Q)` (exact for the small `n` this targets;
+ *     the codebase's `linsolve` does the O(n²)³ = O(n⁶) dense solve).
+ *   - {@link care} — continuous algebraic Riccati equation
+ *     `AᵀX + XA − X B R⁻¹ Bᵀ X + Q = 0`, solved via the **matrix sign
+ *     function** applied to the Hamiltonian `H = [[A, −BR⁻¹Bᵀ], [−Q, −Aᵀ]]`.
+ *     This avoids both complex eigenvectors (this codebase's `eig` only
+ *     returns real eigenvector columns — see `matrix-functions.ts` — so a
+ *     Hamiltonian-eigenvector approach isn't usable here) and the need for a
+ *     stabilizing initial gain that a Kleinman/Newton iteration would
+ *     require (the natural starting point `X₀ = 0` is not stabilizing for
+ *     e.g. the classic double-integrator `A = [[0,1],[0,0]]`, which is only
+ *     marginally stable). The sign-function Newton iteration converges
+ *     unconditionally (given the standard stabilizability/detectability
+ *     assumptions) directly from `H` itself.
+ *   - {@link dare} — discrete algebraic Riccati equation
+ *     `AᵀXA − X − AᵀXB(R + BᵀXB)⁻¹BᵀXA + Q = 0`, solved via the
+ *     **structure-preserving doubling algorithm** (SDA), the discrete-time
+ *     analogue of the sign-function method above: it iterates a triple
+ *     `(Aₖ, Gₖ, Hₖ)` with quadratic convergence and, likewise, needs no
+ *     stabilizing initial gain.
+ *
+ * All three return the (numerically symmetrized) stabilizing solution `X`.
+ * Both `care`/`dare` require `R` invertible and `(A, B)` stabilizable — the
+ * standard LQR well-posedness assumptions.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Solve the discrete-time Lyapunov (Stein) equation `A X Aᵀ − X + Q = 0` for
+ * `X`, given square `A` and `Q` of the same size.
+ *
+ * Builds the Kronecker-product linear system `(I − A⊗A) vec(X) = vec(Q)`
+ * explicitly (practical for the `n ≲ 20` this targets — the system has
+ * `n²` unknowns) and solves it with `linsolve`.
+ *
+ * @example
+ * dlyap([[0.5, 0], [0, 0.5]], [[1, 0], [0, 1]]) // => (4/3) * I  (since 0.25x - x + 1 = 0)
+ */
+export declare function dlyap(A: number[][], Q: number[][]): number[][];
+/**
+ * Solve the continuous-time algebraic Riccati equation (CARE)
+ * `AᵀX + XA − X B R⁻¹ Bᵀ X + Q = 0` for the stabilizing symmetric `X`,
+ * given `A` (n×n), `B` (n×m), `Q` (n×n, typically PSD), `R` (m×m, invertible).
+ *
+ * Method: Newton iteration for the **matrix sign function** of the
+ * Hamiltonian `H = [[A, −BR⁻¹Bᵀ], [−Q, −Aᵀ]]` (2n×2n):
+ *
+ *   `Zₖ₊₁ = ½(cₖ Zₖ + cₖ⁻¹ Zₖ⁻¹)`,  `Z₀ = H`,  `cₖ = √(‖Zₖ⁻¹‖₁ / ‖Zₖ‖₁)`
+ *
+ * converging quadratically to `S = sign(H)`. The projector `P = ½(I − S)`
+ * has range equal to `H`'s stable (Re λ < 0) invariant subspace; taking its
+ * first `n` columns `U = [U₁; U₂]` (split at the `n`-th row) gives
+ * `X = U₂ U₁⁻¹` (real arithmetic throughout — no complex eigenvectors
+ * needed, unlike the classical Hamiltonian-eigenvector construction).
+ *
+ * @example
+ * care([[0, 1], [0, 0]], [[0], [1]], [[1, 0], [0, 1]], [[1]])
+ * // => [[sqrt(3), 1], [1, sqrt(3)]]  (pinned vs scipy.linalg.solve_continuous_are)
+ */
+export declare function care(A: number[][], B: number[][], Q: number[][], R: number[][]): number[][];
+/**
+ * Solve the discrete-time algebraic Riccati equation (DARE)
+ * `AᵀXA − X − AᵀXB(R + BᵀXB)⁻¹BᵀXA + Q = 0` for the stabilizing symmetric
+ * `X`, given `A` (n×n), `B` (n×m), `Q` (n×n, typically PSD), `R` (m×m,
+ * invertible).
+ *
+ * Method: the **structure-preserving doubling algorithm** (SDA) — the
+ * discrete-time analogue of the sign-function iteration used by {@link care}.
+ * Starting from `A₀ = A`, `G₀ = B R⁻¹ Bᵀ`, `H₀ = Q`, it iterates
+ *
+ *   `Aₖ₊₁ = Aₖ(I + GₖHₖ)⁻¹Aₖ`
+ *   `Gₖ₊₁ = Gₖ + Aₖ(I + GₖHₖ)⁻¹Gₖ Aₖᵀ`
+ *   `Hₖ₊₁ = Hₖ + Aₖᵀ Hₖ(I + GₖHₖ)⁻¹Aₖ`
+ *
+ * with `Hₖ → X` quadratically. Like {@link care}'s sign-function method, this
+ * needs no stabilizing initial gain (unlike a Kleinman/Newton iteration on
+ * the DARE directly) — only the standard stabilizability/detectability
+ * assumptions.
+ *
+ * @example
+ * dare([[1, 1], [0, 1]], [[0], [1]], [[1, 0], [0, 1]], [[1]])
+ * // => [[2.94712297, 2.36920541], [2.36920541, 4.61313426]]
+ * //    (pinned vs scipy.linalg.solve_discrete_are)
+ */
+export declare function dare(A: number[][], B: number[][], Q: number[][], R: number[][]): number[][];
+//# sourceMappingURL=control-equations.d.ts.map

package/dist/numeric/control-equations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"control-equations.d.ts","sourceRoot":"","sources":["../../src/numeric/control-equations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAuJH;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAgB9D;AASD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CA6C3F;AAMD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CA+B3F"}

package/dist/numeric/eigsh.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Iterative symmetric eigensolver — Lanczos tridiagonalization + Rayleigh-Ritz.
+ *
+ * For large symmetric problems where the dense `eigs` (full O(n^3)
+ * eigendecomposition of the whole matrix) is prohibitive, `eigsh` extracts
+ * just the `k` largest or smallest eigenpairs. It builds an orthonormal
+ * Krylov basis `V` via the Lanczos iteration (with full reorthogonalization
+ * against every prior Lanczos vector, for numerical stability at the small
+ * sizes this is exercised at), forming the small tridiagonal projection
+ * `T = Vᵀ A V`. `T`'s eigenproblem is solved directly (cyclic Jacobi
+ * rotations — `T` is dense-symmetric-small by construction) and lifted back
+ * through `V` (Rayleigh-Ritz) to approximate `A`'s eigenpairs. Accepts either
+ * a dense matrix or a matvec callback (a linear operator, matching the
+ * `krylov.ts` convention) — the matvec form never forms `A` and requires
+ * `opts.n` since the dimension can't otherwise be inferred.
+ *
+ * @packageDocumentation
+ */
+/** A symmetric linear operator: either a dense matrix or a matvec callback `x -> A x`. */
+export type EigshOperatorInput = number[][] | ((x: number[]) => number[]);
+/** Options accepted by {@link eigsh}. */
+export interface EigshOptions {
+    /** Which end of the spectrum to return: `'LM'` (largest, default) or `'SM'` (smallest). */
+    which?: 'LM' | 'SM';
+    /** Dimension of `A` — required when `A` is a matvec callback. */
+    n?: number;
+    /** Convergence tolerance for diagonalizing the small tridiagonal projection (default 1e-10). */
+    tol?: number;
+    /** Maximum Lanczos steps (default `min(max(2k + 20, 20), n)`). */
+    maxIter?: number;
+}
+/**
+ * Result of {@link eigsh}.
+ *
+ * `eigenvectors` is an `n x k` matrix with eigenvectors stored as **columns**:
+ * `eigenvectors[i][j]` is the `i`-th component of the `j`-th eigenvector,
+ * which corresponds to `eigenvalues[j]`.
+ */
+export interface EigshResult {
+    /** The `k` selected eigenvalues, ordered by `which` (largest-first for `'LM'`, smallest-first for `'SM'`). */
+    eigenvalues: number[];
+    /** The `k` corresponding eigenvectors, as columns of an `n x k` matrix. */
+    eigenvectors: number[][];
+}
+/**
+ * `eigsh` — the `k` largest or smallest eigenpairs of a **symmetric** matrix
+ * via the Lanczos iteration, for problems too large for the dense `eigs`.
+ *
+ * `A` may be a dense `number[][]` or a matvec callback `x => A x` (in which
+ * case `opts.n` is required — the dimension can't be inferred from a
+ * function). Eigenvectors are returned as **columns** of an `n x k` matrix:
+ * `result.eigenvectors[i][j]` is the `i`-th component of the eigenvector for
+ * `result.eigenvalues[j]`.
+ *
+ * @example
+ * eigsh([[2, 1, 0], [1, 2, 1], [0, 1, 2]], 1, { which: 'LM' })
+ * // => { eigenvalues: [2 + Math.SQRT2], eigenvectors: [[...]] }
+ */
+export declare function eigsh(a: EigshOperatorInput, k?: number, opts?: EigshOptions): EigshResult;
+//# sourceMappingURL=eigsh.d.ts.map

package/dist/numeric/eigsh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eigsh.d.ts","sourceRoot":"","sources":["../../src/numeric/eigsh.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,0FAA0F;AAC1F,MAAM,MAAM,kBAAkB,GAAG,MAAM,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC,CAAC;AAE1E,yCAAyC;AACzC,MAAM,WAAW,YAAY;IAC3B,2FAA2F;IAC3F,KAAK,CAAC,EAAE,IAAI,GAAG,IAAI,CAAC;IACpB,iEAAiE;IACjE,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,gGAAgG;IAChG,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,8GAA8G;IAC9G,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,2EAA2E;IAC3E,YAAY,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B;AAkKD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,kBAAkB,EAAE,CAAC,SAAI,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,WAAW,CAmDpF"}

package/dist/numeric/interpn.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Regular-grid N-D multilinear interpolation — `scipy.interpolate.interpn`
+ * (default `method='linear'`, `bounds_error=True`).
+ *
+ * Given `n` strictly-increasing coordinate arrays (`grids`) and a matching
+ * `n`-dimensional array of sampled values, `interpn` evaluates the
+ * multilinear interpolant at each query point: for a query point, the
+ * bracketing grid cell is located along every axis (binary search), and the
+ * result is the weighted average of the `2^n` cell-corner values, weighted
+ * by the fractional position within the cell along each axis. This is exact
+ * for functions that are affine in each coordinate (e.g. `f(x,y) = x + y`)
+ * and reduces to ordinary linear interpolation when `n = 1`.
+ *
+ * @packageDocumentation
+ */
+/** A nested numeric array of arbitrary depth (matches an N-D grid's shape). */
+export type NDArrayInput = number | readonly NDArrayInput[];
+/**
+ * Regular-grid multilinear interpolation, matching `scipy.interpolate.interpn`.
+ *
+ * @param grids - One strictly-increasing coordinate array per dimension (1 for
+ *   1-D, 2 for bilinear, 3 for trilinear, etc.).
+ * @param values - Sampled values on the grid, nested `grids.length` levels
+ *   deep and shaped `grids.map(g => g.length)` (e.g. for 2-D,
+ *   `values[i][j] === f(grids[0][i], grids[1][j])`); for 1-D, a flat
+ *   `number[]`.
+ * @param query - Points to interpolate at, each with `grids.length` coordinates.
+ * @returns The interpolated value at each query point.
+ * @throws If a grid axis is not strictly increasing, if `values`' shape
+ *   doesn't match `grids`, or if a query point falls outside the grid's
+ *   bounding box (matches scipy's default `bounds_error=True` — no
+ *   extrapolation).
+ *
+ * @example
+ * const xs = [0, 1, 2], ys = [0, 1, 2];
+ * const vals = xs.map((x) => ys.map((y) => x + y)); // f(x,y) = x + y
+ * interpn([xs, ys], vals, [[0.5, 0.5]]); // [1] (exact — f is affine)
+ */
+export declare function interpn(grids: readonly (readonly number[])[], values: NDArrayInput, query: readonly (readonly number[])[]): number[];
+//# sourceMappingURL=interpn.d.ts.map

package/dist/numeric/interpn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpn.d.ts","sourceRoot":"","sources":["../../src/numeric/interpn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,+EAA+E;AAC/E,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,SAAS,YAAY,EAAE,CAAC;AA8D5D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACrC,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,GACpC,MAAM,EAAE,CA0CV"}

package/dist/numeric/interval.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Interval arithmetic with outward rounding.
+ *
+ * `Interval` (constructed via the `interval(lo, hi)` factory) implements
+ * rigorous interval arithmetic: every operation guarantees the true
+ * mathematical result over any pair of real inputs drawn from the operand
+ * intervals is contained in the returned interval. JavaScript has no access
+ * to IEEE-754 directed rounding modes (round-toward-negative-infinity /
+ * round-toward-positive-infinity), so as a practical surrogate every result
+ * is nudged outward by a tiny relative epsilon (`Number.EPSILON`) plus one
+ * ULP (`Number.MIN_VALUE`) after each operation: `lo` is decreased and `hi`
+ * is increased. This is the same idea underlying mpmath's `iv` module and
+ * MATLAB's INTLAB — a verified-bounds numeric type, the first in this
+ * library.
+ *
+ * @packageDocumentation
+ */
+/**
+ * A closed real interval `[lo, hi]` with outward-rounded arithmetic.
+ *
+ * Construct via the {@link interval} factory rather than `new Interval(...)`
+ * directly (both work; the factory reads more naturally at call sites).
+ */
+export declare class Interval {
+    readonly lo: number;
+    readonly hi: number;
+    constructor(lo: number, hi: number);
+    /** `[this.lo + b.lo, this.hi + b.hi]`, outward-rounded. */
+    add(b: Interval): Interval;
+    /** `[this.lo - b.hi, this.hi - b.lo]`, outward-rounded. */
+    sub(b: Interval): Interval;
+    /**
+     * Interval product: the min/max of all four endpoint products
+     * (`lo*lo, lo*hi, hi*lo, hi*hi`), outward-rounded. Correct for any
+     * combination of signs.
+     */
+    mul(b: Interval): Interval;
+    /**
+     * Interval quotient. Throws if `b` contains 0 (division would be
+     * unbounded). Otherwise the min/max of the four endpoint quotients,
+     * outward-rounded.
+     */
+    div(b: Interval): Interval;
+    /** `[-this.hi, -this.lo]`, outward-rounded. */
+    neg(): Interval;
+    /** `hi - lo`. */
+    width(): number;
+    /** `(lo + hi) / 2`. */
+    mid(): number;
+    /** Whether the closed interval `[lo, hi]` contains the real number `x`. */
+    contains(x: number): boolean;
+    /**
+     * Square root, monotonic-increasing over `[0, +Infinity)`. Throws if the
+     * interval contains negative values (real square root is undefined there).
+     */
+    sqrt(): Interval;
+    /** Exponential, monotonic-increasing over all reals. */
+    exp(): Interval;
+    /**
+     * Natural log, monotonic-increasing over `(0, +Infinity)`. Throws if the
+     * interval is not strictly positive.
+     */
+    log(): Interval;
+    /**
+     * Integer power `x^n`, monotonic-aware:
+     * - `n` odd: `x^n` is monotonic-increasing over all reals, so the result is
+     *   `[lo^n, hi^n]`.
+     * - `n` even, interval entirely non-negative: monotonic-increasing, so
+     *   `[lo^n, hi^n]`.
+     * - `n` even, interval entirely non-positive: monotonic-decreasing (in
+     *   magnitude, toward zero), so `[hi^n, lo^n]`.
+     * - `n` even, interval spans zero: the minimum is `0` (attained at `x=0`)
+     *   and the maximum is `max(|lo|, |hi|)^n`.
+     * - `n` negative: computed as the reciprocal of `pow(-n)`; throws if that
+     *   positive-power interval contains zero (division by zero).
+     * - `n = 0`: `[1, 1]` for every interval.
+     *
+     * Throws if `n` is not an integer.
+     */
+    pow(n: number): Interval;
+}
+/** Construct an `Interval([lo, hi])`. Throws if `lo > hi`. */
+export declare function interval(lo: number, hi: number): Interval;
+//# sourceMappingURL=interval.d.ts.map

package/dist/numeric/interval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interval.d.ts","sourceRoot":"","sources":["../../src/numeric/interval.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAYH;;;;;GAKG;AACH,qBAAa,QAAQ;IACnB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;gBAER,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM;IAQlC,2DAA2D;IAC3D,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ;IAI1B,2DAA2D;IAC3D,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ;IAI1B;;;;OAIG;IACH,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ;IAQ1B;;;;OAIG;IACH,GAAG,CAAC,CAAC,EAAE,QAAQ,GAAG,QAAQ;IAW1B,+CAA+C;IAC/C,GAAG,IAAI,QAAQ;IAIf,iBAAiB;IACjB,KAAK,IAAI,MAAM;IAIf,uBAAuB;IACvB,GAAG,IAAI,MAAM;IAIb,2EAA2E;IAC3E,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO;IAI5B;;;OAGG;IACH,IAAI,IAAI,QAAQ;IAOhB,wDAAwD;IACxD,GAAG,IAAI,QAAQ;IAIf;;;OAGG;IACH,GAAG,IAAI,QAAQ;IAOf;;;;;;;;;;;;;;;OAeG;IACH,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,QAAQ;CA2BzB;AAED,8DAA8D;AAC9D,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,CAEzD"}

package/dist/numeric/krylov.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Iterative Krylov-subspace linear solvers.
+ *
+ * For the large sparse systems a dense factorization (`lusolve`, `qr`, …)
+ * can't handle — none of these methods ever form or fill in `A`. Each solver
+ * accepts either a dense matrix or a matvec callback (a "linear operator" in
+ * the SciPy/Trilinos sense), plus an optional preconditioner:
+ *
+ * - `cg` — Conjugate Gradient, for symmetric positive-definite `A`.
+ * - `minres` — MINRES, for symmetric (possibly indefinite) `A`.
+ * - `gmres` — restarted GMRES, for general nonsymmetric `A`.
+ * - `bicgstab` — BiCGSTAB, for general nonsymmetric `A`.
+ *
+ * @packageDocumentation
+ */
+/** A linear operator: either a dense matrix or a matvec callback `x -> A x`. */
+export type LinearOperatorInput = number[][] | ((x: number[]) => number[]);
+/** Preconditioner: `'jacobi'` (diagonal, dense-matrix only) or a custom `M⁻¹` callback. */
+export type Preconditioner = 'jacobi' | ((r: number[]) => number[]);
+/** Common options accepted by every solver in this module. */
+export interface KrylovOptions {
+    /** Initial guess (default: the zero vector). */
+    x0?: number[];
+    /** Relative-residual convergence tolerance (default 1e-10). */
+    tol?: number;
+    /** Maximum iterations (default `min(10 * n, 1000)`). */
+    maxIter?: number;
+    /** Preconditioner: `'jacobi'` or a custom `(r) => M⁻¹r` callback. */
+    preconditioner?: Preconditioner;
+}
+/** Options for {@link gmres}, adding the restart length. */
+export interface GmresOptions extends KrylovOptions {
+    /** Restart length (default 30). */
+    restart?: number;
+}
+/** Result returned by every solver in this module. */
+export interface KrylovResult {
+    /** Approximate solution. */
+    x: number[];
+    /** Number of iterations performed. */
+    iterations: number;
+    /** Whether the relative residual dropped below `tol`. */
+    converged: boolean;
+    /** Final relative residual `‖b − A x‖₂ / ‖b‖₂`. */
+    residual: number;
+}
+/**
+ * Conjugate Gradient (CG) — for symmetric positive-definite `A`.
+ *
+ * @example
+ * cg([[4, 1], [1, 3]], [1, 2]) // => { x: [1/11, 7/11], converged: true, ... }
+ */
+export declare function cg(a: LinearOperatorInput, b: number[], opts?: KrylovOptions): KrylovResult;
+/**
+ * MINRES — for symmetric (possibly indefinite) `A`.
+ *
+ * Builds the preconditioned Lanczos tridiagonalization of `A` and, at each
+ * step, solves the growing `(k+1) x k` tridiagonal least-squares problem
+ * `min ||beta1 e1 - T_k y||` via a small dense Householder QR. This is the
+ * textbook MINRES minimization restated directly (rather than the
+ * incrementally-updated Givens-rotation form), which keeps it simple to
+ * verify against a closed-form oracle at the cost of some redundant work
+ * per iteration — acceptable since `maxIter` is bounded by `min(10n, 1000)`.
+ *
+ * @example
+ * minres([[0, 1], [1, 0]], [1, 2]) // => { x: [2, 1], converged: true, ... }
+ */
+export declare function minres(a: LinearOperatorInput, b: number[], opts?: KrylovOptions): KrylovResult;
+/**
+ * Restarted GMRES — for general nonsymmetric `A`.
+ *
+ * @example
+ * gmres([[3, 1], [0, 2]], [4, 2]) // => { x: [1, 1], converged: true, ... }
+ */
+export declare function gmres(a: LinearOperatorInput, b: number[], opts?: GmresOptions): KrylovResult;
+/**
+ * BiCGSTAB — for general nonsymmetric `A`.
+ *
+ * @example
+ * bicgstab([[3, 1], [0, 2]], [4, 2]) // => { x: [1, 1], converged: true, ... }
+ */
+export declare function bicgstab(a: LinearOperatorInput, b: number[], opts?: KrylovOptions): KrylovResult;
+//# sourceMappingURL=krylov.d.ts.map

package/dist/numeric/krylov.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"krylov.d.ts","sourceRoot":"","sources":["../../src/numeric/krylov.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,gFAAgF;AAChF,MAAM,MAAM,mBAAmB,GAAG,MAAM,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC,CAAC;AAE3E,2FAA2F;AAC3F,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC,CAAC;AAEpE,8DAA8D;AAC9D,MAAM,WAAW,aAAa;IAC5B,gDAAgD;IAChD,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC;IACd,+DAA+D;IAC/D,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;AAED,4DAA4D;AAC5D,MAAM,WAAW,YAAa,SAAQ,aAAa;IACjD,mCAAmC;IACnC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,sDAAsD;AACtD,MAAM,WAAW,YAAY;IAC3B,4BAA4B;IAC5B,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,SAAS,EAAE,OAAO,CAAC;IACnB,mDAAmD;IACnD,QAAQ,EAAE,MAAM,CAAC;CAClB;AAmGD;;;;;GAKG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,YAAY,CAwC1F;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,YAAY,CAyF9F;AA8CD;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,YAAY,GAAG,YAAY,CA2F5F;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,mBAAmB,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,YAAY,CAqEhG"}

package/dist/numeric/matrix-functions.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Complex matrix functions — `funm`/`cosm`/`sinm` for a general real matrix.
+ *
+ * `funm(A, f)` evaluates a scalar analytic function `f` at a square matrix
+ * `A`, returning the complex matrix `f(A)`. Unlike `sqrtm`/`matrixLogm`
+ * (which only handle real matrices whose spectrum stays on the principal
+ * branch — positive reals for sqrt/log), `funm` accepts any real spectrum
+ * (negative, complex-conjugate pairs, …) because the result is allowed to be
+ * complex-valued.
+ *
+ * Algorithm (diagonalizable matrices with distinct eigenvalues):
+ *   - If `A` is diagonal, `f(A)` is exact and trivial: apply `f` to each
+ *     diagonal entry (handles repeated eigenvalues fine, since a diagonal
+ *     matrix is always diagonalizable regardless of eigenvalue multiplicity).
+ *   - Otherwise, compute `A`'s eigenvalues `λ_1, …, λ_n` (via the shared
+ *     `@danielsimonjr/mathts-matrix` `eig` — Householder + Francis QR) and,
+ *     when they are all distinct, apply the Lagrange-Sylvester interpolation
+ *     formula for a diagonalizable matrix with simple spectrum:
+ *
+ *       f(A) = Σ_i f(λ_i) · L_i(A),   L_i(A) = Π_{j≠i} (A − λ_j I) / (λ_i − λ_j)
+ *
+ *     evaluated in complex arithmetic (`A` embedded with zero imaginary
+ *     part). This needs only eigenvalues, not eigenvectors, and is exact for
+ *     any polynomial or entire function `f` (cos, sin, sqrt, exp, log, …)
+ *     whenever the spectrum is simple.
+ *
+ * Limitation (documented, not yet implemented): matrices with repeated (or
+ * numerically indistinguishable) eigenvalues that are NOT diagonal — i.e.
+ * genuinely defective/non-diagonalizable matrices, or diagonalizable
+ * matrices with a repeated eigenvalue and off-diagonal structure — are not
+ * supported; `funm` throws rather than silently return a wrong answer. A
+ * full Schur-Parlett block recurrence (Higham 2008 Ch. 9) would lift this
+ * restriction; that is future work, not required by the current call sites.
+ *
+ * @packageDocumentation
+ */
+/** A complex number as a plain `{re, im}` pair. */
+export interface ComplexValue {
+    re: number;
+    im: number;
+}
+/** A complex-valued dense matrix, stored as parallel real/imaginary 2-D arrays. */
+export interface ComplexMatrix {
+    re: number[][];
+    im: number[][];
+}
+/** A scalar analytic function to be applied to a matrix's spectrum. */
+export type ScalarComplexFunction = (z: ComplexValue) => ComplexValue;
+/**
+ * Evaluate the matrix function `f(A)` for a square real matrix `A`, returning
+ * a complex matrix `{re, im}`.
+ *
+ * Supports diagonal matrices unconditionally (exact, elementwise), and
+ * general diagonalizable matrices whose eigenvalues are pairwise distinct
+ * (Lagrange-Sylvester interpolation on the spectrum — see module docs).
+ * Throws for matrices with repeated or numerically indistinguishable
+ * eigenvalues that are not diagonal (defective / non-diagonalizable case;
+ * not yet supported — see module docs for the Schur-Parlett follow-up).
+ *
+ * @param A - Square real matrix, as a plain 2-D array.
+ * @param f - Scalar function to apply to each eigenvalue, e.g. `cos`, `sin`,
+ *   `sqrt`, `exp`, `log`, extended to complex arguments.
+ * @returns `{ re, im }` — the (possibly complex) matrix `f(A)`.
+ */
+export declare function funm(A: number[][], f: ScalarComplexFunction): ComplexMatrix;
+/** Complex cosine: `cos(z) = cos(re)cosh(im) - i sin(re)sinh(im)`. */
+export declare function complexCos(z: ComplexValue): ComplexValue;
+/** Complex sine: `sin(z) = sin(re)cosh(im) + i cos(re)sinh(im)`. */
+export declare function complexSin(z: ComplexValue): ComplexValue;
+/** Matrix cosine `cos(A)`, via {@link funm} with {@link complexCos}. */
+export declare function cosm(A: number[][]): ComplexMatrix;
+/** Matrix sine `sin(A)`, via {@link funm} with {@link complexSin}. */
+export declare function sinm(A: number[][]): ComplexMatrix;
+//# sourceMappingURL=matrix-functions.d.ts.map

package/dist/numeric/matrix-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix-functions.d.ts","sourceRoot":"","sources":["../../src/numeric/matrix-functions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAIH,mDAAmD;AACnD,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,mFAAmF;AACnF,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;IACf,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC;CAChB;AAED,uEAAuE;AACvE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,EAAE,YAAY,KAAK,YAAY,CAAC;AAoHtE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,qBAAqB,GAAG,aAAa,CAuD3E;AAED,sEAAsE;AACtE,wBAAgB,UAAU,CAAC,CAAC,EAAE,YAAY,GAAG,YAAY,CAKxD;AAED,oEAAoE;AACpE,wBAAgB,UAAU,CAAC,CAAC,EAAE,YAAY,GAAG,YAAY,CAKxD;AAED,wEAAwE;AACxE,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,aAAa,CAEjD;AAED,sEAAsE;AACtE,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,aAAa,CAEjD"}

package/dist/numeric/structured-solvers.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Structured and indefinite direct linear solvers.
+ *
+ * These exploit matrix structure (tridiagonal, banded, Toeplitz, symmetric
+ * indefinite) to solve `Ax = b` in less than the O(n^3) a general dense LU
+ * (`lusolve`) would cost, or — for `ldl` — to factor matrices `cholesky`
+ * cannot handle because they are not positive-definite (e.g. KKT systems):
+ *
+ * - `thomasSolve` — the Thomas algorithm, O(n) for tridiagonal systems.
+ * - `solveBanded` — banded-aware Gaussian elimination (no pivoting; touches
+ *   only the O(n(l+u)) entries inside the band), for systems with `l` lower
+ *   and `u` upper nonzero diagonals.
+ * - `toeplitzSolve` — the Levinson–Durbin recursion, O(n^2) for a Toeplitz
+ *   system given only its first row and column.
+ * - `ldl` — Bunch–Kaufman-pivoted LDLᵀ factorization of a symmetric
+ *   (possibly indefinite) matrix, with 1x1/2x2 diagonal blocks.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Thomas algorithm — O(n) solve of a tridiagonal system `Ax = d`.
+ *
+ * `A` is the tridiagonal matrix with subdiagonal `sub` (length n−1),
+ * diagonal `diag` (length n), and superdiagonal `sup` (length n−1). No
+ * pivoting is performed (as with any tridiagonal Thomas solve); the matrix
+ * should be diagonally dominant or otherwise stable without it.
+ *
+ * @example
+ * thomasSolve([-1, -1], [2, 2, 2], [-1, -1], [1, 0, 1]) // => [1, 1, 1]
+ */
+export declare function thomasSolve(sub: number[], diag: number[], sup: number[], d: number[]): number[];
+/**
+ * Banded-aware Gaussian elimination — solve `Ax = b` for a matrix with `l`
+ * nonzero lower diagonals and `u` nonzero upper diagonals (all other entries
+ * are assumed zero, though `A` is passed as a full dense matrix). Only the
+ * O(n(l+u)) entries inside the band are touched during elimination and
+ * back-substitution. No pivoting is performed — as with {@link thomasSolve},
+ * the matrix should be diagonally dominant or otherwise stable without it.
+ *
+ * @example
+ * solveBanded(1, 1, [[2, -1, 0], [-1, 2, -1], [0, -1, 2]], [1, 0, 1]) // => [1, 1, 1]
+ */
+export declare function solveBanded(l: number, u: number, A: number[][], b: number[]): number[];
+/**
+ * Levinson–Durbin recursion — O(n²) solve of a Toeplitz system `Tx = b`
+ * given only the first column `c` and first row `r` (`c[0]` must equal
+ * `r[0]`, the shared diagonal value). `T[i][j] = c[i-j]` for `i >= j`, else
+ * `r[j-i]`.
+ *
+ * Order-recursively builds the solution together with two auxiliary
+ * "predictor" vectors — one for `T`, one for `Tᵀ` (mutually coupled via the
+ * persymmetry `J T J = Tᵀ` that every Toeplitz matrix has, `J` the
+ * reversal/exchange matrix) — which is what makes a general (non-symmetric)
+ * Toeplitz system solvable in O(n²) rather than O(n³).
+ *
+ * @example
+ * toeplitzSolve([2, 1], [2, 1], [1, 2]) // => [0, 1]
+ */
+export declare function toeplitzSolve(c: number[], r: number[], b: number[]): number[];
+/** Result of {@link ldl}. */
+export interface LDLResult {
+    /** Unit lower-triangular factor. */
+    L: number[][];
+    /** Block-diagonal factor (1x1 or 2x2 blocks along the diagonal). */
+    D: number[][];
+    /**
+     * Permutation such that `(P A Pᵀ)[i][j] = A[perm[i]][perm[j]]` and
+     * `L D Lᵀ = P A Pᵀ`.
+     */
+    perm: number[];
+}
+/**
+ * Bunch–Kaufman-pivoted LDLᵀ factorization of a symmetric (possibly
+ * indefinite) matrix `A`, useful for symmetric systems `cholesky` can't
+ * handle because they aren't positive-definite (e.g. KKT / saddle-point
+ * systems from constrained optimization).
+ *
+ * Reconstruction identity: `L D Lᵀ = P A Pᵀ`, where `P` is the permutation
+ * matrix with `P[i][perm[i]] = 1`, i.e. `(P A Pᵀ)[i][j] = A[perm[i]][perm[j]]`.
+ * `L` is unit lower-triangular; `D` is block-diagonal with 1x1 or 2x2 blocks
+ * (2x2 blocks appear where a pivot would otherwise be too small relative to
+ * the rest of its column, per the standard Bunch–Kaufman pivot selection).
+ *
+ * @example
+ * const { L, D, perm } = ldl([[1, 2, 3], [2, 1, 4], [3, 4, 1]]);
+ * // L D L^T reconstructs A with rows/cols permuted by perm.
+ */
+export declare function ldl(A: number[][]): LDLResult;
+//# sourceMappingURL=structured-solvers.d.ts.map

package/dist/numeric/structured-solvers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"structured-solvers.d.ts","sourceRoot":"","sources":["../../src/numeric/structured-solvers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CA+B/F;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAwCtF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CA8E7E;AAED,6BAA6B;AAC7B,MAAM,WAAW,SAAS;IACxB,oCAAoC;IACpC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACd,oEAAoE;IACpE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACd;;;OAGG;IACH,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,SAAS,CAwG5C"}

package/dist/typed/algebra.d.ts

@@ -191,7 +191,13 @@ export declare function variables(expr: string): string[];
 export declare function substitute(expr: string, vars: Record<string, string>): string;
 /**
  * Expand an expression string by distributing multiplication over addition.
- * Basic implementation: handles simple products of sums.
+ *
+ * **Univariate polynomials** (a single variable, integer/no non-integer
+ * powers, no function calls) are expanded EXACTLY via `polyFromExpression` +
+ * `polyToString`: `expand('(x+1)^3')` → `'1*x^3 + 3*x^2 + 3*x + 1'`.
+ *
+ * Everything else (multiple variables, non-polynomial pieces) falls back to
+ * the original regex-based distributor below.
  *
  * @param expr - Expression string
  * @returns Expanded expression string
@@ -199,12 +205,22 @@ export declare function substitute(expr: string, vars: Record<string, string>):
  * @example
  * ```typescript
  * expand('(a+b)*(c+d)'); // 'a*c + a*d + b*c + b*d'
+ * expand('(x+1)^3');     // '1*x^3 + 3*x^2 + 3*x + 1'
  * ```
  */
 export declare function expand(expr: string): string;
 /**
  * Factor an expression string.
- * Basic implementation: factors out common numeric factors and GCDs from terms.
+ *
+ * **Univariate polynomials** (a single variable, integer coefficients,
+ * degree ≥ 2) are factored over ℚ via the rational-root theorem: candidate
+ * roots ±(divisors of the constant term)/(divisors of the leading
+ * coefficient) are tested, each confirmed root's linear factor is divided
+ * out exactly, and any irreducible remainder is left as-is:
+ * `factor('x^2-1')` → `'(x - 1)*(x + 1)'`.
+ *
+ * Everything else (multiple variables, no rational root) falls back to the
+ * original common-integer-factor extraction below.
  *
  * @param expr - Expression string
  * @returns Factored expression string
@@ -235,7 +251,17 @@ export declare function collect(expr: string, variable: string): string;
  */
 export declare function cancel(expr: string): string;
 /**
- * Combine fractions to a common denominator.
+ * Combine a sum of rational terms into a single fraction over a common
+ * (not necessarily lowest) denominator.
+ *
+ * **Univariate rationals** (a single variable, e.g. `1/x + 1/(x+1)`) are
+ * combined EXACTLY: the common denominator is the product of every term's
+ * denominator, and the numerator is the exact polynomial sum
+ * `Σ numᵢ · Π_{j≠i} denⱼ`, simplified via `polyFromExpression`/`polyToString`:
+ * `together('1/x + 1/(x+1)')` → `'(2*x + 1)/((x)*((x+1)))'`.
+ *
+ * Everything else (no variable, i.e. purely numeric) falls back to the
+ * original numeric-fraction addition below.
  *
  * @param expr - Expression string
  * @returns Combined expression
@@ -244,6 +270,17 @@ export declare function together(expr: string): string;
 /**
  * Partial fraction decomposition.
  *
+ * **Univariate rationals with a fully-factorable denominator** (distinct
+ * rational roots only — repeated roots are out of scope) are decomposed via
+ * the cover-up/residue method: `apart('1/(x^2-1)')` →
+ * `'1/(2*(x - 1)) - 1/(2*(x + 1))'`. An improper fraction (numerator degree ≥
+ * denominator degree) is first split into a polynomial quotient + proper
+ * remainder via `polynomialQuotient`/`polynomialRemainder`.
+ *
+ * Everything else (no variable — i.e. purely numeric — multiple variables,
+ * or a denominator that doesn't factor into distinct rational linear
+ * factors) falls back to the original numeric-only path below.
+ *
  * @param expr - Expression string
  * @returns Decomposed expression
  */

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

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