@danielsimonjr/mathts-functions 0.28.0 → 0.30.0

package/dist/linalg-svd-extra.d.ts

@@ -0,0 +1,21 @@
+/** Options for {@link orth}. */
+export interface OrthOptions {
+    /**
+     * Rank-determination tolerance. Singular values `> tol` count toward the
+     * rank. Default: `max(m, n) * S[0] * 2.22e-16` (machine epsilon scaled by
+     * matrix size and the largest singular value).
+     */
+    tol?: number;
+}
+/**
+ * Orthonormal basis for the column space of `A`.
+ *
+ * Computes `{ U, S } = svd(A)` and returns the first `r` columns of `U`,
+ * where `r` is the number of singular values above `tol`. For the all-zero
+ * matrix (`r = 0`), returns an `m x 0` matrix (each row an empty array).
+ *
+ * @example
+ * orth([[1,0,1],[0,1,1],[1,1,2]])  // rank 2 -> 3x2 matrix, U^T U = I
+ */
+export declare function orth(A: number[][], opts?: OrthOptions): number[][];
+//# sourceMappingURL=linalg-svd-extra.d.ts.map

package/dist/linalg-svd-extra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linalg-svd-extra.d.ts","sourceRoot":"","sources":["../src/linalg-svd-extra.ts"],"names":[],"mappings":"AAWA,gCAAgC;AAChC,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,GAAE,WAAgB,GAAG,MAAM,EAAE,EAAE,CAQtE"}

package/dist/numeric/adaptive-quad.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Adaptive Gauss-Kronrod (G7-K15) quadrature.
+ *
+ * QUADPACK-style adaptive numerical integration: on each subinterval, a
+ * 15-point Kronrod estimate `K` is compared against the embedded 7-point
+ * Gauss estimate `G` (both reuse the same 15 evaluation points, so `G` is
+ * "free" once `K` is computed). `|K - G|` is the panel's error estimate; if
+ * it exceeds tolerance the interval is bisected and each half is refined
+ * recursively. This adapts naturally to endpoint singularities and peaked
+ * integrands, unlike a fixed-order Gauss-Legendre rule (see `gaussLegendre5`
+ * in `../typed/numeric.ts`, whose Richardson-extrapolation adaptivity still
+ * converges slowly on e.g. `x^-1/2` near 0).
+ *
+ * @packageDocumentation
+ */
+type f64 = number;
+type i32 = number;
+/** Options for {@link quad}. */
+export interface QuadOptions {
+    /** Relative tolerance on each panel's `|K - G|` vs `|K|` (default 1e-10). */
+    tol?: f64;
+    /** Maximum bisection recursion depth per panel (default 50). */
+    maxDepth?: i32;
+}
+/** Result of {@link quad}. */
+export interface QuadResult {
+    /** The estimated integral. */
+    value: f64;
+    /** Sum of the absolute per-panel `|K - G|` error estimates. */
+    error: f64;
+}
+/**
+ * Adaptive Gauss-Kronrod (G7-K15) numerical integration of `f` over `[a, b]`.
+ *
+ * Each subinterval is evaluated with the 15-point Kronrod rule and its
+ * embedded 7-point Gauss rule; `|K - G|` is the panel's error estimate. A
+ * panel whose error exceeds `tol * |K|` (or the absolute floor, for panels
+ * near zero) is bisected and each half refined recursively, up to
+ * `maxDepth`. This adapts naturally to endpoint singularities and sharply
+ * peaked integrands.
+ *
+ * @param f - Function to integrate
+ * @param a - Lower bound
+ * @param b - Upper bound
+ * @param opts - Options (tol, maxDepth)
+ * @returns `{ value, error }` — the estimated integral and summed panel error
+ *
+ * @example
+ * ```typescript
+ * quad((x) => 4 / (1 + x * x), 0, 1).value; // ~pi
+ * quad((x) => 1 / Math.sqrt(x), 0, 1).value; // ~2, despite the endpoint singularity
+ * ```
+ */
+export declare function quad(f: (x: f64) => f64, a: f64, b: f64, opts?: QuadOptions): QuadResult;
+export {};
+//# sourceMappingURL=adaptive-quad.d.ts.map

