@danielsimonjr/mathts-functions 0.31.0 → 0.33.0

package/dist/numbertheory/extra.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Number-theory fills — closes gaps left by the existing combinatorics/number-theory
+ * surface (`typed/combinatorics.ts`): continued fractions, Euler numbers, the signed
+ * Stirling numbers of the first kind, discrete logarithm (BSGS), primitive roots,
+ * multiplicative order, the Kronecker symbol, and lexicographic
+ * permutation/combination *enumerators* (the existing `permutations`/`combinations`
+ * only return counts, not the tuples themselves).
+ *
+ * Plain exported functions (not `mathTyped` dispatch) — all take/return `number`
+ * or generic arrays, matching the style of `descriptive-stats.ts`.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Simple continued fraction expansion `[a0, a1, a2, ...]` of `x`, where
+ * `a_i = floor(r)` and `r <- 1 / (r - a_i)`.
+ *
+ * Stops after `maxTerms` (default 20) or once the fractional part is smaller
+ * than `1e-12` (the remaining value is effectively an integer).
+ *
+ * @param x - The number to expand
+ * @param maxTerms - Maximum number of terms to compute (default 20)
+ * @returns The sequence of partial-quotient terms
+ *
+ * @example
+ * continuedFraction(3.245, 5) // => [3, 4, 12, 4, ...]
+ */
+export declare function continuedFraction(x: number, maxTerms?: number): number[];
+/**
+ * Euler numbers `E_0..E_n` (the coefficients in the secant Maclaurin series).
+ *
+ * `E_0 = 1`; all odd-index Euler numbers are 0; for even `m > 0`:
+ * `E_m = -sum_{k=0}^{m/2-1} C(m, 2k) * E_{2k}`.
+ *
+ * @param n - Non-negative integer: compute E_0 through E_n
+ * @returns Array of length `n + 1`: `[E_0, E_1, ..., E_n]`
+ *
+ * @example
+ * eulerNumbers(6) // => [1, 0, -1, 0, 5, 0, -61]
+ */
+export declare function eulerNumbers(n: number): number[];
+/**
+ * Signed Stirling number of the first kind `s(n, k)`.
+ *
+ * Recurrence: `s(n, k) = s(n-1, k-1) - (n-1)*s(n-1, k)`, with `s(0, 0) = 1`
+ * and `s(n, 0) = 0` for `n > 0`.
+ *
+ * @param n - Non-negative integer
+ * @param k - Non-negative integer, `0 <= k <= n`
+ * @returns The signed Stirling number `s(n, k)`
+ *
+ * @example
+ * stirlingS1(5, 2) // => -50
+ */
+export declare function stirlingS1(n: number, k: number): number;
+/**
+ * Discrete logarithm via baby-step giant-step: the smallest `x >= 0` such
+ * that `g^x === h (mod p)`, or `-1` if none exists within `[0, p-1]`.
+ *
+ * Uses `BigInt` internally for modular exponentiation/inversion to avoid
+ * overflow. `m = ceil(sqrt(p-1))` baby steps are stored in a map; the giant
+ * steps multiply by `g^(-m) mod p` each round.
+ *
+ * @param g - Base
+ * @param h - Target
+ * @param p - Prime modulus
+ * @returns The smallest non-negative `x` with `g^x === h (mod p)`, or `-1`
+ *
+ * @example
+ * discreteLog(2, 3, 5) // => 3   (2^3 = 8 === 3 mod 5)
+ */
+export declare function discreteLog(g: number, h: number, p: number): number;
+/**
+ * Smallest primitive root modulo a prime `p`.
+ *
+ * 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`.
+ *
+ * @param p - An odd prime (p = 2 returns 1 trivially)
+ * @returns The smallest primitive root modulo p
+ *
+ * @example
+ * primitiveRoot(7) // => 3
+ */
+export declare function primitiveRoot(p: 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).
+ *
+ * @param a - Integer
+ * @param n - Positive integer modulus
+ * @returns The multiplicative order, or -1 if undefined
+ *
+ * @example
+ * multiplicativeOrder(2, 7) // => 3
+ */
+export declare function multiplicativeOrder(a: number, n: number): number;
+/**
+ * Kronecker symbol `(a|n)`, generalizing the Jacobi symbol `(a|n)` (odd
+ * positive `n`) to all integers `n`.
+ *
+ * - `(a|0) = 1` if `|a| = 1`, else `0`.
+ * - Sign of `n` is extracted first: `(a|-1) = -1` if `a < 0`, else `1`.
+ * - Factors of 2 are extracted from `n` using `(a|2)`: `0` if `a` even,
+ *   `1` if `a === ±1 (mod 8)`, `-1` if `a === ±3 (mod 8)`.
+ * - The remaining odd part is evaluated via the standard Jacobi reciprocity
+ *   recursion.
+ *
+ * @param a - Integer
+ * @param n - Integer
+ * @returns -1, 0, or 1
+ *
+ * @example
+ * kroneckerSymbol(2, 3) // => -1
+ */
+export declare function kroneckerSymbol(a: number, n: number): number;
+/**
+ * Enumerate all length-`k` combinations of `arr` (index-order subsequences,
+ * i.e. lexicographic order for a sorted input) as an array of tuples.
+ *
+ * @param arr - Source array
+ * @param k - Combination length
+ * @returns All `C(arr.length, k)` combinations, in lexicographic order
+ *
+ * @example
+ * combinationsGen([1, 2, 3], 2) // => [[1,2],[1,3],[2,3]]
+ */
+export declare function combinationsGen<T>(arr: readonly T[], k: number): T[][];
+/**
+ * Enumerate all length-`k` permutations (ordered arrangements) of `arr`
+ * as an array of tuples, in lexicographic order of index selection.
+ * `k` defaults to `arr.length` (full permutations).
+ *
+ * @param arr - Source array
+ * @param k - Permutation length (default: `arr.length`)
+ * @returns All `n! / (n-k)!` permutations, in lexicographic order
+ *
+ * @example
+ * permutationsGen([1, 2, 3], 2) // => 6 tuples: [1,2],[1,3],[2,1],[2,3],[3,1],[3,2]
+ */
+export declare function permutationsGen<T>(arr: readonly T[], k?: number): T[][];
+//# sourceMappingURL=extra.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extra.d.ts","sourceRoot":"","sources":["../../src/numbertheory/extra.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAMH;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,SAAK,GAAG,MAAM,EAAE,CAcpE;AAiBD;;;;;;;;;;;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"}

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

