@danielsimonjr/mathts-functions 0.70.1 → 0.72.0

package/dist/linalg-extra2.d.ts

@@ -0,0 +1,36 @@
+type Vec = readonly number[] | Float64Array;
+/**
+ * Principal angles between the column spaces of A and B, in radians, sorted in
+ * descending order (largest angle first, as documented for scipy.linalg.subspace_angles).
+ * Each space is orthonormalised by modified Gram-Schmidt. As scipy does, angles whose
+ * sine squared is below 1/2 are taken from the singular values of the residual
+ * Qb - Qa Qaᵀ Qb (arcsin), the rest from those of Qaᵀ Qb (arccos), so small angles
+ * keep full relative accuracy.
+ */
+export declare function subspaceAngles(A: number[][], B: number[][]): number[];
+/**
+ * Matrix sign function sign(A) by the determinant-scaled Newton iteration
+ * X <- (mu X + (mu X)^-1) / 2 with mu = |det X|^(-1/n). Returns the n x n sign matrix.
+ */
+export declare function signm(A: number[][], opts?: {
+    tol?: number;
+    maxIter?: number;
+}): number[][];
+/**
+ * Fractional matrix power A^t = expm(t * logm(A)) for a matrix with a principal
+ * logarithm. Integer t is computed exactly by repeated multiplication.
+ */
+export declare function fractionalMatrixPower(A: number[][], t: number): number[][];
+/**
+ * Cholesky factor of L Lᵀ + x xᵀ, given the lower-triangular factor L.
+ * Standard rank-1 update (Golub & Van Loan, Alg. 6.5.4).
+ */
+export declare function choleskyUpdate(L: number[][], x: Vec): number[][];
+/**
+ * Cholesky factor of L Lᵀ - x xᵀ, given the lower-triangular factor L.
+ *
+ * @throws RangeError if the downdated matrix is not positive definite
+ */
+export declare function choleskyDowndate(L: number[][], x: Vec): number[][];
+export {};
+//# sourceMappingURL=linalg-extra2.d.ts.map

package/dist/linalg-extra2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linalg-extra2.d.ts","sourceRoot":"","sources":["../src/linalg-extra2.ts"],"names":[],"mappings":"AAMA,KAAK,GAAG,GAAG,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;AAsC5C;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,CAgCrE;AAED;;;GAGG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,IAAI,GAAE;IAAE,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,MAAM,EAAE,EAAE,CAqB9F;AAuBD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAI1E;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,EAAE,CAehE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,EAAE,CAmBlE"}

package/dist/linalg-special-matrices.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Special matrix constructors (Gap-analysis 2026-11-04 Batch E7).
+ *
+ * Pure index/closed-form constructions: Hilbert and its exact integer inverse,
+ * Hadamard (Sylvester), Pascal, DFT, Hankel, block-diagonal, Khatri-Rao,
+ * Fiedler, Leslie and Helmert matrices.
+ */
+import { Complex } from '@danielsimonjr/mathts-core';
+type Vec = readonly number[] | Float64Array;
+/** Hilbert matrix H_ij = 1 / (i + j + 1) (0-based). */
+export declare function hilbertMatrix(n: number): number[][];
+/**
+ * Exact inverse of the n x n Hilbert matrix, from the closed-form integer formula
+ * (1-based indices): (-1)^(i+j) (i+j-1) C(n+i-1, n-j) C(n+j-1, n-i) C(i+j-2, i-1)^2.
+ */
+export declare function invHilbertMatrix(n: number): number[][];
+/**
+ * Hadamard matrix of order n by the Sylvester construction. n must be a power of 2.
+ *
+ * @throws RangeError if n is not a positive power of 2
+ */
+export declare function hadamardMatrix(n: number): number[][];
+/**
+ * Pascal matrix. 'symmetric' P_ij = C(i+j, i); 'lower' L_ij = C(i, j); 'upper' is its transpose.
+ */
+export declare function pascalMatrix(n: number, kind?: 'symmetric' | 'lower' | 'upper'): number[][];
+/**
+ * Discrete Fourier transform matrix F_jk = exp(-2*pi*i*j*k/n) times a normalization:
+ * 'none' = 1, 'sqrtn' = 1/sqrt(n), 'n' = 1/n.
+ */
+export declare function dftMatrix(n: number, opts?: {
+    scale?: 'none' | 'sqrtn' | 'n';
+}): Complex[][];
+/**
+ * Hankel matrix with first column c and (optionally) last row r. r[0] is ignored
+ * (the corner is c[last]); the default r is all zeros.
+ */
+export declare function hankelMatrix(c: Vec, r?: Vec): number[][];
+/** Block-diagonal matrix from a list of (possibly rectangular) blocks. */
+export declare function blockDiag(...blocks: ReadonlyArray<ReadonlyArray<readonly number[]>>): number[][];
+/**
+ * Khatri-Rao (column-wise Kronecker) product of A (p x k) and B (q x k):
+ * a (p*q x k) matrix whose row i*q + j is A[i] elementwise-times B[j].
+ *
+ * @throws RangeError if the column counts differ
+ */
+export declare function khatriRao(A: number[][], B: number[][]): number[][];
+/** Fiedler matrix F_ij = |a_i - a_j|. */
+export declare function fiedlerMatrix(a: Vec): number[][];
+/**
+ * Leslie matrix: first row = fecundities f, subdiagonal = survival rates s.
+ *
+ * @throws RangeError unless s.length === f.length - 1
+ */
+export declare function leslieMatrix(f: Vec, s: Vec): number[][];
+/**
+ * Helmert matrix. Returns the (n-1) x n orthonormal contrast rows, or the full
+ * n x n orthogonal matrix when `full` is true (first row 1/sqrt(n)).
+ */
+export declare function helmertMatrix(n: number, full?: boolean): number[][];
+export {};
+//# sourceMappingURL=linalg-special-matrices.d.ts.map

