/**
 * Typed Probability Distribution Functions
 *
 * Probability density/mass functions and information-theoretic measures
 * using typed-function for runtime dispatch.
 *
 * Each PDF/PMF/CDF has a `Float64Array` overload that evaluates the
 * distribution across a whole sample array, parallelizing large inputs via
 * the worker pool.
 *
 * @packageDocumentation
 */
/**
 * Normal (Gaussian) probability density function.
 *
 * PDF(x; mu, sigma) = (1 / (sigma * sqrt(2*pi))) * exp(-(x - mu)^2 / (2*sigma^2))
 *
 * @param x - Value (or Float64Array of values) at which to evaluate
 * @param mu - Mean (default 0)
 * @param sigma - Standard deviation (default 1, must be positive)
 * @returns Probability density at x
 *
 * @example
 * normalPDF(0)       // ~0.3989 (standard normal)
 * normalPDF(1, 0, 2) // ~0.1760
 * normalPDF(new Float64Array([0, 1, 2])) // densities for each sample
 */
export declare const normalPDF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Normal (Gaussian) cumulative distribution function.
 *
 * CDF(x; mu, sigma) = 0.5 * (1 + erf((x - mu) / (sigma * sqrt(2))))
 *
 * @param x - Value (or Float64Array of values) at which to evaluate
 * @param mu - Mean (default 0)
 * @param sigma - Standard deviation (default 1, must be positive)
 * @returns Cumulative probability P(X <= x)
 *
 * @example
 * normalCDF(0)    // 0.5 (standard normal)
 * normalCDF(1.96) // ~0.975
 */
export declare const normalCDF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Exponential probability density function.
 *
 * PDF(x; lambda) = lambda * exp(-lambda * x) for x >= 0.
 *
 * @param x - Value (or Float64Array of values) at which to evaluate
 * @param lambda - Rate parameter (positive)
 * @returns Probability density at x
 *
 * @example
 * exponentialPDF(1, 1) // ~0.3679
 */
export declare const exponentialPDF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Exponential cumulative distribution function.
 *
 * CDF(x; lambda) = 1 - exp(-lambda * x) for x >= 0.
 *
 * @param x - Value (or Float64Array of values) at which to evaluate
 * @param lambda - Rate parameter (positive)
 * @returns Cumulative probability P(X <= x)
 *
 * @example
 * exponentialCDF(1, 1) // ~0.6321
 */
export declare const exponentialCDF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Poisson probability mass function.
 *
 * PMF(k; lambda) = e^(-lambda) * lambda^k / k!
 *
 * Computed in log-space to avoid overflow for large k or lambda.
 *
 * @param k - Number of events (or Float64Array of counts)
 * @param lambda - Expected number of events (positive)
 * @returns Probability of exactly k events
 *
 * @example
 * poissonPMF(3, 2.5) // ~0.2138
 */
export declare const poissonPMF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Binomial probability mass function.
 *
 * PMF(k; n, p) = C(n, k) * p^k * (1-p)^(n-k)
 *
 * Computed in log-space to avoid overflow.
 *
 * @param k - Number of successes (or Float64Array of counts)
 * @param n - Number of trials (positive integer)
 * @param p - Probability of success (0 <= p <= 1)
 * @returns Probability of exactly k successes
 *
 * @example
 * binomialPMF(3, 10, 0.5) // ~0.1172
 */
export declare const binomialPMF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Geometric probability mass function.
 *
 * PMF(k; p) = (1-p)^(k-1) * p for k = 1, 2, 3, ...
 *
 * @param k - Trial number of first success (or Float64Array of counts)
 * @param p - Probability of success (0 < p <= 1)
 * @returns Probability that first success occurs on trial k
 *
 * @example
 * geometricPMF(3, 0.5) // 0.125
 */
export declare const geometricPMF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Bernoulli probability mass function.
 *
 * PMF(k; p) = p if k = 1, (1 - p) if k = 0.
 *
 * @param k - Outcome (0 or 1, or Float64Array of outcomes)
 * @param p - Probability of success (0 <= p <= 1)
 * @returns Probability of outcome k
 *
 * @example
 * bernoulliPMF(1, 0.7) // 0.7
 */
export declare const bernoulliPMF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Shannon entropy of a discrete probability distribution.
 *
 * H(P) = -sum(p_i * log2(p_i)) for all p_i > 0.
 *
 * @param probs - Array of probabilities (should sum to 1)
 * @returns Entropy in bits
 *
 * @example
 * entropy([0.5, 0.5])               // 1.0 (maximum for 2 outcomes)
 * entropy([0.25, 0.25, 0.25, 0.25]) // 2.0
 */