package/dist/numeric/adaptive-quad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adaptive-quad.d.ts","sourceRoot":"","sources":["../../src/numeric/adaptive-quad.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,GAAG,GAAG,MAAM,CAAC;AAElB,gCAAgC;AAChC,MAAM,WAAW,WAAW;IAC1B,6EAA6E;IAC7E,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,gEAAgE;IAChE,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB;AAED,8BAA8B;AAC9B,MAAM,WAAW,UAAU;IACzB,8BAA8B;IAC9B,KAAK,EAAE,GAAG,CAAC;IACX,+DAA+D;IAC/D,KAAK,EAAE,GAAG,CAAC;CACZ;AAgED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,UAAU,CAmBvF"}

package/dist/numeric/bfgs.d.ts

@@ -0,0 +1,70 @@
+/**
+ * BFGS quasi-Newton minimization of `f: ℝⁿ → ℝ`.
+ *
+ * Maintains an approximate inverse Hessian `H` (started at the identity) and
+ * updates it after every accepted step via the classic BFGS formula:
+ *
+ *   s = x_{k+1} − x_k,  y = g_{k+1} − g_k,  ρ = 1 / (yᵀs)
+ *   H ← (I − ρ s yᵀ) H (I − ρ y sᵀ) + ρ s sᵀ
+ *
+ * The update is skipped (H left unchanged) when `yᵀs ≤ 1e-12` — a near-zero
+ * or negative curvature pairing would make H indefinite. The search direction
+ * is `d = −H g`, accepted via a backtracking Armijo line search (`c1 = 1e-4`,
+ * starting step `α = 1`, halved up to 50 times).
+ *
+ * `opts.bounds`, if supplied, turns this into a lightweight **projected**
+ * BFGS: after every accepted step each coordinate is clipped into its
+ * `[lo, hi]` range. This is NOT the full active-set L-BFGS-B method (no
+ * distinction between free/active variables in the Hessian update) — it is a
+ * simple, effective projection that keeps the iterate feasible.
+ *
+ * Complements the derivative-free `minimize` (Nelder–Mead): BFGS converges
+ * superlinearly on smooth functions using gradient information (analytic or
+ * numeric), at the cost of assuming enough smoothness for the gradient/line
+ * search to behave.
+ *
+ * @packageDocumentation
+ */
+type f64 = number;
+/** Options for {@link bfgs}. */
+export interface BfgsOptions {
+    /**
+     * Analytic gradient `∇f(x)`. If omitted, a central-difference gradient is
+     * used with per-coordinate step `h_i = max(1, |x_i|) · cbrt(machine eps)`.
+     */
+    grad?: (x: number[]) => number[];
+    /**
+     * Box constraints `[lo_i, hi_i]` per coordinate. After each accepted step,
+     * `x` is clipped into these bounds (projected BFGS — a lightweight
+     * approximation of L-BFGS-B, not the full active-set method).
+     */
+    bounds?: [f64, f64][];
+    /** Convergence tolerance on `‖g‖∞` (default 1e-8). */
+    tol?: f64;
+    /** Maximum iterations (default 500). */
+    maxIter?: number;
+}
+/** Result of {@link bfgs}. */
+export interface BfgsResult {
+    /** The minimizer. */
+    x: number[];
+    /** `f(x)` at the minimizer. */
+    fval: f64;
+    /** Number of iterations performed. */
+    iterations: number;
+    /** Whether `‖g‖∞ < tol` was reached within `maxIter`. */
+    converged: boolean;
+}
+/**
+ * Minimize `f: ℝⁿ → ℝ` from `x0` via BFGS quasi-Newton with an Armijo
+ * backtracking line search. Uses `opts.grad` if supplied, else a local
+ * central-difference gradient. `opts.bounds` clips each accepted step
+ * (projected BFGS, not full L-BFGS-B).
+ *
+ * @example
+ * bfgs((v) => (1 - v[0]) ** 2 + 100 * (v[1] - v[0] ** 2) ** 2, [-1.2, 1])
+ * // => { x: ~[1, 1], fval: ~0, ... }
+ */
+export declare function bfgs(f: (x: number[]) => number, x0: number[], opts?: BfgsOptions): BfgsResult;
+export {};
+//# sourceMappingURL=bfgs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bfgs.d.ts","sourceRoot":"","sources":["../../src/numeric/bfgs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,KAAK,GAAG,GAAG,MAAM,CAAC;AAElB,gCAAgC;AAChC,MAAM,WAAW,WAAW;IAC1B;;;OAGG;IACH,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;IACjC;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,CAAC;IACtB,sDAAsD;IACtD,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,wCAAwC;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,8BAA8B;AAC9B,MAAM,WAAW,UAAU;IACzB,qBAAqB;IACrB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,+BAA+B;IAC/B,IAAI,EAAE,GAAG,CAAC;IACV,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,yDAAyD;IACzD,SAAS,EAAE,OAAO,CAAC;CACpB;AA+CD;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,WAAgB,GAAG,UAAU,CA8EjG"}