package/dist/linalg-special-matrices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linalg-special-matrices.d.ts","sourceRoot":"","sources":["../src/linalg-special-matrices.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAErD,KAAK,GAAG,GAAG,SAAS,MAAM,EAAE,GAAG,YAAY,CAAC;AAa5C,uDAAuD;AACvD,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAEnD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAUtD;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAmBpD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,CAAC,EAAE,MAAM,EACT,IAAI,GAAE,WAAW,GAAG,OAAO,GAAG,OAAqB,GAClD,MAAM,EAAE,EAAE,CAQZ;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,GAAG,CAAA;CAAO,GAAG,OAAO,EAAE,EAAE,CAS/F;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,EAAE,CAWxD;AAED,0EAA0E;AAC1E,wBAAgB,SAAS,CAAC,GAAG,MAAM,EAAE,aAAa,CAAC,aAAa,CAAC,SAAS,MAAM,EAAE,CAAC,CAAC,GAAG,MAAM,EAAE,EAAE,CAchG;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,MAAM,EAAE,EAAE,CAYlE;AAED,yCAAyC;AACzC,wBAAgB,aAAa,CAAC,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,EAAE,CAGhD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAG,MAAM,EAAE,EAAE,CAWvD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,UAAQ,GAAG,MAAM,EAAE,EAAE,CAWjE"}

package/dist/numbertheory/arithmetic-functions.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Arithmetic functions and integer power / root helpers: squarefree tests,
+ * radical, Omega counts, Liouville, von Mangoldt, Mertens, perfect and
+ * prime-power tests, exact integer roots, digit sums, Collatz and primorial.
+ */
+/** True when n is a positive integer with no square factor greater than 1. */
+export declare function isSquarefree(n: number): boolean;
+/** Product of the distinct prime factors of n (rad(n)). */
+export declare function radical(n: number): number;
+/** Number of prime factors counted with multiplicity (Omega). */
+export declare function bigOmega(n: number): number;
+/** Number of distinct prime factors (omega). */
+export declare function smallOmega(n: number): number;
+/** Liouville function lambda(n) = (-1)^Omega(n). */
+export declare function liouvilleLambda(n: number): -1 | 1;
+/** von Mangoldt function: ln p when n = p^k (k >= 1), otherwise 0. */
+export declare function vonMangoldt(n: number): number;
+/** Mertens function M(n) = sum of mu(k) for k = 1..n. */
+export declare function mertens(n: number): number;
+/** True when n equals the sum of its proper divisors (n >= 2). */
+export declare function isPerfect(n: number): boolean;
+/** Floor of the square root of a non-negative bigint (Newton iteration). */
+export declare function integerSqrt(n: bigint): bigint;
+/** Floor of the k-th root of a non-negative bigint (binary search). */
+export declare function integerNthRoot(n: bigint, k: number): bigint;
+/**
+ * Perfect-power test. Returns `{ base, exp }` with `n = base^exp`, `base > 1`,
+ * and `exp` as large as possible; `null` if n is not a perfect power (or n < 2).
+ */
+export declare function isPerfectPower(n: number): {
+    base: number;
+    exp: number;
+} | null;
+/**
+ * Prime-power test: `{ p, k }` with `n = p^k`, `k >= 1`; `null` if n is not a
+ * prime power (or n < 2).
+ */
+export declare function isPrimePower(n: number): {
+    p: number;
+    k: number;
+} | null;
+/** Sum of the digits of n in the given base (default 10). */
+export declare function digitSum(n: number | bigint, base?: number): number;
+/** Digital root (repeated digit sum until a single digit), base 10. */
+export declare function digitalRoot(n: number): number;
+/** Number of steps for the Collatz (3n+1) sequence to reach 1. */
+export declare function collatzSteps(n: number): number;
+/** Primorial n# = product of all primes <= n (n >= 0). */
+export declare function primorial(n: number): bigint;
+//# sourceMappingURL=arithmetic-functions.d.ts.map