export declare const entropy: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Jensen-Shannon divergence between two probability distributions.
 *
 * JSD(P || Q) = 0.5 * KL(P || M) + 0.5 * KL(Q || M) where M = 0.5*(P + Q).
 *
 * Always non-negative and symmetric. Returns value in bits (base 2).
 *
 * @param p - First probability distribution
 * @param q - Second probability distribution (same length as p)
 * @returns Jensen-Shannon divergence in bits
 *
 * @example
 * jsDivergence([0.5, 0.5], [0.5, 0.5]) // 0 (identical)
 * jsDivergence([1, 0], [0, 1])         // 1.0 (maximum for 2 bins)
 */
export declare const jsDivergence: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Beta probability density function.
 *
 * f(x; α, β) = x^(α-1) · (1-x)^(β-1) / B(α, β),  x ∈ (0, 1).
 *
 * When x is a Float64Array of length ≥ WASM_SPECIAL_THRESHOLD (1024),
 * lgamma is computed in a single vectorised WASM dispatch over the array
 * instead of per-element scalar calls.
 *
 * @param x      - Sample value(s) in (0, 1)
 * @param alpha  - Shape parameter α > 0
 * @param beta_  - Shape parameter β > 0
 * @returns PDF value(s)
 *
 * @example
 * betaPDF(0.5, 2, 2) // 1.5
 */
export declare const betaPDF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Gamma probability density function.
 *
 * f(x; k, θ) = x^(k-1) · exp(−x/θ) / (Γ(k) · θ^k),  x > 0.
 *
 * When x is a Float64Array of length ≥ WASM_SPECIAL_THRESHOLD (1024),
 * lgamma(shape) is pre-computed once (scalar), sparing per-element Γ calls.
 *
 * @param x     - Sample value(s)
 * @param shape - Shape parameter k > 0
 * @param scale - Scale parameter θ > 0
 * @returns PDF value(s)
 *
 * @example
 * gammaPDF(1, 1, 1) // ~0.3679 (Exponential(1) at x=1)
 */
export declare const gammaPDF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Student-t probability density function.
 *
 * f(x; ν) = Γ((ν+1)/2) / (√(νπ)·Γ(ν/2)) · (1 + x²/ν)^(−(ν+1)/2).
 *
 * When x is a Float64Array of length ≥ WASM_SPECIAL_THRESHOLD (1024),
 * the two lgamma calls for the normalisation constant are performed once
 * on the main thread; only the per-element `(1 + x²/ν)` power is looped.
 *
 * @param x  - Sample value(s)
 * @param df - Degrees of freedom ν > 0
 * @returns PDF value(s)
 *
 * @example
 * studentTPDF(0, 5) // ~0.3796 (peak of t(5))
 */
export declare const studentTPDF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * Noncentral chi-squared probability density function.
 *
 * f(x; k, λ) via Poisson-mixture of central chi-squared densities.
 *
 * When x is a Float64Array of length ≥ WASM_SPECIAL_THRESHOLD (1024),
 * lgamma in the inner Bessel sum is vectorised via `lgammaDispatch` over
 * the unique m values needed; for the outer product loop each element is
 * still evaluated independently (the lgamma argument depends on both j and
 * the fixed df, not on x[i], so the per-element work remains O(terms)).
 *
 * @param x   - Sample value(s)
 * @param df  - Degrees of freedom k > 0
 * @param ncp - Non-centrality parameter λ ≥ 0
 * @returns PDF value(s)
 *
 * @example
 * noncentralChi2PDF(1, 2, 1) // ~0.2220
 */
export declare const noncentralChi2PDF: import("@danielsimonjr/mathts-core").TypedFunction;
/**
 * All typed probability distribution functions.
 */
export declare const typedDistributions: {
    normalPDF: import("@danielsimonjr/mathts-core").TypedFunction;
    normalCDF: import("@danielsimonjr/mathts-core").TypedFunction;
    exponentialPDF: import("@danielsimonjr/mathts-core").TypedFunction;
    exponentialCDF: import("@danielsimonjr/mathts-core").TypedFunction;
    poissonPMF: import("@danielsimonjr/mathts-core").TypedFunction;
    binomialPMF: import("@danielsimonjr/mathts-core").TypedFunction;
    geometricPMF: import("@danielsimonjr/mathts-core").TypedFunction;
    bernoulliPMF: import("@danielsimonjr/mathts-core").TypedFunction;
    entropy: import("@danielsimonjr/mathts-core").TypedFunction;
    jsDivergence: import("@danielsimonjr/mathts-core").TypedFunction;
    betaPDF: import("@danielsimonjr/mathts-core").TypedFunction;
    gammaPDF: import("@danielsimonjr/mathts-core").TypedFunction;
    studentTPDF: import("@danielsimonjr/mathts-core").TypedFunction;
    noncentralChi2PDF: import("@danielsimonjr/mathts-core").TypedFunction;
};
//# sourceMappingURL=distributions.d.ts.map