package/dist/numeric/fsolve.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Nonlinear system solver: `fsolve` (damped Newton with a backtracking line
+ * search) for `F: R^n -> R^n`. Complements the scalar open root-finders
+ * (`./open-root-finders.ts`) and reuses the two Phase 1 foundations:
+ * `numericJacobian` (Task 1, central-difference Jacobian) and `linsolve`
+ * (`../typed/numeric.ts`, LU with partial pivoting) for the Newton step.
+ *
+ * @packageDocumentation
+ */
+import { type VectorField } from './numeric-jacobian.js';
+type f64 = number;
+type i32 = number;
+/** Options for `fsolve` / `root`. */
+export interface FsolveOptions {
+    /** Absolute tolerance on max|F_i(x)| for convergence (default 1e-10). */
+    tol?: f64;
+    /** Maximum Newton iterations (default 100). */
+    maxIter?: i32;
+}
+/**
+ * Solve `F(x) = 0` for `F: R^n -> R^n` via damped Newton's method.
+ *
+ * At each iterate: compute `J = numericJacobian(F, x)`, solve the Newton
+ * step `J * delta = -F(x)` via `linsolve`, then backtrack — try
+ * `lambda = 1, 1/2, 1/4, ...` (up to ~20 halvings) and take the largest
+ * `lambda` for which `||F(x + lambda*delta)||_2 < ||F(x)||_2`, falling back
+ * to `lambda = 1` (a plain Newton step) if no halving improves the residual.
+ * Update `x <- x + lambda*delta` and repeat until
+ * `max_i |F_i(x)| < tol` (converged) or `maxIter` is exhausted.
+ *
+ * @param F - Vector field whose root is sought (`F(x) = 0`)
+ * @param x0 - Initial guess (length n)
+ * @param opts - Options (tol, maxIter)
+ * @returns Approximate solution vector x with F(x) ~ 0
+ * @throws If the Jacobian is singular (`linsolve` fails) or Newton fails to
+ *   converge within `maxIter` iterations.
+ *
+ * @example
+ * fsolve((v) => [v[0] ** 2 - v[1], v[0] + v[1] - 2], [0.5, 0.5]) // => ~[1, 1]
+ */
+export declare function fsolve(F: VectorField, x0: readonly number[], opts?: FsolveOptions): number[];
+/** Alias for `fsolve` — `root(F, x0)` solves `F(x) = 0`. */
+export declare const root: typeof fsolve;
+export {};
+//# sourceMappingURL=fsolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fsolve.d.ts","sourceRoot":"","sources":["../../src/numeric/fsolve.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAmB,KAAK,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAG1E,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,GAAG,GAAG,MAAM,CAAC;AAElB,qCAAqC;AACrC,MAAM,WAAW,aAAa;IAC5B,yEAAyE;IACzE,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,+CAA+C;IAC/C,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAgBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,WAAW,EAAE,EAAE,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,aAAkB,GAAG,MAAM,EAAE,CAiDhG;AAED,4DAA4D;AAC5D,eAAO,MAAM,IAAI,eAAS,CAAC"}