package/dist/numbertheory/arithmetic-functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmetic-functions.d.ts","sourceRoot":"","sources":["../../src/numbertheory/arithmetic-functions.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAgDH,8EAA8E;AAC9E,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAG/C;AAED,2DAA2D;AAC3D,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAGzC;AAED,iEAAiE;AACjE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG1C;AAED,gDAAgD;AAChD,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAG5C;AAED,oDAAoD;AACpD,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAEjD;AAED,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAI7C;AAED,yDAAyD;AACzD,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAKzC;AAED,kEAAkE;AAClE,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAG5C;AAED,4EAA4E;AAC5E,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ7C;AAED,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAa3D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAS9E;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAIvE;AAED,6DAA6D;AAC7D,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,SAAK,GAAG,MAAM,CAW9D;AAED,uEAAuE;AACvE,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAK7C;AAED,kEAAkE;AAClE,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAS9C;AAED,0DAA0D;AAC1D,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAe3C"}

package/dist/numbertheory/diophantine.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Diophantine and lattice-style integer problems: linear Diophantine equations,
+ * Pell equations, the Frobenius (coin) number, Zeckendorf representation,
+ * sums of two squares, Egyptian fractions and Farey sequences.
+ */
+/**
+ * Particular integer solution of a x + b y = c with the general solution
+ * x = x0 + stepX * t, y = y0 + stepY * t. Returns null when no solution exists.
+ */
+export declare function linearDiophantine(a: number, b: number, c: number): {
+    x: number;
+    y: number;
+    stepX: number;
+    stepY: number;
+} | null;
+/**
+ * Fundamental solution (x, y) of Pell's equation x^2 - d y^2 = 1 for a positive
+ * non-square integer d, via the continued fraction of sqrt(d). Returns null for
+ * non-positive or perfect-square d.
+ */
+export declare function pellSolve(d: number): {
+    x: bigint;
+    y: bigint;
+} | null;
+/**
+ * Frobenius number: the largest integer not representable as a non-negative
+ * combination of the coins. Requires positive integer coins with gcd 1
+ * (otherwise RangeError). Returns -1 when a coin equals 1.
+ */
+export declare function frobeniusNumber(coins: readonly number[]): number;
+/** Zeckendorf representation of n >= 0 as distinct, non-consecutive Fibonacci parts (descending). */
+export declare function zeckendorf(n: number): number[];
+/** All pairs [a, b] with 0 <= a <= b and a^2 + b^2 = n, in ascending order of a. */
+export declare function sumOfTwoSquares(n: number): Array<[number, number]>;
+/**
+ * Egyptian fraction of p/q (positive integers) by the greedy algorithm: returns
+ * the denominators of a decomposition into distinct unit fractions when the
+ * greedy steps are distinct (for p/q < 1, the usual case).
+ */
+export declare function egyptianFraction(p: number, q: number): number[];
+/** Farey sequence F_n: reduced fractions [num, den] in [0, 1] with den <= n, ascending. */
+export declare function fareySequence(n: number): Array<[number, number]>;
+//# sourceMappingURL=diophantine.d.ts.map

package/dist/numbertheory/diophantine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diophantine.d.ts","sourceRoot":"","sources":["../../src/numbertheory/diophantine.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AA6BH;;;GAGG;AACH,wBAAgB,iBAAiB,CAC/B,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAc/D;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAgCpE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CA6BhE;AAED,qGAAqG;AACrG,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAa9C;AAED,oFAAoF;AACpF,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAclE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CA6B/D;AAED,2FAA2F;AAC3F,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAahE"}

package/dist/numbertheory/extra.d.ts

@@ -71,18 +71,24 @@ export declare function stirlingS1(n: number, k: number): number;
  */
 export declare function discreteLog(g: number, h: number, p: number): number;
 /**
- * Smallest primitive root modulo a prime `p`.
+ * Smallest primitive root modulo `n`.
  *
- * For each candidate `g = 2, 3, ...`, `g` is a primitive root iff
- * `g^((p-1)/q) !== 1 (mod p)` for every prime factor `q` of `p - 1`.
+ * A primitive root exists only for `n` in {1, 2, 4, p^k, 2p^k} (p an odd
+ * prime); for any other `n` (8, 12, 15, ...) this throws, matching the
+ * file's contract of throwing `Error` on invalid input. For such `n`, `g` is a
+ * primitive root iff `gcd(g, n) = 1` and `g^(φ(n)/q) !== 1 (mod n)` for every
+ * prime factor `q` of `φ(n)`.
  *
- * @param p - An odd prime (p = 2 returns 1 trivially)
- * @returns The smallest primitive root modulo p
+ * @param n - An integer >= 2 with a primitive root (n = 2 returns 1)
+ * @returns The smallest primitive root modulo n
+ * @throws Error if n < 2, non-integer, or n has no primitive root
  *
  * @example
  * primitiveRoot(7) // => 3
+ * primitiveRoot(4) // => 3
+ * primitiveRoot(8) // throws (no primitive root)
  */
