@danielsimonjr/mathts-functions 0.2.3 → 0.2.5

package/dist/typed/numeric.d.ts

@@ -0,0 +1,395 @@
+/**
+ * Typed Numerical Methods Functions
+ *
+ * Root finding, optimization, integration, interpolation, curve fitting,
+ * ODE solvers, and linear algebra utilities. All implementations are
+ * pure TypeScript with the WASM acceleration path pattern.
+ *
+ * These use plain exports (not mathTyped) because most accept function
+ * arguments, which typed-function does not handle well.
+ *
+ * @packageDocumentation
+ */
+type f64 = number;
+type i32 = number;
+/**
+ * Options for root-finding algorithms.
+ */
+export interface FindRootOptions {
+    /** Absolute tolerance for convergence (default 1e-12) */
+    tol?: f64;
+    /** Maximum iterations (default 100) */
+    maxIter?: i32;
+}
+/**
+ * Find a root of f(x) = 0 in [a, b] using Brent's method.
+ *
+ * Brent's method combines bisection, secant, and inverse quadratic
+ * interpolation for superlinear convergence with guaranteed reliability.
+ *
+ * @param f - Continuous function
+ * @param a - Lower bound (f(a) and f(b) must have opposite signs)
+ * @param b - Upper bound
+ * @param opts - Options (tol, maxIter)
+ * @returns Approximate root
+ *
+ * @example
+ * findRoot(x => x**2 - 2, 1, 2) // => ~1.4142135
+ */
+export declare function findRoot(f: (x: f64) => f64, a: f64, b: f64, opts?: FindRootOptions): f64;
+/**
+ * Solve linear system Ax = b using LU decomposition with partial pivoting.
+ *
+ * @param A - Coefficient matrix (n x n)
+ * @param b - Right-hand side vector (length n)
+ * @returns Solution vector x
+ *
+ * @example
+ * linsolve([[2, 1], [1, 3]], [5, 10]) // => [1, 3]
+ */
+export declare function linsolve(A: number[][], b: number[]): number[];
+/**
+ * Options for optimization algorithms.
+ */
+export interface MinimizeOptions {
+    /** Absolute tolerance (default 1e-8) */
+    tol?: f64;
+    /** Maximum iterations (default 1000) */
+    maxIter?: i32;
+    /** Initial simplex step size (default 0.1) */
+    step?: f64;
+}
+/**
+ * Minimize a function using the Nelder-Mead simplex method.
+ *
+ * @param f - Objective function (n-dimensional input)
+ * @param x0 - Initial guess
+ * @param opts - Options
+ * @returns Approximate minimizer
+ *
+ * @example
+ * minimize(x => (x[0]-1)**2 + (x[1]-2)**2, [0, 0]) // => ~[1, 2]
+ */
+export declare function minimize(f: (x: number[]) => f64, x0: number[], opts?: MinimizeOptions): number[];
+/**
+ * Maximize a function using Nelder-Mead (negates objective).
+ *
+ * @param f - Objective function
+ * @param x0 - Initial guess
+ * @param opts - Options
+ * @returns Approximate maximizer
+ */
+export declare function maximize(f: (x: number[]) => f64, x0: number[], opts?: MinimizeOptions): number[];
+/**
+ * Global minimization using basin-hopping (random perturbation + local min).
+ *
+ * @param f - Objective function
+ * @param bounds - Array of [min, max] for each dimension
+ * @param opts - Options (maxIter controls number of hops)
+ * @returns Approximate global minimizer
+ */
+export declare function globalMinimize(f: (x: number[]) => f64, bounds: [number, number][], opts?: MinimizeOptions & {
+    nHops?: i32;
+}): number[];
+/**
+ * Least squares solution: minimize ||Ax - b||^2 via normal equations.
+ *
+ * @param A - Matrix (m x n), m >= n
+ * @param b - Right-hand side (length m)
+ * @returns Least squares solution x (length n)
+ */
+export declare function leastSquares(A: number[][], b: number[]): number[];
+/**
+ * Adaptive numerical integration using Gauss-Legendre quadrature
+ * with recursive subdivision.
+ *
+ * @param f - Function to integrate
+ * @param a - Lower bound
+ * @param b - Upper bound
+ * @param opts - Options (tol, maxIter for max subdivisions)
+ * @returns Approximate integral
+ */
+export declare function nintegrate(f: (x: f64) => f64, a: f64, b: f64, opts?: {
+    tol?: f64;
+    maxDepth?: i32;
+}): f64;
+/**
+ * Simpson's 1/3 rule (convenience alias).
+ *
+ * @param f - Function to integrate
+ * @param a - Lower bound
+ * @param b - Upper bound
+ * @param n - Number of subintervals (even, default 100)
+ * @returns Approximate integral
+ */
+export declare function simpsons(f: (x: f64) => f64, a: f64, b: f64, n?: i32): f64;
+/**
+ * Unified interpolation API.
+ *
+ * @param xs - Sorted x-coordinates
+ * @param ys - Corresponding y-values
+ * @param method - 'linear' | 'lagrange' | 'spline' (default 'linear')
+ * @returns Interpolation function
+ */
+export declare function interpolate(xs: number[], ys: number[], method?: 'linear' | 'lagrange' | 'spline'): (x: f64) => f64;
+/**
+ * Cubic spline interpolation (alias).
+ */
+export declare function cspline(xs: number[], ys: number[]): (x: f64) => f64;
+/**
+ * PCHIP interpolation (alias wrapping the value-returning function).
+ */
+export declare function pchip(xs: number[], ys: number[], x: f64): f64;
+/**
+ * Evaluate a Bezier curve at parameter t.
+ *
+ * @param controlPoints - Array of control points (each a number[])
+ * @param t - Parameter in [0, 1]
+ * @returns Point on curve
+ */
+export declare function bezierCurve(controlPoints: number[][], t: f64): number[];
+/**
+ * Evaluate a B-spline at parameter t.
+ *
+ * @param controlPoints - Array of control points
+ * @param degree - Spline degree (must be < number of control points)
+ * @param t - Parameter in [0, 1]
+ * @returns Point on B-spline
+ */
+export declare function bspline(controlPoints: number[][], degree: i32, t: f64): number[];
+/**
+ * LOESS/LOWESS locally weighted regression.
+ *
+ * @param xs - x-coordinates
+ * @param ys - y-values
+ * @param x - Point to evaluate
+ * @param bandwidth - Fraction of data to use (default 0.3)
+ * @returns Smoothed value at x
+ */
+export declare function loess(xs: number[], ys: number[], x: f64, bandwidth?: f64): f64;
+/**
+ * Scattered data gridding using inverse distance weighting.
+ *
+ * @param points - Array of [x, y] data locations
+ * @param values - Corresponding values
+ * @param xi - x-coordinates of grid
+ * @param yi - y-coordinates of grid
+ * @returns 2D array of interpolated values [yi.length][xi.length]
+ */
+export declare function griddata(points: number[][], values: number[], xi: number[], yi: number[]): number[][];
+/**
+ * Radial basis function interpolation.
+ *
+ * @param points - Data point locations (array of number[])
+ * @param values - Data values
+ * @param xi - Query points
+ * @param kernel - RBF kernel: 'gaussian' | 'multiquadric' | 'thinplate' (default 'gaussian')
+ * @returns Interpolated values at xi
+ */
+export declare function rbfInterpolate(points: number[][], values: number[], xi: number[][], kernel?: 'gaussian' | 'multiquadric' | 'thinplate'): number[];
+/**
+ * Nonlinear curve fitting using Levenberg-Marquardt algorithm.
+ *
+ * @param f - Model function f(x, params) => y
+ * @param xs - x data
+ * @param ys - y data
+ * @param p0 - Initial parameter guess
+ * @returns Fitted parameters
+ */
+export declare function curvefit(f: (x: f64, params: number[]) => f64, xs: number[], ys: number[], p0: number[]): number[];
+/**
+ * Exponential fit: y = a * exp(b * x).
+ *
+ * @param xs - x data
+ * @param ys - y data (must be positive)
+ * @returns [a, b] coefficients
+ */
+export declare function expfit(xs: number[], ys: number[]): [f64, f64];
+/**
+ * Logarithmic fit: y = a * ln(x) + b.
+ *
+ * @param xs - x data (must be positive)
+ * @param ys - y data
+ * @returns [a, b] coefficients
+ */
+export declare function logfit(xs: number[], ys: number[]): [f64, f64];
+/**
+ * Power fit: y = a * x^b.
+ *
+ * @param xs - x data (must be positive)
+ * @param ys - y data (must be positive)
+ * @returns [a, b] coefficients
+ */
+export declare function powerfit(xs: number[], ys: number[]): [f64, f64];
+/**
+ * ODE solution result.
+ */
+export interface ODESolution {
+    t: number[];
+    y: number[][];
+}
+/**
+ * Solve a system of ODEs dy/dt = f(t, y) using RK45 (Dormand-Prince).
+ *
+ * @param f - System function (t, y) => dy/dt
+ * @param y0 - Initial state vector
+ * @param tspan - [t0, tf] time span
+ * @param opts - Options (tol, maxIter for max steps)
+ * @returns Solution { t, y }
+ */
+export declare function solveODESystem(f: (t: f64, y: number[]) => number[], y0: number[], tspan: [f64, f64], opts?: {
+    tol?: f64;
+    maxSteps?: i32;
+    dt?: f64;
+}): ODESolution;
+/**
+ * Solve stiff ODE systems using implicit Euler.
+ *
+ * @param f - System function
+ * @param y0 - Initial state
+ * @param tspan - Time span
+ * @returns Solution
+ */
+export declare function stiffODESolver(f: (t: f64, y: number[]) => number[], y0: number[], tspan: [f64, f64]): ODESolution;
+/**
+ * Solve boundary value problem using the shooting method.
+ *
+ * @param f - System function (t, y) => dy/dt
+ * @param bc - Boundary condition function (y0, yf) => residuals
+ * @param mesh - Initial mesh points
+ * @returns Solution
+ */
+export declare function solveBVP(f: (t: f64, y: number[]) => number[], bc: (y0: number[], yf: number[]) => number[], mesh: number[]): ODESolution;
+/**
+ * Single adaptive RK step returning (y_new, error_estimate).
+ *
+ * @param f - System function
+ * @param y0 - Current state
+ * @param t0 - Current time
+ * @param h - Step size
+ * @param tol - Error tolerance
+ * @returns { y: number[], t: number, h: number } with updated step size
+ */
+export declare function odeAdaptiveStep(f: (t: f64, y: number[]) => number[], y0: number[], t0: f64, h: f64, tol?: f64): {
+    y: number[];
+    t: f64;
+    h: f64;
+};
+/**
+ * ODE integration with event detection.
+ * Stops when event(t, y) crosses zero.
+ *
+ * @param f - System function
+ * @param y0 - Initial state
+ * @param tspan - Time span
+ * @param event - Event function; integration stops when this crosses zero
+ * @returns Solution up to event
+ */
+export declare function eventDetection(f: (t: f64, y: number[]) => number[], y0: number[], tspan: [f64, f64], event: (t: f64, y: number[]) => f64): ODESolution & {
+    eventTime?: f64;
+};
+/**
+ * Condition number of a matrix (ratio of largest to smallest singular value).
+ * Uses a simple power iteration estimate.
+ *
+ * @param A - Square matrix
+ * @returns Approximate condition number
+ */
+export declare function cond(A: number[][]): f64;
+/**
+ * Numerical rank of a matrix using SVD-like approach.
+ *
+ * @param A - Matrix (m x n)
+ * @param tol - Tolerance for zero singular values (default 1e-10)
+ * @returns Numerical rank
+ */
+export declare function rank(A: number[][], tol?: f64): i32;
+/**
+ * Null space basis of a matrix.
+ *
+ * @param A - Matrix (m x n)
+ * @returns Array of basis vectors spanning the null space
+ */
+export declare function nullspace(A: number[][]): number[][];
+/**
+ * Partial fraction decomposition residues for P(x)/Q(x).
+ * Assumes Q has distinct real roots. Returns residues at roots.
+ *
+ * @param p - Numerator polynomial coefficients [a0, a1, ..., an] for a0 + a1*x + ...
+ * @param q - Denominator polynomial coefficients
+ * @returns { residues: number[], poles: number[] }
+ */
+export declare function residue(p: number[], q: number[]): {
+    residues: number[];
+    poles: number[];
+};
+/**
+ * Chebyshev polynomial approximation of a function on [a, b].
+ *
+ * @param f - Function to approximate
+ * @param a - Lower bound
+ * @param b - Upper bound
+ * @param n - Number of terms (default 10)
+ * @returns Evaluation function
+ */
+export declare function chebyshevApprox(f: (x: f64) => f64, a: f64, b: f64, n?: i32): (x: f64) => f64;
+/**
+ * Pade approximant [m/n] from Taylor coefficients.
+ *
+ * @param coeffs - Taylor series coefficients [c0, c1, c2, ...]
+ * @param m - Numerator degree
+ * @param n - Denominator degree
+ * @returns { num: number[], den: number[] } polynomial coefficients
+ */
+export declare function padeApproximant(coeffs: number[], m: i32, n: i32): {
+    num: number[];
+    den: number[];
+};
+/**
+ * Quadratic programming: minimize 0.5 * x^T H x + f^T x subject to A x <= b.
+ * Uses projected gradient descent.
+ *
+ * @param H - Hessian matrix (n x n, positive definite)
+ * @param f - Linear term (length n)
+ * @param A - Inequality constraint matrix (m x n)
+ * @param b - Inequality constraint bounds (length m)
+ * @returns Solution vector x
+ */
+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.
+ *
+ * @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
+ */
+export declare function linprog(c: number[], A: number[][], b: number[]): number[] | null;
+/**
+ * Simple 1D PDE solver using finite differences (heat equation).
+ *
+ * Solves u_t = alpha * u_xx on domain [0, L] with boundary conditions.
+ *
+ * @param pde - { alpha: diffusion coefficient }
+ * @param domain - { L: domain length, nx: spatial points, nt: time steps, T: final time }
+ * @param bc - { left: left BC value, right: right BC value, initial: initial condition function }
+ * @returns { x: number[], u: number[] } solution at final time
+ */
+export declare function solvePDE(pde: {
+    alpha: f64;
+}, domain: {
+    L: f64;
+    nx: i32;
+    nt: i32;
+    T: f64;
+}, bc: {
+    left: f64;
+    right: f64;
+    initial: (x: f64) => f64;
+}): {
+    x: number[];
+    u: number[];
+};
+export {};
+//# sourceMappingURL=numeric.d.ts.map

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

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

