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

package/dist/distributions/negbinomial.js

@@ -0,0 +1,325 @@
+// Negative binomial distribution dnbinom / pnbinom / qnbinom (size and prob, or size and mu).
+//
+// Probabilities use the relation to the binomial probability (Loader 2000)
+//   P[X = x] = Γ(x + n) / (Γ(n) x!) p^n q^x = n / (n + x) · b(n; n + x, p)
+// where b is dbinomRawDD from src/special/loader.ts (n need not be an integer).
+// The distribution function is P[X <= x] = I_p(n, x + 1) (regularized incomplete beta function).
+// When mu is given, p = n / (n + mu) and q = mu / (n + mu) are formed in double-double
+// (for n ≫ mu, rounding 1 - p gives q a large relative error). size = Inf is the Poisson distribution.
+// 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 { nonInt } from "../internal/integer.js";
+import { betaIncDD } from "../special/incbet.js";
+import { dbinomRawDD, dpoisRaw } from "../special/loader.js";
+import { ddAdd, ddDiv, ddMul, twoSum } from "../special/dd.js";
+import { qnorm } from "./normal.js";
+import { qgamma1 } from "./gamma.js";
+import { ppois1, qpois1 } from "./poisson.js";
+import { probPair } from "./geometric.js";
+function fromMu(size, mu) {
+    const s = twoSum(size, mu);
+    return { size, pd: ddDiv([size, 0], s), qd: ddDiv([mu, 0], s) };
+}
+function fromProb(size, prob) {
+    return { size, ...probPair(prob) };
+}
+/** P[X = x] (x a nonnegative integer, 0 < size < ∞, 0 < p < 1) */
+function dnbinomRaw(x, par, log) {
+    const { size, pd, qd } = par;
+    const b = dbinomRawDD(size, x, pd, qd, log);
+    if (x === 0)
+        return b;
+    const r = size / (size + x);
+    return log ? b + Math.log(r) : b * r;
+}
+/** P[X <= x] (lower) / P[X > x] (!lower) (x a nonnegative integer) */
+function pnbinomRaw(x, par, lower, log) {
+    const up = upperSeries(x, par);
+    if (up !== undefined) {
+        // The upper tail (the smaller side) was computed directly by the series
+        if (!lower)
+            return log ? Math.log(up) : up;
+        return log ? Math.log1p(-up) : 1 - up;
+    }
+    return betaIncDD(par.size, x + 1, par.pd, par.qd, lower, log);
+}
+/**
+ * For size <= 1 with q close to 1, compute the upper probability P[X > x] = I_q(x + 1, size) directly by the
+ * positive-term series
+ *   I_z(A, B) = z^A (1 - z)^B / (A B(A, B)) [1 + Σ_{k>=1} Π_{j<k} (A + B + j) / (A + 1 + j) z^k]
+ * (z = q, A = x + 1, B = size). In this region the incomplete beta continued fraction is off by about 3e-14
+ * relative near the mean. All terms are positive, so there is no cancellation. The number of terms is about
+ * -log(1e-17) / -log z. Returns undefined when not usable (too many terms, or the value exceeds 1/2)
+ */
+function upperSeries(x, par) {
+    const { size, pd, qd } = par;
+    const z = qd[0] + qd[1];
+    const p = pd[0] + pd[1];
+    if (!(size <= 1) || !(z >= 0.95) || p < 1e-4)
+        return undefined;
+    const A = x + 1;
+    const B = size;
+    // Prefactor z^A (1 - z)^B / (A B(A, B)) = b(A; A + B, z) B / (A + B)
+    const pre = (dbinomRawDD(A, B, qd, pd, false) * B) / (A + B);
+    if (!(pre > 1e-290))
+        return undefined;
+    // Rounding of the term ratios accumulates with the number of terms (1e-12 over tens of thousands), so keep terms and sum in double-double
+    const ab = twoSum(A, B);
+    let term = [1, 0];
+    let sum = [1, 0];
+    for (let k = 0; k < 1e6; k++) {
+        const ratio = ddDiv(ddAdd(ab, [k, 0]), [A + 1 + k, 0]);
+        term = ddMul(ddMul(term, ratio), qd);
+        sum = ddAdd(sum, term);
+        if (term[0] < 1e-18 * sum[0]) {
+            const v = pre * (sum[0] + sum[1]);
+            return v <= 0.5 ? v : undefined;
+        }
+    }
+    return undefined;
+}
+function quantileRaw(p, par, lowerTail, logP) {
+    // Starting value from the Cornish-Fisher expansion
+    const prob = par.pd[0] + par.pd[1];
+    const Q = 1 / prob;
+    const P = (par.qd[0] + par.qd[1]) * Q;
+    const mu = par.size * P;
+    const sigma = Math.sqrt(par.size * P * Q);
+    const gamma = (Q + P) / sigma;
+    let y0;
+    if (prob < 0.05) {
+        // For small p, X (-log q) is nearly gamma (shape = size). Even for highly skewed distributions (small size)
+        // this is a much closer starting value than Cornish-Fisher, reducing distribution-function evaluations
+        // -log q = log(1 + p/q) (taking log of a rounded q loses digits for small p)
+        y0 = qgamma1(p, par.size, 1, lowerTail, logP) / Math.log1p(prob / (par.qd[0] + par.qd[1]));
+    }
+    else {
+        const z = qnorm(p, { lowerTail, logP });
+        y0 = mu + sigma * (z + (gamma * (z * z - 1)) / 6);
+    }
+    let start = Number.isFinite(y0) ? Math.max(y0, 0) : Number.isFinite(mu) ? mu : 0;
+    if (start > 1e4)
+        start = refineContinuous(start, p, par, lowerTail, logP);
+    return discreteQuantile({
+        p,
+        lowerTail,
+        logP,
+        cdf: (y, l, lg) => pnbinomRaw(y, par, l, lg),
+        y0: start,
+        lo: 0,
+        hi: Infinity,
+    });
+}
+/**
+ * Before the integer search, refine the starting value by Newton's method treating y as real.
+ * The discrete search widens from step 1 by doubling, so a starting value off by 1e15 units would need more than
+ * 100 distribution-function evaluations. Solves for the log probability of the smaller tail. The final integer
+ * search determines the answer, so this only needs to be close
+ */
+function refineContinuous(y0, p, par, lowerTail, logP) {
+    // Use the same slack-adjusted target as the integer search (src/internal/discrete.ts)
+    // (when p is close to 1, the slack changes the opposite-tail probability considerably)
+    const E = Number.EPSILON;
+    let t = p;
+    if (logP)
+        t = lowerTail ? p * (1 + 2 * E) : p * (1 - 2 * E);
+    else if (lowerTail)
+        t = p * (1 - 8 * E);
+    else if (1 - p > 32 * E)
+        t = p * (1 + 8 * E);
+    const lp = logP ? t : Math.log(t);
+    // Switch to the smaller tail
+    const useLower = lp <= -Math.LN2 ? lowerTail : !lowerTail;
+    const target = lp <= -Math.LN2 ? lp : logP ? Math.log(-Math.expm1(t)) : Math.log1p(-t);
+    // First step: Newton's method with the slope approximated by the probability mass function; then the secant method
+    let y = y0;
+    let r = pnbinomRaw(y, par, useLower, true) - target;
+    let yPrev = NaN;
+    let rPrev = NaN;
+    for (let i = 0; i < 8 && r !== 0; i++) {
+        let next;
+        if (Number.isNaN(yPrev) || r === rPrev) {
+            const slope = (useLower ? 1 : -1) * Math.exp(dnbinomRaw(y, par, true) - (r + target));
+            next = y - r / slope;
+        }
+        else {
+            next = y - (r * (y - yPrev)) / (r - rPrev);
+        }
+        if (!Number.isFinite(next) || next <= 0)
+            break;
+        if (Math.abs(next - y) < 0.5)
+            return next;
+        yPrev = y;
+        rPrev = r;
+        y = next;
+        r = pnbinomRaw(y, par, useLower, true) - target;
+    }
+    return y;
+}
+// ---- Parameterized by prob ----
+export function dnbinom1(x, size, prob, log) {
+    if (Number.isNaN(x) || Number.isNaN(size) || Number.isNaN(prob))
+        return NaN;
+    if (size < 0 || !(prob > 0) || prob > 1)
+        return NaN;
+    if (nonInt(x) || x < 0 || !Number.isFinite(x))
+        return d0(log);
+    const n = Math.round(x);
+    if (size === 0 || prob === 1)
+        return n === 0 ? (log ? 0 : 1) : d0(log);
+    if (size === Infinity)
+        return d0(log);
+    return dnbinomRaw(n, fromProb(size, prob), log);
+}
+export function pnbinom1(q, size, prob, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(size) || Number.isNaN(prob))
+        return NaN;
+    if (size < 0 || !(prob > 0) || prob > 1 || size === Infinity)
+        return NaN;
+    if (q < 0)
+        return dt0(lowerTail, logP);
+    if (size === 0 || prob === 1 || !Number.isFinite(q))
+        return dt1(lowerTail, logP);
+    return pnbinomRaw(Math.floor(q + 1e-7), fromProb(size, prob), lowerTail, logP);
+}
+export function qnbinom1(p, size, prob, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(size) || Number.isNaN(prob))
+        return NaN;
+    // Same order as R: parameter range → point mass (prob = 1 or size = 0 gives 0 regardless of p) → prob = 0 → range of p
+    if (size < 0 || prob < 0 || prob > 1)
+        return NaN;
+    if (prob === 1 || size === 0)
+        return 0;
+    if (prob === 0)
+        return NaN;
+    const b = quantileBoundaries(p, 0, Infinity, lowerTail, logP);
+    if (b !== undefined)
+        return b;
+    // size = Inf (prob < 1) has its mass at X = ∞ (R gives Inf or NaN depending on p)
+    if (size === Infinity)
+        return Infinity;
+    return quantileRaw(p, fromProb(size, prob), lowerTail, logP);
+}
+// ---- Parameterized by mu ----
+export function dnbinomMu1(x, size, mu, log) {
+    if (Number.isNaN(x) || Number.isNaN(size) || Number.isNaN(mu))
+        return NaN;
+    if (size < 0 || mu < 0)
+        return NaN;
+    if (nonInt(x) || x < 0 || !Number.isFinite(x))
+        return d0(log);
+    const n = Math.round(x);
+    if (size === 0) {
+        if (n === 0)
+            return log ? 0 : 1;
+        return mu === 0 ? NaN : d0(log);
+    }
+    if (mu === Infinity)
+        return d0(log);
+    if (size === Infinity)
+        return dpoisRaw(n, mu, log);
+    if (mu === 0)
+        return n === 0 ? (log ? 0 : 1) : d0(log);
+    return dnbinomRaw(n, fromMu(size, mu), log);
+}
+export function pnbinomMu1(q, size, mu, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(size) || Number.isNaN(mu))
+        return NaN;
+    if (size < 0 || mu < 0 || mu === Infinity)
+        return NaN;
+    if (q < 0)
+        return dt0(lowerTail, logP);
+    if (size === 0 || mu === 0 || !Number.isFinite(q))
+        return dt1(lowerTail, logP);
+    if (size === Infinity)
+        return ppois1(q, mu, lowerTail, logP);
+    return pnbinomRaw(Math.floor(q + 1e-7), fromMu(size, mu), lowerTail, logP);
+}
+export function qnbinomMu1(p, size, mu, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(size) || Number.isNaN(mu))
+        return NaN;
+    // As in R, size = Inf is the Poisson distribution, and size = 0 or mu = 0 gives 0 regardless of the other parameter or p
+    if (size === Infinity)
+        return qpois1(p, mu, lowerTail, logP);
+    if (size === 0 || mu === 0)
+        return 0;
+    if (size < 0 || mu < 0)
+        return NaN;
+    // mu = Inf answers only at the ends (p = 0, 1) and is NaN otherwise (as in R)
+    if (mu === Infinity)
+        return quantileBoundaries(p, 0, Infinity, lowerTail, logP) ?? NaN;
+    const b = quantileBoundaries(p, 0, Infinity, lowerTail, logP);
+    if (b !== undefined)
+        return b;
+    return quantileRaw(p, fromMu(size, mu), lowerTail, logP);
+}
+/** Accept exactly one of prob and mu (as in R, giving both or neither is an error) */
+function which(options) {
+    const { prob, mu } = options;
+    if (prob !== undefined && mu !== undefined)
+        throw new TypeError("specify exactly one of prob and mu");
+    if (prob !== undefined)
+        return { kind: "prob", v: prob };
+    if (mu !== undefined)
+        return { kind: "mu", v: mu };
+    throw new TypeError("specify exactly one of prob and mu");
+}
+/**
+ * Probability mass function of the negative binomial distribution (number of failures before the `size`-th success). Equivalent to R's `dnbinom(x, size, prob, mu, log = FALSE)`.
+ *
+ * The distribution is parameterized by `size` and exactly one of `prob` or `mu`. With `mu`, `size = Infinity` gives the Poisson distribution.
+ *
+ * @throws TypeError unless exactly one of `prob` and `mu` is given.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param size - Target number of successes (need not be an integer).
+ * @param options - `prob` or `mu` (see {@link NegBinomialParams}; exactly one is required) and `log` (see {@link DensityOptions}).
+ * @returns The probability (or log probability).
+ */
+export function dnbinom(x, size, options) {
+    const log = options.log ?? false;
+    const w = which(options);
+    return w.kind === "prob"
+        ? vectorize(x, (v) => dnbinom1(v, size, w.v, log))
+        : vectorize(x, (v) => dnbinomMu1(v, size, w.v, log));
+}
+/**
+ * Distribution function of the negative binomial distribution (number of failures before the `size`-th success). Equivalent to R's `pnbinom(q, size, prob, mu, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * The distribution is parameterized by `size` and exactly one of `prob` or `mu`. With `mu`, `size = Infinity` gives the Poisson distribution.
+ *
+ * @throws TypeError unless exactly one of `prob` and `mu` is given.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param size - Target number of successes (need not be an integer).
+ * @param options - `prob` or `mu` (see {@link NegBinomialParams}; exactly one is required), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ */
+export function pnbinom(q, size, options) {
+    const { lowerTail = true, logP = false } = options;
+    const w = which(options);
+    return w.kind === "prob"
+        ? vectorize(q, (v) => pnbinom1(v, size, w.v, lowerTail, logP))
+        : vectorize(q, (v) => pnbinomMu1(v, size, w.v, lowerTail, logP));
+}
+/**
+ * Quantile function of the negative binomial distribution (number of failures before the `size`-th success). Equivalent to R's `qnbinom(p, size, prob, mu, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * The distribution is parameterized by `size` and exactly one of `prob` or `mu`. With `mu`, `size = Infinity` gives the Poisson distribution.
+ *
+ * @throws TypeError unless exactly one of `prob` and `mu` is given.
+ *
+ * @param p - Probability (or log probability with `logP`): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param size - Target number of successes (need not be an integer).
+ * @param options - `prob` or `mu` (see {@link NegBinomialParams}; exactly one is required), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export function qnbinom(p, size, options) {
+    const { lowerTail = true, logP = false } = options;
+    const w = which(options);
+    return w.kind === "prob"
+        ? vectorize(p, (v) => qnbinom1(v, size, w.v, lowerTail, logP))
+        : vectorize(p, (v) => qnbinomMu1(v, size, w.v, lowerTail, logP));
+}

package/dist/distributions/normal.d.ts

@@ -0,0 +1,66 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+/** Options for {@link pnorm} and {@link qnorm}. */
+export interface NormalOptions {
+    /** Mean. Default `0`. */
+    mean?: number;
+    /** Standard deviation. Default `1`. */
+    sd?: number;
+    /** If `true`, probabilities are P[X <= x]; if `false`, P[X > x]. Default `true`. */
+    lowerTail?: boolean;
+    /** If `true`, probabilities are given (to `qnorm`) and returned (from `pnorm`) as log(p). Default `false`. */
+    logP?: boolean;
+}
+/**
+ * Density of the normal distribution. Equivalent to R's `dnorm(x, mean = 0, sd = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - Distribution parameters and output scale.
+ * @param options.mean - Mean. Default `0`.
+ * @param options.sd - Standard deviation. Default `1`.
+ * @param options.log - If `true`, return the log density. Default `false`.
+ * @returns The density (or log density).
+ *
+ * @example
+ * ```ts
+ * dnorm(0);                                  // 0.3989422804014327
+ * dnorm([-1, 0, 1]);                         // [0.24197072451914337, 0.3989422804014327, 0.24197072451914337]
+ * dnorm(1, { mean: 1, sd: 2, log: true });   // -1.612085713764618
+ * ```
+ */
+export declare function dnorm<T extends Vectorizable>(x: T, options?: {
+    mean?: number;
+    sd?: number;
+    log?: boolean;
+}): VectorResult<T>;
+/**
+ * Distribution function of the normal distribution.
+ * Equivalent to R's `pnorm(q, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `mean`, `sd`, `lowerTail` and `logP` (see {@link NormalOptions}).
+ * @returns The probability (or log probability).
+ *
+ * @example
+ * ```ts
+ * pnorm(1.96);                          // 0.9750021048517795
+ * pnorm(1.96, { lowerTail: false });    // 0.024997895148220435
+ * pnorm(new Float64Array([-1, 0, 1]));  // Float64Array [0.15865525393145707, 0.5, 0.8413447460685429]
+ * pnorm(-40, { logP: true });           // -804.6084420137538
+ * ```
+ */
+export declare function pnorm<T extends Vectorizable>(q: T, options?: NormalOptions): VectorResult<T>;
+/**
+ * Quantile function of the normal distribution.
+ * Equivalent to R's `qnorm(p, mean = 0, sd = 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 - `mean`, `sd`, `lowerTail` and `logP` (see {@link NormalOptions}).
+ * @returns The quantile(s).
+ *
+ * @example
+ * ```ts
+ * qnorm(0.975);                         // 1.959963984540054
+ * qnorm(0.05, { mean: 100, sd: 15 });   // 75.32719559572791
+ * ```
+ */
+export declare function qnorm<T extends Vectorizable>(p: T, options?: NormalOptions): VectorResult<T>;

