@numero-uno-jpn/rstats 0.5.0 → 0.6.1

package/dist/htest/cor.js

@@ -13,7 +13,8 @@
 // - Pairs containing NaN are dropped (Inf is kept). Pearson needs at least 3 pairs, Kendall and Spearman at least 2
 // - Kendall's exact method is the default when n < 50 and there are no ties. Even with exact = true, ties force the normal approximation
 // - Spearman's exact method (AS 89) is the default when n <= 1290 and there are no ties (off by one from "n < 1290" in R's help).
-//   Within AS 89, n <= 9 is enumerated exactly and n >= 10 uses the Edgeworth series. With ties, the t approximation is used
+//   Within AS 89, n <= 9 is enumerated exactly and n >= 10 uses the Edgeworth series (this n <= 9 switch follows
+//   R's behaviour). With ties, the t approximation is used
 // - continuity only affects the approximations. For Kendall it moves S one step towards 0. For Spearman it
 //   replaces rho with (rho + 6 / (n^3 - n)) / (1 + 6 / (n^3 - n)) (regardless of sign or alternative; R's behaviour)
 // - When the correlation is undefined (constant data), the statistic, p-value, estimate and interval are NaN. Kendall's
@@ -86,7 +87,7 @@ function scaledDeviations(x) {
     return d.map((v) => [v[0] * f, v[1] * f]);
 }
 /** Pearson's correlation coefficient in double-double (so 1 - r is computed without cancellation near perfect correlation) */