-export declare function primitiveRoot(p: number): number;
+export declare function primitiveRoot(n: number): number;
 /**
  * Multiplicative order of `a` modulo `n`: the smallest `k > 0` with
  * `a^k === 1 (mod n)`. Returns `-1` if `gcd(a, n) !== 1` (no order exists).

package/dist/numbertheory/extra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"extra.d.ts","sourceRoot":"","sources":["../../src/numbertheory/extra.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAQH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,SAAK,GAAG,MAAM,EAAE,CAcpE;AAWD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBhD;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAevD;AAqCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CA+BnE;AAoBD;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAmB/C;AAeD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAehE;AAaD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CA0C5D;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,CAoBtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,GAAE,MAAmB,GAAG,CAAC,EAAE,EAAE,CAwBnF"}
+{"version":3,"file":"extra.d.ts","sourceRoot":"","sources":["../../src/numbertheory/extra.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAQH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,SAAK,GAAG,MAAM,EAAE,CAcpE;AAWD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAkBhD;AAMD;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAevD;AAqCD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CA+BnE;AAoBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CA4B/C;AAeD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAuBhE;AAaD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CA0C5D;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,EAAE,EAAE,CAoBtE;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,GAAE,MAAmB,GAAG,CAAC,EAAE,EAAE,CAwBnF"}

package/dist/numbertheory/integer-matrices.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Integer normal forms: row-style Hermite normal form, Smith normal form (with
+ * invariant factors) and the LLL lattice-basis reduction over floats.
+ */
+/**
+ * Row-style Hermite normal form (upper-triangular echelon form obtained by
+ * unimodular row operations): positive pivots, and entries above each pivot
+ * reduced into [0, pivot).
+ */
+export declare function hermiteNormalForm(A: ReadonlyArray<readonly (number | bigint)[]>): bigint[][];
+/**
+ * Smith normal form: diagonal matrix D with d1 | d2 | ... (positive, zero
+ * padding allowed) equivalent to A under unimodular row and column operations.
+ * `invariants` lists the diagonal entries d1..d_min(m,n).
+ */
+export declare function smithNormalForm(A: ReadonlyArray<readonly (number | bigint)[]>): {
+    D: bigint[][];
+    invariants: bigint[];
+};
+/**
+ * LLL reduction of a lattice basis given as row vectors (Lenstra–Lenstra–Lovász
+ * with Lovász parameter `delta`, default 0.75), in floating point with
+ * Gram–Schmidt recomputed after each change.
+ */
+export declare function lll(basis: ReadonlyArray<readonly number[]>, delta?: number): number[][];
+//# sourceMappingURL=integer-matrices.d.ts.map

package/dist/numbertheory/integer-matrices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integer-matrices.d.ts","sourceRoot":"","sources":["../../src/numbertheory/integer-matrices.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAiCH;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC,GAAG,MAAM,EAAE,EAAE,CAqC5F;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC,GAAG;IAC/E,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;IACd,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAwEA;AAED;;;;GAIG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,aAAa,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,KAAK,SAAO,GAAG,MAAM,EAAE,EAAE,CAsDrF"}

package/dist/numbertheory/modular.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Modular arithmetic: modular exponentiation, previous prime, Legendre symbol,
+ * modular square roots (Tonelli–Shanks) and Carmichael-number test (Korselt).
+ */
+/**
+ * Modular exponentiation `base^exp mod mod` by right-to-left binary squaring.
+ * The result lies in `[0, mod)`.
+ */
+export declare function modPow(base: bigint | number, exp: bigint | number, mod_: bigint | number): bigint;
+/** Largest prime strictly less than `n`. Throws RangeError when `n <= 2`. */
+export declare function prevPrime(n: number): number;
+/**
+ * Legendre symbol (a/p) for an odd prime p, via Euler's criterion.
+ * Returns 0 when p divides a, 1 for a quadratic residue, -1 otherwise.
+ */
+export declare function legendreSymbol(a: number, p: number): -1 | 0 | 1;
+/**
+ * Square root of `a` modulo a prime `p` (Tonelli–Shanks). Returns the smallest
+ * root in `[0, p)`, or `null` when `a` is a non-residue. For `p = 2` returns `a mod 2`.
+ */
+export declare function sqrtMod(a: number, p: number): number | null;
+/**
+ * Carmichael test by Korselt's criterion: `n` is composite, squarefree, and
+ * `(p - 1)` divides `(n - 1)` for every prime factor `p` of `n`.
+ */
+export declare function isCarmichael(n: number): boolean;
+//# sourceMappingURL=modular.d.ts.map

