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

package/dist/distributions/hypergeometric.js

@@ -0,0 +1,234 @@
+// Hypergeometric distribution dhyper / phyper / qhyper (same arguments as R: k balls drawn from m white and n black).
+//
+// Probabilities use Loader's (2000) decomposition into binomial probabilities:
+//   p(x) = b(x; m, p) b(k - x; n, p) / b(k; m + n, p),   p = k / (m + n)
+// The exponents of the three binomial probabilities are added and subtracted in double-double before taking exp.
+// The distribution function sums the tail far from the mean directly as p(x) × Σ (products of ratios of adjacent
+// probabilities) (products and sums in double-double). Quantiles use an integer search on the distribution function.
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0, dt1, quantileBoundaries } from "../internal/dpq.js";
+import { discreteQuantile } from "../internal/discrete.js";
+import { nonInt, roundHalfEven } from "../internal/integer.js";
+import { bd0dd, dbinomExponent } from "../special/loader.js";
+import { ddAdd, ddDiv, ddLog, ddMul, ddNeg, ddSub, twoProd } from "../special/dd.js";
+import { qnorm } from "./normal.js";
+/**
+ * Binomial probability b(x; x + nmx, p) as an ExpForm (0 <= x, 0 <= nmx, 0 < p < 1).
+ * At the ends (x = 0 or nmx = 0), q^n / p^n is represented by the exponent alone.
+ */
+function binomForm(x, nmx, p, q) {
+    if (x === 0 && nmx === 0)
+        return { e: [0, 0], logDenom: 0 };
+    if (x === 0 || nmx === 0) {
+        // q^n (x = 0) or p^n (nmx = 0)
+        const n = x + nmx;
+        const [a, b] = x === 0 ? [q, p] : [p, q];
+        // When the base is close to 1 (the other side b is small), avoid cancellation with n log a = -bd0(n, n a) - n b
+        const e = b[0] < 0.1 ? ddAdd(bd0dd(n, ddMul([n, 0], a)), ddMul([n, 0], b)) : ddNeg(ddMul([n, 0], ddLog(a)));
+        return { e, logDenom: 0 };
+    }
+    return dbinomExponent(x, nmx, p, q);
+}
+/** ExpForm of p(x) (x an integer in the support, 0 < k < m + n) */
+function hyperForm(x, m, n, k) {
+    const N = m + n;
+    const p = ddDiv([k, 0], [N, 0]);
+    const q = ddDiv([N - k, 0], [N, 0]);
+    const f1 = binomForm(x, m - x, p, q);
+    const f2 = binomForm(k - x, n - k + x, p, q);
+    const f3 = binomForm(k, N - k, p, q);
+    return {
+        e: ddSub(ddAdd(f1.e, f2.e), f3.e),
+        logDenom: f1.logDenom + f2.logDenom - f3.logDenom,
+    };
+}
+/** exp(-e) / sqrt(exp(logDenom)) × s. Rounding happens once at the end even for results near subnormal */
+function evalForm(f, s) {
+    const [eh, el] = f.e;
+    const scale = s * Math.exp(-0.5 * f.logDenom);
+    if (eh < 700)
+        return Math.exp(-eh) * (1 - el) * scale;
+    return Math.exp(700 - eh) * (1 - el) * scale * Math.exp(-700);
+}
+function logForm(f) {
+    return -f.e[0] - f.e[1] - 0.5 * f.logDenom;
+}
+/** Support [lo, hi] */
+function support(m, n, k) {
+    return [Math.max(0, k - n), Math.min(k, m)];
+}
+export function dhyper1(x, m, n, k, log) {
+    if ([x, m, n, k].some(Number.isNaN))
+        return NaN;
+    if (![m, n, k].every(Number.isFinite) || nonInt(m) || nonInt(n) || nonInt(k))
+        return NaN;
+    m = roundHalfEven(m);
+    n = roundHalfEven(n);
+    k = roundHalfEven(k);
+    if (m < 0 || n < 0 || k < 0 || k > m + n)
+        return NaN;
+    if (nonInt(x))
+        return d0(log);
+    x = roundHalfEven(x);
+    const [lo, hi] = support(m, n, k);
+    if (x < lo || x > hi)
+        return d0(log);
+    if (k === 0 || k === m + n)
+        return log ? 0 : 1;
+    const f = hyperForm(x, m, n, k);
+    return log ? logForm(f) : evalForm(f, 1);
+}
+/** a b / (c d) in double-double (a..d integers) */
+function ratio(a, b, c, d) {
+    return ddDiv(twoProd(a, b), twoProd(c, d));
+}
+/**
+ * Sum of the tail far from the mean. If lower, P[X <= x] = p(x) Σ_{j>=0} p(x-j)/p(x);
+ * otherwise P[X >= x] = p(x) Σ p(x+j)/p(x). Returns the sum S = Σ p(x∓j)/p(x).
+ */
+function tailSum(x, m, n, k, lower, lo, hi) {
+    let t = [1, 0];
+    let s = [1, 0];
+    let y = x;
+    for (;;) {
+        if (lower ? y <= lo : y >= hi)
+            break;
+        // Ratio p(y-1)/p(y) = y (n - k + y) / ((m - y + 1)(k - y + 1))
+        //    p(y+1)/p(y) = (m - y)(k - y) / ((y + 1)(n - k + y + 1))
+        const r = lower ? ratio(y, n - k + y, m - y + 1, k - y + 1) : ratio(m - y, k - y, y + 1, n - k + y + 1);
+        t = ddMul(t, r);
+        s = ddAdd(s, t);
+        y += lower ? -1 : 1;
+        // Moving away from the mean, the ratio decreases monotonically. The remaining sum is bounded by t r / (1 - r)
+        const rr = r[0];
+        if (rr < 1 && (t[0] * rr) / (1 - rr) < s[0] * 2 ** -60)
+            break;
+    }
+    return s[0] + s[1];
+}
+/** P[X <= x] (lowerTail) / P[X > x] at an integer x inside the support (lo <= x < hi) */
+function phyperRaw(x, m, n, k, lowerTail, logP) {
+    const [lo, hi] = support(m, n, k);
+    const N = m + n;
+    // Below the mean k m / N sum the lower tail directly; otherwise the upper tail P[X >= x + 1]
+    let lowerSide = x * N < k * m;
+    let tail = directTail(x, m, n, k, lowerSide, lo, hi);
+    if (tail.value > 0.5) {
+        // When the mean is near an end of the support, even the side far from the mean can exceed 1/2. Sum the other
+        // side directly too and use the smaller (so that the log of a value near 1 is formed from 1 - (other side))
+        const other = directTail(x, m, n, k, !lowerSide, lo, hi);
+        if (other.value < tail.value) {
+            tail = other;
+            lowerSide = !lowerSide;
+        }
+    }
+    if (lowerSide === lowerTail) {
+        if (!logP)
+            return tail.value;
+        return tail.value > 1e-300 ? Math.log(tail.value) : logForm(tail.form) + Math.log(tail.sum);
+    }
+    return logP ? Math.log1p(-tail.value) : 1 - tail.value;
+}
+/** P[X <= x] (lowerSide) or P[X >= x + 1], computed directly as the probability at the tail's end × the sum of ratios */
+function directTail(x, m, n, k, lowerSide, lo, hi) {
+    const start = lowerSide ? x : x + 1;
+    const form = hyperForm(start, m, n, k);
+    const sum = tailSum(start, m, n, k, lowerSide, lo, hi);
+    return { form, sum, value: evalForm(form, sum) };
+}
+/** Check and round the parameters of phyper / qhyper. undefined if invalid */
+function hyperParams(m, n, k) {
+    if (![m, n, k].every(Number.isFinite))
+        return undefined;
+    m = roundHalfEven(m);
+    n = roundHalfEven(n);
+    k = roundHalfEven(k);
+    if (m < 0 || n < 0 || k < 0 || k > m + n)
+        return undefined;
+    return [m, n, k];
+}
+export function phyper1(q, m, n, k, lowerTail, logP) {
+    if ([q, m, n, k].some(Number.isNaN))
+        return NaN;
+    const params = hyperParams(m, n, k);
+    if (params === undefined)
+        return NaN;
+    [m, n, k] = params;
+    const x = Math.floor(q + 1e-7);
+    const [lo, hi] = support(m, n, k);
+    if (x < lo)
+        return dt0(lowerTail, logP);
+    if (x >= hi)
+        return dt1(lowerTail, logP);
+    return phyperRaw(x, m, n, k, lowerTail, logP);
+}
+export function qhyper1(p, m, n, k, lowerTail, logP) {
+    if ([p, m, n, k].some(Number.isNaN))
+        return NaN;
+    const params = hyperParams(m, n, k);
+    if (params === undefined)
+        return NaN;
+    [m, n, k] = params;
+    const [lo, hi] = support(m, n, k);
+    const b = quantileBoundaries(p, lo, hi, lowerTail, logP);
+    if (b !== undefined)
+        return b;
+    if (lo === hi)
+        return lo;
+    const N = m + n;
+    const mu = (k * m) / N;
+    const sigma = Math.sqrt((((k * m) / N) * (n / N) * (N - k)) / Math.max(N - 1, 1));
+    const z = qnorm(p, { lowerTail, logP });
+    const y0 = mu + sigma * z;
+    return discreteQuantile({
+        p,
+        lowerTail,
+        logP,
+        cdf: (y, l, lg) => (y < lo ? dt0(l, lg) : y >= hi ? dt1(l, lg) : phyperRaw(y, m, n, k, l, lg)),
+        y0: Number.isFinite(y0) ? y0 : mu,
+        lo,
+        hi,
+    });
+}
+/**
+ * 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 function dhyper(x, m, n, k, options = {}) {
+    const log = options.log ?? false;
+    return vectorize(x, (v) => dhyper1(v, m, n, k, log));
+}
+/**
+ * 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 function phyper(q, m, n, k, options = {}) {
+    const { lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => phyper1(v, m, n, k, lowerTail, logP));
+}
+/**
+ * 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 function qhyper(p, m, n, k, options = {}) {
+    const { lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qhyper1(v, m, n, k, lowerTail, logP));
+}

package/dist/distributions/logistic.d.ts

@@ -0,0 +1,36 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+/** Location and scale parameters, used by the logistic and Cauchy distributions. */
+export interface LocationScaleParams {
+    /** Location. Default `0`. */
+    location?: number;
+    /** Scale. Default `1`. */
+    scale?: number;
+}
+export declare function dlogis1(x: number, location: number, scale: number, log: boolean): number;
+export declare function plogis1(q: number, location: number, scale: number, lowerTail: boolean, logP: boolean): number;
+export declare function qlogis1(p: number, location: number, scale: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Density of the logistic distribution. Equivalent to R's `dlogis(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 dlogis<T extends Vectorizable>(x: T, options?: LocationScaleParams & DensityOptions): VectorResult<T>;
+/**
+ * Distribution function of the logistic distribution. Equivalent to R's `plogis(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 plogis<T extends Vectorizable>(q: T, options?: LocationScaleParams & TailOptions): VectorResult<T>;
+/**
+ * Quantile function of the logistic distribution. Equivalent to R's `qlogis(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 qlogis<T extends Vectorizable>(p: T, options?: LocationScaleParams & TailOptions): VectorResult<T>;

package/dist/distributions/logistic.js

@@ -0,0 +1,94 @@
+// Logistic distribution dlogis / plogis / qlogis.
+//
+// With z = (x - location) / scale, a = |z|, e = exp(-a),
+//   f(x) = e / (scale (1 + e)^2), probability of the larger side 1 / (1 + e), of the smaller side e / (1 + e)
+// z is formed in double-double (the relative error of exp(-a) equals the absolute error of a).
+// Quantiles compute logit(p) = log(p / (1 - p)) in a cancellation-free form.
+import { vectorize } from "../internal/vectorize.js";
+import { quantileBoundaries } from "../internal/dpq.js";
+import { expNeg, locationScale, log1mExp, standardizeDD } from "../internal/ddexp.js";
+export function dlogis1(x, location, scale, log) {
+    if (Number.isNaN(x) || Number.isNaN(location) || Number.isNaN(scale))
+        return NaN;
+    if (!(scale > 0))
+        return NaN;
+    const z = standardizeDD(x, location, scale);
+    if (Number.isNaN(z[0]))
+        return NaN;
+    const a = z[0] < 0 ? [-z[0], -z[1]] : [z[0], z[1]];
+    const e = expNeg(a);
+    if (log)
+        return -a[0] - a[1] - Math.log(scale) - 2 * Math.log1p(e);
+    return e / (scale * (1 + e) * (1 + e));
+}
+export function plogis1(q, location, scale, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(location) || Number.isNaN(scale))
+        return NaN;
+    if (!(scale > 0))
+        return NaN;
+    const z = standardizeDD(q, location, scale);
+    if (Number.isNaN(z[0]))
+        return NaN;
+    const a = z[0] < 0 ? [-z[0], -z[1]] : [z[0], z[1]];
+    const e = expNeg(a);
+    // The lower probability is the larger side when z >= 0
+    const big = lowerTail === z[0] >= 0;
+    if (big)
+        return logP ? -Math.log1p(e) : 1 / (1 + e);
+    return logP ? -a[0] - a[1] - Math.log1p(e) : e / (1 + e);
+}
+/** logit(p) = log(p / (1 - p)). p is a log if logP */
+function logit(p, logP) {
+    if (logP)
+        return p - log1mExp(p);
+    if (p < 0.25)
+        return Math.log(p / (1 - p));
+    // 2p - 1 is exact. Avoids cancellation in log near 1/2
+    return Math.log1p((2 * p - 1) / (1 - p));
+}
+export function qlogis1(p, location, scale, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(location) || Number.isNaN(scale))
+        return NaN;
+    const b = quantileBoundaries(p, -Infinity, Infinity, lowerTail, logP);
+    if (b !== undefined)
+        return b;
+    if (scale < 0)
+        return NaN;
+    if (scale === 0)
+        return location;
+    const l = logit(p, logP);
+    return locationScale(location, scale, lowerTail ? l : -l);
+}
+/**
+ * Density of the logistic distribution. Equivalent to R's `dlogis(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 dlogis(x, options = {}) {
+    const { location = 0, scale = 1, log = false } = options;
+    return vectorize(x, (v) => dlogis1(v, location, scale, log));
+}
+/**
+ * Distribution function of the logistic distribution. Equivalent to R's `plogis(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 plogis(q, options = {}) {
+    const { location = 0, scale = 1, lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => plogis1(v, location, scale, lowerTail, logP));
+}
+/**
+ * Quantile function of the logistic distribution. Equivalent to R's `qlogis(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 qlogis(p, options = {}) {
+    const { location = 0, scale = 1, lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qlogis1(v, location, scale, lowerTail, logP));
+}

package/dist/distributions/lognormal.d.ts

@@ -0,0 +1,39 @@
+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";
+/** Parameters of the log-normal distribution (mean and standard deviation on the log scale). */
+export interface LognormalParams {
+    /** Mean of the distribution on the log scale. Default `0`. */
+    meanlog?: number;
+    /** Standard deviation of the distribution on the log scale. Default `1`. */
+    sdlog?: number;
+}
+/** P[Z <= t] of the standard normal. t is double-double (finite) */
+export declare function pnormDD(t: DD, logP: boolean): number;
+export declare function dlnorm1(x: number, meanlog: number, sdlog: number, log: boolean): number;
+export declare function plnorm1(q: number, meanlog: number, sdlog: number, lowerTail: boolean, logP: boolean): number;
+export declare function qlnorm1(p: number, meanlog: number, sdlog: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Density of the log-normal distribution. Equivalent to R's `dlnorm(x, meanlog = 0, sdlog = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `meanlog` and `sdlog` (see {@link LognormalParams}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export declare function dlnorm<T extends Vectorizable>(x: T, options?: LognormalParams & DensityOptions): VectorResult<T>;
+/**
+ * Distribution function of the log-normal distribution. Equivalent to R's `plnorm(q, meanlog = 0, sdlog = 1, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `meanlog` and `sdlog` (see {@link LognormalParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ */
+export declare function plnorm<T extends Vectorizable>(q: T, options?: LognormalParams & TailOptions): VectorResult<T>;
+/**
+ * Quantile function of the log-normal distribution. Equivalent to R's `qlnorm(p, meanlog = 0, sdlog = 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 - `meanlog` and `sdlog` (see {@link LognormalParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export declare function qlnorm<T extends Vectorizable>(p: T, options?: LognormalParams & TailOptions): VectorResult<T>;

package/dist/distributions/lognormal.js

@@ -0,0 +1,158 @@
+// Log-normal distribution dlnorm / plnorm / qlnorm.
+//
+// log X ~ N(meanlog, sdlog^2). z = (log x - meanlog) / sdlog is formed in double-double, and z^2 in
+// exp(-z^2/2) is also computed in double-double (for large |log x|, the rounding of log x becomes an absolute
+// error in z^2/2 and hence a relative error in the density and tail probabilities).
+// Tail probabilities use Φ(-a) = erfcx(a/√2) exp(-a^2/2) / 2 (xsf's erfcx, src/special/erf.ts).
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0 } from "../internal/dpq.js";
+import { expNeg, mulDD } from "../internal/ddexp.js";
+import { ddAdd, ddDiv, ddLog, ddMul, ddSub, twoSum } from "../special/dd.js";
+import { erfcxNonNegative } from "../special/erf.js";
+import { pnorm, qnorm } from "./normal.js";
+const LN_SQRT_2PI = 0.918938533204672741780329736406;
+const INV_SQRT_2PI = 0.398942280401432677939946059934;
+/** z = (log x - meanlog) / sdlog (x > 0, finite parameters, sdlog > 0) */
+function zOf(x, meanlog, sdlog) {
+    const d = ddSub(ddLog([x, 0]), [meanlog, 0]);
+    if (sdlog === 1)
+        return d;
+    const hi = d[0] / sdlog;
+    return Number.isFinite(hi) && Math.abs(hi) < 1e300 ? ddDiv(d, [sdlog, 0]) : [hi, 0];
+}
+/** z^2 / 2 in double-double */
+function halfSquare(z) {
+    if (Math.abs(z[0]) > 1e150)
+        return [(z[0] * z[0]) / 2, 0];
+    const s = ddMul(z, z);
+    return [s[0] / 2, s[1] / 2];
+}
+/** P[Z <= t] of the standard normal. t is double-double (finite) */
+export function pnormDD(t, logP) {
+    if (t[0] > -Math.SQRT2) {
+        if (t[0] < Math.SQRT2)
+            return pnorm(t[0] + t[1], { logP });
+        // Side close to 1: 1 - Φ(-t)
+        const other = smallTail(t[0], [t[0], t[1]], false);
+        return logP ? Math.log1p(-other) : 1 - other;
+    }
+    return smallTail(-t[0], [-t[0], -t[1]], logP);
+}
+/** Φ(-a) (a >= √2) */
+function smallTail(a, ad, logP) {
+    const c = 0.5 * erfcxNonNegative(a * Math.SQRT1_2);
+    const h = halfSquare(ad);
+    if (logP)
+        return Math.log(c) - h[0] - h[1];
+    return c * expNeg(h);
+}
+const SQRT_2PI = 2.506628274631000502415765284811;
+/**
+ * Attach a double-double low-order term to the standard normal quantile z0 (the double value from qnorm).
+ * In exp(meanlog + sdlog z) the rounding of z (1e-16 relative) is amplified sdlog |z| times, so compute one
+ * Newton correction δ from the residual of the distribution function and set z = z0 + δ.
+ * In the tails use φ(s) / Φ(s) = 1 / (√(2π) c) (c = erfcx(|s|/√2) / 2) to avoid dividing probabilities.
+ */
+function refineStdQuantile(z0, p, lowerTail, logP) {
+    // s is the point corresponding to the probability p on that side (P[Z <= s] = p)
+    const s = lowerTail ? z0 : -z0;
+    let delta;
+    // Residual r = log(Φ(-a) / target) = log c - a^2/2 - log target. Subtract the large terms from each other first
+    const residual = (c, h, lt) => -h[0] - lt[0] + (-h[1] - lt[1]) + Math.log(c);
+    if (s <= -Math.SQRT2) {
+        const c = 0.5 * erfcxNonNegative(-s * Math.SQRT1_2);
+        const lt = logP ? [p, 0] : ddLog([p, 0]);
+        delta = -residual(c, halfSquare([-s, 0]), lt) * SQRT_2PI * c;
+    }
+    else if (s >= Math.SQRT2) {
+        // Measure the residual with the other side G = P[Z > s] (1 - p is exact for p >= 1/2)
+        const c = 0.5 * erfcxNonNegative(s * Math.SQRT1_2);
+        const target = logP ? -Math.expm1(p) : 1 - p;
+        delta = residual(c, halfSquare([s, 0]), ddLog([target, 0])) * SQRT_2PI * c;
+    }
+    else {
+        const F = pnorm(s);
+        const phi = Math.exp((-s * s) / 2) / SQRT_2PI;
+        delta = ((logP ? Math.exp(p) : p) - F) / phi;
+    }
+    if (!Number.isFinite(delta))
+        return [z0, 0];
+    return twoSum(z0, lowerTail ? delta : -delta);
+}
+export function dlnorm1(x, meanlog, sdlog, log) {
+    if (Number.isNaN(x) || Number.isNaN(meanlog) || Number.isNaN(sdlog))
+        return NaN;
+    if (sdlog < 0)
+        return NaN;
+    if (x <= 0)
+        return d0(log);
+    if (sdlog === 0)
+        return Math.log(x) === meanlog ? Infinity : d0(log);
+    if (!Number.isFinite(x) || !Number.isFinite(meanlog) || !Number.isFinite(sdlog)) {
+        const y = (Math.log(x) - meanlog) / sdlog;
+        return Number.isNaN(y) ? NaN : d0(log);
+    }
+    const z = zOf(x, meanlog, sdlog);
+    const h = halfSquare(z);
+    if (log)
+        return -(LN_SQRT_2PI + h[0] + h[1] + Math.log(sdlog) + Math.log(x));
+    return (INV_SQRT_2PI * expNeg(h)) / sdlog / x;
+}
+export function plnorm1(q, meanlog, sdlog, lowerTail, logP) {
+    if (Number.isNaN(q) || Number.isNaN(meanlog) || Number.isNaN(sdlog))
+        return NaN;
+    if (sdlog < 0)
+        return NaN;
+    if (q <= 0)
+        return dt0(lowerTail, logP);
+    if (sdlog === 0 || !Number.isFinite(q) || !Number.isFinite(meanlog) || !Number.isFinite(sdlog)) {
+        return pnorm(Math.log(q), { mean: meanlog, sd: sdlog, lowerTail, logP });
+    }
+    const z = zOf(q, meanlog, sdlog);
+    return pnormDD(lowerTail ? z : [-z[0], -z[1]], logP);
+}
+export function qlnorm1(p, meanlog, sdlog, lowerTail, logP) {
+    if (Number.isNaN(p) || Number.isNaN(meanlog) || Number.isNaN(sdlog))
+        return NaN;
+    const z = qnorm(p, { lowerTail, logP });
+    if (!Number.isFinite(z) || !(sdlog > 0) || !Number.isFinite(sdlog) || !Number.isFinite(meanlog)) {
+        return Math.exp(qnorm(p, { mean: meanlog, sd: sdlog, lowerTail, logP }));
+    }
+    // exp(meanlog + sdlog z). Form the exponent in double-double and apply the low-order term to first order
+    const zd = refineStdQuantile(z, p, lowerTail, logP);
+    const e = ddAdd(ddAdd(mulDD(sdlog, zd[0]), [sdlog * zd[1], 0]), [meanlog, 0]);
+    return Math.exp(e[0]) * (1 + e[1]);
+}
+/**
+ * Density of the log-normal distribution. Equivalent to R's `dlnorm(x, meanlog = 0, sdlog = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `meanlog` and `sdlog` (see {@link LognormalParams}) and `log` (see {@link DensityOptions}).
+ * @returns The density (or log density).
+ */
+export function dlnorm(x, options = {}) {
+    const { meanlog = 0, sdlog = 1, log = false } = options;
+    return vectorize(x, (v) => dlnorm1(v, meanlog, sdlog, log));
+}
+/**
+ * Distribution function of the log-normal distribution. Equivalent to R's `plnorm(q, meanlog = 0, sdlog = 1, lower.tail = TRUE, log.p = FALSE)`.
+ *
+ * @param q - Quantile(s): a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `meanlog` and `sdlog` (see {@link LognormalParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The probability (or log probability).
+ */
+export function plnorm(q, options = {}) {
+    const { meanlog = 0, sdlog = 1, lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => plnorm1(v, meanlog, sdlog, lowerTail, logP));
+}
+/**
+ * Quantile function of the log-normal distribution. Equivalent to R's `qlnorm(p, meanlog = 0, sdlog = 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 - `meanlog` and `sdlog` (see {@link LognormalParams}), `lowerTail` and `logP` (see {@link TailOptions}).
+ * @returns The quantile(s).
+ */
+export function qlnorm(p, options = {}) {
+    const { meanlog = 0, sdlog = 1, lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qlnorm1(v, meanlog, sdlog, lowerTail, logP));
+}

package/dist/distributions/nbeta.d.ts

@@ -0,0 +1,7 @@
+export declare function dnbeta1(x: number, a: number, b: number, ncp: number, log: boolean): number;
+export declare function pnbeta1(q: number, a: number, b: number, ncp: number, lowerTail: boolean, logP: boolean): number;
+export declare function qnbeta1(p: number, a: number, b: number, ncp: number, lowerTail: boolean, logP: boolean): number;
+export declare function pnfRaw(q: number, m: number, n: number, ncp: number, lower: boolean, log: boolean): number;
+export declare function dnf1(x: number, m: number, n: number, ncp: number, log: boolean): number;
+export declare function pnf1(q: number, m: number, n: number, ncp: number, lowerTail: boolean, logP: boolean): number;
+export declare function qnf1(p: number, m: number, n: number, ncp: number, lowerTail: boolean, logP: boolean): number;