@danielsimonjr/mathts-functions 0.2.3 → 0.2.5

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

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

package/dist/typed/combinatorics.d.ts

@@ -0,0 +1,333 @@
+/**
+ * Extended Combinatorics Functions
+ *
+ * Provides combinatorial number sequences and factorial variants:
+ * - fibonacci: nth Fibonacci number (fast doubling, O(log n))
+ * - lucas: nth Lucas number
+ * - doubleFactorial: n!! = n * (n-2) * (n-4) * ...
+ * - risingFactorial: Pochhammer symbol x^(n) = x(x+1)...(x+n-1)
+ * - fallingFactorial: x_(n) = x(x-1)...(x-n+1)
+ * - subfactorial: !n = number of derangements
+ *
+ * Uses mathTyped for type dispatch on numeric arguments.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Compute the nth Fibonacci number using the fast doubling method.
+ *
+ * Fast doubling uses the identities:
+ *   F(2k) = F(k) * [2*F(k+1) - F(k)]
+ *   F(2k+1) = F(k)^2 + F(k+1)^2
+ *
+ * Time complexity: O(log n)
+ *
+ * @param n - Non-negative integer index
+ * @returns The nth Fibonacci number
+ *
+ * @example
+ * fibonacci(0)  // => 0
+ * fibonacci(1)  // => 1
+ * fibonacci(10) // => 55
+ * fibonacci(20) // => 6765
+ */
+export declare const fibonacci: import("typed-function").TypedFunction;
+/**
+ * Compute the nth Lucas number.
+ *
+ * Lucas numbers follow the same recurrence as Fibonacci but with
+ * L(0) = 2, L(1) = 1. Related to Fibonacci by L(n) = F(n-1) + F(n+1).
+ *
+ * Uses the fast doubling identities:
+ *   L(2k) = L(k)^2 - 2*(-1)^k
+ *   L(2k+1) = L(k)*L(k+1) - (-1)^k * ... (via Fibonacci relation)
+ *
+ * @param n - Non-negative integer index
+ * @returns The nth Lucas number
+ *
+ * @example
+ * lucas(0)  // => 2
+ * lucas(1)  // => 1
+ * lucas(10) // => 123
+ */
+export declare const lucas: import("typed-function").TypedFunction;
+/**
+ * Compute the double factorial n!!.
+ *
+ * n!! = n * (n-2) * (n-4) * ... * (2 or 1)
+ *
+ * For odd n:  n!! = n * (n-2) * ... * 3 * 1
+ * For even n: n!! = n * (n-2) * ... * 4 * 2
+ *
+ * Special cases: 0!! = 1, (-1)!! = 1
+ *
+ * @param n - Non-negative integer (or -1)
+ * @returns The double factorial
+ *
+ * @example
+ * doubleFactorial(7) // => 105 (7*5*3*1)
+ * doubleFactorial(6) // => 48 (6*4*2)
+ * doubleFactorial(0) // => 1
+ */
+export declare const doubleFactorial: import("typed-function").TypedFunction;
+/**
+ * Compute the rising factorial (Pochhammer symbol).
+ *
+ * x^(n) = x * (x+1) * (x+2) * ... * (x+n-1)
+ *
+ * Also written as (x)_n in some notations.
+ * Rising factorial of 0 terms is 1 by convention.
+ *
+ * @param x - Base value
+ * @param n - Number of terms (non-negative integer)
+ * @returns The rising factorial
+ *
+ * @example
+ * risingFactorial(3, 4) // => 3*4*5*6 = 360
+ * risingFactorial(1, 5) // => 1*2*3*4*5 = 120 = 5!
+ */
+export declare const risingFactorial: import("typed-function").TypedFunction;
+/**
+ * Compute the falling factorial.
+ *
+ * x_(n) = x * (x-1) * (x-2) * ... * (x-n+1)
+ *
+ * Falling factorial of 0 terms is 1 by convention.
+ *
+ * @param x - Base value
+ * @param n - Number of terms (non-negative integer)
+ * @returns The falling factorial
+ *
+ * @example
+ * fallingFactorial(5, 3) // => 5*4*3 = 60
+ * fallingFactorial(5, 5) // => 5*4*3*2*1 = 120 = 5!
+ */
+export declare const fallingFactorial: import("typed-function").TypedFunction;
+/**
+ * Compute the subfactorial (number of derangements).
+ *
+ * !n = n! * sum_{k=0}^{n} (-1)^k / k!
+ *
+ * A derangement is a permutation where no element appears in its original position.
+ *
+ * @param n - Non-negative integer
+ * @returns The number of derangements of n elements
+ *
+ * @example
+ * subfactorial(0) // => 1
+ * subfactorial(1) // => 0
+ * subfactorial(2) // => 1
+ * subfactorial(5) // => 44
+ */
+export declare const subfactorial: import("typed-function").TypedFunction;
+/**
+ * Return the nth prime number (1-indexed).
+ *
+ * Uses a sieve-based approach. For n <= 6, returns from lookup.
+ * For larger n, estimates an upper bound and sieves.
+ *
+ * @param n - Positive integer index (1-indexed)
+ * @returns The nth prime number
+ *
+ * @example
+ * prime(1)  // => 2
+ * prime(4)  // => 7
+ * prime(10) // => 29
+ */
+export declare const prime: import("typed-function").TypedFunction;
+/**
+ * Return the smallest prime number strictly greater than n.
+ *
+ * @param n - Non-negative number
+ * @returns Smallest prime > n
+ *
+ * @example
+ * nextPrime(4)  // => 5
+ * nextPrime(7)  // => 11
+ * nextPrime(10) // => 11
+ */
+export declare const nextPrime: import("typed-function").TypedFunction;
+/**
+ * Prime counting function pi(n): number of primes <= n.
+ *
+ * @param n - Non-negative integer
+ * @returns Number of primes not exceeding n
+ *
+ * @example
+ * primePi(10) // => 4 (primes: 2, 3, 5, 7)
+ * primePi(1)  // => 0
+ */
+export declare const primePi: import("typed-function").TypedFunction;
+/**
+ * Return the prime factorization of n as an array of prime factors
+ * (with repetition, sorted ascending).
+ *
+ * @param n - Positive integer >= 2
+ * @returns Array of prime factors
+ *
+ * @example
+ * primeFactors(12)  // => [2, 2, 3]
+ * primeFactors(60)  // => [2, 2, 3, 5]
+ * primeFactors(7)   // => [7]
+ */
+export declare const primeFactors: import("typed-function").TypedFunction;
+/**
+ * Return all positive divisors of n, sorted ascending.
+ *
+ * @param n - Positive integer
+ * @returns Sorted array of divisors
+ *
+ * @example
+ * divisors(12) // => [1, 2, 3, 4, 6, 12]
+ * divisors(7)  // => [1, 7]
+ */
+export declare const divisors: import("typed-function").TypedFunction;
+/**
+ * Euler's totient function phi(n): count of integers 1..n coprime to n.
+ *
+ * @param n - Positive integer
+ * @returns phi(n)
+ *
+ * @example
+ * eulerPhi(1)  // => 1
+ * eulerPhi(10) // => 4 (1, 3, 7, 9)
+ * eulerPhi(12) // => 4 (1, 5, 7, 11)
+ */
+export declare const eulerPhi: import("typed-function").TypedFunction;
+/**
+ * Sum of the kth powers of divisors of n: sigma_k(n).
+ *
+ * sigma_0(n) = number of divisors
+ * sigma_1(n) = sum of divisors
+ *
+ * @param n - Positive integer
+ * @param k - Power (non-negative integer, default 1)
+ * @returns sigma_k(n)
+ *
+ * @example
+ * divisorSigma(12)     // => 28 (1+2+3+4+6+12)
+ * divisorSigma(12, 0)  // => 6 (number of divisors)
+ * divisorSigma(12, 2)  // => 210
+ */
+export declare const divisorSigma: import("typed-function").TypedFunction;
+/**
+ * Carmichael function lambda(n): smallest positive integer m such that
+ * a^m === 1 (mod n) for all a coprime to n.
+ *
+ * @param n - Positive integer
+ * @returns lambda(n)
+ *
+ * @example
+ * carmichaelLambda(1)  // => 1
+ * carmichaelLambda(8)  // => 2
+ * carmichaelLambda(15) // => 4
+ */
+export declare const carmichaelLambda: import("typed-function").TypedFunction;
+/**
+ * Mobius function mu(n).
+ *
+ * mu(1) = 1
+ * mu(n) = 0 if n has a squared prime factor
+ * mu(n) = (-1)^k if n is a product of k distinct primes
+ *
+ * @param n - Positive integer
+ * @returns mu(n): -1, 0, or 1
+ *
+ * @example
+ * moebiusMu(1)  // => 1
+ * moebiusMu(6)  // => 1 (6 = 2*3, two distinct primes)
+ * moebiusMu(4)  // => 0 (4 = 2^2, squared factor)
+ * moebiusMu(30) // => -1 (30 = 2*3*5, three distinct primes)
+ */
+export declare const moebiusMu: import("typed-function").TypedFunction;
+/**
+ * Jacobi symbol (a/n), a generalization of the Legendre symbol.
+ *
+ * n must be a positive odd integer.
+ *
+ * @param a - Integer
+ * @param n - Positive odd integer
+ * @returns -1, 0, or 1
+ *
+ * @example
+ * jacobiSymbol(2, 7)  // => 1
+ * jacobiSymbol(5, 21) // => 1
+ * jacobiSymbol(7, 15) // => -1
+ */
+export declare const jacobiSymbol: import("typed-function").TypedFunction;
+/**
+ * Solve a system of simultaneous congruences using the Chinese Remainder Theorem.
+ *
+ * Find x such that x === remainders[i] (mod moduli[i]) for all i.
+ * Moduli must be pairwise coprime.
+ *
+ * @param remainders - Array of remainders
+ * @param moduli - Array of moduli (pairwise coprime)
+ * @returns Solution x (smallest non-negative)
+ *
+ * @example
+ * chineseRemainder([2, 3, 2], [3, 5, 7]) // => 23
+ * // x === 2 (mod 3), x === 3 (mod 5), x === 2 (mod 7)
+ */
+export declare const chineseRemainder: import("typed-function").TypedFunction;
+/**
+ * Compute the nth Lucas number L(n).
+ *
+ * This is a standalone implementation using iterative computation.
+ * L(0) = 2, L(1) = 1, L(n) = L(n-1) + L(n-2).
+ *
+ * Note: the `lucas` export above uses a Fibonacci-based approach.
+ * This provides a direct iterative alternative.
+ *
+ * @param n - Non-negative integer
+ * @returns L(n)
+ *
+ * @example
+ * lucasL(0)  // => 2
+ * lucasL(5)  // => 11
+ * lucasL(10) // => 123
+ */
+export declare const lucasL: import("typed-function").TypedFunction;
+/**
+ * Number of integer partitions of n.
+ *
+ * A partition of n is a way to write n as a sum of positive integers
+ * (order doesn't matter).
+ *
+ * Uses dynamic programming.
+ *
+ * @param n - Non-negative integer
+ * @returns p(n)
+ *
+ * @example
+ * partitions(0) // => 1
+ * partitions(4) // => 5 (4, 3+1, 2+2, 2+1+1, 1+1+1+1)
+ * partitions(5) // => 7
+ */
+export declare const partitions: import("typed-function").TypedFunction;
+/**
+ * Compute the nth harmonic number H(n) = 1 + 1/2 + 1/3 + ... + 1/n.
+ *
+ * @param n - Positive integer
+ * @returns H(n)
+ *
+ * @example
+ * harmonicNumber(1) // => 1
+ * harmonicNumber(4) // => 2.0833... (1 + 1/2 + 1/3 + 1/4)
+ */
+export declare const harmonicNumber: import("typed-function").TypedFunction;
+/**
+ * Return the digits of n in the given base as an array (most significant first).
+ *
+ * @param n - Non-negative integer
+ * @param base - Base (integer >= 2, default 10)
+ * @returns Array of digits
+ *
+ * @example
+ * integerDigits(123)     // => [1, 2, 3]
+ * integerDigits(255, 16) // => [15, 15]
+ * integerDigits(10, 2)   // => [1, 0, 1, 0]
+ * integerDigits(0)       // => [0]
+ */
+export declare const integerDigits: import("typed-function").TypedFunction;
+//# sourceMappingURL=combinatorics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"combinatorics.d.ts","sourceRoot":"","sources":["../../src/typed/combinatorics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAQH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,SAAS,wCAsCpB,CAAC;AAMH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,KAAK,wCAuChB,CAAC;AAMH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,wCAa1B,CAAC;AAMH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,wCAa1B,CAAC;AAMH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,wCAa3B,CAAC;AAMH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,YAAY,wCAoBvB,CAAC;AAUH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,KAAK,wCAiBhB,CAAC;AAyBH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,SAAS,wCAWpB,CAAC;AAmBH;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,wCAOlB,CAAC;AAMH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,wCAgBvB,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,wCAenB,CAAC;AAMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,wCAgBnB,CAAC;AAMH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY,wCAOvB,CAAC;AAuBH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,wCA0B3B,CAAC;AA8BH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS,wCAmBpB,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,wCA0BvB,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,wCA6B3B,CAAC;AAwBH;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,MAAM,wCAcjB,CAAC;AAMH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,UAAU,wCAerB,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,cAAc,wCAWzB,CAAC;AAMH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,wCAOxB,CAAC"}