package/dist/numbertheory/modular.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modular.d.ts","sourceRoot":"","sources":["../../src/numbertheory/modular.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA4BH;;;GAGG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAejG;AAED,6EAA6E;AAC7E,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAM3C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAM/D;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAuC3D;AAoBD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAM/C"}

package/dist/numbertheory/sequences.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Integer sequences and enumerators: Motzkin, Narayana, Schroder, Delannoy,
+ * Pell, tribonacci, Eulerian and Lah numbers, partition and composition
+ * generators, Gray code, and binomial coefficients mod a prime (Lucas).
+ */
+/** Motzkin number M(n): number of Motzkin paths of length n. */
+export declare function motzkin(n: number): number;
+/** Narayana number N(n, k) = (1/n) C(n,k) C(n,k-1); 0 outside 1 <= k <= n. */
+export declare function narayana(n: number, k: number): number;
+/** Large Schroder number S(n) (1, 2, 6, 22, 90, ...). */
+export declare function schroder(n: number): number;
+/** Delannoy number D(m, n) = sum_k C(m,k) C(n,k) 2^k. */
+export declare function delannoy(m: number, n: number): number;
+/** Pell number P(n): P0 = 0, P1 = 1, P(n) = 2 P(n-1) + P(n-2). */
+export declare function pell(n: number): number;
+/** Tribonacci number T(n) with T(0) = 0, T(1) = 0, T(2) = 1. */
+export declare function tribonacci(n: number): number;
+/**
+ * Eulerian number A(n, k): permutations of n with k ascents. Defined for
+ * 0 <= k <= n - 1 (and A(0, 0) = 1); 0 otherwise.
+ */
+export declare function eulerianNumber(n: number, k: number): number;
+/** Lah number L(n, k) = C(n-1, k-1) n! / k!; 0 unless 1 <= k <= n. */
+export declare function lahNumber(n: number, k: number): number;
+/** All integer partitions of n, in descending lexicographic order. */
+export declare function integerPartitionsGen(n: number): number[][];
+/** All compositions (ordered partitions) of n. There are 2^(n-1) for n >= 1. */
+export declare function compositionsGen(n: number): number[][];
+/** Binary reflected Gray code over `bits` bits: 2^bits codewords. */
+export declare function grayCode(bits: number): number[];
+/**
+ * Binomial coefficient C(n, k) modulo a prime p, by Lucas' theorem.
+ * `p` must be prime.
+ */
+export declare function binomialMod(n: bigint, k: bigint, p: bigint): bigint;
+//# sourceMappingURL=sequences.d.ts.map

package/dist/numbertheory/sequences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequences.d.ts","sourceRoot":"","sources":["../../src/numbertheory/sequences.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAkBH,gEAAgE;AAChE,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAWzC;AAED,8EAA8E;AAC9E,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAIrD;AAED,yDAAyD;AACzD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAa1C;AAED,yDAAyD;AACzD,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAQrD;AAED,kEAAkE;AAClE,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAQtC;AAED,gEAAgE;AAChE,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAS5C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAU3D;AAED,sEAAsE;AACtE,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAOtD;AAED,sEAAsE;AACtE,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAiB1D;AAED,gFAAgF;AAChF,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,CAkBrD;AAED,qEAAqE;AACrE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAQ/C;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAkBnE"}

package/dist/numeric/constrained.d.ts