package/dist/typed/probability.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Typed Probability & Combinatorics Functions
+ *
+ * Promotes genuinely-missing exports from the synced `probability/` layer that
+ * are not already surfaced by `typed/distributions.ts` (PDF/PMF/CDF/entropy) or
+ * `typed/special.ts` (erf, beta, bessel, …).
+ *
+ * After dedup audit (2026-05-24):
+ *
+ * | Synced name        | Promote? | Existing surface (if any)                      | Rationale                                        |
+ * | ------------------ | -------- | ---------------------------------------------- | ------------------------------------------------ |
+ * | bernoulli          | YES      | —                                              | genuinely missing (bernoulliPMF ≠ Bernoulli number) |
+ * | combinations       | YES      | —                                              | genuinely missing                                |
+ * | combinationsWithRep| YES      | —                                              | genuinely missing                                |
+ * | factorial          | SKIP     | factories/index.ts (tier 7) exports `factorial`| already in active factory surface                |
+ * | gamma              | SKIP     | factories/index.ts (tier 6) exports `gamma`    | needs Complex/BigNumber factory deps; in scope   |
+ * | kldivergence       | SKIP     | factories/index.ts (tier 13)                   | needs matrix/sum/divide factory wiring           |
+ * | lgamma             | SKIP     | factories/index.ts (tier 1)                    | needs WASM bridge + Complex; already wired       |
+ * | multinomial        | YES      | —                                              | genuinely missing; clean number[] → number impl  |
+ * | permutations       | YES      | —                                              | genuinely missing                                |
+ * | pickRandom         | YES      | —                                              | genuinely missing                                |
+ * | random             | YES      | —                                              | genuinely missing (scalar seeded-RNG)            |
+ * | randomInt          | YES      | —                                              | genuinely missing                                |
+ *
+ * 8 of 12 promoted; 4 skipped (already in the active factory surface under the
+ * same name with richer type coverage than can be achieved in a clean typed/
+ * reimplementation).
+ *
+ * @packageDocumentation
+ */
+/**
+ * Return the n-th Bernoulli number.
+ *
+ * B_0=1, B_1=-1/2, B_{odd>1}=0.
+ * For even n, uses the cotangent-coefficient recursion.
+ *
+ * @example
+ * bernoulli(0)  // 1
+ * bernoulli(1)  // -0.5
+ * bernoulli(2)  // 1/6 ≈ 0.16666…
+ * bernoulli(4)  // -1/30
+ * bernoulli(7)  // 0 (all odd B_n for n > 1 are zero)
+ */
+export declare const bernoulli: import("typed-function").TypedFunction;
+/**
+ * Compute the binomial coefficient C(n, k) — the number of ways of choosing
+ * k unordered elements from n elements without replacement.
+ *
+ * @example
+ * combinations(5, 2)  // 10
+ * combinations(7, 5)  // 21
+ * combinations(10, 0) // 1
+ */
+export declare const combinations: import("typed-function").TypedFunction;
+/**
+ * Compute the number of ways of choosing k unordered elements from n elements
+ * WITH replacement: C(n + k - 1, k).
+ *
+ * @example
+ * combinationsWithRep(7, 5)  // 462
+ * combinationsWithRep(5, 2)  // 15
+ */
+export declare const combinationsWithRep: import("typed-function").TypedFunction;
+/**
+ * Compute the multinomial coefficient n! / (a1! * a2! * … * am!) where
+ * n = a1 + a2 + … + am.
+ *
+ * @param a - Array of positive integers
+ * @returns Multinomial coefficient as a number
+ *
+ * @example
+ * multinomial([2, 1, 1])  // 12  (= 4! / (2! * 1! * 1!))
+ * multinomial([1, 1])     // 2
+ * multinomial([3])        // 1
+ */
+export declare const multinomial: import("typed-function").TypedFunction;
+/**
+ * Compute the number of ordered subsets of k elements from n elements:
+ * P(n, k) = n! / (n-k)!
+ *
+ * When called with a single argument, returns n! (all permutations of n items).
+ *
+ * @example
+ * permutations(5)     // 120  (= 5!)
+ * permutations(5, 3)  // 60   (= 5*4*3)
+ */
+export declare const permutations: import("typed-function").TypedFunction;
+/**
+ * Reset the internal RNG used by `random`, `randomInt`, and `pickRandom`.
+ *
+ * Pass `null` to re-initialize with a time-based seed (non-reproducible).
+ * Pass a string or number for a reproducible sequence.
+ *
+ * @example
+ * seedProbabilityRng('my-seed-42');
+ * random();      // reproducible
+ * randomInt(10); // same sequence
+ */
+export declare function seedProbabilityRng(seed: string | number | null): void;
+/**
+ * Return a uniform random number in [min, max).
+ *
+ * Overloads:
+ *  - `random()` → [0, 1)
+ *  - `random(max)` → [0, max)
+ *  - `random(min, max)` → [min, max)
+ *
+ * Uses the shared seeded PRNG (reset via `seedProbabilityRng`).
+ *
+ * @example
+ * seedProbabilityRng('test');
+ * random();       // always the same value after a given seed
+ * random(100);    // uniform in [0, 100)
+ * random(30, 40); // uniform in [30, 40)
+ */
+export declare const random: import("typed-function").TypedFunction;
+/**
+ * Return a uniform random integer in [min, max).
+ *
+ * Overloads:
+ *  - `randomInt()` → 0 or 1
+ *  - `randomInt(max)` → integer in [0, max)
+ *  - `randomInt(min, max)` → integer in [min, max)
+ *
+ * Uses the shared seeded PRNG (reset via `seedProbabilityRng`).
+ *
+ * @example
+ * seedProbabilityRng('test');
+ * randomInt(10);     // integer in [0, 10)
+ * randomInt(30, 40); // integer in [30, 40)
+ */
+export declare const randomInt: import("typed-function").TypedFunction;
+/**
+ * Pick one or more random elements from an array, using uniform or weighted
+ * sampling with replacement.
+ *
+ * Overloads:
+ *  - `pickRandom(array)` → single element (uniform)
+ *  - `pickRandom(array, n)` → n elements (uniform, with replacement)
+ *  - `pickRandom(array, weights)` → single element (weighted)
+ *  - `pickRandom(array, n, weights)` → n elements (weighted, with replacement)
+ *
+ * Uses the shared seeded PRNG (reset via `seedProbabilityRng`).
+ *
+ * @example
+ * pickRandom([1, 2, 3, 4])        // one of the four values
+ * pickRandom([1, 2, 3, 4], 2)     // array of two values
+ * pickRandom(['a','b','c'], 1, [1, 3, 1]) // 'b' chosen 3× more often
+ */
+export declare const pickRandom: import("typed-function").TypedFunction;
+/**
+ * All typed probability & combinatorics functions promoted by Slice 4.6.
+ * (Seeded-RNG state is shared; call `seedProbabilityRng` to reset.)
+ */
+export declare const typedProbability: {
+    bernoulli: import("typed-function").TypedFunction;
+    combinations: import("typed-function").TypedFunction;
+    combinationsWithRep: import("typed-function").TypedFunction;
+    multinomial: import("typed-function").TypedFunction;
+    permutations: import("typed-function").TypedFunction;
+    random: import("typed-function").TypedFunction;
+    randomInt: import("typed-function").TypedFunction;
+    pickRandom: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=probability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"probability.d.ts","sourceRoot":"","sources":["../../src/typed/probability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAoIH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,SAAS,wCAEpB,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,wCAEvB,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,mBAAmB,wCAY9B,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW,wCAgBtB,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,wCAsBvB,CAAC;AAaH;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,IAAI,CAErE;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM,wCAUjB,CAAC;AAEH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,SAAS,wCAcpB,CAAC;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,UAAU,wCAQrB,CAAC;AAgDH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;CAS5B,CAAC"}