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

package/dist/distributions/binomial.js

@@ -0,0 +1,136 @@
+// Binomial distribution dbinom / pbinom / qbinom.
+//
+// Probabilities use Loader's (2000) dbinomRaw; the distribution function is
+//   P[X <= x] = 1 - I_p(x + 1, n - x)   (regularized incomplete beta function)
+// Quantiles use an integer search from a Cornish-Fisher starting value.
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0, dt1, quantileBoundaries } from "../internal/dpq.js";
+import { discreteQuantile } from "../internal/discrete.js";
+import { betaInc } from "../special/incbet.js";
+import { dbinomRawDD } from "../special/loader.js";
+import { twoSum } from "../special/dd.js";
+import { qnorm } from "./normal.js";
+import { nonInteger } from "./poisson.js";
+function badParams(size, prob) {
+    return nonInteger(size) || size < 0 || !Number.isFinite(size) || prob < 0 || prob > 1;
+}
+export function dbinom1(x, size, prob, log) {
+    if (Number.isNaN(x) || Number.isNaN(size) || Number.isNaN(prob))
+        return NaN;
+    if (badParams(size, prob))
+        return NaN;
+    if (nonInteger(x) || x < 0 || !Number.isFinite(x))
+        return d0(log);
+    // q = 1 - prob is formed exactly in double-double (rounding in q would be amplified n - x times)
+    const xr = Math.round(x);
+    const n = Math.round(size);
+    if (xr > n)
+        return d0(log);
+    const pd = prob <= 0.5 ? [prob, 0] : twoSum(1, -(1 - prob));
+    const qd = prob <= 0.5 ? twoSum(1, -prob) : [1 - prob, 0];
+    return dbinomRawDD(xr, n - xr, pd, qd, log);
+}
+/** P[X <= x] (lower) / P[X > x] (!lower). x an integer, 0 <= x < n */
+function pbinomRaw(x, n, prob, lower, log) {
+    // P[X <= x] = 1 - I_p(x + 1, n - x)
+    return betaInc(x + 1, n - x, prob, 1 - prob, !lower, log);
+}
+export function pbinom1(q, size, prob, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(size) || Number.isNaN(prob))
+        return NaN;
+    if (badParams(size, prob))
+        return NaN;
+    const n = Math.round(size);
+    if (q < 0)
+        return dt0(lowerTail, logP);
+    const x = Math.floor(q + 1e-7);
+    if (n <= x)
+        return dt1(lowerTail, logP);
+    if (prob === 0)
+        return dt1(lowerTail, logP);
+    if (prob === 1)
+        return dt0(lowerTail, logP);
+    return pbinomRaw(x, n, prob, lowerTail, logP);
+}
+export function qbinom1(p, size, prob, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(size) || Number.isNaN(prob))
+        return NaN;
+    if (!Number.isFinite(size) || !Number.isFinite(prob) || prob < 0 || prob > 1 || size < 0)
+        return NaN;
+    // R returns the endpoints (p = 0, 1) first even for non-integer size. The upper end is size rounded half to even
+    const b = quantileBoundaries(p, 0, roundHalfEven(size), lowerTail, logP);
+    if (b !== undefined)
+        return b;
+    if (badParams(size, prob))
+        return NaN;
+    const n = Math.round(size);
+    if (prob === 0 || n === 0)
+        return 0;
+    if (prob === 1)
+        return n;
+    const q = 1 - prob;
+    const mu = n * prob;
+    const sigma = Math.sqrt(n * prob * q);
+    const gamma = (q - prob) / sigma;
+    const z = qnorm(p, { lowerTail, logP });
+    const y0 = mu + sigma * (z + (gamma * (z * z - 1)) / 6);
+    return discreteQuantile({
+        p,
+        lowerTail,
+        logP,
+        cdf: (y, l, lg) => (y >= n ? dt1(l, lg) : pbinomRaw(y, n, prob, l, lg)),
+        y0: Number.isFinite(y0) ? y0 : mu,
+        lo: 0,
+        hi: n,
+    });
+}
+/**
+ * Probability mass function of the binomial distribution. Equivalent to R's `dbinom(x, size, prob, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param size - Number of trials.
+ * @param prob - Probability of success on each trial.
+ * @param options - `log` (see {@link DensityOptions}).
+ * @returns The probability (or log probability).
+ */
+export function dbinom(x, size, prob, options = {}) {
+    const log = options.log ?? false;
+    return vectorize(x, (v) => dbinom1(v, size, prob, log));
+}
+/**
+ * Distribution function of the binomial distribution. Equivalent to R's `pbinom(q, size, prob, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param size - Number of trials.
+ * @param prob - Probability of success on each trial.
+ * @param options - `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ *
+ * @example
+ * ```ts
+ * pbinom(3, 10, 0.5);      // 0.171875
+ * pbinom([3, 5], 10, 0.5); // [0.171875, 0.623046875]
+ * ```
+ */
+export function pbinom(q, size, prob, options = {}) {
+    const { lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => pbinom1(v, size, prob, lowerTail, logP));
+}
+/**
+ * Quantile function of the binomial distribution. Equivalent to R's `qbinom(p, size, 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 size - Number of trials.
+ * @param prob - Probability of success on each trial.
+ * @param options - `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export function qbinom(p, size, prob, options = {}) {
+    const { lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qbinom1(v, size, prob, lowerTail, logP));
+}
+/** Round half to even (0.5 goes to the nearest even number; same as R's nearbyint) */
+function roundHalfEven(x) {
+    const r = Math.round(x);
+    return Math.abs(x % 1) === 0.5 && r % 2 !== 0 ? r - 1 : r;
+}