@@ -0,0 +1,42 @@
+/** Options for {@link minimizeConstrained}. */
+export interface ConstrainedOptions {
+    /** Equality constraints `h(x) = 0`. */
+    eq?: ReadonlyArray<(x: number[]) => number>;
+    /** Inequality constraints `g(x) ≤ 0`. */
+    ineq?: ReadonlyArray<(x: number[]) => number>;
+    /** Box constraints `[lo, hi]` per coordinate. */
+    bounds?: ReadonlyArray<readonly [number, number]>;
+    /** Feasibility tolerance on the maximum constraint violation (default 1e-8). */
+    tol?: number;
+    /** Maximum number of outer (multiplier) iterations (default 50). */
+    maxOuter?: number;
+    /** Initial penalty parameter `μ` (default 10). */
+    mu0?: number;
+}
+/** Result of {@link minimizeConstrained}. */
+export interface ConstrainedResult {
+    /** The constrained minimizer estimate. */
+    x: number[];
+    /** Objective value `f(x)` (not the augmented Lagrangian). */
+    fx: number;
+    /** Maximum of `|h_i(x)|` and `max(0, g_j(x))` at the returned point. */
+    constraintViolation: number;
+    /** Number of outer iterations performed. */
+    outerIterations: number;
+    /** Whether the constraint violation fell below `tol`. */
+    converged: boolean;
+}
+/**
+ * Minimize `f` from `x0` subject to the constraints in `opts`.
+ *
+ * With no equality or inequality constraints this is a single {@link bfgs}
+ * call (projected onto `bounds` if given).
+ *
+ * @example
+ * // min x² + y²  s.t.  x + y = 1  →  x ≈ [0.5, 0.5], fx ≈ 0.5
+ * minimizeConstrained((v) => v[0] ** 2 + v[1] ** 2, [0, 0], {
+ *   eq: [(v) => v[0] + v[1] - 1],
+ * });
+ */
+export declare function minimizeConstrained(f: (x: number[]) => number, x0: readonly number[], opts?: ConstrainedOptions): ConstrainedResult;
+//# sourceMappingURL=constrained.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constrained.d.ts","sourceRoot":"","sources":["../../src/numeric/constrained.ts"],"names":[],"mappings":"AAoBA,+CAA+C;AAC/C,MAAM,WAAW,kBAAkB;IACjC,uCAAuC;IACvC,EAAE,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC,CAAC;IAC5C,yCAAyC;IACzC,IAAI,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,CAAC,CAAC;IAC9C,iDAAiD;IACjD,MAAM,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,gFAAgF;IAChF,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,kDAAkD;IAClD,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAChC,0CAA0C;IAC1C,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,6DAA6D;IAC7D,EAAE,EAAE,MAAM,CAAC;IACX,wEAAwE;IACxE,mBAAmB,EAAE,MAAM,CAAC;IAC5B,4CAA4C;IAC5C,eAAe,EAAE,MAAM,CAAC;IACxB,yDAAyD;IACzD,SAAS,EAAE,OAAO,CAAC;CACpB;AAKD;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAC1B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,IAAI,GAAE,kBAAuB,GAC5B,iBAAiB,CA2EnB"}

package/dist/numeric/finite-differences.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Finite-difference weights and two scalar fixed-point / bracketing solvers.
+ *
+ * - {@link finiteDifferenceCoefficients}: Fornberg's recursion for the weights
+ *   of the `derivOrder`-th derivative at 0 from arbitrary offsets.
+ * - {@link ridders}: Ridders' bracketing root finder (exponential-fit false
+ *   position), quadratic convergence on a sign-change bracket.
+ * - {@link fixedPoint}: iteration `x ← g(x)`, optionally accelerated by
+ *   Aitken's Δ² extrapolation at every step.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Weights `c_j` such that `f^{(m)}(0) ≈ Σ_j c_j f(x_j)` for the given offsets
+ * `x_j` (Fornberg 1988). The offsets must be distinct and there must be more
+ * than `derivOrder` of them.
+ *
+ * @example
+ * finiteDifferenceCoefficients(2, [-1, 0, 1]) // [1, -2, 1]
+ * finiteDifferenceCoefficients(1, [-1, 0, 1]) // [-0.5, 0, 0.5]
+ */
+export declare function finiteDifferenceCoefficients(derivOrder: number, offsets: readonly number[]): number[];
+/** Options for {@link ridders} and {@link fixedPoint}. */
+export interface ScalarSolveOptions {
+    /** Tolerance on the step (relative to `max(1, |x|)`). */
+    tol?: number;
+    /** Maximum iterations. */
+    maxIter?: number;
+}
+/** Options for {@link fixedPoint}. */
+export interface FixedPointOptions extends ScalarSolveOptions {
+    /** Apply Aitken Δ² extrapolation to each two-step update (default false). */
+    aitken?: boolean;
+}
+/**
+ * Root of `f` in the bracket `[a, b]` by Ridders' method. Requires
+ * `f(a)·f(b) ≤ 0`; throws `RangeError` otherwise and `Error` if `maxIter` is
+ * exhausted.
+ *
+ * @example
+ * ridders((x) => Math.cos(x) - x, 0, 1) // ~0.7390851332151607
+ */
+export declare function ridders(f: (x: number) => number, a: number, b: number, opts?: ScalarSolveOptions): number;
+/**
+ * Fixed point of `g` from `x0`: iterate `x ← g(x)` until the step is below
+ * `tol · max(1, |x|)`. With `aitken: true` each step applies two evaluations
+ * of `g` and Aitken's extrapolation `x₂ − (x₂ − x₁)² / (x₂ − 2x₁ + x₀)`.
+ * Throws if `maxIter` is exhausted or an iterate is not finite.
+ *
+ * @example
+ * fixedPoint(Math.cos, 1) // ~0.7390851332151607
+ */
+export declare function fixedPoint(g: (x: number) => number, x0: number, opts?: FixedPointOptions): number;
+//# sourceMappingURL=finite-differences.d.ts.map