@@ -0,0 +1,35 @@
+/**
+ * Gauss-Legendre quadrature nodes and weights.
+ *
+ * `rootsLegendre(n)` finds the n roots of the degree-n Legendre polynomial
+ * P_n via Newton's method (initial guess from the standard asymptotic
+ * approximation), then derives the corresponding quadrature weights. This is
+ * the classical fixed-node table underlying Gauss-Legendre quadrature on
+ * [-1, 1]; callers needing a custom node count (rather than the library's
+ * built-in fixed-order `integrate`/`gaussLegendre` routines) use this
+ * directly.
+ *
+ * @packageDocumentation
+ */
+/** Result of {@link rootsLegendre}: nodes ascending on [-1, 1] with matching weights. */
+export interface RootsLegendreResult {
+    nodes: number[];
+    weights: number[];
+}
+/**
+ * n-point Gauss-Legendre quadrature nodes and weights on [-1, 1].
+ *
+ * Nodes are the roots of the degree-n Legendre polynomial P_n, refined by
+ * Newton's method from the standard asymptotic initial guess
+ * `cos(pi*(i+0.75)/(n+0.5))`. Weights are `2 / ((1-x_i^2) * P'_n(x_i)^2)`.
+ *
+ * @param n - Number of quadrature points (positive integer)
+ * @returns Nodes (ascending) and matching weights
+ *
+ * @example
+ * rootsLegendre(3)
+ * // { nodes: [-0.7745966692, 0, 0.7745966692],
+ * //   weights: [0.5555555556, 0.8888888889, 0.5555555556] }
+ */
+export declare function rootsLegendre(n: number): RootsLegendreResult;
+//# sourceMappingURL=gauss-nodes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gauss-nodes.d.ts","sourceRoot":"","sources":["../../src/numeric/gauss-nodes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,yFAAyF;AACzF,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAuBD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,GAAG,mBAAmB,CA+B5D"}

