@numero-uno-jpn/rstats 0.0.0-stage → 0.5.0

package/dist/distributions/f.js

@@ -0,0 +1,214 @@
+// F distribution df / pf / qf. Passing ncp gives the noncentral F (src/distributions/nbeta.ts).
+//
+// The density uses the relation to the binomial probability. With p = m x/(n + m x) and q = n/(n + m x),
+//   m >= 2: f(x) = m q / 2 * dbinom((m-2)/2; (m+n-2)/2, p)
+//   m <  2: f(x) = m/(n + m x) * m n / (2 (m + n) p) * dbinom(m/2; (m+n)/2, p)
+// (both derived by rewriting the F density in terms of Gamma functions).
+// The distribution function is P[F <= x] = I_p(m/2, n/2); quantiles use Newton's method in u = log x.
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0, dt1, quantileBoundaries, smallerTail } from "../internal/dpq.js";
+import { invertContinuous } from "../internal/invert.js";
+import { lbeta } from "../special/beta.js";
+import { betaInc, betaIncBoth, betaIncBothDD, betaIncDD } from "../special/incbet.js";
+import { dbinomRawDD } from "../special/loader.js";
+import { ddAdd, ddDiv, twoProd } from "../special/dd.js";
+import { dgamma1, pgamma1, qgamma1 } from "./gamma.js";
+import { dnf1, pnf1, qnf1 } from "./nbeta.js";
+import { betaQuantileGuess } from "./beta.js";
+function fDensity(x, m, n, log) {
+    // p = m x/(n + m x) and q = n/(n + m x) are formed in double-double. Rounding in p and q would be
+    // amplified m/2 and n/2 times respectively (5e-13 relative at df1 = 1e6)
+    const mx = twoProd(m, x);
+    let pd;
+    let qd;
+    if (Number.isFinite(mx[0]) && Number.isFinite(mx[1]) && Math.abs(mx[0]) < 1e290) {
+        const d = ddAdd(mx, [n, 0]);
+        pd = ddDiv(mx, d);
+        qd = ddDiv([n, 0], d);
+    }
+    else {
+        // m x is huge (the double-double product overflows): p ≈ 1, q ≈ n/(m x) in double precision
+        qd = [n / m / x, 0];
+        pd = [1, -qd[0]];
+    }
+    const p = pd[0];
+    const q = qd[0];
+    if (m >= 2) {
+        const c = (m * q) / 2;
+        const v = dbinomRawDD((m - 2) / 2, n / 2, pd, qd, log);
+        return log ? Math.log(c) + v : c * v;
+    }
+    const c = ((m / (n + m * x)) * m * n) / (2 * (m + n) * p);
+    const v = dbinomRawDD(m / 2, n / 2, pd, qd, log);
+    return log ? Math.log(c) + v : c * v;
+}
+export function dfDensity1(x, m, n, log) {
+    if (Number.isNaN(x) || Number.isNaN(m) || Number.isNaN(n))
+        return NaN;
+    if (m <= 0 || n <= 0)
+        return NaN;
+    if (x < 0)
+        return d0(log);
+    if (x === 0) {
+        if (m > 2)
+            return d0(log);
+        if (m === 2)
+            return log ? 0 : 1;
+        return Infinity;
+    }
+    if (!Number.isFinite(m) && !Number.isFinite(n))
+        return x === 1 ? Infinity : d0(log);
+    if (!Number.isFinite(n))
+        return dgamma1(x, m / 2, 2 / m, log); // χ²_m / m
+    if (!Number.isFinite(m)) {
+        // n / χ²_n: 1/x follows a gamma distribution with shape n/2, scale 2/n
+        const dens = dgamma1(1 / x, n / 2, 2 / n, log);
+        return log ? dens - 2 * Math.log(x) : dens / (x * x);
+    }
+    if (!Number.isFinite(x))
+        return m < 2 ? NaN : d0(log); // R gives NaN at x = Inf when df1 < 2
+    return fDensity(x, m, n, log);
+}
+/** P[F <= x] (lower) / P[F > x] (!lower). x finite and positive, m, n finite */
+function pfRaw(x, m, n, lower, log) {
+    // Form m x/(n + m x) and n/(n + m x) in double-double (rounding would be amplified m/2 and n/2 times)
+    const mx = twoProd(m, x);
+    if (Number.isFinite(mx[0]) && Number.isFinite(mx[1]) && Math.abs(mx[0]) < 1e290) {
+        const d = ddAdd(mx, [n, 0]);
+        return betaIncDD(m / 2, n / 2, ddDiv(mx, d), ddDiv([n, 0], d), lower, log);
+    }
+    // m x is huge: form 1 - z = n/(n + m x) ≈ (n/m)/x directly
+    const zc = n / m / x;
+    return betaInc(m / 2, n / 2, 1 - zc, zc, lower, log);
+}
+/** Starting value for quantiles, from F = (n/m) Y/(1 - Y), Y ~ Beta(m/2, n/2), with the A&S 26.5.22 approximation (1 if unusable) */
+function fQuantileGuess(m, n, lower, logTarget) {
+    const y = betaQuantileGuess(m / 2, n / 2, lower, logTarget);
+    if (y === undefined)
+        return 1;
+    const f = (n * y) / (m * (1 - y));
+    return f > 0 && Number.isFinite(f) ? f : 1;
+}
+/** [log, linear] of pfRaw (each value identical to pfRaw) */
+function pfRawBoth(x, m, n, lower) {
+    const mx = twoProd(m, x);
+    if (Number.isFinite(mx[0]) && Number.isFinite(mx[1]) && Math.abs(mx[0]) < 1e290) {
+        const d = ddAdd(mx, [n, 0]);
+        return betaIncBothDD(m / 2, n / 2, ddDiv(mx, d), ddDiv([n, 0], d), lower);
+    }
+    const zc = n / m / x;
+    return betaIncBoth(m / 2, n / 2, 1 - zc, zc, lower);
+}
+export function pf1(q, m, n, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(m) || Number.isNaN(n))
+        return NaN;
+    if (m <= 0 || n <= 0)
+        return NaN;
+    if (q <= 0)
+        return dt0(lowerTail, logP);
+    if (q === Infinity)
+        return dt1(lowerTail, logP);
+    if (!Number.isFinite(m) && !Number.isFinite(n)) {
+        // Distribution concentrated at 1. R returns 1/2 at q = 1
+        if (q === 1)
+            return logP ? -Math.LN2 : 0.5;
+        return q < 1 ? dt0(lowerTail, logP) : dt1(lowerTail, logP);
+    }
+    if (!Number.isFinite(n))
+        return pgamma1(q * m, m / 2, 2, lowerTail, logP); // χ²_m
+    if (!Number.isFinite(m))
+        return pgamma1(n / q, n / 2, 2, !lowerTail, logP); // n / χ²_n
+    return pfRaw(q, m, n, lowerTail, logP);
+}
+export function qf1(p, m, n, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(m) || Number.isNaN(n))
+        return NaN;
+    if (m <= 0 || n <= 0)
+        return NaN;
+    const b = quantileBoundaries(p, 0, Infinity, lowerTail, logP);
+    if (b !== undefined)
+        return b;
+    if (!Number.isFinite(m) && !Number.isFinite(n))
+        return 1;
+    if (!Number.isFinite(n))
+        return qgamma1(p, m / 2, 2, lowerTail, logP) / m;
+    if (!Number.isFinite(m))
+        return n / qgamma1(p, n / 2, 2, !lowerTail, logP);
+    const { lower, logTarget, linearTarget } = smallerTail(p, lowerTail, logP);
+    // Near 0, P[F <= x] ≈ (m x / n)^(m/2) / ((m/2) B(m/2, n/2)). The answer is 0 if it underflows
+    if (lower && (logTarget + Math.log(m / 2) + lbeta(m / 2, n / 2)) / (m / 2) + Math.log(n / m) < -746)
+        return 0;
+    // Near infinity, P[F > x] ≈ (n / (m x))^(n/2) / ((n/2) B(m/2, n/2)). Inf if it overflows
+    if (!lower && -(logTarget + Math.log(n / 2) + lbeta(m / 2, n / 2)) / (n / 2) + Math.log(n / m) > 709.78)
+        return Infinity;
+    return invertContinuous({
+        logTarget,
+        ...(linearTarget !== undefined && { linearTarget }),
+        lower,
+        cdf: (x, l) => pfRaw(x, m, n, l, false),
+        cdfLog: (x, l) => pfRaw(x, m, n, l, true),
+        cdfBoth: (x, l) => pfRawBoth(x, m, n, l),
+        pdfLog: (x) => fDensity(x, m, n, true),
+        dlogPdf: (x) => (m / 2 - 1) / x - ((m + n) / 2) * (m / (n + m * x)),
+        x0: fQuantileGuess(m, n, lower, logTarget),
+        lo: 0,
+        hi: Infinity,
+        positive: true,
+    });
+}
+/**
+ * Density of the F distribution. Equivalent to R's `df(x, df1, df2, ncp, log = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral F distribution.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param df1 - Numerator degrees of freedom.
+ * @param df2 - Denominator degrees of freedom.
+ * @param options - `ncp` (see {@link NoncentralOption}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export function df(x, df1, df2, options = {}) {
+    const { log = false, ncp } = options;
+    if (ncp !== undefined)
+        return vectorize(x, (v) => dnf1(v, df1, df2, ncp, log));
+    return vectorize(x, (v) => dfDensity1(v, df1, df2, log));
+}
+/**
+ * Distribution function of the F distribution. Equivalent to R's `pf(q, df1, df2, ncp, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral F distribution.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param df1 - Numerator degrees of freedom.
+ * @param df2 - Denominator degrees of freedom.
+ * @param options - `ncp` (see {@link NoncentralOption}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ *
+ * @example
+ * ```ts
+ * pf(4.1, 2, 20, { lowerTail: false }); // 0.03219651558603902
+ * ```
+ */
+export function pf(q, df1, df2, options = {}) {
+    const { lowerTail = true, logP = false, ncp } = options;
+    if (ncp !== undefined)
+        return vectorize(q, (v) => pnf1(v, df1, df2, ncp, lowerTail, logP));
+    return vectorize(q, (v) => pf1(v, df1, df2, lowerTail, logP));
+}
+/**
+ * Quantile function of the F distribution. Equivalent to R's `qf(p, df1, df2, ncp, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral F distribution.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param df1 - Numerator degrees of freedom.
+ * @param df2 - Denominator degrees of freedom.
+ * @param options - `ncp` (see {@link NoncentralOption}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export function qf(p, df1, df2, options = {}) {
+    const { lowerTail = true, logP = false, ncp } = options;
+    if (ncp !== undefined)
+        return vectorize(p, (v) => qnf1(v, df1, df2, ncp, lowerTail, logP));
+    return vectorize(p, (v) => qf1(v, df1, df2, lowerTail, logP));
+}

package/dist/distributions/gamma.d.ts

@@ -0,0 +1,61 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+/**
+ * Parameters of the gamma distribution. Give either `rate` or `scale`; if both are given,
+ * `scale` must equal `1 / rate`.
+ */
+export interface GammaParams {
+    /** Rate (`rate = 1 / scale`). Default `1`. */
+    rate?: number;
+    /** Scale. Default `1`. Do not combine with a different `rate`. */
+    scale?: number;
+}
+/** Determine scale from rate / scale (as in R, giving both is an error unless scale = 1/rate; also used by rgamma) */
+export declare function gammaScale(params: GammaParams): number;
+/** Log density of the standardized (scale = 1) gamma distribution. x > 0, shape > 0 */
+export declare function dgammaStdLog(x: number, shape: number): number;
+export declare function dgamma1(x: number, shape: number, scale: number, log: boolean): number;
+export declare function pgamma1(q: number, shape: number, scale: number, lowerTail: boolean, logP: boolean): number;
+/** Quantile of the standardized gamma distribution. 0 < p < 1 (range checks are the caller's job) */
+export declare function qgammaStd(p: number, shape: number, lowerTail: boolean, logP: boolean): number;
+export declare function qgamma1(p: number, shape: number, scale: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Density of the gamma distribution. Equivalent to R's `dgamma(x, shape, rate = 1, scale = 1/rate, log = FALSE)`.
+ *
+ * @throws RangeError if both `rate` and `scale` are given and `scale` is not `1 / rate`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape - Shape parameter.
+ * @param options - `rate` or `scale` (see {@link GammaParams}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export declare function dgamma<T extends Vectorizable>(x: T, shape: number, options?: GammaParams & DensityOptions): VectorResult<T>;
+/**
+ * Distribution function of the gamma distribution. Equivalent to R's `pgamma(q, shape, rate = 1, scale = 1/rate, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @throws RangeError if both `rate` and `scale` are given and `scale` is not `1 / rate`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape - Shape parameter.
+ * @param options - `rate` or `scale` (see {@link GammaParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ *
+ * @example
+ * ```ts
+ * pgamma(2, 2);              // 0.5939941502901619
+ * pgamma(2, 2, { rate: 3 }); // 0.9826487347633355
+ * pgamma(2, 2, { scale: 3 }); // 0.14430480161234657
+ * ```
+ */
+export declare function pgamma<T extends Vectorizable>(q: T, shape: number, options?: GammaParams & TailOptions): VectorResult<T>;
+/**
+ * Quantile function of the gamma distribution. Equivalent to R's `qgamma(p, shape, rate = 1, scale = 1/rate, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @throws RangeError if both `rate` and `scale` are given and `scale` is not `1 / rate`.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape - Shape parameter.
+ * @param options - `rate` or `scale` (see {@link GammaParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export declare function qgamma<T extends Vectorizable>(p: T, shape: number, options?: GammaParams & TailOptions): VectorResult<T>;

package/dist/distributions/gamma.js

@@ -0,0 +1,188 @@
+// Gamma distribution dgamma / pgamma / qgamma.
+//
+// The density uses the relation to the Poisson probability (Loader 2000). With y = x/scale,
+//   f(x) = dpois(shape - 1; y) / scale            (shape >= 1)
+//        = dpois(shape; y) * shape / x            (shape < 1)
+// The distribution function uses the incomplete gamma function (src/special/igam.ts); quantiles use Newton's
+// method (src/internal/invert.ts) from the DiDonato & Morris starting value.
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0, dt1, quantileBoundaries, smallerTail } from "../internal/dpq.js";
+import { invertContinuous } from "../internal/invert.js";
+import { gammaInc, gammaIncBoth } from "../special/igam.js";
+import { findInverseGamma } from "../special/igami.js";
+import { lgamma, lgamma1p } from "../special/gamma.js";
+import { dpoisRaw } from "../special/loader.js";
+import { qnorm } from "./normal.js";
+/** Determine scale from rate / scale (as in R, giving both is an error unless scale = 1/rate; also used by rgamma) */
+export function gammaScale(params) {
+    const { rate, scale } = params;
+    if (rate !== undefined && scale !== undefined) {
+        if (Math.abs(rate * scale - 1) >= 1e-15) {
+            throw new RangeError("rate and scale can both be given only when scale = 1 / rate");
+        }
+        return scale;
+    }
+    if (scale !== undefined)
+        return scale;
+    if (rate !== undefined)
+        return 1 / rate;
+    return 1;
+}
+/** Log density of the standardized (scale = 1) gamma distribution. x > 0, shape > 0 */
+export function dgammaStdLog(x, shape) {
+    if (shape < 1) {
+        const pr = dpoisRaw(shape, x, true);
+        const r = shape / x;
+        return pr + (Number.isFinite(r) ? Math.log(r) : Math.log(shape) - Math.log(x));
+    }
+    return dpoisRaw(shape - 1, x, true);
+}
+export function dgamma1(x, shape, scale, log) {
+    if (Number.isNaN(x) || Number.isNaN(shape) || Number.isNaN(scale))
+        return NaN;
+    if (shape < 0 || scale <= 0)
+        return NaN;
+    if (x < 0)
+        return d0(log);
+    if (shape === 0)
+        return x === 0 ? Infinity : d0(log);
+    if (x === 0) {
+        if (shape < 1)
+            return Infinity;
+        if (shape > 1)
+            return d0(log);
+        return log ? -Math.log(scale) : 1 / scale;
+    }
+    if (shape < 1) {
+        const pr = dpoisRaw(shape, x / scale, log);
+        if (log) {
+            const r = shape / x;
+            return pr + (Number.isFinite(r) ? Math.log(r) : Math.log(shape) - Math.log(x));
+        }
+        return (pr * shape) / x;
+    }
+    const pr = dpoisRaw(shape - 1, x / scale, log);
+    return log ? pr - Math.log(scale) : pr / scale;
+}
+export function pgamma1(q, shape, scale, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(shape) || Number.isNaN(scale))
+        return NaN;
+    if (shape < 0 || scale <= 0)
+        return NaN;
+    const x = q / scale;
+    if (Number.isNaN(x))
+        return x;
+    if (shape === 0)
+        return x <= 0 ? dt0(lowerTail, logP) : dt1(lowerTail, logP);
+    if (x <= 0)
+        return dt0(lowerTail, logP);
+    return gammaInc(shape, x, lowerTail, logP);
+}
+/** Quantile of the standardized gamma distribution. 0 < p < 1 (range checks are the caller's job) */
+export function qgammaStd(p, shape, lowerTail, logP) {
+    const { lower, logTarget, linearTarget } = smallerTail(p, lowerTail, logP);
+    // If the distribution function at the smallest positive number already passes the target, the answer is too small to represent (0)
+    const atMin = gammaInc(shape, Number.MIN_VALUE, lower, true);
+    if (lower ? atMin >= logTarget : atMin <= logTarget)
+        return 0;
+    let x0;
+    if (shape > 1 && logTarget <= -700) {
+        // Deep tail: Wilson-Hilferty approximation x = a (1 - 1/(9a) + z / sqrt(9a))^3
+        const z = qnorm(logTarget, { lowerTail: lower, logP: true });
+        const w = 1 - 1 / (9 * shape) + z / Math.sqrt(9 * shape);
+        x0 = w > 0 ? shape * w * w * w : shape * 1e-3;
+    }
+    else if (logTarget > -700) {
+        const t = Math.exp(logTarget);
+        const c = -Math.expm1(logTarget);
+        x0 = lower ? findInverseGamma(shape, t, c) : findInverseGamma(shape, c, t);
+    }
+    else if (lower) {
+        // P(a, x) ≈ x^a / Gamma(a + 1)
+        x0 = Math.exp((logTarget + lgamma1p(shape)) / shape);
+    }
+    else {
+        // Q(a, x) ≈ x^(a-1) e^-x / Gamma(a)
+        x0 = -logTarget;
+        for (let i = 0; i < 3; i++)
+            x0 = -logTarget - lgamma(shape) + (shape - 1) * Math.log(x0);
+    }
+    return invertContinuous({
+        logTarget,
+        ...(linearTarget !== undefined && { linearTarget }),
+        lower,
+        cdf: (x, l) => gammaInc(shape, x, l, false),
+        cdfLog: (x, l) => gammaInc(shape, x, l, true),
+        cdfBoth: (x, l) => gammaIncBoth(shape, x, l),
+        pdfLog: (x) => dgammaStdLog(x, shape),
+        dlogPdf: (x) => (shape - 1) / x - 1,
+        x0,
+        lo: 0,
+        hi: Infinity,
+        positive: true,
+    });
+}
+export function qgamma1(p, shape, scale, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(shape) || Number.isNaN(scale))
+        return NaN;
+    const b = quantileBoundaries(p, 0, Infinity, lowerTail, logP);
+    if (b !== undefined)
+        return b;
+    if (shape < 0 || scale <= 0)
+        return NaN;
+    if (shape === 0)
+        return 0;
+    return qgammaStd(p, shape, lowerTail, logP) * scale;
+}
+/**
+ * Density of the gamma distribution. Equivalent to R's `dgamma(x, shape, rate = 1, scale = 1/rate, log = FALSE)`.
+ *
+ * @throws RangeError if both `rate` and `scale` are given and `scale` is not `1 / rate`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape - Shape parameter.
+ * @param options - `rate` or `scale` (see {@link GammaParams}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export function dgamma(x, shape, options = {}) {
+    const scale = gammaScale(options);
+    const log = options.log ?? false;
+    return vectorize(x, (v) => dgamma1(v, shape, scale, log));
+}
+/**
+ * Distribution function of the gamma distribution. Equivalent to R's `pgamma(q, shape, rate = 1, scale = 1/rate, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @throws RangeError if both `rate` and `scale` are given and `scale` is not `1 / rate`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape - Shape parameter.
+ * @param options - `rate` or `scale` (see {@link GammaParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ *
+ * @example
+ * ```ts
+ * pgamma(2, 2);              // 0.5939941502901619
+ * pgamma(2, 2, { rate: 3 }); // 0.9826487347633355
+ * pgamma(2, 2, { scale: 3 }); // 0.14430480161234657
+ * ```
+ */
+export function pgamma(q, shape, options = {}) {
+    const scale = gammaScale(options);
+    const { lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => pgamma1(v, shape, scale, lowerTail, logP));
+}
+/**
+ * Quantile function of the gamma distribution. Equivalent to R's `qgamma(p, shape, rate = 1, scale = 1/rate, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @throws RangeError if both `rate` and `scale` are given and `scale` is not `1 / rate`.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param shape - Shape parameter.
+ * @param options - `rate` or `scale` (see {@link GammaParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export function qgamma(p, shape, options = {}) {
+    const scale = gammaScale(options);
+    const { lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qgamma1(v, shape, scale, lowerTail, logP));
+}

package/dist/distributions/geometric.d.ts

@@ -0,0 +1,38 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+import { type DD } from "../special/dd.js";
+/** p and q = 1 - p in double-double (the smaller one is the exact base) */
+export declare function probPair(prob: number): {
+    pd: DD;
+    qd: DD;
+};
+export declare function dgeom1(x: number, prob: number, log: boolean): number;
+export declare function pgeom1(q: number, prob: number, lowerTail: boolean, logP: boolean): number;
+export declare function qgeom1(p: number, prob: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Probability mass function of the geometric distribution (number of failures before the first success). Equivalent to R's `dgeom(x, prob, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param prob - Probability of success on each trial.
+ * @param options - `log` (see {@link DensityOptions}).
+ * @returns The probability (or log probability).
+ */
+export declare function dgeom<T extends Vectorizable>(x: T, prob: number, options?: DensityOptions): VectorResult<T>;
+/**
+ * Distribution function of the geometric distribution (number of failures before the first success). Equivalent to R's `pgeom(q, prob, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param prob - Probability of success on each trial.
+ * @param options - `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ */
+export declare function pgeom<T extends Vectorizable>(q: T, prob: number, options?: TailOptions): VectorResult<T>;
+/**
+ * Quantile function of the geometric distribution (number of failures before the first success). Equivalent to R's `qgeom(p, prob, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param prob - Probability of success on each trial.
+ * @param options - `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export declare function qgeom<T extends Vectorizable>(p: T, prob: number, options?: TailOptions): VectorResult<T>;

package/dist/distributions/geometric.js

@@ -0,0 +1,116 @@
+// Geometric distribution dgeom / pgeom / qgeom.
+//
+// P[X = x] = p q^x, P[X > x] = q^(x+1) (q = 1 - p). q^n is computed with Loader's (2000) building blocks
+// (dbinomRawDD in src/special/loader.ts, as the binomial probability of 0 successes and n failures)
+// (the exponent is kept in double-double so that the rounding of n log q is not amplified n times).
+// Quantiles use a closed form.
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0, dt1, quantileBoundaries } from "../internal/dpq.js";
+import { log1mExp } from "../internal/ddexp.js";
+import { nonInt } from "../internal/integer.js";
+import { dbinomRawDD } from "../special/loader.js";
+import { twoSum } from "../special/dd.js";
+/** p and q = 1 - p in double-double (the smaller one is the exact base) */
+export function probPair(prob) {
+    return prob <= 0.5
+        ? { pd: [prob, 0], qd: twoSum(1, -prob) }
+        : { pd: twoSum(1, -(1 - prob)), qd: [1 - prob, 0] };
+}
+function badProb(prob) {
+    return !(prob > 0) || prob > 1;
+}
+export function dgeom1(x, prob, log) {
+    if (Number.isNaN(x) || Number.isNaN(prob))
+        return NaN;
+    if (badProb(prob))
+        return NaN;
+    if (nonInt(x) || x < 0 || !Number.isFinite(x))
+        return d0(log);
+    const n = Math.round(x);
+    const { pd, qd } = probPair(prob);
+    // q^n
+    const qn = dbinomRawDD(0, n, pd, qd, log);
+    return log ? Math.log(prob) + qn : prob * qn;
+}
+/** P[X > x] = q^(x+1) (x a nonnegative integer) */
+function upper(x, prob, log) {
+    const { pd, qd } = probPair(prob);
+    return dbinomRawDD(0, x + 1, pd, qd, log);
+}
+function pgeomRaw(x, prob, lowerTail, logP) {
+    if (!lowerTail)
+        return upper(x, prob, logP);
+    const lu = upper(x, prob, true);
+    if (!logP)
+        return -Math.expm1(lu);
+    // When the upper tail is small, use log1p of the linear value (whose exponent was computed in double-double)
+    return lu < -Math.LN2 ? Math.log1p(-upper(x, prob, false)) : Math.log(-Math.expm1(lu));
+}
+export function pgeom1(q, prob, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(prob))
+        return NaN;
+    if (badProb(prob))
+        return NaN;
+    if (q < 0)
+        return dt0(lowerTail, logP);
+    if (!Number.isFinite(q) || prob === 1)
+        return dt1(lowerTail, logP);
+    return pgeomRaw(Math.floor(q + 1e-7), prob, lowerTail, logP);
+}
+export function qgeom1(p, prob, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(prob))
+        return NaN;
+    if (badProb(prob))
+        return NaN;
+    const b = quantileBoundaries(p, 0, Infinity, lowerTail, logP);
+    if (Number.isNaN(b))
+        return NaN;
+    if (prob === 1)
+        return 0;
+    if (b !== undefined)
+        return b;
+    // Smallest integer y with P[X > y] = q^(y+1) <= (upper probability), solved in closed form
+    // (matches R's output. The distribution function is flat, so in an integer search the probability slack would move the answer a lot)
+    let lu;
+    if (logP)
+        lu = lowerTail ? log1mExp(p) : p;
+    else
+        lu = lowerTail ? Math.log1p(-p) : Math.log(p);
+    return Math.max(0, Math.ceil(lu / Math.log1p(-prob) - 1 - 1e-12));
+}
+/**
+ * Probability mass function of the geometric distribution (number of failures before the first success). Equivalent to R's `dgeom(x, prob, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param prob - Probability of success on each trial.
+ * @param options - `log` (see {@link DensityOptions}).
+ * @returns The probability (or log probability).
+ */
+export function dgeom(x, prob, options = {}) {
+    const log = options.log ?? false;
+    return vectorize(x, (v) => dgeom1(v, prob, log));
+}
+/**
+ * Distribution function of the geometric distribution (number of failures before the first success). Equivalent to R's `pgeom(q, prob, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param prob - Probability of success on each trial.
+ * @param options - `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ */
+export function pgeom(q, prob, options = {}) {
+    const { lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => pgeom1(v, prob, lowerTail, logP));
+}
+/**
+ * Quantile function of the geometric distribution (number of failures before the first success). Equivalent to R's `qgeom(p, prob, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param prob - Probability of success on each trial.
+ * @param options - `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export function qgeom(p, prob, options = {}) {
+    const { lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qgeom1(v, prob, lowerTail, logP));
+}

package/dist/distributions/hypergeometric.d.ts

@@ -0,0 +1,38 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+export declare function dhyper1(x: number, m: number, n: number, k: number, log: boolean): number;
+export declare function phyper1(q: number, m: number, n: number, k: number, lowerTail: boolean, logP: boolean): number;
+export declare function qhyper1(p: number, m: number, n: number, k: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Probability mass function of the hypergeometric distribution (number of white balls among `k` drawn without replacement from an urn of `m` white and `n` black balls). Equivalent to R's `dhyper(x, m, n, k, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param m - Number of white balls in the urn.
+ * @param n - Number of black balls in the urn.
+ * @param k - Number of balls drawn.
+ * @param options - `log` (see {@link DensityOptions}).
+ * @returns The probability (or log probability).
+ */
+export declare function dhyper<T extends Vectorizable>(x: T, m: number, n: number, k: number, options?: DensityOptions): VectorResult<T>;
+/**
+ * Distribution function of the hypergeometric distribution (number of white balls among `k` drawn without replacement from an urn of `m` white and `n` black balls). Equivalent to R's `phyper(q, m, n, k, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param m - Number of white balls in the urn.
+ * @param n - Number of black balls in the urn.
+ * @param k - Number of balls drawn.
+ * @param options - `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ */
+export declare function phyper<T extends Vectorizable>(q: T, m: number, n: number, k: number, options?: TailOptions): VectorResult<T>;
+/**
+ * Quantile function of the hypergeometric distribution (number of white balls among `k` drawn without replacement from an urn of `m` white and `n` black balls). Equivalent to R's `qhyper(p, m, n, k, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param m - Number of white balls in the urn.
+ * @param n - Number of black balls in the urn.
+ * @param k - Number of balls drawn.
+ * @param options - `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export declare function qhyper<T extends Vectorizable>(p: T, m: number, n: number, k: number, options?: TailOptions): VectorResult<T>;