@numero-uno-jpn/rstats 0.5.0 → 0.6.1

package/dist/distributions/invgamma.js

@@ -0,0 +1,85 @@
+// Inverse gamma distribution dinvgamma / pinvgamma / qinvgamma, with extraDistr's parameters (alpha shape, beta scale).
+//
+// Written for rStats.js (no ported code). X = 1/Y with Y ~ Gamma(alpha, rate = beta), so with z = beta / x
+//   f(x) = f_Gamma(z; alpha, 1) z / x,   P[X <= x] = P[Z >= z],   q(p) = beta / q_Gamma(1 - p; alpha, 1)
+// which keeps the gamma functions' accuracy in both tails. z is formed in double-double and its low part enters to
+// first order (the density and the tails are steep in z when alpha is large).
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0, dt1, quantileBoundaries } from "../internal/dpq.js";
+import { standardizeDD } from "../internal/ddexp.js";
+import { dgamma1, pgamma1, qgamma1 } from "./gamma.js";
+const valid = (alpha, beta) => alpha > 0 && beta > 0 && Number.isFinite(beta);
+// alpha = Inf is taken as the limit (the distribution concentrates at 0), as extraDistr does
+export function dinvgamma1(x, alpha, beta, log) {
+    if (Number.isNaN(x) || !valid(alpha, beta))
+        return NaN;
+    if (x <= 0 || x === Infinity)
+        return d0(log);
+    if (alpha === Infinity)
+        return NaN;
+    const [z, zl] = standardizeDD(beta, 0, x);
+    if (z === Infinity)
+        return d0(log);
+    // d/dz log(f_Gamma(z) z) = alpha / z - 1
+    const c = Number.isFinite(zl) ? (alpha / z - 1) * zl : 0;
+    if (log)
+        return dgamma1(z, alpha, 1, true) + Math.log(z) - Math.log(x) + c;
+    return ((dgamma1(z, alpha, 1, false) * z) / x) * (1 + c);
+}
+export function pinvgamma1(q, alpha, beta, lowerTail, logP) {
+    if (Number.isNaN(q) || !valid(alpha, beta))
+        return NaN;
+    if (q <= 0)
+        return dt0(lowerTail, logP);
+    if (q === Infinity || alpha === Infinity)
+        return dt1(lowerTail, logP);
+    const [z, zl] = standardizeDD(beta, 0, q);
+    const v = pgamma1(z, alpha, 1, !lowerTail, logP);
+    if (!(zl !== 0 && Number.isFinite(zl) && Number.isFinite(z)))
+        return v;
+    // P[Z <= z] grows by f(z) zl, P[Z > z] falls by it
+    const sign = lowerTail ? -1 : 1;
+    if (!logP)
+        return v + sign * dgamma1(z, alpha, 1, false) * zl;
+    // log P + f(z) zl / P, with f / P from the logs (P may underflow)
+    const c = sign * Math.exp(dgamma1(z, alpha, 1, true) - v) * zl;
+    return Number.isFinite(c) ? v + c : v;
+}
+export function qinvgamma1(p, alpha, beta, lowerTail, logP) {
+    if (Number.isNaN(p) || !valid(alpha, beta))
+        return NaN;
+    const b = quantileBoundaries(p, 0, Infinity, lowerTail, logP);
+    if (b !== undefined)
+        return b;
+    if (alpha === Infinity)
+        return 0;
+    return beta / qgamma1(p, alpha, 1, !lowerTail, logP);
+}
+/**
+ * Density of the inverse gamma distribution. Equivalent to `extraDistr::dinvgamma(x, alpha, beta = 1, log = FALSE)`:
+ * f(x) = beta^alpha x^(-alpha-1) exp(-beta/x) / Gamma(alpha).
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param alpha - Shape parameter.
+ * @param options - `beta` (see {@link InvgammaParams}) and `log` (see {@link DensityOptions}).
+ */
+export function dinvgamma(x, alpha, options = {}) {
+    const { beta = 1, log = false } = options;
+    return vectorize(x, (v) => dinvgamma1(v, alpha, beta, log));
+}
+/**
+ * Distribution function of the inverse gamma distribution. Equivalent to
+ * `extraDistr::pinvgamma(q, alpha, beta = 1, lower.tail = TRUE, log.p = FALSE)`.
+ */
+export function pinvgamma(q, alpha, options = {}) {
+    const { beta = 1, lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => pinvgamma1(v, alpha, beta, lowerTail, logP));
+}
+/**
+ * Quantile function of the inverse gamma distribution. Equivalent to
+ * `extraDistr::qinvgamma(p, alpha, beta = 1, lower.tail = TRUE, log.p = FALSE)`.
+ */
+export function qinvgamma(p, alpha, options = {}) {
+    const { beta = 1, lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qinvgamma1(v, alpha, beta, lowerTail, logP));
+}