package/dist/numeric/finite-differences.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"finite-differences.d.ts","sourceRoot":"","sources":["../../src/numeric/finite-differences.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,MAAM,EAAE,CAyCV;AAED,0DAA0D;AAC1D,MAAM,WAAW,kBAAkB;IACjC,yDAAyD;IACzD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,0BAA0B;IAC1B,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,sCAAsC;AACtC,MAAM,WAAW,iBAAkB,SAAQ,kBAAkB;IAC3D,6EAA6E;IAC7E,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,OAAO,CACrB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACxB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,IAAI,GAAE,kBAAuB,GAC5B,MAAM,CAqCR;AAED;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EACxB,EAAE,EAAE,MAAM,EACV,IAAI,GAAE,iBAAsB,GAC3B,MAAM,CAqBR"}

package/dist/numeric/gauss-nodes-extra.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Gauss quadrature nodes and weights for classical weight functions.
+ *
+ * - Hermite (weight `e^{−x²}` on ℝ), Laguerre (weight `x^α e^{−x}` on `[0, ∞)`),
+ *   Jacobi (weight `(1−x)^α (1+x)^β` on `[−1, 1]`): the nodes are the roots of
+ *   the degree-n orthogonal polynomial, found by a sign-change scan with
+ *   bisection; the weights come from the Christoffel formula
+ *   `w_i = 1 / Σ_{k<n} p_k(x_i)²` with orthonormal `p_k`.
+ * - Chebyshev T and U: closed-form nodes and weights.
+ *
+ * @packageDocumentation
+ */
+/** Nodes (ascending) and matching weights. */
+export interface GaussRule {
+    nodes: number[];
+    weights: number[];
+}
+/**
+ * Hermite Gauss rule: nodes are the roots of H_n; weights satisfy
+ * `Σ w_i f(x_i) ≈ ∫ e^{−x²} f(x) dx`.
+ *
+ * @example
+ * rootsHermite(2).nodes // [-0.7071067811865476, 0.7071067811865476]
+ */
+export declare function rootsHermite(n: number): GaussRule;
+/**
+ * Generalized Laguerre Gauss rule for weight `x^α e^{−x}` on `[0, ∞)`
+ * (`α = 0` by default). Weights: `w_i = 1 / Σ_{k<n} k! (L_k^α(x_i))² / Γ(k+α+1)`.
+ *
+ * @example
+ * rootsLaguerre(2).nodes // [0.5857864376269049, 3.414213562373095]
+ */
+export declare function rootsLaguerre(n: number, alpha?: number): GaussRule;
+/**
+ * Chebyshev first-kind Gauss rule for weight `1/√(1−x²)`: closed-form nodes
+ * `cos((2i−1)π/(2n))` and equal weights `π/n`.
+ *
+ * @example
+ * rootsChebyshevT(3).nodes // [-0.8660254037844387, 0, 0.8660254037844387]
+ */
+export declare function rootsChebyshevT(n: number): GaussRule;
+/**
+ * Chebyshev second-kind Gauss rule for weight `√(1−x²)`: nodes `cos(iπ/(n+1))`
+ * and weights `π/(n+1) · sin²(iπ/(n+1))`.
+ *
+ * @example
+ * rootsChebyshevU(1).nodes // [0]
+ */
+export declare function rootsChebyshevU(n: number): GaussRule;
+/**
+ * Jacobi Gauss rule for weight `(1−x)^α (1+x)^β` on `[−1, 1]`. Weights use
+ * the Christoffel formula with the Jacobi norms
+ * `h_k = 2^{α+β+1}/(2k+α+β+1) · Γ(k+α+1)Γ(k+β+1)/(Γ(k+α+β+1) k!)`.
+ *
+ * @example
+ * rootsJacobi(3, 0, 0) // Legendre: nodes ±√(3/5), 0
+ */
+export declare function rootsJacobi(n: number, alpha: number, beta: number): GaussRule;
+/**
+ * Gauss–Hermite approximation of `∫_ℝ e^{−x²} f(x) dx` with `n` nodes.
+ *
+ * @example
+ * gaussHermiteIntegrate((x) => x * x, 5) // √π / 2
+ */
+export declare function gaussHermiteIntegrate(f: (x: number) => number, n: number): number;
+/**
+ * Gauss–Laguerre approximation of `∫₀^∞ e^{−x} f(x) dx` with `n` nodes.
+ *
+ * @example
+ * gaussLaguerreIntegrate((x) => x * x, 5) // 2
+ */
+export declare function gaussLaguerreIntegrate(f: (x: number) => number, n: number): number;
+//# sourceMappingURL=gauss-nodes-extra.d.ts.map

package/dist/numeric/gauss-nodes-extra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gauss-nodes-extra.d.ts","sourceRoot":"","sources":["../../src/numeric/gauss-nodes-extra.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,8CAA8C;AAC9C,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAiHD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAajD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,SAAI,GAAG,SAAS,CAkB7D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CASpD;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,SAAS,CAUpD;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CA6B7E;AAMD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKjF;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKlF"}