package/dist/typed/complex.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Typed Complex Helper Functions
+ *
+ * Polymorphic complex-number utilities using typed-function for runtime dispatch.
+ * Supports `number`, `bigint`, `BigNumber`, `Complex`, and `Array` types.
+ *
+ * Semantics follow the mathjs convention:
+ *   - `arg(number)` → `Math.atan2(0, number)` — 0 for positive, π for negative, 0 for 0, NaN for NaN.
+ *   - `conj(real)` → identity (real numbers are self-conjugate).
+ *   - `im(real)`   → 0 (real numbers have no imaginary part).
+ *   - `re(real)`   → the number itself.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Compute the argument (phase angle in radians) of a complex number or real value.
+ *
+ * For a complex number `a + bi`, the argument is `atan2(b, a)`.
+ * For a real number `x`, the result is `atan2(0, x)`:
+ *   - `x > 0` → 0
+ *   - `x < 0` → π
+ *   - `x = 0` → 0 (mathjs convention, not -π)
+ *   - `x = NaN` → NaN
+ *
+ * For arrays, the function is applied element-wise.
+ *
+ * @example
+ * ```typescript
+ * arg(1)                      // 0
+ * arg(-1)                     // Math.PI
+ * arg(new Complex(1, 1))      // Math.PI / 4
+ * arg([1, -1, new Complex(0, 1)])  // [0, Math.PI, Math.PI / 2]
+ * ```
+ */
+export declare const arg: import("typed-function").TypedFunction;
+/**
+ * Compute the complex conjugate of a value.
+ * For a complex number `a + bi`, the conjugate is `a - bi`.
+ * For real numbers (number, bigint, BigNumber), the value is returned as-is
+ * (real numbers are self-conjugate).
+ *
+ * For arrays, the function is applied element-wise.
+ *
+ * @example
+ * ```typescript
+ * conj(5)                        // 5
+ * conj(new Complex(3, 4))        // Complex(3, -4)
+ * conj([new Complex(1, 2), 3])   // [Complex(1, -2), 3]
+ * ```
+ */
+export declare const conj: import("typed-function").TypedFunction;
+/**
+ * Get the imaginary part of a complex number.
+ * For a complex number `a + bi`, the function returns `b`.
+ * For real numbers (number, bigint, BigNumber), returns 0.
+ *
+ * For arrays, the function is applied element-wise.
+ *
+ * @example
+ * ```typescript
+ * im(new Complex(3, 4))   // 4
+ * im(5)                   // 0
+ * im([new Complex(1, 2), 3])  // [2, 0]
+ * ```
+ */
+export declare const im: import("typed-function").TypedFunction;
+/**
+ * Get the real part of a complex number.
+ * For a complex number `a + bi`, the function returns `a`.
+ * For real numbers (number, bigint, BigNumber), returns the value itself.
+ *
+ * For arrays, the function is applied element-wise.
+ *
+ * @example
+ * ```typescript
+ * re(new Complex(3, 4))   // 3
+ * re(5)                   // 5
+ * re([new Complex(1, 2), 3])  // [1, 3]
+ * ```
+ */
+export declare const re: import("typed-function").TypedFunction;
+/**
+ * All typed complex helper functions.
+ */
+export declare const typedComplex: {
+    arg: import("typed-function").TypedFunction;
+    conj: import("typed-function").TypedFunction;
+    im: import("typed-function").TypedFunction;
+    re: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=complex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"complex.d.ts","sourceRoot":"","sources":["../../src/typed/complex.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAsBH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,GAAG,wCAoBd,CAAC;AAMH;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,IAAI,wCAUf,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,EAAE,wCAUb,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,EAAE,wCAUb,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;CAKxB,CAAC"}

package/dist/typed/dist-objects.d.ts

@@ -0,0 +1,219 @@
+/**
+ * Distribution Objects
+ *
+ * Each factory function returns an object with .pdf(x), .cdf(x),
+ * .quantile(p), .mean, .variance, .sample() and .sampleN(n, opts?) methods.
+ *
+ * Supported distributions:
+ * - normalDist, betaDist, binomialDist, chiSquaredDist
+ * - exponentialDist, fDist, gammaDist, logNormalDist
+ * - poissonDist, tDist, uniformDist, weibullDist
+ *
+ * Worker dispatch (Slice 5.12):
+ * - `.sampleN(n, opts?)` routes to workers via `sampleChunk` kernel when
+ *   `n >= DIST_WORKER_THRESHOLD` (100 000).
+ * - Supports five distributions with worker paths: normalDist, gammaDist,
+ *   betaDist, tDist, exponentialDist.
+ * - Below threshold (or for distributions without a worker kernel), falls back
+ *   to a synchronous JS loop.
+ * - Seed splitting: chunk k uses seed `(baseSeed ^ (k * 0x9E3779B9)) >>> 0`
+ *   (SplitMix64-style Fibonacci hashing — gives uncorrelated chunk streams
+ *   even when baseSeed is 0 or small).
+ *
+ * @packageDocumentation
+ */
+/** 64-bit float (default for decimals) */
+type f64 = number;
+/**
+ * Minimum sample count that triggers the worker-dispatch path in `.sampleN()`.
+ * Below this threshold, `.sampleN()` falls back to a synchronous JS loop.
+ */
+export declare const DIST_WORKER_THRESHOLD = 100000;
+/**
+ * Options for batch sampling via `.sampleN()`.
+ */
+export interface SampleNOptions {
+    /**
+     * Integer seed for the Mulberry32 PRNG used within each worker chunk.
+     * When omitted, a random seed is chosen (non-reproducible).
+     */
+    seed?: number;
+    /**
+     * Number of worker tasks to fan out when `n >= DIST_WORKER_THRESHOLD`.
+     * Defaults to the pool's `maxWorkers` setting.  Set to 1 to use the
+     * worker path with a single task (useful for testing the async code path).
+     */
+    workerCount?: number;
+}
+/**
+ * A probability distribution object with common statistical methods.
+ */
+export interface Distribution {
+    /** Probability density (or mass) function */
+    pdf: (x: f64) => f64;
+    /** Cumulative distribution function */
+    cdf: (x: f64) => f64;
+    /** Quantile (inverse CDF) function */
+    quantile: (p: f64) => f64;
+    /** Distribution mean */
+    mean: f64;
+    /** Distribution variance */
+    variance: f64;
+    /** Generate a single random sample (synchronous) */
+    sample: () => f64;
+    /**
+     * Generate `n` random samples.
+     *
+     * - When `n < DIST_WORKER_THRESHOLD` returns a plain `Float64Array`
+     *   synchronously (wrapped in a resolved Promise for a uniform call-site).
+     * - When `n >= DIST_WORKER_THRESHOLD` **and** the distribution supports
+     *   the worker kernel, fans out across workers asynchronously.
+     * - For distributions without a dedicated worker kernel (binomialDist,
+     *   chiSquaredDist, etc.) always uses the JS loop regardless of `n`.
+     */
+    sampleN: (n: number, opts?: SampleNOptions) => Promise<Float64Array>;
+}
+/**
+ * Create a normal (Gaussian) distribution object.
+ *
+ * @param mu - Mean (default 0)
+ * @param sigma - Standard deviation (default 1, must be positive)
+ * @returns Distribution object
+ *
+ * @example
+ * const d = normalDist(0, 1);
+ * d.pdf(0)       // ~0.3989
+ * d.cdf(0)       // 0.5
+ * d.quantile(0.975) // ~1.96
+ */
+export declare function normalDist(mu?: f64, sigma?: f64): Distribution;
+/**
+ * Create a Beta distribution object.
+ *
+ * @param alpha - Shape parameter alpha > 0
+ * @param beta_ - Shape parameter beta > 0
+ * @returns Distribution object
+ *
+ * @example
+ * const d = betaDist(2, 5);
+ * d.mean // 2/7
+ */
+export declare function betaDist(alpha: f64, beta_: f64): Distribution;
+/**
+ * Create a Binomial distribution object.
+ *
+ * @param n - Number of trials (positive integer)
+ * @param p - Success probability (0 <= p <= 1)
+ * @returns Distribution object
+ *
+ * @example
+ * const d = binomialDist(10, 0.5);
+ * d.mean // 5
+ */
+export declare function binomialDist(n: number, p: f64): Distribution;
+/**
+ * Create a Chi-squared distribution object.
+ *
+ * @param k - Degrees of freedom (positive integer)
+ * @returns Distribution object
+ *
+ * @example
+ * const d = chiSquaredDist(3);
+ * d.mean // 3
+ */
+export declare function chiSquaredDist(k: number): Distribution;
+/**
+ * Create an Exponential distribution object.
+ *
+ * @param lambda - Rate parameter (positive)
+ * @returns Distribution object
+ *
+ * @example
+ * const d = exponentialDist(2);
+ * d.mean // 0.5
+ */
+export declare function exponentialDist(lambda?: f64): Distribution;
+/**
+ * Create an F-distribution object.
+ *
+ * @param d1 - Numerator degrees of freedom (positive)
+ * @param d2 - Denominator degrees of freedom (positive)
+ * @returns Distribution object
+ *
+ * @example
+ * const d = fDist(5, 10);
+ * d.mean // 10 / (10 - 2) = 1.25
+ */
+export declare function fDist(d1: f64, d2: f64): Distribution;
+/**
+ * Create a Gamma distribution object.
+ *
+ * @param shape - Shape parameter (positive)
+ * @param rate - Rate parameter (positive, default 1)
+ * @returns Distribution object
+ *
+ * @example
+ * const d = gammaDist(2, 1);
+ * d.mean // 2
+ */
+export declare function gammaDist(shape: f64, rate?: f64): Distribution;
+/**
+ * Create a Log-Normal distribution object.
+ *
+ * @param mu - Mean of the log (default 0)
+ * @param sigma - Standard deviation of the log (default 1, positive)
+ * @returns Distribution object
+ *
+ * @example
+ * const d = logNormalDist(0, 1);
+ * d.mean // e^0.5
+ */
+export declare function logNormalDist(mu?: f64, sigma?: f64): Distribution;
+/**
+ * Create a Poisson distribution object.
+ *
+ * @param lambda - Rate parameter (positive)
+ * @returns Distribution object
+ *
+ * @example
+ * const d = poissonDist(5);
+ * d.mean // 5
+ */
+export declare function poissonDist(lambda: f64): Distribution;
+/**
+ * Create a Student's t-distribution object.
+ *
+ * @param nu - Degrees of freedom (positive)
+ * @returns Distribution object
+ *
+ * @example
+ * const d = tDist(10);
+ * d.mean // 0
+ */
+export declare function tDist(nu: f64): Distribution;
+/**
+ * Create a Uniform distribution object.
+ *
+ * @param a - Lower bound (default 0)
+ * @param b - Upper bound (default 1, must be > a)
+ * @returns Distribution object
+ *
+ * @example
+ * const d = uniformDist(0, 10);
+ * d.mean // 5
+ */
+export declare function uniformDist(a?: f64, b?: f64): Distribution;
+/**
+ * Create a Weibull distribution object.
+ *
+ * @param k - Shape parameter (positive)
+ * @param lambda - Scale parameter (positive, default 1)
+ * @returns Distribution object
+ *
+ * @example
+ * const d = weibullDist(2, 1);
+ * d.mean // sqrt(pi) / 2
+ */
+export declare function weibullDist(k: f64, lambda?: f64): Distribution;
+export {};
+//# sourceMappingURL=dist-objects.d.ts.map

package/dist/typed/dist-objects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dist-objects.d.ts","sourceRoot":"","sources":["../../src/typed/dist-objects.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAQH,0CAA0C;AAC1C,KAAK,GAAG,GAAG,MAAM,CAAC;AAElB;;;GAGG;AACH,eAAO,MAAM,qBAAqB,SAAU,CAAC;AAE7C;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,6CAA6C;IAC7C,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAAC;IACrB,uCAAuC;IACvC,GAAG,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAAC;IACrB,sCAAsC;IACtC,QAAQ,EAAE,CAAC,CAAC,EAAE,GAAG,KAAK,GAAG,CAAC;IAC1B,wBAAwB;IACxB,IAAI,EAAE,GAAG,CAAC;IACV,4BAA4B;IAC5B,QAAQ,EAAE,GAAG,CAAC;IACd,oDAAoD;IACpD,MAAM,EAAE,MAAM,GAAG,CAAC;IAClB;;;;;;;;;OASG;IACH,OAAO,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,cAAc,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;CACtE;AA8OD;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,EAAE,GAAE,GAAO,EAAE,KAAK,GAAE,GAAO,GAAG,YAAY,CA6BpE;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,GAAG,YAAY,CAiD7D;AA6DD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,GAAG,YAAY,CAsD5D;AAMD;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,GAAG,YAAY,CAsDtD;AAMD;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,MAAM,GAAE,GAAO,GAAG,YAAY,CAuB7D;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,GAAG,YAAY,CAwDpD;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE,IAAI,GAAE,GAAO,GAAG,YAAY,CA8CjE;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,EAAE,GAAE,GAAO,EAAE,KAAK,GAAE,GAAO,GAAG,YAAY,CAiCvE;AAMD;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,GAAG,GAAG,YAAY,CAoDrD;AAMD;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,EAAE,EAAE,GAAG,GAAG,YAAY,CAmD3C;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,GAAE,GAAO,EAAE,CAAC,GAAE,GAAO,GAAG,YAAY,CA2BhE;AAMD;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAE,GAAO,GAAG,YAAY,CA8BjE"}