package/dist/numeric/minimize-scalar.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Scalar (1-D) function minimization via Brent's method.
+ *
+ * Distinct from root-finding (`findRoot`, `newton`, `secant`, `halley`, which
+ * solve f(x) = 0): this locates a local minimizer of f over a bounded
+ * interval. Combines golden-section search (guaranteed, slow) with parabolic
+ * interpolation (fast near a smooth minimum) — the classic algorithm of
+ * Brent (1973) / Numerical Recipes §10.2, and the same method behind
+ * `scipy.optimize.minimize_scalar(method='bounded')`.
+ *
+ * @packageDocumentation
+ */
+type f64 = number;
+type i32 = number;
+/**
+ * Options for {@link minimizeScalar}.
+ */
+export interface MinimizeScalarOptions {
+    /**
+     * Interval `[a, b]` to search over (bounded Brent). If omitted, defaults to
+     * `[-10, 10]` — a generic finite bracket; supply an explicit bracket for
+     * functions whose minimum may lie outside that range.
+     */
+    bracket?: [f64, f64];
+    /** Convergence tolerance on the interval width (default 1e-8). */
+    tol?: f64;
+    /** Maximum iterations (default 100). */
+    maxIter?: i32;
+}
+/**
+ * Result of {@link minimizeScalar}.
+ */
+export interface MinimizeScalarResult {
+    /** The minimizer. */
+    x: f64;
+    /** f(x) at the minimizer. */
+    fval: f64;
+}
+/**
+ * Minimize a scalar function `f: R -> R` over a bounded interval using
+ * Brent's method (golden-section search + parabolic interpolation).
+ *
+ * If `opts.bracket` is not supplied, the default search interval is
+ * `[-10, 10]`.
+ *
+ * @param f - Function to minimize
+ * @param opts - Options (bracket, tol, maxIter)
+ * @returns `{ x, fval }` — the minimizer and its function value
+ *
+ * @example
+ * minimizeScalar(x => (x - 2) ** 2) // => { x: ~2, fval: ~0 }
+ * minimizeScalar(Math.sin, { bracket: [0, 2 * Math.PI] }) // => { x: ~3pi/2, fval: ~-1 }
+ */
+export declare function minimizeScalar(f: (x: f64) => f64, opts?: MinimizeScalarOptions): MinimizeScalarResult;
+export {};
+//# sourceMappingURL=minimize-scalar.d.ts.map

package/dist/numeric/minimize-scalar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minimize-scalar.d.ts","sourceRoot":"","sources":["../../src/numeric/minimize-scalar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,GAAG,GAAG,MAAM,CAAC;AAQlB;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IACrB,kEAAkE;IAClE,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,wCAAwC;IACxC,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,qBAAqB;IACrB,CAAC,EAAE,GAAG,CAAC;IACP,6BAA6B;IAC7B,IAAI,EAAE,GAAG,CAAC;CACX;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,EAClB,IAAI,CAAC,EAAE,qBAAqB,GAC3B,oBAAoB,CAqFtB"}