-function pearsonDD(x, y) {
+export function pearsonDD(x, y) {
     const n = x.length;
     if (n < 2)
         return [NaN, 0];
@@ -137,7 +138,7 @@ function pFromZ(z, alternative) {
     return 2 * Math.min(pnorm(z), pnorm(z, { lowerTail: false }));
 }
 /** Count concordant and discordant pairs (O(n^2)). Two Infs are tied */
-function kendall(x, y) {
+export function kendall(x, y) {
     const n = x.length;
     let s = 0;
     for (let i = 0; i < n; i++) {

package/dist/htest/core/ansari.d.ts

@@ -0,0 +1,18 @@
+/**
+ * P(AB <= q) (lowerTail) or P(AB > q) for the Ansari-Bradley statistic with sample sizes m and n, without ties.
+ *
+ * @param q - Value of the statistic.
+ * @param m - Size of the first sample.
+ * @param n - Size of the second sample.
+ * @param lowerTail - `true` for P(AB <= q), `false` for P(AB > q).
+ */
+export declare function pansariExact(q: number, m: number, n: number, lowerTail?: boolean): number;
+/**
+ * P(AB = x) for the Ansari-Bradley statistic with sample sizes m and n, without ties.
+ */
+export declare function dansariExact(x: number, m: number, n: number): number;
+/**
+ * The smallest q with P(AB <= q) >= p (quantile of the Ansari-Bradley statistic), without ties. A relative slack of
+ * 64 ε on p keeps p = P(AB <= q) itself from being missed by rounding.
+ */
+export declare function qansariExact(p: number, m: number, n: number): number;

package/dist/htest/core/ansari.js

@@ -0,0 +1,121 @@
+// Exact null distribution of the Ansari-Bradley statistic, for ansari.test.
+//
+// Written for rStats.js from the definition (Ansari and Bradley, Annals of Mathematical Statistics 31, 1960; no
+// ported code). The N = m + n pooled observations get the scores a_i = min(i, N + 1 - i) by rank, and the statistic
+// is the sum of the scores of the first sample. Without ties every set of m ranks is equally likely, so the
+// distribution follows from choosing a random m-subset position by position: at position t with r picks left among
+// N - t + 1 positions, the position is picked with probability r / (N - t + 1). The probabilities are kept directly
+// (counts overflow: C(100, 50) = 1e29), and tail probabilities are sums of positive terms.
+const cache = new Map();
+function ansariDist(m, n) {
+    const key = `${m},${n}`;
+    const hit = cache.get(key);
+    if (hit !== undefined)
+        return hit;
+    const N = m + n;
+    const scores = [];
+    for (let i = 1; i <= N; i++)
+        scores.push(Math.min(i, N + 1 - i));
+    const maxSum = scores.reduce((a, b) => a + b, 0);
+    // P[r][s]: probability of r picks so far with score sum s (rows r = 0..m)
+    let P = Array.from({ length: m + 1 }, () => new Float64Array(maxSum + 1));
+    P[0][0] = 1;
+    for (let t = 0; t < N; t++) {
+        const left = N - t; // positions not yet decided, including this one
+        const a = scores[t];
+        const Q = Array.from({ length: m + 1 }, () => new Float64Array(maxSum + 1));
+        for (let r = 0; r <= m; r++) {
+            const row = P[r];
+            const need = m - r;
+            if (need > left)
+                continue;
+            const pick = need / left;
+            for (let s = 0; s <= maxSum; s++) {
+                const v = row[s];
+                if (v === 0)
+                    continue;
+                if (need > 0)
+                    Q[r + 1][s + a] += v * pick;
+                if (need < left)
+                    Q[r][s] += v * (1 - pick);
+            }
+        }
+        P = Q;
+    }
+    const full = P[m];
+    let lo = 0;
+    while (lo < full.length && full[lo] === 0)
+        lo++;
+    let hi = full.length - 1;
+    while (hi > lo && full[hi] === 0)
+        hi--;
+    const dist = { min: lo, probs: full.slice(lo, hi + 1) };
+    cache.set(key, dist);
+    return dist;
+}
+/**
+ * P(AB <= q) (lowerTail) or P(AB > q) for the Ansari-Bradley statistic with sample sizes m and n, without ties.
+ *
+ * @param q - Value of the statistic.
+ * @param m - Size of the first sample.
+ * @param n - Size of the second sample.
+ * @param lowerTail - `true` for P(AB <= q), `false` for P(AB > q).
+ */
+export function pansariExact(q, m, n, lowerTail = true) {
+    if (Number.isNaN(q) || !(m >= 1) || !(n >= 1) || m !== Math.floor(m) || n !== Math.floor(n))
+        return NaN;
+    const { min, probs } = ansariDist(m, n);
+    const k = Math.floor(q + 1e-7) - min; // index of the largest value <= q
+    let s = 0;
+    if (lowerTail) {
+        for (let i = 0; i <= Math.min(k, probs.length - 1); i++)
+            s += probs[i];
+    }
+    else {
+        for (let i = Math.max(k + 1, 0); i < probs.length; i++)
+            s += probs[i];
+    }
+    return Math.min(s, 1);
+}
+/**
+ * P(AB = x) for the Ansari-Bradley statistic with sample sizes m and n, without ties.
+ */
+export function dansariExact(x, m, n) {
+    if (Number.isNaN(x) || !(m >= 1) || !(n >= 1) || m !== Math.floor(m) || n !== Math.floor(n))
+        return NaN;
+    if (x !== Math.floor(x))
+        return 0;
+    const { min, probs } = ansariDist(m, n);
+    const i = x - min;
+    return i >= 0 && i < probs.length ? probs[i] : 0;
+}
+/**
+ * The smallest q with P(AB <= q) >= p (quantile of the Ansari-Bradley statistic), without ties. A relative slack of
+ * 64 ε on p keeps p = P(AB <= q) itself from being missed by rounding.
+ */
+export function qansariExact(p, m, n) {
+    if (Number.isNaN(p) || p < 0 || p > 1 || !(m >= 1) || !(n >= 1))
+        return NaN;
+    const { min, probs } = ansariDist(m, n);
+    if (p > 0.5) {
+        // Compare the small upper tail P(AB > q) <= 1 - p instead, so that the tiny probabilities at the top are not
+        // lost to the rounding of a cumulative sum near 1 (p = 1 must give the maximum)
+        const target = (1 - p) * (1 + 64 * Number.EPSILON);
+        let up = 0;
+        for (let i = probs.length - 1; i >= 0; i--) {
+            // up = P(AB > min + i)
+            if (up > target)
+                return min + i + 1;
+            up += probs[i];
+        }
+        return min;
+    }
+    const target = p * (1 - 64 * Number.EPSILON);
+    let s = 0;
+    for (let i = 0; i < probs.length; i++) {
+        s += probs[i];
+        if (s >= target)
+            return min + i;
+    }
+    return min + probs.length - 1;
+}

package/dist/htest/core/kolmogorov.d.ts

@@ -0,0 +1,26 @@
+/**
+ * P(D_n < d), the exact distribution of the two-sided one-sample Kolmogorov-Smirnov statistic for a continuous
+ * distribution (Marsaglia, Tsang and Wang 2003). The matrix has size 2 floor(n d) + 1, so the cost grows like
+ * (n d)^3 log n; ks.test uses it for small samples.
+ *
+ * @param n - Sample size, a positive integer.
+ * @param d - Value of the statistic.
+ */
+export declare function pkolmogorovExact(n: number, d: number): number;
+/**
+ * The limiting distribution of sqrt(n) D_n (Kolmogorov's distribution), K(x) = P(sqrt(n) D_n <= x) as n -> infinity,
+ * or 1 - K(x) for the upper tail. Each tail is summed directly with the series that converges fast for it.
+ *
+ * @param x - Value of sqrt(n) D_n.
+ * @param lowerTail - `true` for K(x), `false` for 1 - K(x).
+ */
+export declare function pkolmogorovLimit(x: number, lowerTail?: boolean): number;
+/**
+ * P(D_n^+ >= d) for the one-sided one-sample statistic D_n^+ = sup (F_n(x) - F(x)) of a continuous distribution
+ * (the same distribution holds for D_n^- = sup (F(x) - F_n(x))), exactly by the Birnbaum-Tingey formula. All terms are
+ * positive, so small p-values keep their relative accuracy.
+ *
+ * @param n - Sample size, a positive integer.
+ * @param d - Value of the statistic.
+ */
+export declare function pkolmogorovOneSidedUpper(n: number, d: number): number;

package/dist/htest/core/kolmogorov.js

@@ -0,0 +1,221 @@
+// Distribution of the one-sample Kolmogorov-Smirnov statistic D_n = sup |F_n(x) - F(x)|, for ks.test.
+//
+// Written for rStats.js from the published methods (no ported code):
+// - Exact distribution: Marsaglia, Tsang and Wang, "Evaluating Kolmogorov's distribution", Journal of Statistical
+//   Software 8(18), 2003. P(D_n < d) = n! / n^n (H^n)_(k,k) with k = floor(n d) + 1 and an m x m matrix H, m = 2k - 1.
+// - Limiting distribution of sqrt(n) D_n (Kolmogorov 1933):
+//     K(x) = 1 - 2 sum_(j>=1) (-1)^(j-1) exp(-2 j^2 x^2)                           (large x)
+//          = sqrt(2 pi) / x sum_(j>=1) exp(-(2j - 1)^2 pi^2 / (8 x^2))            (small x)
+// - For d < 1/n the matrix is 1 x 1 and the closed form P(D_n < d) = n! / n^n (2 n d - 1)^n (Ruben and Gambino 1982)
+//   is used, with 2 n d - 1 formed exactly (it cancels near d = 1/(2n)).
+// - One-sided statistic D_n^+ = sup (F_n(x) - F(x)) (Birnbaum and Tingey, Annals of Mathematical Statistics 22, 1951):
+//     P(D_n^+ >= d) = d sum_(j=0)^(floor(n (1 - d))) C(n, j) (1 - d - j/n)^(n-j) (d + j/n)^(j-1),
+//   whose terms are b(j; n, a) / a with a = d + j/n: binomial probabilities from Loader's dbinomRawDD.
+import { ddAdd, ddDiv, twoProd, twoSum } from "../../special/dd.js";
+import { dbinomRawDD } from "../../special/loader.js";
+/** pi^2 / 8 as a double-double */
+const PI2_8 = [1.2337005501361697, 7.831619385924639e-17];
+/** H^n with the binary exponent kept apart: returns [matrix, e2] with the true power = matrix * 2^e2 */
+function matPow(H, m, n) {
+    const mul = (A, B) => {
+        const C = new Float64Array(m * m);
+        for (let i = 0; i < m; i++) {
+            for (let l = 0; l < m; l++) {
+                const a = A[i * m + l];
+                if (a === 0)
+                    continue;
+                for (let j = 0; j < m; j++)
+                    C[i * m + j] += a * B[l * m + j];
+            }
+        }
+        return C;
+    };
+    // Rescale by a power of two (exact) so that the entries stay in range
+    const normalise = (A) => {
+        let mx = 0;
+        for (const v of A)
+            mx = Math.max(mx, Math.abs(v));
+        if (mx === 0 || !Number.isFinite(mx))
+            return 0;
+        const e = Math.floor(Math.log2(mx));
+        if (Math.abs(e) < 500)
+            return 0;
+        const f = 2 ** -e;
+        for (let i = 0; i < A.length; i++)
+            A[i] *= f;
+        return e;
+    };
+    let result;
+    let re = 0;
+    let base = H.slice();
+    let be = 0;
+    let p = n;
+    while (p > 0) {
+        if (p & 1) {
+            result = result === undefined ? base.slice() : mul(result, base);
+            re += be;
+            re += normalise(result);
+        }
+        p >>= 1;
+        if (p > 0) {
+            base = mul(base, base);
+            be *= 2;
+            be += normalise(base);
+        }
+    }
+    return [result, re];
+}
+/**
+ * P(D_n < d), the exact distribution of the two-sided one-sample Kolmogorov-Smirnov statistic for a continuous
+ * distribution (Marsaglia, Tsang and Wang 2003). The matrix has size 2 floor(n d) + 1, so the cost grows like
+ * (n d)^3 log n; ks.test uses it for small samples.
+ *
+ * @param n - Sample size, a positive integer.
+ * @param d - Value of the statistic.
+ */
+export function pkolmogorovExact(n, d) {
+    if (Number.isNaN(d) || !(n >= 1) || n !== Math.floor(n))
+        return NaN;
+    // D_n >= 1/(2n) always, and D_n <= 1
+    if (d <= 1 / (2 * n))
+        return 0;
+    if (d >= 1)
+        return 1;
+    if (n * d < 1) {
+        // n! / n^n (2 n d - 1)^n, with n d = hi + lo exact so that 2 n d - 1 = (2 hi - 1) + 2 lo has no rounding error
+        const [hi, lo] = twoProd(n, d);
+        const t = 2 * hi - 1 + 2 * lo;
+        let s = 1;
+        let e = 0;
+        for (let i = 1; i <= n; i++) {
+            s *= (i / n) * t;
+            if (s < 2 ** -500) {
+                s *= 2 ** 500;
+                e -= 500;
+            }
+        }
+        while (e < -1000) {
+            s *= 2 ** -1000;
+            e += 1000;
+        }
+        return s * 2 ** e;
+    }
+    const k = Math.floor(n * d) + 1;
+    const m = 2 * k - 1;
+    const h = k - n * d;
+    const H = new Float64Array(m * m);
+    for (let i = 0; i < m; i++)
+        for (let j = 0; j < m; j++)
+            H[i * m + j] = i - j + 1 >= 0 ? 1 : 0;
+    for (let i = 0; i < m; i++) {
+        H[i * m] -= Math.pow(h, i + 1);
+        H[(m - 1) * m + i] -= Math.pow(h, m - i);
+    }
+    if (2 * h - 1 > 0)
+        H[(m - 1) * m] += Math.pow(2 * h - 1, m);
+    // divide by (i - j + 1)!
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < m; j++) {
+            const r = i - j + 1;
+            if (r > 0) {
+                let f = 1;
+                for (let g = 2; g <= r; g++)
+                    f *= g;
+                H[i * m + j] /= f;
+            }
+        }
+    }
+    const [Q, e2] = matPow(H, m, n);
+    // n! / n^n, multiplied in step by step with the binary exponent kept apart
+    let s = Q[(k - 1) * m + k - 1];
+    let e = e2;
+    for (let i = 1; i <= n; i++) {
+        s = (s * i) / n;
+        if (Math.abs(s) < 2 ** -500) {
+            s *= 2 ** 500;
+            e -= 500;
+        }
+    }
+    while (e > 1000) {
+        s *= 2 ** 1000;
+        e -= 1000;
+    }
+    while (e < -1000) {
+        s *= 2 ** -1000;
+        e += 1000;
+    }
+    return s * 2 ** e;
+}
+/**
+ * The limiting distribution of sqrt(n) D_n (Kolmogorov's distribution), K(x) = P(sqrt(n) D_n <= x) as n -> infinity,
+ * or 1 - K(x) for the upper tail. Each tail is summed directly with the series that converges fast for it.
+ *
+ * @param x - Value of sqrt(n) D_n.
+ * @param lowerTail - `true` for K(x), `false` for 1 - K(x).
+ */
+export function pkolmogorovLimit(x, lowerTail = true) {
+    if (Number.isNaN(x))
+        return NaN;
+    if (x <= 0)
+        return lowerTail ? 0 : 1;
+    if (x === Infinity)
+        return lowerTail ? 1 : 0;
+    if (x < 1) {
+        // K(x) = sqrt(2 pi) / x sum exp(-(2j - 1)^2 pi^2 / (8 x^2)): terms fall off at least like exp(-pi^2 j / x^2)
+        // The first term carries the value; its exponent pi^2 / (8 x^2) reaches the hundreds for small x, so it is formed
+        // in double-double (its rounding alone is 1e-13 relative at x = 0.05)
+        const wd = ddDiv(PI2_8, twoProd(x, x));
+        const w = wd[0] + wd[1];
+        const first = Math.exp(-wd[0]) * (1 - wd[1]);
+        let s = 0;
+        for (let j = 2; j < 100; j++) {
+            const t = Math.exp(-(2 * j - 1) * (2 * j - 1) * w);
+            s += t;
+            if (t <= 1e-17 * (s + first))
+                break;
+        }
+        const k = (Math.sqrt(2 * Math.PI) / x) * (first + s);
+        return lowerTail ? k : 1 - k;
+    }
+    // 1 - K(x) = 2 sum (-1)^(j-1) exp(-2 j^2 x^2), alternating with terms below exp(-2) times the previous
+    let s = 0;
+    for (let j = 1; j < 100; j++) {
+        const t = Math.exp(-2 * j * j * x * x);
+        s += j % 2 === 1 ? t : -t;
+        if (t <= 1e-17 * Math.abs(s))
+            break;
+    }
+    const q = 2 * s;
+    return lowerTail ? 1 - q : q;
+}
+/**
+ * P(D_n^+ >= d) for the one-sided one-sample statistic D_n^+ = sup (F_n(x) - F(x)) of a continuous distribution
+ * (the same distribution holds for D_n^- = sup (F(x) - F_n(x))), exactly by the Birnbaum-Tingey formula. All terms are
+ * positive, so small p-values keep their relative accuracy.
+ *
+ * @param n - Sample size, a positive integer.
+ * @param d - Value of the statistic.
+ */
+export function pkolmogorovOneSidedUpper(n, d) {
+    if (Number.isNaN(d) || !(n >= 1) || n !== Math.floor(n))
+        return NaN;
+    if (d <= 0)
+        return 1;
+    if (d > 1)
+        return 0;
+    // n (1 - d) = n - n d, with n d = hi + lo exact
+    const [hi, lo] = twoProd(n, d);
+    const jmax = Math.floor(n - hi - lo);
+    let s = 0;
+    for (let j = 0; j <= jmax; j++) {
+        // a = d + j/n and b = 1 - a = (n - n d - j) / n, both from the exact n d
+        const nb = ddAdd(twoSum(n - j, -hi), [-lo, 0]);
+        if (nb[0] <= 0)
+            break;
+        const na = ddAdd(twoSum(j, hi), [lo, 0]);
+        const a = ddDiv(na, [n, 0]);
+        const b = ddDiv(nb, [n, 0]);
+        s += dbinomRawDD(j, n - j, a, b, false) / (a[0] + a[1]);
+    }
+    return Math.min(d * s, 1);
+}

package/dist/htest/core/mantelhaen.d.ts

@@ -0,0 +1,26 @@
+/** One 2 x 2 stratum as [[a, b], [c, d]] counts */
+export type Stratum = readonly [readonly [number, number], readonly [number, number]];
+/**
+ * The distribution of S = sum of the (1, 1) cells of K 2 x 2 tables with fixed margins, as a function of the common
+ * odds ratio (noncentrality).
+ */
+export declare class ConvolvedNoncentralHyper {
+    /** Smallest and largest attainable S */
+    readonly lo: number;
+    readonly hi: number;
+    /** log d0(s) for s = lo..hi (d0: the null, psi = 1, density) */
+    private readonly logNull;
+    constructor(strata: readonly Stratum[]);
+    /** P(S = s; psi) for s = lo..hi, for 0 < psi < Infinity (psi = 0 and Infinity give the point masses at lo and hi) */
+    density(psi: number): Float64Array;
+    /** E[S; psi] */
+    mean(psi: number): number;
+    /** P(S <= q; psi), or P(S >= q; psi) when upper */
+    cdf(q: number, psi: number, upper: boolean): number;
+}
+/** The conditional maximum likelihood estimate of the common odds ratio given the observed sum s */
+export declare function conditionalMLE(h: ConvolvedNoncentralHyper, s: number): number;
+/** Upper confidence limit: the psi with P(S <= s; psi) = alpha */
+export declare function upperLimit(h: ConvolvedNoncentralHyper, s: number, alpha: number): number;
+/** Lower confidence limit: the psi with P(S >= s; psi) = alpha */
+export declare function lowerLimit(h: ConvolvedNoncentralHyper, s: number, alpha: number): number;

package/dist/htest/core/mantelhaen.js

@@ -0,0 +1,145 @@
+// Exact conditional distribution for the Mantel-Haenszel test on 2 x 2 x K tables (mantelhaen.test with
+// exact = TRUE).
+//
+// Written for rStats.js from the textbook construction and R's behaviour. With all margins fixed, the
+// (1, 1) cell of stratum k follows Fisher's noncentral hypergeometric distribution with noncentrality psi, the common
+// odds ratio (Mantel and Haenszel, JNCI 22, 1959; Birch, JRSS B 26, 1964), so their sum S has the density
+// d0(s) psi^s / sum_t d0(t) psi^t, where d0 is the convolution of the K central hypergeometric densities. The
+// conditional MLE of psi is the noncentrality whose mean equals the observed S, and the confidence limits are the
+// noncentralities at which a one-sided probability equals alpha; the roots are found with uniroot on psi in [0, 1] or
+// on 1/psi in [eps, 1], as for fisher.test's 2 x 2 tables (src/htest/fisherTest.ts).
+import { dhyper1 } from "../../distributions/hypergeometric.js";
+import { uniroot } from "../../internal/uniroot.js";
+import { ddAdd } from "../../special/dd.js";
+/** Compensated (double-double) sum of v[from..to) */
+function sumRange(v, from, to) {
+    let acc = [0, 0];
+    for (let i = Math.max(0, from); i < Math.min(to, v.length); i++)
+        acc = ddAdd(acc, [v[i], 0]);
+    return acc[0];
+}
+/** Central hypergeometric density of the (1, 1) cell of one stratum, with its support start */
+function stratumDensity([[a, b], [c, d]]) {
+    const m = a + c; // first column
+    const n = b + d; // second column
+    const k = a + b; // first row
+    const lo = Math.max(0, k - n);
+    const hi = Math.min(k, m);
+    const dens = new Float64Array(hi - lo + 1);
+    for (let x = lo; x <= hi; x++)
+        dens[x - lo] = dhyper1(x, m, n, k, false);
+    return { lo, d: dens };
+}
+/** Discrete convolution of two densities on consecutive integers */
+function convolve(p, q) {
+    const out = new Float64Array(p.length + q.length - 1);
+    for (let i = 0; i < p.length; i++) {
+        const pi = p[i];
+        if (pi === 0)
+            continue;
+        for (let j = 0; j < q.length; j++)
+            out[i + j] += pi * q[j];
+    }
+    return out;
+}
+/**
+ * The distribution of S = sum of the (1, 1) cells of K 2 x 2 tables with fixed margins, as a function of the common
+ * odds ratio (noncentrality).
+ */
+export class ConvolvedNoncentralHyper {
+    /** Smallest and largest attainable S */
+    lo;
+    hi;
+    /** log d0(s) for s = lo..hi (d0: the null, psi = 1, density) */
+    logNull;
+    constructor(strata) {
+        let lo = 0;
+        let d0 = new Float64Array([1]);
+        for (const t of strata) {
+            const s = stratumDensity(t);
+            lo += s.lo;
+            d0 = convolve(d0, s.d);
+        }
+        this.lo = lo;
+        this.hi = lo + d0.length - 1;
+        this.logNull = d0.map(Math.log);
+    }
+    /** P(S = s; psi) for s = lo..hi, for 0 < psi < Infinity (psi = 0 and Infinity give the point masses at lo and hi) */
+    density(psi) {
+        const len = this.logNull.length;
+        const out = new Float64Array(len);
+        if (psi === 0 || psi === Infinity) {
+            out[psi === 0 ? 0 : len - 1] = 1;
+            return out;
+        }
+        const lp = Math.log(psi);
+        let top = -Infinity;
+        for (let i = 0; i < len; i++) {
+            // exp(s log psi): the exponent is formed from the support value itself (lo + i)
+            const v = this.logNull[i] + (this.lo + i) * lp;
+            out[i] = v;
+            if (v > top)
+                top = v;
+        }
+        for (let i = 0; i < len; i++)
+            out[i] = Math.exp(out[i] - top);
+        const total = sumRange(out, 0, len);
+        for (let i = 0; i < len; i++)
+            out[i] = out[i] / total;
+        return out;
+    }
+    /** E[S; psi] */
+    mean(psi) {
+        if (psi === 0)
+            return this.lo;
+        if (psi === Infinity)
+            return this.hi;
+        const d = this.density(psi);
+        let acc = [0, 0];
+        for (let i = 0; i < d.length; i++)
+            acc = ddAdd(acc, [(this.lo + i) * d[i], 0]);
+        return acc[0];
+    }
+    /** P(S <= q; psi), or P(S >= q; psi) when upper */
+    cdf(q, psi, upper) {
+        const d = this.density(psi);
+        const i = q - this.lo;
+        return upper ? sumRange(d, i, d.length) : sumRange(d, 0, i + 1);
+    }
+}
+/**
+ * Root in psi of a function that is monotone in psi, given whether the root lies below 1: search psi in [0, 1], or
+ * t = 1/psi in [eps, 1]
+ */
+function oddsRoot(f, belowOne) {
+    return belowOne ? uniroot(f, 0, 1) : 1 / uniroot((t) => f(1 / t), Number.EPSILON, 1);
+}
+/** The conditional maximum likelihood estimate of the common odds ratio given the observed sum s */
+export function conditionalMLE(h, s) {
+    if (s === h.lo)
+        return 0;
+    if (s === h.hi)
+        return Infinity;
+    const atOne = h.mean(1);
+    if (atOne === s)
+        return 1;
+    return oddsRoot((psi) => h.mean(psi) - s, atOne > s);
+}
+/** Upper confidence limit: the psi with P(S <= s; psi) = alpha */
+export function upperLimit(h, s, alpha) {
+    if (s === h.hi)
+        return Infinity;
+    const atOne = h.cdf(s, 1, false);
+    if (atOne === alpha)
+        return 1;
+    return oddsRoot((psi) => alpha - h.cdf(s, psi, false), atOne < alpha);
+}
+/** Lower confidence limit: the psi with P(S >= s; psi) = alpha */
+export function lowerLimit(h, s, alpha) {
+    if (s === h.lo)
+        return 0;
+    const atOne = h.cdf(s, 1, true);
+    if (atOne === alpha)
+        return 1;
+    return oddsRoot((psi) => h.cdf(s, psi, true) - alpha, atOne > alpha);
+}

package/dist/htest/core/shapiro.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The Shapiro-Wilk coefficients a_1..a_n for a sample of size n (3 <= n <= 5000), antisymmetric
+ * (a_i = -a_(n+1-i)) with sum a_i^2 = 1.
+ */
+export declare function swilkCoefficients(n: number): Float64Array;
+/**
+ * 1 - W for a sample sorted in increasing order, formed as (r + c)(r - c) / r^2 from c = sum a_i (x_i - mean) and
+ * r^2 = sum a_i^2 sum (x_i - mean)^2, so that it keeps its relative accuracy when W is close to 1 (the p-value
+ * depends on log(1 - W)). The data are scaled by their range first.
+ */
+export declare function swilkOneMinusW(sorted: readonly number[]): number;
+/**
+ * The W statistic of a sample sorted in increasing order:
+ * W = (sum a_i x_(i))^2 / sum (x_i - mean)^2.
+ */
+export declare function swilkW(sorted: readonly number[]): number;
+/**
+ * The p-value P(W' <= W) of the Shapiro-Wilk test for a sample of size n (Royston's approximations), from W.
+ */
+export declare function swilkPValue(w: number, n: number): number;
+/**
+ * The p-value P(W' <= W) of the Shapiro-Wilk test for a sample of size n, from w1 = 1 - W (see swilkOneMinusW).
+ */
+export declare function swilkPValueFromOneMinusW(w1: number, n: number): number;