package/dist/distributions/kumaraswamy.d.ts

@@ -0,0 +1,17 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+export declare function dkumar1(x: number, a: number, b: number, log: boolean): number;
+export declare function pkumar1(q: number, a: number, b: number, lowerTail: boolean, logP: boolean): number;
+export declare function qkumar1(p: number, a: number, b: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Density of the Kumaraswamy distribution. Equivalent to `extraDistr::dkumar(x, a, b, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param a - First shape parameter.
+ * @param b - Second shape parameter.
+ */
+export declare function dkumar<T extends Vectorizable>(x: T, a: number, b: number, options?: DensityOptions): VectorResult<T>;
+/** Distribution function of the Kumaraswamy distribution. Equivalent to `extraDistr::pkumar(q, a, b, lower.tail, log.p)`. */
+export declare function pkumar<T extends Vectorizable>(q: T, a: number, b: number, options?: TailOptions): VectorResult<T>;
+/** Quantile function of the Kumaraswamy distribution. Equivalent to `extraDistr::qkumar(p, a, b, lower.tail, log.p)`. */
+export declare function qkumar<T extends Vectorizable>(p: T, a: number, b: number, options?: TailOptions): VectorResult<T>;

package/dist/distributions/kumaraswamy.js

@@ -0,0 +1,96 @@
+// Kumaraswamy distribution dkumar / pkumar / qkumar (extraDistr's names).
+//
+// Written for rStats.js (no ported code). On [0, 1] with shapes a, b > 0:
+//   f(x) = a b x^(a-1) (1 - x^a)^(b-1),   P[X > x] = (1 - x^a)^b,   q(p) = (1 - (1 - p)^(1/b))^(1/a)
+// 1 - x^a is formed as -expm1(a log x) when x^a is near 1, and the tails as exp / -expm1 of b log(1 - x^a).
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0, dt1, quantileBoundaries } from "../internal/dpq.js";
+import { log1mExp } from "../internal/ddexp.js";
+const valid = (a, b) => a > 0 && b > 0 && Number.isFinite(b);
+// a = Inf is taken as the limit (the distribution concentrates at 1), as extraDistr does
+/** log(1 - x^a) for 0 <= x <= 1 */
+function log1mPow(x, a) {
+    const xa = Math.pow(x, a);
+    return xa < 0.5 ? Math.log1p(-xa) : Math.log(-Math.expm1(a * Math.log(x)));
+}
+/** (1 - x^a)^e for 0 < x < 1: pow of 1 - x^a with the rounding of the subtraction corrected to first order */
+function powOneMinus(x, a, e) {
+    const xa = Math.pow(x, a);
+    if (xa >= 0.5)
+        return Math.pow(-Math.expm1(a * Math.log(x)), e);
+    const hi = 1 - xa;
+    const lo = 1 - hi - xa; // exact remainder (Fast2Sum)
+    return Math.pow(hi, e) * (1 + (e * lo) / hi);
+}
+/** c log(v), 0 when c is 0 */
+const xlog = (c, v) => (c === 0 ? 0 : c * Math.log(v));
+export function dkumar1(x, a, b, log) {
+    if (Number.isNaN(x) || !valid(a, b))
+        return NaN;
+    if (x < 0 || x > 1)
+        return d0(log);
+    if (a === Infinity)
+        return x === 1 ? Infinity : d0(log);
+    const l1 = x === 1 ? -Infinity : log1mPow(x, a);
+    const ld = Math.log(a) + Math.log(b) + xlog(a - 1, x) + (b === 1 ? 0 : (b - 1) * l1);
+    if (log)
+        return ld;
+    // the product keeps the relative accuracy that exp(ld) loses for large |ld|; exp(ld) where it under- or overflows
+    // x^(a-1) as x^a / x (a - 1 itself may round, which x^(a-1) magnifies by |log x|)
+    const xa = Math.pow(x, a);
+    const d = a * b * (a === 1 ? 1 : xa > 1e-290 ? xa / x : Math.pow(x, a - 1)) * (b === 1 || x === 0 ? 1 : powOneMinus(x, a, b - 1));
+    return d > 2.2250738585072014e-308 && d < Infinity ? d : Math.exp(ld);
+}
+export function pkumar1(q, a, b, lowerTail, logP) {
+    if (Number.isNaN(q) || !valid(a, b))
+        return NaN;
+    if (q <= 0)
+        return dt0(lowerTail, logP);
+    if (q >= 1)
+        return dt1(lowerTail, logP);
+    if (a === Infinity)
+        return dt0(lowerTail, logP);
+    const lu = b * log1mPow(q, a); // log P[X > q]
+    if (!lowerTail)
+        return logP ? lu : powOneMinus(q, a, b);
+    if (!logP)
+        return -Math.expm1(lu);
+    // for tiny x^a, P[X <= q] = b x^a (1 + O(b x^a)) whose log survives where 1 - exp(lu) underflows
+    const xa = Math.pow(q, a);
+    if (xa < 1e-20)
+        return Math.log(b) + a * Math.log(q) + Math.log1p((-(b - 1) * xa) / 2);
+    return lu < -Math.LN2 ? Math.log1p(-powOneMinus(q, a, b)) : log1mExp(lu);
+}
+export function qkumar1(p, a, b, lowerTail, logP) {
+    if (Number.isNaN(p) || !valid(a, b))
+        return NaN;
+    const bd = quantileBoundaries(p, 0, 1, lowerTail, logP);
+    if (bd !== undefined)
+        return bd;
+    if (a === Infinity)
+        return 1;
+    // log of the upper probability
+    const lu = lowerTail ? (logP ? log1mExp(p) : Math.log1p(-p)) : logP ? p : Math.log(p);
+    return Math.pow(-Math.expm1(lu / b), 1 / a);
+}
+/**
+ * Density of the Kumaraswamy distribution. Equivalent to `extraDistr::dkumar(x, a, b, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param a - First shape parameter.
+ * @param b - Second shape parameter.
+ */
+export function dkumar(x, a, b, options = {}) {
+    const { log = false } = options;
+    return vectorize(x, (v) => dkumar1(v, a, b, log));
+}
+/** Distribution function of the Kumaraswamy distribution. Equivalent to `extraDistr::pkumar(q, a, b, lower.tail, log.p)`. */
+export function pkumar(q, a, b, options = {}) {
+    const { lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => pkumar1(v, a, b, lowerTail, logP));
+}
+/** Quantile function of the Kumaraswamy distribution. Equivalent to `extraDistr::qkumar(p, a, b, lower.tail, log.p)`. */
+export function qkumar(p, a, b, options = {}) {
+    const { lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qkumar1(v, a, b, lowerTail, logP));
+}

package/dist/distributions/laplace.d.ts

@@ -0,0 +1,23 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+/** Location and scale of the Laplace distribution. */
+export interface LaplaceParams {
+    /** Location. Default `0`. */
+    mu?: number;
+    /** Scale. Default `1`. */
+    sigma?: number;
+}
+export declare function dlaplace1(x: number, mu: number, sigma: number, log: boolean): number;
+export declare function plaplace1(q: number, mu: number, sigma: number, lowerTail: boolean, logP: boolean): number;
+export declare function qlaplace1(p: number, mu: number, sigma: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Density of the Laplace distribution. Equivalent to `extraDistr::dlaplace(x, mu = 0, sigma = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `mu` and `sigma` (see {@link LaplaceParams}) and `log` (see {@link DensityOptions}).
+ */
+export declare function dlaplace<T extends Vectorizable>(x: T, options?: LaplaceParams & DensityOptions): VectorResult<T>;
+/** Distribution function of the Laplace distribution. Equivalent to `extraDistr::plaplace(q, mu = 0, sigma = 1, lower.tail, log.p)`. */
+export declare function plaplace<T extends Vectorizable>(q: T, options?: LaplaceParams & TailOptions): VectorResult<T>;
+/** Quantile function of the Laplace distribution. Equivalent to `extraDistr::qlaplace(p, mu = 0, sigma = 1, lower.tail, log.p)`. */
+export declare function qlaplace<T extends Vectorizable>(p: T, options?: LaplaceParams & TailOptions): VectorResult<T>;

package/dist/distributions/laplace.js

@@ -0,0 +1,69 @@
+// Laplace (double exponential) distribution dlaplace / plaplace / qlaplace (extraDistr's names mu, sigma).
+//
+// Written for rStats.js (no ported code). With z = (x - mu) / sigma formed in double-double and a = |z|:
+//   f(x) = exp(-a) / (2 sigma),   probability of the smaller side exp(-a) / 2,   q(p) = mu + sigma log(2p) for p <= 1/2
+// (and the mirror image above 1/2).
+import { vectorize } from "../internal/vectorize.js";
+import { quantileBoundaries, smallerTail } from "../internal/dpq.js";
+import { expNeg, locationScale, standardizeDD } from "../internal/ddexp.js";
+const valid = (mu, sigma) => !Number.isNaN(mu) && sigma > 0 && Number.isFinite(sigma);
+// an infinite mu is taken as the limit (the distribution moves out to that infinity), as extraDistr does
+export function dlaplace1(x, mu, sigma, log) {
+    if (Number.isNaN(x) || !valid(mu, sigma))
+        return NaN;
+    if (!Number.isFinite(mu))
+        return log ? -Infinity : 0;
+    const z = standardizeDD(x, mu, sigma);
+    const a = z[0] < 0 ? [-z[0], -z[1]] : [z[0], z[1]];
+    if (log)
+        return -a[0] - a[1] - Math.log(2 * sigma);
+    return expNeg(a) / (2 * sigma);
+}
+export function plaplace1(q, mu, sigma, lowerTail, logP) {
+    if (Number.isNaN(q) || !valid(mu, sigma))
+        return NaN;
+    if (!Number.isFinite(mu)) {
+        const lower = mu === Infinity ? 0 : 1;
+        const v = lowerTail ? lower : 1 - lower;
+        return logP ? Math.log(v) : v;
+    }
+    const z = standardizeDD(q, mu, sigma);
+    const a = z[0] < 0 ? [-z[0], -z[1]] : [z[0], z[1]];
+    const half = expNeg(a) / 2; // probability of the smaller side
+    if (lowerTail === z[0] < 0)
+        return logP ? -a[0] - a[1] - Math.LN2 : half;
+    return logP ? Math.log1p(-half) : 1 - half;
+}
+export function qlaplace1(p, mu, sigma, lowerTail, logP) {
+    if (Number.isNaN(p) || !valid(mu, sigma))
+        return NaN;
+    const bd = quantileBoundaries(p, -Infinity, Infinity, lowerTail, logP);
+    if (bd !== undefined)
+        return bd;
+    if (!Number.isFinite(mu))
+        return mu;
+    const { lower, logTarget, linearTarget } = smallerTail(p, lowerTail, logP);
+    // log(2 t) of the smaller tail t (<= 1/2)
+    const l = linearTarget !== undefined ? Math.log(2 * linearTarget) : Math.LN2 + logTarget;
+    return locationScale(mu, sigma, lower ? l : -l);
+}
+/**
+ * Density of the Laplace distribution. Equivalent to `extraDistr::dlaplace(x, mu = 0, sigma = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `mu` and `sigma` (see {@link LaplaceParams}) and `log` (see {@link DensityOptions}).
+ */
+export function dlaplace(x, options = {}) {
+    const { mu = 0, sigma = 1, log = false } = options;
+    return vectorize(x, (v) => dlaplace1(v, mu, sigma, log));
+}
+/** Distribution function of the Laplace distribution. Equivalent to `extraDistr::plaplace(q, mu = 0, sigma = 1, lower.tail, log.p)`. */
+export function plaplace(q, options = {}) {
+    const { mu = 0, sigma = 1, lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => plaplace1(v, mu, sigma, lowerTail, logP));
+}
+/** Quantile function of the Laplace distribution. Equivalent to `extraDistr::qlaplace(p, mu = 0, sigma = 1, lower.tail, log.p)`. */
+export function qlaplace(p, options = {}) {
+    const { mu = 0, sigma = 1, lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qlaplace1(v, mu, sigma, lowerTail, logP));
+}

package/dist/distributions/multinomial.d.ts

@@ -0,0 +1,24 @@
+/** Options for {@link dmultinom}. */
+export interface MultinomialOptions {
+    /** Total number of objects; defaults to the sum of `x` (it must equal it, as in R). */
+    size?: number;
+    /** If `true`, return the log probability. Default `false`. */
+    log?: boolean;
+}
+/**
+ * Probability function of the multinomial distribution. Equivalent to R's
+ * `dmultinom(x, size = NULL, prob, log = FALSE)`.
+ *
+ * @param x - Counts, a vector of K non-negative integers.
+ * @param prob - Category weights, K finite non-negative numbers, not all 0 (divided by their sum).
+ * @param options - `size` and `log` (see {@link MultinomialOptions}).
+ * @returns The probability `N! / (x_1! ... x_K!) prod p_j^x_j` with `N = sum(x)`, or its log.
+ * @throws RangeError if `x` and `prob` differ in length, `x` has a negative or non-integer value, `prob` has a
+ *   negative or non-finite value or no positive value, or `size` differs from the sum of `x`.
+ *
+ * @example
+ * ```ts
+ * dmultinom([1, 2, 1], [0.2, 0.5, 0.3]);  // 0.18000000000000002
+ * ```
+ */
+export declare function dmultinom(x: readonly number[], prob: readonly number[], options?: MultinomialOptions): number;

package/dist/distributions/multinomial.js

@@ -0,0 +1,70 @@
+// Multinomial probability dmultinom.
+//
+// P[X = x] = N! / (x_1! ... x_K!) p_1^x_1 ... p_K^x_K is computed as a product of binomial probabilities,
+//   P[X = x] = prod_k b(x_k; n_k, q_k),  n_k = x_k + ... + x_K,  q_k = p_k / (p_k + ... + p_K),
+// each from Loader's dbinomRawDD with q_k and 1 - q_k = (p_(k+1) + ... + p_K) / (p_k + ... + p_K) formed separately.
+// The sums of the weights are kept in double-double: q_k is raised to the power x_k, so a rounded sum would give an
+// error of x_k ε (1e-9 at x_k = 1e7).
+// Summing lgamma terms instead loses digits to cancellation for large counts.
+import { dbinomRawDD } from "../special/loader.js";
+import { ddAdd, ddDiv } from "../special/dd.js";
+/**
+ * Probability function of the multinomial distribution. Equivalent to R's
+ * `dmultinom(x, size = NULL, prob, log = FALSE)`.
+ *
+ * @param x - Counts, a vector of K non-negative integers.
+ * @param prob - Category weights, K finite non-negative numbers, not all 0 (divided by their sum).
+ * @param options - `size` and `log` (see {@link MultinomialOptions}).
+ * @returns The probability `N! / (x_1! ... x_K!) prod p_j^x_j` with `N = sum(x)`, or its log.
+ * @throws RangeError if `x` and `prob` differ in length, `x` has a negative or non-integer value, `prob` has a
+ *   negative or non-finite value or no positive value, or `size` differs from the sum of `x`.
+ *
+ * @example
+ * ```ts
+ * dmultinom([1, 2, 1], [0.2, 0.5, 0.3]);  // 0.18000000000000002
+ * ```
+ */
+export function dmultinom(x, prob, options = {}) {
+    const log = options.log ?? false;
+    const K = prob.length;
+    if (x.length !== K)
+        throw new RangeError("x and prob must have the same length");
+    if (prob.some((p) => !Number.isFinite(p) || p < 0))
+        throw new RangeError("probabilities must be finite and non-negative");
+    if (!prob.some((p) => p > 0))
+        throw new RangeError("probabilities must not all be 0");
+    if (x.some((v) => !(v >= 0) || !Number.isFinite(v) || v !== Math.round(v)))
+        throw new RangeError("x must be non-negative integers");
+    const N = x.reduce((a, b) => a + b, 0);
+    if (options.size !== undefined && options.size !== N)
+        throw new RangeError("size must equal the sum of x");
+    // A category with probability 0 and a positive count makes the probability 0
+    for (let k = 0; k < K; k++)
+        if (prob[k] === 0 && x[k] > 0)
+            return log ? -Infinity : 0;
+    // Suffix sums of the weights (double-double) and the counts
+    const ps = new Array(K + 1).fill([0, 0]);
+    const ns = new Array(K + 1).fill(0);
+    for (let k = K - 1; k >= 0; k--) {
+        ps[k] = ddAdd(ps[k + 1], [prob[k], 0]);
+        ns[k] = ns[k + 1] + x[k];
+    }
+    let logSum = 0;
+    let prodLin = 1;
+    for (let k = 0; k < K; k++) {
+        if (prob[k] === 0)
+            continue;
+        const rest = ps[k + 1];
+        if (rest[0] === 0)
+            break; // the remaining counts all fall here: probability 1
+        const q = ddDiv([prob[k], 0], ps[k]);
+        const qc = ddDiv(rest, ps[k]);
+        const xk = x[k];
+        const nmx = ns[k + 1];
+        if (log)
+            logSum += dbinomRawDD(xk, nmx, q, qc, true);
+        else
+            prodLin *= dbinomRawDD(xk, nmx, q, qc, false);
+    }
+    return log ? logSum : prodLin;
+}

package/dist/distributions/nbeta.js

@@ -17,6 +17,7 @@ import { invertContinuous } from "../internal/invert.js";
 import { mixtureCdf, mixtureDensity } from "../internal/poissonMixture.js";
 import { ddAdd, ddDiv, ddLog, ddMul, ddMulNum, ddNeg, twoProd, twoSum } from "../special/dd.js";
 import { lbeta, lbetaDD } from "../special/beta.js";
+import { digamma } from "../special/psigamma.js";
 import { betaIncDD } from "../special/incbet.js";
 import { dbinomExponent, dbinomRawDD } from "../special/loader.js";
 import { dbeta1, pbeta1, qbeta1 } from "./beta.js";
@@ -31,29 +32,46 @@ function betaKernel(a, b, xd, xcd) {
         ratioK: tiny ? -1 : 0,
         cdf: (j, lower, log) => betaIncDD(a + j, b, xd, xcd, lower, log),
         inc: (j, log) => {
-            const c = b / (a + b + j);
-            return log ? dbinomRawDD(a + j, b, xd, xcd, true) + Math.log(c) : dbinomRawDD(a + j, b, xd, xcd, false) * c;
+            const [s, corr] = incCorrection(a, b, j, xd);
+            const c = b / (s + b);
+            return log
+                ? dbinomRawDD(s, b, xd, xcd, true) + Math.log(c) + corr
+                : dbinomRawDD(s, b, xd, xcd, false) * c * (1 + corr);
         },
         // e_j / e_{j-1} = x (a + b + j - 1) / (a + j)
         ratio: (j) => ddDiv(ddMul(xs, ddAdd(ab, [j - 1, 0])), twoSum(a, j)),
         incLogDD: (j) => {
             // log e_j = log dbinom(a + j; a + b + j, x) + log(b / (a + b + j))
             // Near subnormal x the binomial-probability helpers break down, so build it from the log of the beta function
-            if (!(xd[0] > 1e-305 && xcd[0] > 1e-305))
-                return betaKernelIncLog(a, b, xd, xcd, j);
-            const { e, logDenom } = dbinomExponent(a + j, b, xd, xcd);
-            return ddAdd([-e[0], -e[1]], [-0.5 * logDenom + Math.log(b / (a + b + j)), 0]);
+            const [s, corr] = incCorrection(a, b, j, xd);
+            if (!(xd[0] > 1e-305 && xcd[0] > 1e-305)) {
+                const l = betaKernelIncLog(s, b, xd, xcd);
+                return typeof l === "number" ? l + corr : ddAdd(l, [corr, 0]);
+            }
+            const { e, logDenom } = dbinomExponent(s, b, xd, xcd);
+            return ddAdd([-e[0], -e[1]], [-0.5 * logDenom + Math.log(b / (s + b)) + corr, 0]);
         },
     };
 }
 /**
- * log e_j in double-double when x (or 1 - x) is near subnormal:
- * log e_j = -log B(a + j, b) - log(a + j) + (a + j) log x + b log(1 - x)
+ * The shape a + j rounded to double, s, and the first-order change in log e_j from s to the exact a + j:
+ * δ ∂log e/∂s with δ the rounding and ∂log e_j/∂s = log x + ψ(s + b) - ψ(s + 1) (e_j = x^s (1 - x)^b / (s B(s, b))).
+ * Far in a tail this derivative is large, and the recurrences carry e_j to every other term, so the rounding of s
+ * would otherwise reach the result in full (as in nchisq.ts)
  */
-function betaKernelIncLog(a, b, xd, xcd, j) {
+function incCorrection(a, b, j, xd) {
+    const [s, delta] = twoSum(a, j);
+    if (delta === 0)
+        return [s, 0];
+    return [s, delta * (Math.log(xd[0]) + xd[1] / xd[0] + digamma(s + b) - digamma(s + 1))];
+}
+/**
+ * log e_j in double-double when x (or 1 - x) is near subnormal, for the shape s = a + j:
+ * log e_j = -log B(s, b) - log(s) + s log x + b log(1 - x)
+ */
+function betaKernelIncLog(s, b, xd, xcd) {
     if (!(xd[0] > 0 && xcd[0] > 0))
         return -Infinity;
-    const s = a + j;
     const l = ddAdd(ddMulNum(ddLog(xd), s), ddMulNum(ddLog(xcd), b));
     return ddAdd(ddAdd(l, ddNeg(lbetaDD(s, b))), [-Math.log(s), 0]);
 }

package/dist/distributions/nchisq.js

@@ -13,7 +13,8 @@ import { invertContinuous } from "../internal/invert.js";
 import { dpoisLogDD, mixtureCdf, mixtureCdfBoth, mixtureDensity } from "../internal/poissonMixture.js";
 import { gammaInc } from "../special/igam.js";
 import { dpoisRaw } from "../special/loader.js";
-import { ddDiv, twoSum } from "../special/dd.js";
+import { ddAdd, ddDiv, twoSum } from "../special/dd.js";
+import { digamma } from "../special/psigamma.js";
 import { dgamma1, qgamma1 } from "./gamma.js";
 function gammaKernel(a, y) {
     // For very small y the ratio y/(a+j) underflows, so keep it scaled by 2^500
@@ -22,12 +23,28 @@ function gammaKernel(a, y) {
     return {
         ratioK: tiny ? -1 : 0,
         cdf: (j, lower, log) => gammaInc(a + j, y, lower, log),
-        inc: (j, log) => dpoisRaw(a + j, y, log),
+        inc: (j, log) => {
+            const [s, corr] = incCorrection(a, j, y);
+            return log ? dpoisRaw(s, y, true) + corr : dpoisRaw(s, y, false) * (1 + corr);
+        },
         // d_j / d_{j-1} = y / (a + j)
         ratio: (j) => ddDiv([ys, 0], twoSum(a, j)),
-        incLogDD: (j) => dpoisLogDD(a + j, y),
+        incLogDD: (j) => {
+            const [s, corr] = incCorrection(a, j, y);
+            return ddAdd(dpoisLogDD(s, y), [corr, 0]);
+        },
     };
 }
+/**
+ * The shape a + j rounded to double, s, and the first-order change in log d_j from s to the exact a + j:
+ * δ ∂log d/∂s with δ the rounding and ∂log dpois(s; y)/∂s = log y - ψ(s + 1). Far in a tail |log y - ψ(s + 1)| is
+ * large (above 1 at s = 1130, y = 331), and since the recurrences carry d_j to every other term, the rounding of
+ * s (1e-13 there) would otherwise reach the result in full
+ */
+function incCorrection(a, j, y) {
+    const [s, delta] = twoSum(a, j);
+    return [s, delta === 0 ? 0 : delta * (Math.log(y) - digamma(s + 1))];
+}
 /** Whether the parameters are valid for the noncentral χ² (R gives NaN for df = Inf or ncp = Inf) */
 function validParams(df, ncp) {
     return df >= 0 && ncp >= 0 && Number.isFinite(df) && Number.isFinite(ncp);

package/dist/distributions/pareto.d.ts

@@ -0,0 +1,23 @@
+import { type Vectorizable, type VectorResult } from "../internal/vectorize.js";
+import { type DensityOptions, type TailOptions } from "../internal/dpq.js";
+/** Shape and scale of the Pareto distribution. */
+export interface ParetoParams {
+    /** Shape. Default `1`. */
+    a?: number;
+    /** Scale (the lower limit of the support). Default `1`. */
+    b?: number;
+}
+export declare function dpareto1(x: number, a: number, b: number, log: boolean): number;
+export declare function ppareto1(q: number, a: number, b: number, lowerTail: boolean, logP: boolean): number;
+export declare function qpareto1(p: number, a: number, b: number, lowerTail: boolean, logP: boolean): number;
+/**
+ * Density of the Pareto distribution. Equivalent to `extraDistr::dpareto(x, a = 1, b = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `a` and `b` (see {@link ParetoParams}) and `log` (see {@link DensityOptions}).
+ */
+export declare function dpareto<T extends Vectorizable>(x: T, options?: ParetoParams & DensityOptions): VectorResult<T>;
+/** Distribution function of the Pareto distribution. Equivalent to `extraDistr::ppareto(q, a = 1, b = 1, lower.tail, log.p)`. */
+export declare function ppareto<T extends Vectorizable>(q: T, options?: ParetoParams & TailOptions): VectorResult<T>;
+/** Quantile function of the Pareto distribution. Equivalent to `extraDistr::qpareto(p, a = 1, b = 1, lower.tail, log.p)`. */
+export declare function qpareto<T extends Vectorizable>(p: T, options?: ParetoParams & TailOptions): VectorResult<T>;

package/dist/distributions/pareto.js

@@ -0,0 +1,76 @@
+// Pareto distribution dpareto / ppareto / qpareto, with extraDistr's parameters (a shape, b scale).
+//
+// Written for rStats.js (no ported code). For x >= b:
+//   f(x) = (a / b) (b / x)^(a+1),   P[X > x] = (b / x)^a,   q(p) = b (1 - p)^(-1/a)
+// r = x / b is formed in double-double and the powers taken with pow, whose rounding does not grow with a (the low
+// part of r enters to first order).
+import { vectorize } from "../internal/vectorize.js";
+import { d0, dt0, dt1, quantileBoundaries } from "../internal/dpq.js";
+import { log1mExp, standardizeDD } from "../internal/ddexp.js";
+const valid = (a, b) => a > 0 && b > 0 && Number.isFinite(b);
+// a = Inf is taken as the limit (the distribution concentrates at b), as extraDistr does
+export function dpareto1(x, a, b, log) {
+    if (Number.isNaN(x) || !valid(a, b))
+        return NaN;
+    if (x < b || x === Infinity)
+        return d0(log);
+    if (a === Infinity)
+        return x === b ? Infinity : d0(log);
+    const [r, rl] = standardizeDD(x, 0, b);
+    const e = Number.isFinite(rl) ? rl / r : 0;
+    if (log)
+        return Math.log(a / b) - (a + 1) * (Math.log(r) + e);
+    const d = ((a / b) * Math.pow(r, -a)) / r;
+    return d > 0 && d < Infinity ? d * (1 - (a + 1) * e) : Math.exp(Math.log(a / b) - (a + 1) * (Math.log(r) + e));
+}
+export function ppareto1(q, a, b, lowerTail, logP) {
+    if (Number.isNaN(q) || !valid(a, b))
+        return NaN;
+    if (q <= b)
+        return dt0(lowerTail, logP);
+    if (q === Infinity || a === Infinity)
+        return dt1(lowerTail, logP);
+    const [r, rl] = standardizeDD(q, 0, b);
+    const e = Number.isFinite(rl) ? rl / r : 0;
+    const lu = -a * (Math.log(r) + e); // log P[X > q]
+    if (!lowerTail) {
+        if (logP)
+            return lu;
+        const u = Math.pow(r, -a);
+        return u > 0 ? u * (1 - a * e) : Math.exp(lu);
+    }
+    if (!logP)
+        return -Math.expm1(lu);
+    return lu < -Math.LN2 ? Math.log1p(-Math.pow(r, -a) * (1 - a * e)) : log1mExp(lu);
+}
+export function qpareto1(p, a, b, lowerTail, logP) {
+    if (Number.isNaN(p) || !valid(a, b))
+        return NaN;
+    const bd = quantileBoundaries(p, b, Infinity, lowerTail, logP);
+    if (bd !== undefined)
+        return bd;
+    if (a === Infinity)
+        return b;
+    const lu = lowerTail ? (logP ? log1mExp(p) : Math.log1p(-p)) : logP ? p : Math.log(p);
+    return b * Math.exp(-lu / a);
+}
+/**
+ * Density of the Pareto distribution. Equivalent to `extraDistr::dpareto(x, a = 1, b = 1, log = FALSE)`.
+ *
+ * @param x - Value(s) at which to evaluate: a number, `number[]` or `Float64Array`. The result has the same shape.
+ * @param options - `a` and `b` (see {@link ParetoParams}) and `log` (see {@link DensityOptions}).
+ */
+export function dpareto(x, options = {}) {
+    const { a = 1, b = 1, log = false } = options;
+    return vectorize(x, (v) => dpareto1(v, a, b, log));
+}
+/** Distribution function of the Pareto distribution. Equivalent to `extraDistr::ppareto(q, a = 1, b = 1, lower.tail, log.p)`. */
+export function ppareto(q, options = {}) {
+    const { a = 1, b = 1, lowerTail = true, logP = false } = options;
+    return vectorize(q, (v) => ppareto1(v, a, b, lowerTail, logP));
+}
+/** Quantile function of the Pareto distribution. Equivalent to `extraDistr::qpareto(p, a = 1, b = 1, lower.tail, log.p)`. */
+export function qpareto(p, options = {}) {
+    const { a = 1, b = 1, lowerTail = true, logP = false } = options;
+    return vectorize(p, (v) => qpareto1(v, a, b, lowerTail, logP));
+}

package/dist/distributions/summary.d.ts

@@ -0,0 +1,25 @@
+/** Result of {@link distSummary}. */
+export interface DistSummary {
+    mean: number;
+    variance: number;
+    sd: number;
+    median: number;
+    mode: number;
+    skewness: number;
+    /** Excess kurtosis (0 for the normal distribution). */
+    kurtosis: number;
+}
+/** Distributions known to {@link distSummary} (the names of their d/p/q/r functions). */
+export type DistName = "norm" | "lnorm" | "unif" | "exp" | "gamma" | "chisq" | "beta" | "t" | "f" | "cauchy" | "weibull" | "logis" | "binom" | "pois" | "geom" | "nbinom" | "hyper" | "invgamma" | "kumar" | "pareto" | "triang" | "laplace" | "arcsine";
+/**
+ * Mean, variance, standard deviation, median, mode, skewness and excess kurtosis of a distribution, given by the
+ * name of its d/p/q/r functions and their parameters (with the same names and defaults; `gamma` takes `rate` or
+ * `scale`, `nbinom` takes `prob` or `mu`). Invalid parameters give NaN throughout.
+ *
+ * @example
+ * ```ts
+ * distSummary("gamma", { shape: 2.5, rate: 2 }); // { mean: 1.25, variance: 0.625, ..., mode: 0.75, kurtosis: 2.4 }
+ * distSummary("binom", { size: 9, prob: 0.5 }).mode; // 5 (4 and 5 are equally likely: the larger)
+ * ```
+ */
+export declare function distSummary(distribution: DistName, params?: Record<string, number | undefined>): DistSummary;