package/dist/numeric/nnls.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Constrained least squares: `nnls` (Lawson–Hanson active-set non-negative
+ * least squares) and `lsqBounded` (projected-gradient box-constrained least
+ * squares). Both minimize `||Ax - b||_2` subject to simple bound constraints
+ * on `x`, complementing the unconstrained `leastSquares` (`../typed/numeric.ts`).
+ *
+ * @packageDocumentation
+ */
+/** Options shared by `nnls` and `lsqBounded`. */
+export interface NnlsOptions {
+    /** Convergence tolerance (default 1e-10). */
+    tol?: number;
+    /** Maximum iterations (default `3 * n`). */
+    maxIter?: number;
+}
+/** Options for `lsqBounded` (same shape as `NnlsOptions`, kept as a distinct alias for clarity). */
+export type LsqBoundedOptions = NnlsOptions;
+/** Result of `nnls` / `lsqBounded`: the solution and its residual norm. */
+export interface NnlsResult {
+    /** Solution vector x. */
+    x: number[];
+    /** `||Ax - b||_2` at the returned solution. */
+    residual: number;
+}
+/** Alias for `NnlsResult` (used by `lsqBounded`). */
+export type LsqBoundedResult = NnlsResult;
+/**
+ * Non-negative least squares: `min ||Ax - b||_2 s.t. x >= 0`, via the
+ * Lawson–Hanson active-set algorithm.
+ *
+ * Maintains a "passive" set `P` of coordinates allowed to be nonzero (all
+ * others held at 0). Each outer iteration adds to `P` the inactive index
+ * with the most positive gradient component `w_j = (A^T(b - Ax))_j`, solves
+ * the unconstrained least-squares problem restricted to the columns in `P`
+ * (via `leastSquares`), and — if that restricted solution has any
+ * non-positive component — walks back along the line from the current `x`
+ * toward it until the first such component would hit zero, dropping that
+ * index from `P` and re-solving. Terminates when no inactive index has a
+ * positive gradient (KKT optimality) or `maxIter` is exhausted.
+ *
+ * @param A - Matrix (m x n)
+ * @param b - Right-hand side (length m)
+ * @param opts - Options (tol, maxIter; default maxIter = 3n)
+ * @returns `{ x, residual }` with `x >= 0` (up to `tol`) and `residual = ||Ax - b||_2`
+ *
+ * @example
+ * nnls([[1, 0], [0, 1]], [3, -2]) // => { x: [3, 0], residual: 2 }
+ */
+export declare function nnls(A: number[][], b: number[], opts?: NnlsOptions): NnlsResult;
+/**
+ * Box-constrained least squares: `min ||Ax - b||_2 s.t. lower <= x <= upper`,
+ * via projected-gradient descent.
+ *
+ * Each iteration computes the gradient `g = A^T(Ax - b)` of the smooth
+ * objective `f(x) = (1/2)||Ax - b||^2`, takes a candidate step
+ * `x - alpha*g` projected (clipped) into the box, and backtracks
+ * (`alpha /= 2`) until the projected step does not increase `f`. Converges
+ * when the projected-gradient norm `||x - clip(x - g, lower, upper)||` is
+ * below `tol`.
+ *
+ * @param A - Matrix (m x n)
+ * @param b - Right-hand side (length m)
+ * @param lower - Per-component lower bounds (length n)
+ * @param upper - Per-component upper bounds (length n)
+ * @param opts - Options (tol, maxIter; default maxIter = max(200, 20n))
+ * @returns `{ x, residual }` with `lower <= x <= upper` and `residual = ||Ax - b||_2`
+ *
+ * @example
+ * lsqBounded([[1, 0], [0, 1]], [5, -3], [0, 0], [2, 2]) // => { x: [2, 0], residual: ... }
+ */
+export declare function lsqBounded(A: number[][], b: number[], lower: number[], upper: number[], opts?: LsqBoundedOptions): LsqBoundedResult;
+//# sourceMappingURL=nnls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nnls.d.ts","sourceRoot":"","sources":["../../src/numeric/nnls.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,iDAAiD;AACjD,MAAM,WAAW,WAAW;IAC1B,6CAA6C;IAC7C,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,4CAA4C;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,oGAAoG;AACpG,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC;AAE5C,2EAA2E;AAC3E,MAAM,WAAW,UAAU;IACzB,yBAAyB;IACzB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,qDAAqD;AACrD,MAAM,MAAM,gBAAgB,GAAG,UAAU,CAAC;AA8B1C;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,GAAE,WAAgB,GAAG,UAAU,CA6EnF;AAOD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,MAAM,EAAE,EAAE,EACb,CAAC,EAAE,MAAM,EAAE,EACX,KAAK,EAAE,MAAM,EAAE,EACf,KAAK,EAAE,MAAM,EAAE,EACf,IAAI,GAAE,iBAAsB,GAC3B,gBAAgB,CAgElB"}