package/dist/distributions/normal.js

@@ -0,0 +1,184 @@
+// Normal distribution function pnorm and quantile function qnorm.
+//
+// The building blocks are ports of xsf (Cephes) erf / erfc / ndtri / ndtri_exp
+// (src/special/). Argument handling (NaN, ±Inf, sd <= 0, lowerTail, logP) is matched to
+// R's output (test/fixtures/). R's source code was not consulted.
+import { erf, erfcxNonNegative } from "../special/erf.js";
+import { ndtri, ndtriExp } from "../special/ndtri.js";
+import { vectorize } from "../internal/vectorize.js";
+const SQRT1_2 = Math.SQRT1_2;
+/**
+ * exp(-a^2 / 2) (a >= 0) multiplied by scale.
+ *
+ * Computing a^2 directly lets its rounding error be amplified by the exponential, reaching a relative error of
+ * 1e-13 around a = 38. Split a = hi + lo (hi on a 1/16 grid so hi^2 is exact) and compute
+ * exp(-hi^2/2) * exp(-lo (a + hi) / 2).
+ * Where the result is subnormal, rounding happens only in the final multiplication.
+ */
+function scaledExpNegHalfSq(a, scale) {
+    const hi = Math.floor(a * 16) / 16;
+    const lo = a - hi;
+    const halfHiSq = (hi * hi) / 2;
+    const m = scale * Math.exp((-lo * (a + hi)) / 2);
+    if (halfHiSq <= 700)
+        return m * Math.exp(-halfHiSq);
+    return m * Math.exp(700 - halfHiSq) * Math.exp(-700);
+}
+/** Lower probability P[Z <= t] of the standard normal (t <= 0) */
+function lowerTailProb(t) {
+    const a = -t;
+    if (a < Math.SQRT2)
+        return 0.5 - 0.5 * erf(a * SQRT1_2);
+    return scaledExpNegHalfSq(a, 0.5 * erfcxNonNegative(a * SQRT1_2));
+}
+/** P[Z <= t] of the standard normal (log if logP). t is not NaN */
+function pnormStd(t, logP) {
+    if (!logP)
+        return t <= 0 ? lowerTailProb(t) : 1 - lowerTailProb(-t);
+    if (t > -1)
+        return Math.log1p(-lowerTailProb(-t));
+    const a = -t;
+    return Math.log(0.5 * erfcxNonNegative(a * SQRT1_2)) - (a * a) / 2;
+}
+function pnorm1(q, mean, sd, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(mean) || Number.isNaN(sd))
+        return NaN;
+    if (!Number.isFinite(q) && mean === q)
+        return NaN; // Inf - Inf
+    const p0 = lowerTail ? (logP ? -Infinity : 0) : logP ? 0 : 1;
+    const p1 = lowerTail ? (logP ? 0 : 1) : logP ? -Infinity : 0;
+    if (sd < 0)
+        return NaN;
+    if (sd === 0)
+        return q < mean ? p0 : p1;
+    const x = (q - mean) / sd;
+    if (!Number.isFinite(x))
+        return q < mean ? p0 : p1;
+    return pnormStd(lowerTail ? x : -x, logP);
+}
+function qnorm1(p, mean, sd, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(mean) || Number.isNaN(sd))
+        return NaN;
+    // Endpoints corresponding to probabilities 0 and 1
+    const left = lowerTail ? -Infinity : Infinity;
+    if (logP) {
+        if (p > 0)
+            return NaN;
+        if (p === 0)
+            return -left;
+        if (p === -Infinity)
+            return left;
+    }
+    else {
+        if (p < 0 || p > 1)
+            return NaN;
+        if (p === 0)
+            return left;
+        if (p === 1)
+            return -left;
+    }
+    if (sd < 0)
+        return NaN;
+    if (sd === 0)
+        return mean;
+    const z = logP ? ndtriLogRefined(p) : ndtri(p);
+    return mean + sd * (lowerTail ? z : -z);
+}
+const SQRT_2_OVER_PI = 0.797884560802865355879892119869;
+/**
+ * ndtriExp with one Newton correction applied only outside the design range of the Cephes approximation.
+ *
+ * The tail approximation of Cephes' ndtri assumes z = sqrt(-2 log p) up to 64 (log p >= -2048). Beyond that
+ * the relative error grows to about 5e-13 (measured at log p = -1e5). So log Φ(x) = y is re-solved using the
+ * logP of pnormStd, which is accurate in the tails as well. The derivative φ(x)/Φ(x) is √(2/π) / erfcx(a/√2),
+ * since Φ(x) = erfcx(a/√2) φ(x) √(π/2) for x = -a < 0. This avoids dividing exp(-a²/2) by itself.
+ */
+function ndtriLogRefined(y) {
+    const x = ndtriExp(y);
+    if (!(y < -2048) || !Number.isFinite(x))
+        return x;
+    const slope = SQRT_2_OVER_PI / erfcxNonNegative(-x * SQRT1_2);
+    const step = (pnormStd(x, true) - y) / slope;
+    // For |x| > 1.3e154, a² in pnormStd overflows; return without correction there
+    return Number.isFinite(step) ? x - step : x;
+}
+const LN_SQRT_2PI = 0.918938533204672741780329736406;
+const INV_SQRT_2PI = 0.398942280401432677939946059934;
+function dnorm1(x, mean, sd, log) {
+    if (Number.isNaN(x) || Number.isNaN(mean) || Number.isNaN(sd))
+        return NaN;
+    if (sd < 0)
+        return NaN;
+    if (!Number.isFinite(sd))
+        return log ? -Infinity : 0;
+    if (!Number.isFinite(x) && mean === x)
+        return NaN; // Inf - Inf
+    if (sd === 0)
+        return x === mean ? Infinity : log ? -Infinity : 0;
+    const z = (x - mean) / sd;
+    if (!Number.isFinite(z))
+        return log ? -Infinity : 0;
+    if (log)
+        return -(LN_SQRT_2PI + 0.5 * z * z + Math.log(sd));
+    // Rounding of z^2 is amplified by the exponential in exp(-z^2/2), so split it as in pnorm
+    return scaledExpNegHalfSq(Math.abs(z), INV_SQRT_2PI / sd);
+}
+/**
+ * Density of the normal distribution. Equivalent to R's `dnorm(x, mean = 0, sd = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - Distribution parameters and output scale.
+ * @param options.mean - Mean. Default `0`.
+ * @param options.sd - Standard deviation. Default `1`.
+ * @param options.log - If `true`, return the log density. Default `false`.
+ * @returns The density (or log density).
+ *
+ * @example
+ * ```ts
+ * dnorm(0);                                  // 0.3989422804014327
+ * dnorm([-1, 0, 1]);                         // [0.24197072451914337, 0.3989422804014327, 0.24197072451914337]
+ * dnorm(1, { mean: 1, sd: 2, log: true });   // -1.612085713764618
+ * ```
+ */
+export function dnorm(x, options = {}) {
+    const { mean = 0, sd = 1, log = false } = options;
+    return vectorize(x, (v) => dnorm1(v, mean, sd, log));
+}
+/**
+ * Distribution function of the normal distribution.
+ * Equivalent to R's `pnorm(q, mean = 0, sd = 1, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `mean`, `sd`, `lowerTail` and `logP` (see {@link NormalOptions}).
+ * @returns The probability (or log probability).
+ *
+ * @example
+ * ```ts
+ * pnorm(1.96);                          // 0.9750021048517795
+ * pnorm(1.96, { lowerTail: false });    // 0.024997895148220435
+ * pnorm(new Float64Array([-1, 0, 1]));  // Float64Array [0.15865525393145707, 0.5, 0.8413447460685429]
+ * pnorm(-40, { logP: true });           // -804.6084420137538
+ * ```
+ */
+export function pnorm(q, options = {}) {
+    const { mean = 0, sd = 1, lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => pnorm1(v, mean, sd, lowerTail, logP));
+}
+/**
+ * Quantile function of the normal distribution.
+ * Equivalent to R's `qnorm(p, mean = 0, sd = 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 - `mean`, `sd`, `lowerTail` and `logP` (see {@link NormalOptions}).
+ * @returns The quantile(s).
+ *
+ * @example
+ * ```ts
+ * qnorm(0.975);                         // 1.959963984540054
+ * qnorm(0.05, { mean: 100, sd: 15 });   // 75.32719559572791
+ * ```
+ */
+export function qnorm(p, options = {}) {
+    const { mean = 0, sd = 1, lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qnorm1(v, mean, sd, lowerTail, logP));
+}

package/dist/distributions/nt.d.ts

@@ -0,0 +1,3 @@
+export declare function dnt1(x: number, df: number, ncp: number, log: boolean): number;
+export declare function pnt1(q: number, df: number, ncp: number, lowerTail: boolean, logP: boolean): number;
+export declare function qnt1(p: number, df: number, ncp: number, lowerTail: boolean, logP: boolean): number;