package/dist/numeric/global-optimizers.d.ts

@@ -0,0 +1,64 @@
+/** Options shared by the global optimizers. */
+export interface GlobalOptimizeOptions {
+    /** Seed for the deterministic RNG (default `0`). */
+    seed?: number;
+    /** Maximum number of generations / iterations (default 1000 for DE, 10000 for SA). */
+    maxIter?: number;
+    /** Differential-evolution population size (default `15 · dim`). */
+    popSize?: number;
+    /** Convergence tolerance (DE: population fitness spread; SA: final temperature). */
+    tol?: number;
+    /** Differential weight `F` (default 0.8). */
+    F?: number;
+    /** Crossover probability `CR` (default 0.9). */
+    CR?: number;
+}
+/** Result of the global optimizers. */
+export interface GlobalOptimizeResult {
+    /** Best point found. */
+    x: number[];
+    /** Objective value at `x`. */
+    fx: number;
+    /** Generations (DE) or iterations (SA) performed. */
+    iterations: number;
+    /** Number of objective evaluations. */
+    evaluations: number;
+    /** Whether the convergence test was met before the iteration budget ran out. */
+    converged: boolean;
+}
+/** Options for {@link simulatedAnnealing}. */
+export interface SimulatedAnnealingOptions extends GlobalOptimizeOptions {
+    /** Initial temperature (default 1). */
+    T0?: number;
+    /** Geometric cooling factor applied per iteration, in (0, 1) (default 0.995). */
+    cooling?: number;
+    /** Optional box `[lo, hi]` per coordinate; proposals are clipped into it. */
+    bounds?: ReadonlyArray<readonly [number, number]>;
+    /** Finish with a Nelder-Mead local polish from the best point (default `true`). */
+    polish?: boolean;
+}
+/**
+ * Minimize `f` over the box `bounds` with differential evolution (`rand/1/bin`).
+ *
+ * @example
+ * differentialEvolution((x) => x[0] ** 2 + x[1] ** 2, [[-5, 5], [-5, 5]], { seed: 1 }).fx
+ * // ~0
+ */
+export declare function differentialEvolution(f: (x: number[]) => number, bounds: ReadonlyArray<readonly [number, number]>, opts?: GlobalOptimizeOptions): GlobalOptimizeResult;
+/**
+ * Minimize `f` from `x0` by simulated annealing (Metropolis acceptance,
+ * geometric cooling `T ← cooling · T`). The proposal width for coordinate `i`
+ * is `0.1 · (T / T0) · scale_i`, where `scale_i` is the bound width when
+ * `bounds` is given and `max(1, |x_i|)` otherwise.
+ *
+ * Stops when `T < tol` or after `maxIter` iterations. Unless `polish: false`,
+ * the best point is then refined by a bounded Nelder-Mead local search (with
+ * restarts). `converged` is `true` only when the cooling schedule finished
+ * (`T < tol`) AND the polish stopped on its own tolerance rather than its
+ * evaluation cap.
+ *
+ * @example
+ * simulatedAnnealing((x) => (x[0] - 3) ** 2, [0], { seed: 7 }).x // ~[3]
+ */
+export declare function simulatedAnnealing(f: (x: number[]) => number, x0: readonly number[], opts?: SimulatedAnnealingOptions): GlobalOptimizeResult;
+//# sourceMappingURL=global-optimizers.d.ts.map

package/dist/numeric/global-optimizers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-optimizers.d.ts","sourceRoot":"","sources":["../../src/numeric/global-optimizers.ts"],"names":[],"mappings":"AAiBA,+CAA+C;AAC/C,MAAM,WAAW,qBAAqB;IACpC,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,sFAAsF;IACtF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,oFAAoF;IACpF,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,6CAA6C;IAC7C,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,gDAAgD;IAChD,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,uCAAuC;AACvC,MAAM,WAAW,oBAAoB;IACnC,wBAAwB;IACxB,CAAC,EAAE,MAAM,EAAE,CAAC;IACZ,8BAA8B;IAC9B,EAAE,EAAE,MAAM,CAAC;IACX,qDAAqD;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,gFAAgF;IAChF,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,8CAA8C;AAC9C,MAAM,WAAW,yBAA0B,SAAQ,qBAAqB;IACtE,uCAAuC;IACvC,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,iFAAiF;IACjF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6EAA6E;IAC7E,MAAM,CAAC,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAClD,mFAAmF;IACnF,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAoBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAC1B,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChD,IAAI,GAAE,qBAA0B,GAC/B,oBAAoB,CAoEtB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,MAAM,EAC1B,EAAE,EAAE,SAAS,MAAM,EAAE,EACrB,IAAI,GAAE,yBAA8B,GACnC,oBAAoB,CA4EtB"}