package/dist/numeric/numeric-jacobian.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Numeric Jacobian of a vector-valued function `f: R^n -> R^m` via central
+ * differences. Complements the symbolic `jacobian(exprs, vars, scope)` in
+ * `typed/cas.ts` — that path requires expression strings and throws on a
+ * plain numeric function (`exprs.map is not a function`). This is the
+ * foundation for numeric root-finding (`fsolve`, Phase 1 Task 3).
+ */
+/** A vector field ℝⁿ → ℝᵐ. */
+export type VectorField = (x: number[]) => number[];
+export interface NumericJacobianOptions {
+    /** Absolute step override. Default: per-coordinate relative step (see below). */
+    h?: number;
+}
+/**
+ * Central-difference Jacobian: `J[i][j] = ∂f_i/∂x_j = (f_i(x0 + h·e_j) − f_i(x0 − h·e_j)) / (2h)`.
+ *
+ * `f` need not be square (`m = f(x0).length` rows, `n = x0.length` columns).
+ * The per-coordinate step defaults to `h = max(1, |x0[j]|) * cbrt(eps)`
+ * (eps = 2.22e-16, i.e. Number.EPSILON), the standard relative step for
+ * central differences (~6e-6 relative) that balances truncation error
+ * (O(h^2)) against floating-point round-off (O(eps/h)).
+ *
+ * @example
+ * numericJacobian((v) => [v[0] ** 2 + v[1], v[0] * v[1]], [1, 2])
+ * // => [[2, 1], [2, 1]]
+ */
+export declare function numericJacobian(f: VectorField, x0: readonly number[], opts?: NumericJacobianOptions): number[][];
+//# sourceMappingURL=numeric-jacobian.d.ts.map

package/dist/numeric/numeric-jacobian.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numeric-jacobian.d.ts","sourceRoot":"","sources":["../../src/numeric/numeric-jacobian.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,8BAA8B;AAC9B,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;AAEpD,MAAM,WAAW,sBAAsB;IACrC,iFAAiF;IACjF,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,CAAC,EAAE,WAAW,EACd,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,IAAI,GAAE,sBAA2B,GAChC,MAAM,EAAE,EAAE,CA0BZ"}

package/dist/numeric/open-root-finders.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Open (non-bracketing) scalar root-finders.
+ *
+ * Complements the bracketing `findRoot` (bisection/Brent, `../typed/numeric.ts`)
+ * with classic open methods that iterate from a starting point (or two)
+ * without requiring a sign-change bracket: Newton–Raphson, secant, and
+ * Halley's method (cubic convergence).
+ *
+ * @packageDocumentation
+ */
+type f64 = number;
+type i32 = number;
+/**
+ * Options for Newton's method.
+ */
+export interface NewtonOptions {
+    /** Analytic derivative f'(x). If omitted, a central-difference estimate is used. */
+    fprime?: (x: f64) => f64;
+    /** Absolute tolerance for convergence (default 1e-12) */
+    tol?: f64;
+    /** Maximum iterations (default 100) */
+    maxIter?: i32;
+}
+/**
+ * Find a root of f(x) = 0 via Newton–Raphson iteration:
+ * `x_{k+1} = x_k - f(x_k) / f'(x_k)`.
+ *
+ * If `opts.fprime` is not supplied, the derivative is estimated by a
+ * central difference with step `h = max(1, |x|) * cbrt(eps)`.
+ *
+ * @param f - Function whose root is sought
+ * @param x0 - Initial guess
+ * @param opts - Options (fprime, tol, maxIter)
+ * @returns Approximate root
+ *
+ * @example
+ * newton(x => x ** 2 - 2, 1) // => ~1.4142135623730951
+ */
+export declare function newton(f: (x: f64) => f64, x0: f64, opts?: NewtonOptions): f64;
+/**
+ * Options for the secant method.
+ */
+export interface SecantOptions {
+    /** Absolute tolerance for convergence (default 1e-12) */
+    tol?: f64;
+    /** Maximum iterations (default 100) */
+    maxIter?: i32;
+}
+/**
+ * Find a root of f(x) = 0 via the secant method:
+ * `x_{k+1} = x_k - f(x_k) (x_k - x_{k-1}) / (f(x_k) - f(x_{k-1}))`.
+ *
+ * Requires no derivative, but two initial estimates.
+ *
+ * @param f - Function whose root is sought
+ * @param x0 - First initial estimate
+ * @param x1 - Second initial estimate
+ * @param opts - Options (tol, maxIter)
+ * @returns Approximate root
+ *
+ * @example
+ * secant(x => x ** 2 - 2, 1, 2) // => ~1.4142135623730951
+ */
+export declare function secant(f: (x: f64) => f64, x0: f64, x1: f64, opts?: SecantOptions): f64;
+/**
+ * Options for Halley's method.
+ */
+export interface HalleyOptions {
+    /** Analytic first derivative f'(x). If omitted, estimated via central difference. */
+    fprime?: (x: f64) => f64;
+    /** Analytic second derivative f''(x). If omitted, estimated via central difference. */
+    fprime2?: (x: f64) => f64;
+    /** Absolute tolerance for convergence (default 1e-12) */
+    tol?: f64;
+    /** Maximum iterations (default 100) */
+    maxIter?: i32;
+}
+/**
+ * Find a root of f(x) = 0 via Halley's method (cubic convergence):
+ * `x_{k+1} = x_k - 2 f f' / (2 f'^2 - f f'')`.
+ *
+ * If `opts.fprime` / `opts.fprime2` are not supplied, both derivatives are
+ * estimated by central differences with step `h = max(1, |x|) * cbrt(eps)`.
+ *
+ * @param f - Function whose root is sought
+ * @param x0 - Initial guess
+ * @param opts - Options (fprime, fprime2, tol, maxIter)
+ * @returns Approximate root
+ *
+ * @example
+ * halley(x => x ** 3 - 2, 1) // => ~1.2599210498948732
+ */
+export declare function halley(f: (x: f64) => f64, x0: f64, opts?: HalleyOptions): f64;
+export {};
+//# sourceMappingURL=open-root-finders.d.ts.map