package/dist/special/hypergeometric.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Hypergeometric functions.
+ *
+ * Implements the generalized hypergeometric series pFq via the ascending
+ * Pochhammer-ratio method: each term is generated from the previous one by
+ * multiplying by the ratio of rising factorials,
+ *
+ *   term_{n+1} / term_n = ( prod_i (a_i + n) / prod_j (b_j + n) ) * z / (n + 1)
+ *
+ * accumulating until the term becomes negligible relative to the running sum
+ * (|term| < 1e-16 * |sum|) or a hard iteration cap is hit. This incremental
+ * form avoids recomputing factorials/Pochhammer symbols from scratch at each
+ * order and is numerically well-behaved for the convergent regimes documented
+ * per function below.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Generalized hypergeometric function pFq(a; b; z), computed via the
+ * ascending Pochhammer-ratio series:
+ *
+ *   pFq(a_1..a_p; b_1..b_q; z) = sum_{n=0}^inf
+ *     ( prod_i (a_i)_n / prod_j (b_j)_n ) * z^n / n!
+ *
+ * This is the generic engine that hyp0f1/hyp1f1/hyp2f1 delegate to. No
+ * convergence-region check is performed here (that is the caller's
+ * responsibility, see hyp2f1's |z| < 1 guard) — the series is simply summed
+ * until it converges to machine precision or MAX_TERMS is reached.
+ *
+ * @param a - Upper (numerator) parameters
+ * @param b - Lower (denominator) parameters
+ * @param z - Argument
+ * @returns pFq(a; b; z)
+ */
+export declare function pFq(a: number[], b: number[], z: number): number;
+/**
+ * Confluent hypergeometric limit function 0F1(; b; z):
+ *
+ *   hyp0f1(b, z) = sum_{n=0}^inf z^n / ((b)_n n!)
+ *
+ * Entire in z (converges for all finite z, real or otherwise real-valued
+ * here); related to the Bessel functions.
+ *
+ * @param b - Parameter
+ * @param z - Argument
+ * @returns 0F1(; b; z)
+ *
+ * @example
+ * hyp0f1(2, 0.5) // ~1.2717234563
+ */
+export declare function hyp0f1(b: number, z: number): number;
+/**
+ * Kummer's confluent hypergeometric function 1F1(a; b; z) (Kummer's M):
+ *
+ *   hyp1f1(a, b, z) = sum_{n=0}^inf ( (a)_n / (b)_n ) * z^n / n!
+ *
+ * Entire in z. The direct ascending series targets moderate |z| — for large
+ * |z| the series requires many terms and loses accuracy to cancellation
+ * (particularly when a and b have opposite signs); an asymptotic expansion
+ * would be needed for large |z| but is not implemented here.
+ *
+ * @param a - Numerator parameter
+ * @param b - Denominator parameter
+ * @param z - Argument
+ * @returns 1F1(a; b; z)
+ *
+ * @example
+ * hyp1f1(1, 2, 0.5) // ~1.2974425414
+ */
+export declare function hyp1f1(a: number, b: number, z: number): number;
+/**
+ * Gauss's hypergeometric function 2F1(a, b; c; z):
+ *
+ *   hyp2f1(a, b, c, z) = sum_{n=0}^inf ( (a)_n (b)_n / (c)_n ) * z^n / n!
+ *
+ * The ascending series converges only for |z| < 1. Analytic continuation
+ * beyond the unit disk (e.g. via connection formulas or a transformation to
+ * 1-z) is not yet implemented.
+ *
+ * @param a - First numerator parameter
+ * @param b - Second numerator parameter
+ * @param c - Denominator parameter
+ * @param z - Argument, must satisfy |z| < 1
+ * @returns 2F1(a, b; c; z)
+ * @throws {Error} If |z| >= 1
+ *
+ * @example
+ * hyp2f1(1, 2, 3, 0.5) // ~1.5451774445
+ */
+export declare function hyp2f1(a: number, b: number, c: number, z: number): number;
+//# sourceMappingURL=hypergeometric.d.ts.map

package/dist/special/hypergeometric.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hypergeometric.d.ts","sourceRoot":"","sources":["../../src/special/hypergeometric.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAQH;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgB/D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAKzE"}

package/dist/special/jacobi-elliptic.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Jacobi elliptic functions sn, cn, dn.
+ *
+ * Uses the parameter convention `m = k^2` (matching scipy's
+ * `scipy.special.ellipj(u, m)` and mpmath's `ellipfun(..., u, m)`), not the
+ * modulus-angle convention some texts use.
+ *
+ * Computed via the descending Landen transformation / arithmetic-geometric
+ * mean (AGM) method (Abramowitz & Stegun 16.4, the Bulirsch algorithm):
+ * build the AGM sequences
+ *
+ *   a_0 = 1, b_0 = sqrt(1 - m), c_0 = sqrt(m)
+ *   a_{i+1} = (a_i + b_i) / 2
+ *   b_{i+1} = sqrt(a_i * b_i)
+ *   c_{i+1} = (a_i - b_i) / 2
+ *
+ * until c_N is negligible, then descend the amplitude
+ *
+ *   phi_N = 2^N * a_N * u
+ *   phi_{i-1} = (phi_i + asin((c_i / a_i) * sin(phi_i))) / 2   for i = N..1
+ *
+ * so that sn(u,m) = sin(phi_0), cn(u,m) = cos(phi_0),
+ * dn(u,m) = sqrt(1 - m * sn^2(u,m)).
+ *
+ * @packageDocumentation
+ */
+/**
+ * Jacobi elliptic function sn(u, m), parameter convention m = k^2.
+ *
+ * @param u - Argument
+ * @param m - Parameter m = k^2, must be in [0, 1]
+ * @returns sn(u, m)
+ *
+ * @example
+ * jacobiSN(0.5, 0.3) // ~0.4742156227
+ */
+export declare function jacobiSN(u: number, m: number): number;
+/**
+ * Jacobi elliptic function cn(u, m), parameter convention m = k^2.
+ *
+ * @param u - Argument
+ * @param m - Parameter m = k^2, must be in [0, 1]
+ * @returns cn(u, m)
+ *
+ * @example
+ * jacobiCN(0.5, 0.3) // ~0.8804087364
+ */
+export declare function jacobiCN(u: number, m: number): number;
+/**
+ * Jacobi elliptic function dn(u, m), parameter convention m = k^2.
+ *
+ * @param u - Argument
+ * @param m - Parameter m = k^2, must be in [0, 1]
+ * @returns dn(u, m)
+ *
+ * @example
+ * jacobiDN(0.5, 0.3) // ~0.9656789647
+ */
+export declare function jacobiDN(u: number, m: number): number;
+//# sourceMappingURL=jacobi-elliptic.d.ts.map

package/dist/special/jacobi-elliptic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jacobi-elliptic.d.ts","sourceRoot":"","sources":["../../src/special/jacobi-elliptic.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAwDH;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAErD"}

package/dist/special/polygamma-orthopoly.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Polygamma functions and classical orthogonal polynomials.
+ *
+ * `polygamma(n, x)` is the n-th derivative of the digamma function,
+ * ψ^(n)(x) = d^n/dx^n ψ(x). It is computed by shifting the argument up via
+ * the standard recurrence
+ *
+ *   ψ^(n)(x) = ψ^(n)(x + m) + (-1)^(n+1) n! * sum_{k=0}^{m-1} 1/(x+k)^(n+1)
+ *
+ * until x + m is large enough (>= SHIFT_THRESHOLD) for the asymptotic
+ * (Bernoulli) expansion (DLMF 5.15.8) to converge to machine precision:
+ *
+ *   psi^(n)(X) ~ (-1)^(n-1) * [ (n-1)!/X^n + n!/(2 X^(n+1))
+ *                 + sum_j B_{2j} * (2j+n-1)! / ((2j)! * X^(2j+n)) ]
+ *
+ * Since (-1)^(n+1) = (-1)^(n-1), both pieces share the same overall sign.
+ *
+ * `jacobiP` and `gegenbauerC` are evaluated with their standard stable
+ * three-term recurrences (DLMF 18.9.2 and 18.9.1 respectively), matching the
+ * pattern already used for `chebyshevT` / `hermiteH` / `laguerreL` /
+ * `legendreP`.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Polygamma function ψ^(n)(x): the n-th derivative of the digamma function.
+ *
+ * `polygamma(0, x)` delegates to `digamma(x)`. For `n >= 1`, x is shifted up
+ * via the standard recurrence until it is large enough for the Bernoulli
+ * asymptotic expansion to converge.
+ *
+ * @param n - Derivative order (nonnegative integer)
+ * @param x - Argument (must not be a nonpositive integer, where ψ^(n) has poles)
+ * @returns ψ^(n)(x)
+ *
+ * @example
+ * polygamma(1, 2) // ~0.6449340668 (trigamma(2))
+ * polygamma(2, 1) // ~-2.4041138063
+ */
+export declare function polygamma(n: number, x: number): number;
+/**
+ * Trigamma function ψ'(x) = ψ^(1)(x): the first derivative of the digamma
+ * function. Equivalent to `polygamma(1, x)`.
+ *
+ * @param x - Argument
+ * @returns ψ'(x)
+ *
+ * @example
+ * trigamma(2) // ~0.6449340668 (= zeta(2) - 1 = pi^2/6 - 1)
+ */
+export declare function trigamma(x: number): number;
+/**
+ * Jacobi polynomial P_n^(alpha,beta)(x), evaluated via the standard
+ * three-term recurrence (DLMF 18.9.2).
+ *
+ * @param n - Degree (nonnegative integer)
+ * @param alpha - Parameter alpha (> -1)
+ * @param beta - Parameter beta (> -1)
+ * @param x - Evaluation point
+ * @returns P_n^(alpha,beta)(x)
+ *
+ * @example
+ * jacobiP(2, 1, 1, 0.5) // 0.1875
+ */
+export declare function jacobiP(n: number, alpha: number, beta: number, x: number): number;
+/**
+ * Gegenbauer (ultraspherical) polynomial C_n^(alpha)(x), evaluated via the
+ * standard three-term recurrence (DLMF 18.9.1).
+ *
+ * @param n - Degree (nonnegative integer)
+ * @param alpha - Parameter alpha (> -1/2, alpha != 0)
+ * @param x - Evaluation point
+ * @returns C_n^(alpha)(x)
+ *
+ * @example
+ * gegenbauerC(2, 1, 1) // 3 (C_2^(1)(x) = 4x^2 - 1)
+ */
+export declare function gegenbauerC(n: number, alpha: number, x: number): number;
+//# sourceMappingURL=polygamma-orthopoly.d.ts.map

package/dist/special/polygamma-orthopoly.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygamma-orthopoly.d.ts","sourceRoot":"","sources":["../../src/special/polygamma-orthopoly.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAiBH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAkCtD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAqBjF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBvE"}

package/dist/stats/fit-distribution.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Maximum-likelihood distribution fitting (Phase 4 Task 1).
+ *
+ * `fitDistribution(name, data)` fits one of five common distributions to a
+ * sample by maximum likelihood and reports the fitted parameters plus the
+ * achieved log-likelihood.
+ *
+ * - `normal`      — closed form: mu = mean, sigma = population std (ddof=0).
+ * - `exponential` — closed form: lambda = 1 / mean.
+ * - `lognormal`   — fit a normal to ln(data) (requires all data > 0).
+ * - `poisson`     — closed form: lambda = mean.
+ * - `gamma`       — no closed form for the shape parameter. Given shape k,
+ *   the MLE scale is theta = xbar / k; substituting back yields the
+ *   1-D shape equation `ln(k) - psi(k) = ln(xbar) - mean(ln x)`
+ *   (psi = digamma), solved here with the secant method starting from the
+ *   Choi & Wette (1969) initial guess.
+ *
+ * @packageDocumentation
+ */
+/** Supported distribution families for {@link fitDistribution}. */
+export type DistributionName = 'normal' | 'exponential' | 'lognormal' | 'poisson' | 'gamma';
+/** Result of {@link fitDistribution}: fitted parameters + achieved log-likelihood. */
+export interface FitDistributionResult {
+    /** Fitted parameters, named per distribution (see {@link fitDistribution}). */
+    params: Record<string, number>;
+    /** Log-likelihood of `data` under the fitted parameters. */
+    logLikelihood: number;
+}
+/**
+ * Fit a distribution to `data` by maximum likelihood.
+ *
+ * @param name - Distribution family: 'normal' | 'exponential' | 'lognormal' | 'poisson' | 'gamma'
+ * @param data - Sample data
+ * @returns Fitted parameters and the log-likelihood achieved under them
+ *
+ * @example
+ * fitDistribution('normal', [2, 4, 4, 4, 5, 5, 7, 9]);
+ * // { params: { mean: 5, std: 2 }, logLikelihood: ... }
+ *
+ * fitDistribution('exponential', [1, 2, 3, 2]);
+ * // { params: { lambda: 0.5 }, logLikelihood: ... }
+ */
+export declare function fitDistribution(name: DistributionName, data: readonly number[]): FitDistributionResult;
+//# sourceMappingURL=fit-distribution.d.ts.map

package/dist/stats/fit-distribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fit-distribution.d.ts","sourceRoot":"","sources":["../../src/stats/fit-distribution.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAMH,mEAAmE;AACnE,MAAM,MAAM,gBAAgB,GAAG,QAAQ,GAAG,aAAa,GAAG,WAAW,GAAG,SAAS,GAAG,OAAO,CAAC;AAE5F,sFAAsF;AACtF,MAAM,WAAW,qBAAqB;IACpC,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,4DAA4D;IAC5D,aAAa,EAAE,MAAM,CAAC;CACvB;AA8FD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,SAAS,MAAM,EAAE,GACtB,qBAAqB,CAoBvB"}

package/dist/stats/inference-extra2.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Noncentral chi-squared CDF via the Poisson-mixture representation:
+ *
+ *   F(x; k, λ) = Σ_{j=0}^∞ Pois(j; λ/2) · chiSquaredCDF(x, k + 2j)
+ *
+ * Truncated once the cumulative Poisson mass covers `1 − 1e-12` of the total
+ * (past the Poisson mode, so truncation never fires during the rising phase).
+ *
+ * @example
+ * noncentralChi2CDF(10, 3, 2); // ~0.89856 (scipy ncx2.cdf)
+ */
+export declare function noncentralChi2CDF(x: number, df: number, nc: number): number;
+/**
+ * Noncentral F CDF via the Poisson-mixture representation over the numerator
+ * degrees of freedom:
+ *
+ *   F(x; d1, d2, λ) = Σ_{j=0}^∞ Pois(j; λ/2) · fCDF(x·d1/(d1+2j), d1+2j, d2)
+ *
+ * Truncated the same way as {@link noncentralChi2CDF}.
+ *
+ * @example
+ * noncentralFCDF(2, 3, 10, 4); // ~0.46636 (scipy ncf.cdf)
+ */
+export declare function noncentralFCDF(x: number, dfn: number, dfd: number, nc: number): number;
+/**
+ * Noncentral Student-t CDF via the mixture representation
+ * `T = (Z + δ) / sqrt(V/ν)`, `Z ~ N(0,1)`, `V ~ χ²_ν` independent:
+ *
+ *   F(t; ν, δ) = E_V[ Φ(t·sqrt(V/ν) − δ) ] = ∫₀^∞ Φ(t·sqrt(v/ν) − δ) · χ²_ν(v) dv
+ *
+ * Evaluated by composite Simpson's rule over `v` (central-χ² density; `δ`
+ * only enters the normal-CDF term). The upper integration bound is set
+ * generously past the χ²_ν tail so the truncation error is negligible
+ * relative to the ~1e-4 Simpson discretization error at the panel count used.
+ *
+ * @example
+ * noncentralTCDF(1.5, 10, 2); // ~0.30479 (scipy nct.cdf)
+ */
+export declare function noncentralTCDF(t: number, df: number, nc: number): number;
+/** Options shared by the circular-statistics functions. */
+export interface CircularOptions {
+    /** Upper bound of the angular range. Default `2π`. */
+    high?: number;
+    /** Lower bound of the angular range. Default `0`. */
+    low?: number;
+}
+/**
+ * Circular (angular) mean, mapped back into `[low, high)`.
+ *
+ * `mean = atan2(Σsinθ, Σcosθ)`, where `θ` is `angles` rescaled into
+ * `[0, 2π)` when a non-default `[low, high)` range is given (matching
+ * `scipy.stats.circmean`).
+ *
+ * @example
+ * circmean([0.1, 0.2, 6.2]); // ~0.07236 (scipy circmean; wraps near 0)
+ */
+export declare function circmean(angles: readonly number[], opts?: CircularOptions): number;
+/**
+ * Circular variance `1 − R`, where `R = |Σcosθ + iΣsinθ| / n` is the mean
+ * resultant length. `R ∈ [0, 1]`, so `circvar ∈ [0, 1]`.
+ */
+export declare function circvar(angles: readonly number[], opts?: CircularOptions): number;
+/**
+ * Circular standard deviation `sqrt(−2·ln(R))` (matches `scipy.stats.circstd`
+ * with the default `normalize=False` low/high dispersion measure).
+ */
+export declare function circstd(angles: readonly number[], opts?: CircularOptions): number;
+/**
+ * Von Mises probability density function (the circular analogue of the
+ * normal distribution).
+ *
+ *   f(θ; μ, κ) = exp(κ·cos(θ − μ)) / (2π·I₀(κ))
+ *
+ * `I₀` is the modified Bessel function of the first kind, order 0
+ * (`besselIScalar` — the shared special-function scalar backing the public
+ * `besselI`).
+ *
+ * @example
+ * vonMisesPDF(0, 0, 2); // ~0.51589 (scipy vonmises.pdf(0, 2))
+ */
+export declare function vonMisesPDF(theta: number, mu: number, kappa: number): number;
+/** Options for {@link mcnemar}. */
+export interface McNemarOptions {
+    /** Apply the continuity correction (`|b−c| − 1`). Default `true`. */
+    correction?: boolean;
+}
+/** Result of {@link mcnemar}. */
+export interface McNemarResult {
+    chi2: number;
+    pValue: number;
+}
+/**
+ * McNemar's test for paired nominal data on a 2x2 table
+ * `[[a, b], [c, d]]` (only the discordant pairs `b`, `c` matter):
+ *
+ *   chi2 = (|b − c| − correction)² / (b + c)
+ *
+ * with the continuity correction (`1`) applied by default, matching
+ * `statsmodels.stats.contingency_tables.mcnemar`. `pValue = 1 −
+ * chiSquaredCDF(chi2, 1)`.
+ *
+ * @example
+ * mcnemar([[10, 5], [3, 12]], { correction: false }); // { chi2: 0.5, pValue: ... }
+ */
+export declare function mcnemar(table: readonly (readonly number[])[], opts?: McNemarOptions): McNemarResult;
+/** Result of {@link cochranQ}. */
+export interface CochranQResult {
+    Q: number;
+    pValue: number;
+    dof: number;
+}
+/**
+ * Cochran's Q test — the extension of McNemar's test to `k > 2` matched
+ * binary treatments. `data` has one row per subject, one column per
+ * treatment (0/1 entries).
+ *
+ *   Q = (k−1)·(k·ΣCⱼ² − N²) / (k·N − ΣRᵢ²)
+ *
+ * where `Cⱼ` are column sums, `Rᵢ` are row sums, and `N = ΣRᵢ`. `dof = k −
+ * 1`; `pValue = 1 − chiSquaredCDF(Q, k−1)`. Matches
+ * `statsmodels.stats.contingency_tables.cochrans_q`.
+ *
+ * @example
+ * cochranQ([[1, 1, 0], [1, 0, 0], [1, 1, 1], [0, 1, 0], [1, 1, 0]]);
+ */
+export declare function cochranQ(data: readonly (readonly number[])[]): CochranQResult;
+//# sourceMappingURL=inference-extra2.d.ts.map

package/dist/stats/inference-extra2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inference-extra2.d.ts","sourceRoot":"","sources":["../../src/stats/inference-extra2.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAiB3E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAkBtF;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAsBxE;AAED,2DAA2D;AAC3D,MAAM,WAAW,eAAe;IAC9B,sDAAsD;IACtD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAsBD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,eAAoB,GAAG,MAAM,CAMtF;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,eAAoB,GAAG,MAAM,CAMrF;AAED;;;GAGG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,IAAI,GAAE,eAAoB,GAAG,MAAM,CAMrF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAG5E;AAED,mCAAmC;AACnC,MAAM,WAAW,cAAc;IAC7B,qEAAqE;IACrE,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,iCAAiC;AACjC,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CACrB,KAAK,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACrC,IAAI,GAAE,cAAmB,GACxB,aAAa,CAYf;AAED,kCAAkC;AAClC,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,GAAG,cAAc,CA8B7E"}

package/dist/stats/timeseries.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Partial autocorrelation function up to `nlags` (inclusive), via the
+ * Levinson-Durbin recursion applied to the biased autocorrelations (`acf`).
+ * `pacf[0] = 1`. Matches `statsmodels.tsa.stattools.pacf(x, nlags, method='ldb')`.
+ *
+ * @example
+ * pacf([1, 2, 3, 2, 1, 2, 3, 2, 1, 2, 3, 2], 3) // => [1, 0, -0.8333..., 0]
+ */
+export declare function pacf(x: number[], nlags: number): number[];
+/** Result of {@link ljungBox}. */
+export interface LjungBoxResult {
+    statistic: number;
+    pValue: number;
+}
+/**
+ * Ljung-Box portmanteau test for autocorrelation up to lag `lags`.
+ * `Q = n(n+2) * Σ_{k=1}^{lags} ρ_k² / (n-k)`, `pValue = 1 - chiSquaredCDF(Q, lags)`.
+ * Matches `statsmodels.stats.diagnostic.acorr_ljungbox`.
+ */
+export declare function ljungBox(x: number[], lags: number): LjungBoxResult;
+/**
+ * Durbin-Watson statistic for residual autocorrelation:
+ * `Σ_{t=2}^{n}(e_t - e_{t-1})² / Σ_{t=1}^{n} e_t²`. Ranges (0, 4); ~2 indicates
+ * no autocorrelation, <2 positive autocorrelation, >2 negative. Matches
+ * `statsmodels.stats.stattools.durbin_watson`.
+ */
+export declare function durbinWatson(residuals: number[]): number;
+/** Result of {@link adfuller}. */
+export interface AdfullerResult {
+    statistic: number;
+    pValue: number;
+    usedLag: number;
+}
+/**
+ * Augmented Dickey-Fuller unit-root test (constant-only "c" model):
+ * regresses `Δx_t` on `[1, x_{t-1}, Δx_{t-1}, ..., Δx_{t-maxlag}]` via OLS.
+ * `statistic = coefficients[1] / stderr[1]` (the t-stat on the lagged level,
+ * `coefficients[0]` being the intercept). `pValue` is an approximate
+ * MacKinnon-style interpolation (see module docstring) — not exact.
+ *
+ * Default `maxlag = floor(12 * (n/100)^0.25)` (matches
+ * `statsmodels.tsa.stattools.adfuller`'s default rule), clamped downward if
+ * needed so the regression has more observations than parameters; `usedLag`
+ * reports the lag count actually used.
+ *
+ * @example
+ * adfuller(whiteNoiseSeries) // => { statistic: <very negative>, pValue: <small>, usedLag }
+ */
+export declare function adfuller(x: number[], maxlag?: number): AdfullerResult;
+//# sourceMappingURL=timeseries.d.ts.map

package/dist/stats/timeseries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeseries.d.ts","sourceRoot":"","sources":["../../src/stats/timeseries.ts"],"names":[],"mappings":"AA6BA;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CA+BzD;AAED,kCAAkC;AAClC,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,cAAc,CAUlE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,MAAM,CAUxD;AAED,kCAAkC;AAClC,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB;AAkDD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,cAAc,CAwCrE"}