package/dist/distributions/cauchy.d.ts

@@ -0,0 +1,34 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+import type { LocationScaleParams } from "./logistic.js";
+export declare function dcauchy1(x: number, location: number, scale: number, log: boolean): number;
+/**
+ * P[X <= q] (lower) / P[X > q] (!lower). For |z| > 1 the smaller tail atan(1/|z|)/π is computed without forming z,
+ * using 1/|z| = scale / |q - location| (so the log value survives even if z overflows)
+ */
+export declare function pcauchy1(q: number, location: number, scale: number, lowerTail: boolean, logP: boolean): number;
+export declare function qcauchy1(p: number, location: number, scale: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Density of the Cauchy distribution. Equivalent to R's `dcauchy(x, location = 0, scale = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `location` and `scale` (see {@link LocationScaleParams}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export declare function dcauchy<T extends Vectorizable>(x: T, options?: LocationScaleParams & DensityOptions): VectorResult<T>;
+/**
+ * Distribution function of the Cauchy distribution. Equivalent to R's `pcauchy(q, location = 0, scale = 1, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `location` and `scale` (see {@link LocationScaleParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ */
+export declare function pcauchy<T extends Vectorizable>(q: T, options?: LocationScaleParams & TailOptions): VectorResult<T>;
+/**
+ * Quantile function of the Cauchy distribution. Equivalent to R's `qcauchy(p, location = 0, scale = 1, 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 options - `location` and `scale` (see {@link LocationScaleParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export declare function qcauchy<T extends Vectorizable>(p: T, options?: LocationScaleParams & TailOptions): VectorResult<T>;

package/dist/distributions/cauchy.js

@@ -0,0 +1,139 @@
+// Cauchy distribution dcauchy / pcauchy / qcauchy.
+//
+// With z = (x - location) / scale, f(x) = 1 / (π scale (1 + z^2)) and
+// P[X <= x] = 1/2 + atan(z)/π. For |z| > 1 the smaller tail is computed directly as atan(1/|z|)/π,
+// avoiding subtraction from 1/2 and overflow of z^2. Quantiles compute tan(π (p - 1/2)) as
+// -1/tan(π p) for p < 1/4 and -tan(π (1/2 - p)) for 1/4 <= p <= 1/2.
+import { vectorize } from "../internal/vectorize.js";
+import { locationScale } from "../internal/ddexp.js";
+const LOG_PI = 1.1447298858494002;
+export function dcauchy1(x, location, scale, log) {
+    if (Number.isNaN(x) || Number.isNaN(location) || Number.isNaN(scale))
+        return NaN;
+    if (!(scale > 0))
+        return NaN;
+    const z = (x - location) / scale;
+    if (Number.isNaN(z))
+        return NaN;
+    const az = Math.abs(z);
+    if (az <= 1) {
+        if (log)
+            return -(LOG_PI + Math.log(scale)) - Math.log1p(z * z);
+        return 1 / (Math.PI * scale * (1 + z * z));
+    }
+    // With y = 1/z, f = y^2 / (π scale (1 + y^2))
+    const y = 1 / az;
+    if (log)
+        return -(LOG_PI + Math.log(scale)) - 2 * Math.log(az) - Math.log1p(y * y);
+    return (y / (Math.PI * scale)) * (y / (1 + y * y));
+}
+/**
+ * P[X <= q] (lower) / P[X > q] (!lower). For |z| > 1 the smaller tail atan(1/|z|)/π is computed without forming z,
+ * using 1/|z| = scale / |q - location| (so the log value survives even if z overflows)
+ */
+export function pcauchy1(q, location, scale, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(location) || Number.isNaN(scale))
+        return NaN;
+    if (!(scale > 0))
+        return NaN;
+    const d = q - location;
+    if (Number.isNaN(d))
+        return NaN;
+    if (!(Math.abs(d) > scale)) {
+        const z = d / scale;
+        const v = 0.5 + Math.atan(lowerTail ? z : -z) / Math.PI;
+        return logP ? Math.log(v) : v;
+    }
+    // Probability of the smaller side v = atan(w)/π (w = 1/|z|)
+    const w = scale / Math.abs(d);
+    const v = Math.atan(w) / Math.PI;
+    const small = lowerTail === d < 0;
+    if (small) {
+        if (!logP)
+            return v;
+        // atan(w) = w (1 - w^2/3 + ...). For small w use log w directly (survives even if w underflows)
+        return w < 1e-150 ? Math.log(scale) - Math.log(Math.abs(d)) - LOG_PI : Math.log(v);
+    }
+    return logP ? Math.log1p(-v) : 1 - v;
+}
+const TINY = 1e-200;
+const TINY_LOG = -460;
+/**
+ * scale |T| = scale / tan(π s) ≈ scale / (π s) when the probability on that side is tiny.
+ * When π s is subnormal, 1 / (π s) overflows and loses accuracy, so change the order of division.
+ * With logP (s is a log), multiply by e^-s split into two halves (taking log and exp back would amplify the rounding of the exponent)
+ */
+function tinyTail(scale, s, logP) {
+    if (!logP)
+        return scale / s / Math.PI;
+    const h = Math.exp(-s / 2);
+    return h * (scale / Math.PI) * h;
+}
+/** Quantile tan(π (s - 1/2)) of the standard Cauchy for lower probability s (0 < s <= 1/2) */
+function quantileSmall(s) {
+    if (s <= 0.25)
+        return -1 / Math.tan(Math.PI * s);
+    return -Math.tan(Math.PI * (0.5 - s));
+}
+export function qcauchy1(p, location, scale, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(location) || Number.isNaN(scale))
+        return NaN;
+    if (logP ? p > 0 : p < 0 || p > 1)
+        return NaN;
+    if (!(scale > 0) || !Number.isFinite(scale))
+        return scale === 0 ? location : NaN;
+    // Standard quantile T for the probability p on that side (x = location + scale T for the lower tail)
+    let t;
+    if (logP) {
+        if (p === 0)
+            t = Infinity;
+        else if (p === -Infinity)
+            t = -Infinity;
+        else if (p < TINY_LOG)
+            return location + (lowerTail ? -1 : 1) * tinyTail(scale, p, true);
+        else
+            t = p < -Math.LN2 ? quantileSmall(Math.exp(p)) : -quantileSmall(-Math.expm1(p));
+    }
+    else if (p === 0)
+        t = -Infinity;
+    else if (p === 1)
+        t = Infinity;
+    else if (p < TINY)
+        return location + (lowerTail ? -1 : 1) * tinyTail(scale, p, false);
+    else
+        t = p <= 0.5 ? quantileSmall(p) : -quantileSmall(1 - p);
+    return locationScale(location, scale, lowerTail ? t : -t);
+}
+/**
+ * Density of the Cauchy distribution. Equivalent to R's `dcauchy(x, location = 0, scale = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `location` and `scale` (see {@link LocationScaleParams}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export function dcauchy(x, options = {}) {
+    const { location = 0, scale = 1, log = false } = options;
+    return vectorize(x, (v) => dcauchy1(v, location, scale, log));
+}
+/**
+ * Distribution function of the Cauchy distribution. Equivalent to R's `pcauchy(q, location = 0, scale = 1, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `location` and `scale` (see {@link LocationScaleParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ */
+export function pcauchy(q, options = {}) {
+    const { location = 0, scale = 1, lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => pcauchy1(v, location, scale, lowerTail, logP));
+}
+/**
+ * Quantile function of the Cauchy distribution. Equivalent to R's `qcauchy(p, location = 0, scale = 1, 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 options - `location` and `scale` (see {@link LocationScaleParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export function qcauchy(p, options = {}) {
+    const { location = 0, scale = 1, lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qcauchy1(v, location, scale, lowerTail, logP));
+}

package/dist/distributions/chisq.d.ts

@@ -0,0 +1,42 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import type { DensityOptions, TailOptions } from "../internal/dpq.js";
+import type { NoncentralOption } from "../internal/noncentral.js";
+/**
+ * Density of the chi-squared distribution. Equivalent to R's `dchisq(x, df, ncp = 0, log = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral chi-squared distribution.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param df - Degrees of freedom.
+ * @param options - `ncp` (see {@link NoncentralOption}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export declare function dchisq<T extends Vectorizable>(x: T, df: number, options?: DensityOptions & NoncentralOption): VectorResult<T>;
+/**
+ * Distribution function of the chi-squared distribution. Equivalent to R's `pchisq(q, df, ncp = 0, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral chi-squared distribution.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param df - Degrees of freedom.
+ * @param options - `ncp` (see {@link NoncentralOption}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ *
+ * @example
+ * ```ts
+ * pchisq(3.84, 1, { lowerTail: false }); // 0.05004352124870517
+ * pchisq(5, 3, { ncp: 2 });              // 0.5934051800831556
+ * ```
+ */
+export declare function pchisq<T extends Vectorizable>(q: T, df: number, options?: TailOptions & NoncentralOption): VectorResult<T>;
+/**
+ * Quantile function of the chi-squared distribution. Equivalent to R's `qchisq(p, df, ncp = 0, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral chi-squared distribution.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param df - Degrees of freedom.
+ * @param options - `ncp` (see {@link NoncentralOption}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export declare function qchisq<T extends Vectorizable>(p: T, df: number, options?: TailOptions & NoncentralOption): VectorResult<T>;

package/dist/distributions/chisq.js

@@ -0,0 +1,60 @@
+// χ² distribution dchisq / pchisq / qchisq, computed as the gamma distribution with shape = df/2, scale = 2.
+// Passing ncp gives the noncentral χ² (src/distributions/nchisq.ts). As in R, when ncp is omitted the
+// central distribution is used.
+import { vectorize } from "../internal/vectorize.js";
+import { dgamma1, pgamma1, qgamma1 } from "./gamma.js";
+import { dnchisq1, pnchisq1, qnchisq1 } from "./nchisq.js";
+/**
+ * Density of the chi-squared distribution. Equivalent to R's `dchisq(x, df, ncp = 0, log = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral chi-squared distribution.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param df - Degrees of freedom.
+ * @param options - `ncp` (see {@link NoncentralOption}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export function dchisq(x, df, options = {}) {
+    const { log = false, ncp } = options;
+    if (ncp !== undefined)
+        return vectorize(x, (v) => dnchisq1(v, df, ncp, log));
+    return vectorize(x, (v) => dgamma1(v, df / 2, 2, log));
+}
+/**
+ * Distribution function of the chi-squared distribution. Equivalent to R's `pchisq(q, df, ncp = 0, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral chi-squared distribution.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param df - Degrees of freedom.
+ * @param options - `ncp` (see {@link NoncentralOption}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ *
+ * @example
+ * ```ts
+ * pchisq(3.84, 1, { lowerTail: false }); // 0.05004352124870517
+ * pchisq(5, 3, { ncp: 2 });              // 0.5934051800831556
+ * ```
+ */
+export function pchisq(q, df, options = {}) {
+    const { lowerTail = true, logP = false, ncp } = options;
+    if (ncp !== undefined)
+        return vectorize(q, (v) => pnchisq1(v, df, ncp, lowerTail, logP));
+    return vectorize(q, (v) => pgamma1(v, df / 2, 2, lowerTail, logP));
+}
+/**
+ * Quantile function of the chi-squared distribution. Equivalent to R's `qchisq(p, df, ncp = 0, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * If `ncp` is omitted the central distribution is used; otherwise the noncentral chi-squared distribution.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param df - Degrees of freedom.
+ * @param options - `ncp` (see {@link NoncentralOption}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export function qchisq(p, df, options = {}) {
+    const { lowerTail = true, logP = false, ncp } = options;
+    if (ncp !== undefined)
+        return vectorize(p, (v) => qnchisq1(v, df, ncp, lowerTail, logP));
+    return vectorize(p, (v) => qgamma1(v, df / 2, 2, lowerTail, logP));
+}

package/dist/distributions/exponential.d.ts

@@ -0,0 +1,34 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+/** Parameters of the exponential distribution. */
+export interface ExponentialParams {
+    /** Rate. Default `1`. */
+    rate?: number;
+}
+export declare function dexp1(x: number, rate: number, log: boolean): number;
+export declare function pexp1(q: number, rate: number, lowerTail: boolean, logP: boolean): number;
+export declare function qexp1(p: number, rate: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Density of the exponential distribution. Equivalent to R's `dexp(x, rate = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `rate` (see {@link ExponentialParams}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export declare function dexp<T extends Vectorizable>(x: T, options?: ExponentialParams & DensityOptions): VectorResult<T>;
+/**
+ * Distribution function of the exponential distribution. Equivalent to R's `pexp(q, rate = 1, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `rate` (see {@link ExponentialParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ */
+export declare function pexp<T extends Vectorizable>(q: T, options?: ExponentialParams & TailOptions): VectorResult<T>;
+/**
+ * Quantile function of the exponential distribution. Equivalent to R's `qexp(p, rate = 1, 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 options - `rate` (see {@link ExponentialParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export declare function qexp<T extends Vectorizable>(p: T, options?: ExponentialParams & TailOptions): VectorResult<T>;

package/dist/distributions/exponential.js

@@ -0,0 +1,93 @@
+// Exponential distribution dexp / pexp / qexp.
+//
+// f(x) = rate exp(-rate x), P[X > x] = exp(-rate x). rate x is formed in double-double
+// (the relative error of exp(-t) equals the absolute error of t, and at t = 700 the rounding of the product alone gives 6e-14).
+// Argument handling (rate = 0, Inf) is matched to R's output.
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0, dt1, quantileBoundaries } from "../internal/dpq.js";
+import { expNeg, log1mExp, logOneMinusExpNeg, mulDD } from "../internal/ddexp.js";
+export function dexp1(x, rate, log) {
+    if (Number.isNaN(x) || Number.isNaN(rate))
+        return NaN;
+    if (rate < 0 || rate === Infinity)
+        return NaN;
+    if (x < 0)
+        return d0(log);
+    const t = mulDD(rate, x);
+    if (Number.isNaN(t[0]))
+        return NaN;
+    if (log)
+        return Math.log(rate) - t[0] - t[1];
+    return rate * expNeg(t);
+}
+/** Log or linear value of P[X > x], according to the tail direction */
+function expTail(t, lowerTail, logP) {
+    if (!lowerTail)
+        return logP ? -t[0] - t[1] : expNeg(t);
+    // Lower tail 1 - exp(-t)
+    const s = t[0] + t[1];
+    return logP ? logOneMinusExpNeg(t) : -Math.expm1(-s);
+}
+export function pexp1(q, rate, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(rate))
+        return NaN;
+    if (rate < 0)
+        return NaN;
+    if (q <= 0)
+        return dt0(lowerTail, logP);
+    const t = mulDD(rate, q);
+    if (Number.isNaN(t[0]))
+        return NaN;
+    if (t[0] === Infinity)
+        return dt1(lowerTail, logP);
+    return expTail(t, lowerTail, logP);
+}
+export function qexp1(p, rate, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(rate))
+        return NaN;
+    if (rate < 0)
+        return NaN;
+    const b = quantileBoundaries(p, 0, Infinity, lowerTail, logP);
+    if (Number.isNaN(b) || b === 0)
+        return b;
+    // Log of the upper probability, log P[X > x] = -rate x
+    let lu;
+    if (logP)
+        lu = lowerTail ? log1mExp(p) : p;
+    else
+        lu = lowerTail ? Math.log1p(-p) : Math.log(p);
+    return -lu / rate;
+}
+/**
+ * Density of the exponential distribution. Equivalent to R's `dexp(x, rate = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `rate` (see {@link ExponentialParams}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export function dexp(x, options = {}) {
+    const { rate = 1, log = false } = options;
+    return vectorize(x, (v) => dexp1(v, rate, log));
+}
+/**
+ * Distribution function of the exponential distribution. Equivalent to R's `pexp(q, rate = 1, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `rate` (see {@link ExponentialParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ */
+export function pexp(q, options = {}) {
+    const { rate = 1, lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => pexp1(v, rate, lowerTail, logP));
+}
+/**
+ * Quantile function of the exponential distribution. Equivalent to R's `qexp(p, rate = 1, 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 options - `rate` (see {@link ExponentialParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export function qexp(p, options = {}) {
+    const { rate = 1, lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qexp1(v, rate, lowerTail, logP));
+}

package/dist/distributions/f.d.ts

@@ -0,0 +1,47 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+import type { NoncentralOption } from "../internal/noncentral.js";
+export declare function dfDensity1(x: number, m: number, n: number, log: boolean): number;
+export declare function pf1(q: number, m: number, n: number, lowerTail: boolean, logP: boolean): number;
+export declare function qf1(p: number, m: number, n: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * 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 declare function df<T extends Vectorizable>(x: T, df1: number, df2: number, options?: DensityOptions & NoncentralOption): VectorResult<T>;
+/**
+ * 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 declare function pf<T extends Vectorizable>(q: T, df1: number, df2: number, options?: TailOptions & NoncentralOption): VectorResult<T>;
+/**
+ * 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 declare function qf<T extends Vectorizable>(p: T, df1: number, df2: number, options?: TailOptions & NoncentralOption): VectorResult<T>;