package/dist/numeric/open-root-finders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-root-finders.d.ts","sourceRoot":"","sources":["../../src/numeric/open-root-finders.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,KAAK,GAAG,GAAG,MAAM,CAAC;AAClB,KAAK,GAAG,GAAG,MAAM,CAAC;AAelB;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,oFAAoF;IACpF,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAAC;IACzB,yDAAyD;IACzD,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,uCAAuC;IACvC,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,GAAG,CAuB7E;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,yDAAyD;IACzD,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,uCAAuC;IACvC,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,GAAG,CA2BtF;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,qFAAqF;IACrF,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAAC;IACzB,uFAAuF;IACvF,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAAC;IAC1B,yDAAyD;IACzD,GAAG,CAAC,EAAE,GAAG,CAAC;IACV,uCAAuC;IACvC,OAAO,CAAC,EAAE,GAAG,CAAC;CACf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,aAAa,GAAG,GAAG,CA2B7E"}

package/dist/typed/cas.d.ts

@@ -21,6 +21,7 @@
  */
 import { parse } from '../factories/evaluate.js';
 import { Complex } from '@danielsimonjr/mathts-core';
+import { type VectorField } from '../numeric/numeric-jacobian.js';
 type f64 = number;
 type MathNode = ReturnType<typeof parse>;
 /**
@@ -109,17 +110,25 @@ export declare function gradientSymbolic(expr: string, vars: string[], scope: Re
 /**
  * Compute the Jacobian matrix of a vector-valued function.
  *
- * J[i][j] = partial derivative of exprs[i] with respect to vars[j].
+ * Polymorphic: symbolic when `exprs` is an array of expression strings
+ * (J[i][j] = partial derivative of exprs[i] with respect to vars[j]);
+ * numeric (central differences) when `exprs` is a plain function
+ * `f: number[] => number[]` — dispatches to `numericJacobian(f, x0)`.
  *
- * @param exprs - Array of expression strings (vector field components)
- * @param vars - Variable names
- * @param scope - Variable values at which to evaluate
+ * @param exprs - Array of expression strings (vector field components), OR a
+ *   numeric vector field `f: (x: number[]) => number[]`
+ * @param vars - Variable names (symbolic), OR the numeric evaluation point `x0`
+ * @param scope - Variable values at which to evaluate (symbolic path only)
  * @returns 2D array (matrix) of partial derivatives
  *
  * @example
  * jacobian(['x*y', 'x^2'], ['x', 'y'], { x: 2, y: 3 })
  * // => [[3, 2], [4, 0]]
+ * @example
+ * jacobian((v) => [v[0] * v[1], v[0] ** 2], [2, 3])
+ * // => [[3, 2], [4, 0]] (numeric, central differences)
  */
+export declare function jacobian(exprs: VectorField, vars: number[]): f64[][];
 export declare function jacobian(exprs: string[], vars: string[], scope: Record<string, f64>): f64[][];
 /**
  * Compute the Laplacian of a scalar field.

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

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

package/dist/typed/numeric.d.ts

@@ -100,13 +100,17 @@ export declare function globalMinimize(f: (x: number[]) => f64, bounds: [number,
  */
 export declare function leastSquares(A: number[][], b: number[]): number[];
 /**
- * Adaptive numerical integration using Gauss-Legendre quadrature
- * with recursive subdivision.
+ * Adaptive numerical integration via Gauss-Kronrod (G7-K15) quadrature (see
+ * {@link quad} in `../numeric/adaptive-quad.js`). Previously used a fixed
+ * 5-point Gauss-Legendre panel with Richardson-extrapolation adaptivity,
+ * which converged slowly on endpoint singularities (e.g. `x^-1/2` near 0,
+ * ~1.7e-6 error); G7-K15's embedded error estimate resolves those panels
+ * directly, down to ~1e-10.
  *
  * @param f - Function to integrate
  * @param a - Lower bound
  * @param b - Upper bound
- * @param opts - Options (tol, maxIter for max subdivisions)
+ * @param opts - Options (tol, maxDepth for max subdivisions)
  * @returns Approximate integral
  */
 export declare function nintegrate(f: (x: f64) => f64, a: f64, b: f64, opts?: {
@@ -363,15 +367,36 @@ export declare function padeApproximant(coeffs: number[], m: i32, n: i32): {
  */
 export declare function quadprog(H: number[][], f: number[], A: number[][], b: number[]): number[];
 /**
- * Linear programming: minimize c^T x subject to Ax <= b, x >= 0.
- * Simple simplex method implementation.
+ * Options form of {@link linprog}: minimize c^T x subject to A_ub x <= b_ub,
+ * A_eq x = b_eq, and per-variable bounds.
+ */
+export interface LinprogOptions {
+    A_ub?: number[][];
+    b_ub?: number[];
+    A_eq?: number[][];
+    b_eq?: number[];
+    /** Per-variable [lower, upper] bounds; null = unbounded. Default: [0, null] for every variable. */
+    bounds?: readonly (readonly [number | null, number | null])[];
+}
+/** Result of the options form of {@link linprog}. */
+export interface LinprogResult {
+    x: number[];
+    fun: number;
+    success: boolean;
+    status: 'optimal' | 'infeasible' | 'unbounded';
+}
+/**
+ * Linear programming: minimize c^T x.
  *
- * @param c - Objective coefficients (length n)
- * @param A - Constraint matrix (m x n)
- * @param b - Constraint bounds (length m, non-negative)
- * @returns Solution vector x, or null if infeasible
+ * Two overloads:
+ * - Legacy positional form `linprog(c, A_ub, b_ub)` — subject to `A_ub x <= b_ub`,
+ *   `x >= 0`; returns the solution vector `x` (or `null` if unbounded).
+ * - Options form `linprog(c, { A_ub, b_ub, A_eq, b_eq, bounds })` — a two-phase
+ *   simplex supporting equality constraints, variable bounds, and negative-RHS
+ *   rows; returns `{ x, fun, success, status }`.
  */
-export declare function linprog(c: number[], A: number[][], b: number[]): number[] | null;
+export declare function linprog(c: number[], A_ub: number[][], b_ub: number[]): number[] | null;
+export declare function linprog(c: number[], opts: LinprogOptions): LinprogResult;
 /**
  * Simple 1D PDE solver using finite differences (heat equation).
  *