@numero-uno-jpn/rstats 0.5.0 → 0.6.1

package/dist/htest/core/shapiro.js

@@ -0,0 +1,142 @@
+// Shapiro-Wilk W statistic and its p-value, for shapiro.test.
+//
+// Written for rStats.js from the published approximations (no ported code): Royston, "Approximating the
+// Shapiro-Wilk W-test for non-normality", Statistics and Computing 2, 1992, and Royston, "Remark AS R94: A remark on
+// Algorithm AS 181: The W-test for normality", Applied Statistics 44, 1995.
+//
+// Coefficients: m_i = qnorm((i - 3/8) / (n + 1/4)) and, with u = 1/sqrt(n), polynomial corrections for the two
+// largest coefficients; the others are m_i / sqrt(phi) so that sum a_i^2 = 1.
+// p-value: n = 3 exactly; 4 <= n <= 11: -log(gamma - log(1 - W)) is normal; n >= 12: log(1 - W) is normal, with
+// means and standard deviations given as polynomials in n or log(n).
+// Beyond the range of Royston's approximation for 4 <= n <= 11 the p-value is 1e-99: 1e-99 is the value R reports
+// here (observed behaviour).
+import { pnorm, qnorm } from "../../distributions/normal.js";
+/** Polynomial c[0] + c[1] x + c[2] x^2 + ... */
+function poly(c, x) {
+    let s = 0;
+    for (let i = c.length - 1; i >= 0; i--)
+        s = s * x + c[i];
+    return s;
+}
+const C1 = [0, 0.221157, -0.147981, -2.07119, 4.434685, -2.706056];
+const C2 = [0, 0.042981, -0.293762, -1.752461, 5.682633, -3.582633];
+const C3 = [0.544, -0.39978, 0.025054, -6.714e-4];
+const C4 = [1.3822, -0.77857, 0.062767, -0.0020322];
+const C5 = [-1.5861, -0.31082, -0.083751, 0.0038915];
+const C6 = [-0.4803, -0.082676, 0.0030302];
+const G = [-2.273, 0.459];
+/**
+ * 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 function swilkCoefficients(n) {
+    if (!(n >= 3) || n !== Math.floor(n))
+        throw new RangeError("n must be an integer of at least 3");
+    const a = new Float64Array(n);
+    if (n === 3) {
+        a[0] = -Math.SQRT1_2;
+        a[2] = Math.SQRT1_2;
+        return a;
+    }
+    const half = Math.floor(n / 2);
+    const m = new Float64Array(half); // m for the upper half, m[0] the largest
+    let summ2 = 0;
+    for (let i = 0; i < half; i++) {
+        // upper half: i-th largest expected normal order statistic
+        m[i] = -qnorm((i + 1 - 0.375) / (n + 0.25));
+        summ2 += m[i] * m[i];
+    }
+    summ2 *= 2;
+    const ssumm2 = Math.sqrt(summ2);
+    const rsn = 1 / Math.sqrt(n);
+    // the two largest coefficients a_n and a_(n-1), corrected by polynomials in u = 1/sqrt(n)
+    const an = m[0] / ssumm2 + poly(C1, rsn);
+    const up = new Float64Array(half);
+    up[0] = an;
+    let first;
+    let fac;
+    if (n > 5) {
+        const an1 = m[1] / ssumm2 + poly(C2, rsn);
+        up[1] = an1;
+        first = 2;
+        fac = Math.sqrt((summ2 - 2 * m[0] * m[0] - 2 * m[1] * m[1]) / (1 - 2 * an * an - 2 * an1 * an1));
+    }
+    else {
+        first = 1;
+        fac = Math.sqrt((summ2 - 2 * m[0] * m[0]) / (1 - 2 * an * an));
+    }
+    for (let i = first; i < half; i++)
+        up[i] = m[i] / fac;
+    // a_n, a_(n-1), ... positive for the largest observations
+    for (let i = 0; i < half; i++) {
+        a[n - 1 - i] = up[i];
+        a[i] = -up[i];
+    }
+    return a;
+}
+/**
+ * 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 function swilkOneMinusW(sorted) {
+    const n = sorted.length;
+    const a = swilkCoefficients(n);
+    const range = sorted[n - 1] - sorted[0];
+    let mean = 0;
+    for (const v of sorted)
+        mean += v / range;
+    mean /= n;
+    let ssa = 0;
+    let ssx = 0;
+    let sax = 0;
+    for (let i = 0; i < n; i++) {
+        const d = sorted[i] / range - mean;
+        ssa += a[i] * a[i];
+        ssx += d * d;
+        sax += a[i] * d;
+    }
+    const r = Math.sqrt(ssa * ssx);
+    return ((r - sax) * (r + sax)) / (ssa * ssx);
+}
+/**
+ * The W statistic of a sample sorted in increasing order:
+ * W = (sum a_i x_(i))^2 / sum (x_i - mean)^2.
+ */
+export function swilkW(sorted) {
+    return 1 - swilkOneMinusW(sorted);
+}
+/**
+ * The p-value P(W' <= W) of the Shapiro-Wilk test for a sample of size n (Royston's approximations), from W.
+ */
+export function swilkPValue(w, n) {
+    return swilkPValueFromOneMinusW(1 - w, n);
+}
+/** 6/pi and asin(sqrt(3/4)) to 15 digits, the values R's swilk uses for n = 3 */
+const PI6 = 1.90985931710274;
+const STQR = 1.0471975511966;
+/**
+ * The p-value P(W' <= W) of the Shapiro-Wilk test for a sample of size n, from w1 = 1 - W (see swilkOneMinusW).
+ */
+export function swilkPValueFromOneMinusW(w1, n) {
+    if (Number.isNaN(w1) || !(n >= 3))
+        return NaN;
+    if (n === 3) {
+        // exact: 6/pi (asin(sqrt(W)) - asin(sqrt(3/4))), W >= 3/4
+        const p = PI6 * (Math.asin(Math.sqrt(1 - w1)) - STQR);
+        return Math.max(p, 0);
+    }
+    const y = Math.log(w1);
+    if (n <= 11) {
+        const gamma = poly(G, n);
+        if (y >= gamma)
+            return 1e-99; // beyond the range of the approximation; 1e-99 is the value R reports here
+        const mu = poly(C3, n);
+        const sigma = Math.exp(poly(C4, n));
+        return pnorm(-Math.log(gamma - y), { mean: mu, sd: sigma, lowerTail: false });
+    }
+    const xx = Math.log(n);
+    const mu = poly(C5, xx);
+    const sigma = Math.exp(poly(C6, xx));
+    return pnorm(y, { mean: mu, sd: sigma, lowerTail: false });
+}

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

@@ -0,0 +1,20 @@
+export type SmirnovAlternative = "two.sided" | "less" | "greater";
+export interface SmirnovOptions {
+    /** Which statistic: max |F_x - F_y| ("two.sided", default), max (F_x - F_y) ("greater"), max (F_y - F_x) ("less"). */
+    alternative?: SmirnovAlternative;
+    /**
+     * The pooled sample (length m + n). With ties, the statistic is only observed where the sorted values change.
+     * Omit for continuous data without ties.
+     */
+    z?: readonly number[];
+}
+/**
+ * P(D >= d) for the two-sample Smirnov statistic with sample sizes m and n, exactly.
+ * The comparison D >= d is done on the integer scale |i n - j m| >= d m n with a relative fuzz of 1e-10, so that a
+ * statistic computed in floating point from the data is not lost to rounding.
+ *
+ * @param d - Value of the statistic.
+ * @param m - Size of the first sample (x).
+ * @param n - Size of the second sample (y).
+ */
+export declare function psmirnovUpper(d: number, m: number, n: number, options?: SmirnovOptions): number;

package/dist/htest/core/smirnov.js

@@ -0,0 +1,75 @@
+// Exact distribution of the two-sample Kolmogorov-Smirnov (Smirnov) statistic, for ks.test.
+//
+// Written for rStats.js from the published method (no ported code). Under the null hypothesis every arrangement of
+// the m + n pooled observations is equally likely, i.e. every lattice path from (0, 0) to (m, n) (i steps for x,
+// j steps for y). The statistic is the largest |i/m - j/n| (two-sided) or i/m - j/n ("greater") or j/n - i/m ("less")
+// over the points where it can be observed: after every observation without ties, and only where the pooled sorted
+// sample changes value when there are ties (Schröer and Trenkler, Computational Statistics & Data Analysis 20, 1995).
+//
+// P(D >= d) is summed over the points where a path first reaches the boundary: with v(i, j) the fraction of paths
+// to (i, j) that stay inside,
+//   v(i, j) = i/(i+j) v(i-1, j) + j/(i+j) v(i, j-1),
+// and a path through a boundary point is counted with the probability dhyper(i; m, n, i + j) of passing it. All
+// terms are positive, so small p-values keep their relative accuracy (1 - P(D < d) would lose them).
+import { dhyper1 } from "../../distributions/hypergeometric.js";
+/**
+ * P(D >= d) for the two-sample Smirnov statistic with sample sizes m and n, exactly.
+ * The comparison D >= d is done on the integer scale |i n - j m| >= d m n with a relative fuzz of 1e-10, so that a
+ * statistic computed in floating point from the data is not lost to rounding.
+ *
+ * @param d - Value of the statistic.
+ * @param m - Size of the first sample (x).
+ * @param n - Size of the second sample (y).
+ */
+export function psmirnovUpper(d, m, n, options = {}) {
+    const alternative = options.alternative ?? "two.sided";
+    if (Number.isNaN(d) || !(m >= 1) || !(n >= 1) || m !== Math.floor(m) || n !== Math.floor(n))
+        return NaN;
+    if (d <= 0)
+        return 1;
+    if (d > 1)
+        return 0;
+    // where the statistic is observed: after step s = i + j (1..m+n-1), or only where z changes
+    const N = m + n;
+    let observed;
+    if (options.z !== undefined) {
+        if (options.z.length !== N)
+            throw new RangeError("z must have length m + n");
+        const zs = [...options.z].sort((a, b) => a - b);
+        observed = new Array(N + 1).fill(false);
+        for (let s = 1; s < N; s++)
+            observed[s] = zs[s] !== zs[s - 1];
+    }
+    const threshold = d * m * n * (1 - 1e-10);
+    const crosses = (i, j) => {
+        const diff = i * n - j * m;
+        const v = alternative === "two.sided" ? Math.abs(diff) : alternative === "greater" ? diff : -diff;
+        return v >= threshold;
+    };
+    // v over j for the current i (rolling row)
+    let prev = new Float64Array(n + 1);
+    let cur = new Float64Array(n + 1);
+    let p = 0;
+    for (let i = 0; i <= m; i++) {
+        for (let j = 0; j <= n; j++) {
+            if (i === 0 && j === 0) {
+                cur[0] = 1;
+                continue;
+            }
+            const s = i + j;
+            const reach = (i > 0 ? (i / s) * prev[j] : 0) + (j > 0 ? (j / s) * cur[j - 1] : 0);
+            const obs = observed === undefined ? s < N : observed[s];
+            if (obs && crosses(i, j)) {
+                if (reach > 0)
+                    p += reach * dhyper1(i, m, n, s, false);
+                cur[j] = 0;
+            }
+            else {
+                cur[j] = reach;
+            }
+        }
+        [prev, cur] = [cur, prev];
+        cur.fill(0);
+    }
+    return Math.min(p, 1);
+}

package/dist/htest/fisherTest.js

@@ -1,15 +1,19 @@
 // Fisher's exact test (R's fisher.test).
 //
-// 2x2 tables: with the margins fixed, the (1, 1) cell follows a noncentral hypergeometric distribution
-// (noncentrality = odds ratio; Fisher 1935). The conditional MLE is the noncentrality whose mean equals the
-// cell value; the confidence limits are the noncentralities at which a one-sided probability equals α. This construction
-// is the same as scipy.stats.contingency.odds_ratio (scipy/stats/_odds_ratio.py; SciPy commit a087e61,
-// BSD-3-Clause, see THIRD_PARTY_NOTICES.md). The root finding and defaults follow observed R output.
-// - Roots are found with uniroot (Brent, tolerance eps^0.25): if the noncentrality ψ is below 1, search
-//   ψ ∈ [0, 1]; if above 1, search 1/ψ ∈ [ε, 1] (R's estimate and interval endpoints are 1e-6 to 1e-2 away
-//   from the true roots, but this procedure reproduces them to the last few digits)
-// - The two-sided p-value is the sum of probabilities of tables whose probability is at most (1 + 1e-7) times the observed one
+// 2x2 tables, written for rStats.js from the textbook construction and R's documented behaviour: with the margins
+// fixed, the (1, 1) cell follows Fisher's noncentral hypergeometric distribution, the central hypergeometric density
+// tilted by psi^x (noncentrality psi = odds ratio; Fisher 1935, Cornfield 1956). The conditional MLE is the psi whose
+// mean equals the observed cell; the confidence limits are the psi at which a one-sided tail probability equals α.
+// - Densities are formed in logs from the accurate log dhyper (evaluated every 16 points, exact ratios in
+//   between) and normalised with double-double sums, so the root
+//   search sees accurate function values; at psi = 1 the tails are the central hypergeometric distribution function
+// - Roots are found with R's uniroot conventions (Brent, tolerance eps^0.25; src/internal/uniroot.ts): if the root
+//   lies below 1, on psi in [0, 1]; otherwise on s = 1/psi in [eps, 1]. R's estimate and limits are where this
+//   iteration stops (1e-6 to 1e-2 from the true roots), so the brackets and tolerance are part of the result
+// - The two-sided p-value is the sum of probabilities of tables whose probability is at most (1 + 1e-7) times the
+//   observed one (R's convention); for or = 0 or Inf the distribution is a point mass at the end of the support
 // - Counts are made integer by rounding half to even (R rounds with a warning)
+// The same distribution and root conventions are used for the exact Mantel-Haenszel test (src/htest/core/mantelhaen.ts).
 //
 // rxc tables: the probabilities of tables with fixed margins (multivariate hypergeometric) are
 // traversed via a network that fixes one column at a time (Mehta & Patel 1983, JASA 78, 427-434),
@@ -27,8 +31,6 @@ import { roundHalfEven } from "../internal/integer.js";
 import { uniroot } from "../internal/uniroot.js";
 import { ddAdd, ddLog, ddNeg, ddSub } from "../special/dd.js";
 import { matchAlternative } from "./types.js";
-/** Relative tolerance for treating a table as "equally probable as the observed table" in the two-sided p-value */
-const REL_ERR = 1 + 1e-7;
 /**
  * Fisher's exact test for count data. Equivalent to R's `fisher.test()`.
  *
@@ -78,93 +80,109 @@ export function fisherTest(x, options = {}) {
     };
 }
 // ---- 2×2 ----
-/** Noncentral hypergeometric distribution (the (1, 1) cell of a 2x2 table) */
-class NoncentralHyper {
+/** Relative slack for counting a table as "no more likely than the observed one" in the two-sided p-value */
+const SLACK = 1 + 1e-7;
+/** Spacing of the points at which the central log density is evaluated directly */
+const ANCHOR = 16;
+/** Double-double sum of v[from..to] (inclusive, clipped to the array) */
+function accurateSum(v, from, to) {
+    let acc = [0, 0];
+    for (let i = Math.max(0, from); i <= Math.min(to, v.length - 1); i++)
+        if (v[i] !== 0)
+            acc = ddAdd(acc, [v[i], 0]);
+    return acc[0];
+}
+/**
+ * Fisher's noncentral hypergeometric distribution of the (1, 1) cell of a 2 x 2 table with margins fixed:
+ * P(X = i; psi) proportional to dhyper(i; m, n, k) psi^i on lo..hi
+ */
+class OddsRatioDistribution {
     m;
     n;
     k;
     lo;
     hi;
-    logdc;
+    /** log dhyper(i; m, n, k) for i = lo..hi */
+    logCentral;
     constructor(m, n, k) {
         this.m = m;
         this.n = n;
         this.k = k;
         this.lo = Math.max(0, k - n);
         this.hi = Math.min(k, m);
-        // log P(X = x). Computed with dhyper every 64 points, linked in between by the ratio of neighbours
-        // P(x + 1) / P(x) = (m - x)(k - x) / ((x + 1)(n - k + x + 1)) (the log-ratio error is about
-        // 1 ulp, so 63 chained steps stay within 1e-14; calling dhyper at every point is slow for large tables)
-        const len = this.hi - this.lo + 1;
-        this.logdc = new Float64Array(len);
-        for (let i = 0; i < len; i++) {
-            const x = this.lo + i;
-            if (i % 64 === 0)
-                this.logdc[i] = dhyper1(x, m, n, k, true);
-            else {
-                const y = x - 1;
-                this.logdc[i] = this.logdc[i - 1] + Math.log(((m - y) * (k - y)) / ((y + 1) * (n - k + y + 1)));
+        this.logCentral = new Float64Array(this.hi - this.lo + 1);
+        // dhyper1 at every ANCHOR-th point; in between, multiply by the exact ratio
+        // c(i+1)/c(i) = (m - i)(k - i) / ((i + 1)(n - k + i + 1)) (the product stays within a few ulps)
+        let anchor = 0;
+        let prod = 1;
+        for (let i = this.lo; i <= this.hi; i++) {
+            const j = i - this.lo;
+            if (j % ANCHOR === 0 || !(prod > 0 && prod < Infinity)) {
+                anchor = dhyper1(i, m, n, k, true);
+                prod = 1;
+                this.logCentral[j] = anchor;
             }
+            else
+                this.logCentral[j] = anchor + Math.log(prod);
+            prod *= ((m - i) * (k - i)) / ((i + 1) * (n - k + i + 1));
         }
     }
-    /** Probabilities (in support order). The noncentrality ncp satisfies 0 < ncp < ∞ */
-    density(ncp) {
-        const lc = Math.log(ncp);
-        const d = new Float64Array(this.logdc.length);
-        let max = -Infinity;
-        for (let i = 0; i < d.length; i++) {
-            d[i] = this.logdc[i] + lc * (this.lo + i);
-            if (d[i] > max)
-                max = d[i];
+    /** Normalised density on lo..hi for 0 < psi < Infinity */
+    density(psi) {
+        const len = this.logCentral.length;
+        const lp = Math.log(psi);
+        const out = new Float64Array(len);
+        let top = -Infinity;
+        for (let j = 0; j < len; j++) {
+            const v = this.logCentral[j] + (this.lo + j) * lp;
+            out[j] = v;
+            if (v > top)
+                top = v;
         }
-        // Skip exp where exp(d - max) underflows to 0 (R also gives 0 there)
-        for (let i = 0; i < d.length; i++)
-            d[i] = d[i] - max < -760 ? 0 : Math.exp(d[i] - max);
-        const s = sumDD(d, 0, d.length);
-        for (let i = 0; i < d.length; i++)
-            d[i] = d[i] / s;
-        return d;
+        // exp underflows to exactly 0 below -746; skipping those terms leaves every sum unchanged
+        for (let j = 0; j < len; j++) {
+            const e = out[j] - top;
+            out[j] = e < -746 ? 0 : Math.exp(e);
+        }
+        const total = accurateSum(out, 0, len - 1);
+        for (let j = 0; j < len; j++)
+            if (out[j] !== 0)
+                out[j] = out[j] / total;
+        return out;
     }
-    mean(ncp) {
-        if (ncp === 0)
+    /** E[X; psi] */
+    mean(psi) {
+        if (psi === 0)
             return this.lo;
-        if (ncp === Infinity)
+        if (psi === Infinity)
             return this.hi;
-        const d = this.density(ncp);
-        let s = [0, 0];
-        for (let i = 0; i < d.length; i++)
-            s = ddAdd(s, [(this.lo + i) * d[i], 0]);
-        return s[0];
+        const d = this.density(psi);
+        let acc = [0, 0];
+        for (let j = 0; j < d.length; j++)
+            if (d[j] !== 0)
+                acc = ddAdd(acc, [(this.lo + j) * d[j], 0]);
+        return acc[0];
     }
-    /** P(X <= q) (P(X >= q) if upper) */
-    cdf(q, ncp, upper) {
-        if (ncp === 1) {
+    /** P(X <= q; psi), or P(X >= q; psi) when upper */
+    tail(q, psi, upper) {
+        if (psi === 1) {
             return upper ? phyper1(q - 1, this.m, this.n, this.k, false, false) : phyper1(q, this.m, this.n, this.k, true, false);
         }
-        if (ncp === 0)
-            return Number(upper ? q <= this.lo : q >= this.lo);
-        if (ncp === Infinity)
-            return Number(upper ? q <= this.hi : q >= this.hi);
-        const d = this.density(ncp);
-        const i = q - this.lo;
-        return upper ? sumDD(d, i, d.length) : sumDD(d, 0, i + 1);
+        if (psi === 0 || psi === Infinity) {
+            const at = psi === 0 ? this.lo : this.hi;
+            return (upper ? q <= at : q >= at) ? 1 : 0;
+        }
+        const d = this.density(psi);
+        const j = q - this.lo;
+        return upper ? accurateSum(d, j, d.length - 1) : accurateSum(d, 0, j);
     }
 }
-function sumDD(d, from, to) {
-    let s = [0, 0];
-    for (let i = Math.max(0, from); i < Math.min(to, d.length); i++)
-        s = ddAdd(s, [d[i], 0]);
-    return s[0];
-}
 /**
- * Root of the increasing function f(ψ) = 0. If f(1) < 0 there is no root in ψ ∈ [0, 1], so search 1/ψ ∈ [ε, 1]
- * (the caller chooses the interval from the sign of f(1))
+ * Root of f, monotone in the odds ratio psi: searched for as psi in [0, 1] when it lies below 1, otherwise as
+ * s = 1/psi in [eps, 1] (uniroot with its default tolerance in both cases)
  */
-function rootBelowOne(f) {
-    return uniroot(f, 0, 1);
-}
-function rootAboveOne(f) {
-    return 1 / uniroot((t) => f(1 / t), Number.EPSILON, 1);
+function oddsRatioRoot(f, belowOne) {
+    return belowOne ? uniroot(f, 0, 1) : 1 / uniroot((s) => f(1 / s), Number.EPSILON, 1);
 }
 function fisher2x2(t, options, method) {
     const alternative = matchAlternative(options.alternative);
@@ -174,39 +192,36 @@ function fisher2x2(t, options, method) {
     const confLevel = options.confLevel ?? 0.95;
     if (!(confLevel > 0 && confLevel < 1))
         throw new RangeError("confLevel must be a single number between 0 and 1");
-    const x = t[0][0];
-    const m = x + t[1][0];
-    const n = t[0][1] + t[1][1];
-    const k = x + t[0][1];
-    const h = new NoncentralHyper(m, n, k);
+    const [[a, b], [c, d]] = t;
+    const x = a;
+    const dist = new OddsRatioDistribution(a + c, b + d, a + b);
+    const { lo, hi } = dist;
     let pValue;
     if (alternative === "less")
-        pValue = h.cdf(x, or, false);
+        pValue = dist.tail(x, or, false);
     else if (alternative === "greater")
-        pValue = h.cdf(x, or, true);
+        pValue = dist.tail(x, or, true);
     else if (or === 0)
-        pValue = Number(x === h.lo);
+        pValue = x === lo ? 1 : 0;
     else if (or === Infinity)
-        pValue = Number(x === h.hi);
+        pValue = x === hi ? 1 : 0;
     else {
-        const d = h.density(or);
-        const limit = d[x - h.lo] * REL_ERR;
-        let s = [0, 0];
-        for (const v of d)
-            if (v <= limit)
-                s = ddAdd(s, [v, 0]);
-        pValue = s[0];
+        const dens = dist.density(or);
+        const cut = dens[x - lo] * SLACK;
+        let acc = [0, 0];
+        for (const v of dens)
+            if (v <= cut)
+                acc = ddAdd(acc, [v, 0]);
+        pValue = acc[0];
     }
-    // Conditional MLE: the noncentrality whose mean is x
     let estimate;
-    if (x === h.lo)
+    if (x === lo)
         estimate = 0;
-    else if (x === h.hi)
+    else if (x === hi)
         estimate = Infinity;
     else {
-        const mu = h.mean(1);
-        const f = (psi) => h.mean(psi) - x;
-        estimate = mu > x ? rootBelowOne(f) : mu < x ? rootAboveOne(f) : 1;
+        const mu1 = dist.mean(1);
+        estimate = mu1 === x ? 1 : oddsRatioRoot((psi) => dist.mean(psi) - x, mu1 > x);
     }
     const result = {
         method,
@@ -217,32 +232,31 @@ function fisher2x2(t, options, method) {
         nullValue: or,
         nullValueName: "odds ratio",
     };
-    if (options.confInt ?? true) {
-        // Upper limit: P(X <= x; ψ) = α (P is decreasing in ψ)
-        const upper = (alpha) => {
-            if (x === h.hi)
-                return Infinity;
-            const p = h.cdf(x, 1, false);
-            const f = (psi) => alpha - h.cdf(x, psi, false);
-            return p < alpha ? rootBelowOne(f) : p > alpha ? rootAboveOne(f) : 1;
-        };
-        // Lower limit: P(X >= x; ψ) = α (P is increasing in ψ)
-        const lower = (alpha) => {
-            if (x === h.lo)
-                return 0;
-            const p = h.cdf(x, 1, true);
-            const f = (psi) => h.cdf(x, psi, true) - alpha;
-            return p > alpha ? rootBelowOne(f) : p < alpha ? rootAboveOne(f) : 1;
-        };
-        result.confInt =
-            alternative === "less"
-                ? [0, upper(1 - confLevel)]
-                : alternative === "greater"
-                    ? [lower(1 - confLevel), Infinity]
-                    : [lower((1 - confLevel) / 2), upper((1 - confLevel) / 2)];
-        result.confLevel = confLevel;
+    if (!(options.confInt ?? true))
+        return result;
+    // P(X <= x; psi) decreases and P(X >= x; psi) increases in psi
+    const upperLimit = (level) => {
+        if (x === hi)
+            return Infinity;
+        const p1 = dist.tail(x, 1, false);
+        return p1 === level ? 1 : oddsRatioRoot((psi) => dist.tail(x, psi, false) - level, p1 < level);
+    };
+    const lowerLimit = (level) => {
+        if (x === lo)
+            return 0;
+        const p1 = dist.tail(x, 1, true);
+        return p1 === level ? 1 : oddsRatioRoot((psi) => dist.tail(x, psi, true) - level, p1 > level);
+    };
+    let confInt;
+    if (alternative === "less")
+        confInt = [0, upperLimit(1 - confLevel)];
+    else if (alternative === "greater")
+        confInt = [lowerLimit(1 - confLevel), Infinity];
+    else {
+        const alpha = (1 - confLevel) / 2;
+        confInt = [lowerLimit(alpha), upperLimit(alpha)];
     }
-    return result;
+    return { ...result, confInt, confLevel };
 }
 // ---- r×c ----
 /** Table of log k! in double-double (extended as needed) */

package/dist/htest/groups.d.ts

@@ -0,0 +1,20 @@
+import type { Sample } from "./types.js";
+/** Group label: a number or a string. */
+export type GroupLabel = number | string;
+/** Groups with their labels: the sorted labels (x, g form) or the 1-based positions in the list (list form) */
+export interface LabelledGroups {
+    labels: string[];
+    groups: number[][];
+}
+/**
+ * Normalise the two input forms to groups with NaN removed, each with its label. In the x, g form a label whose
+ * values are all missing has no group (as R drops an unused factor level). In the list form a group left empty is
+ * dropped, or rejected with R's message when `emptyGroups` is `"error"` (kruskal.test, fligner.test).
+ */
+export declare function labelledGroups(x: Sample | readonly Sample[], g?: readonly GroupLabel[], emptyGroups?: "drop" | "error"): LabelledGroups;
+/** Normalise the two input forms to an array of non-empty groups with NaN removed (see {@link labelledGroups}) */
+export declare function toGroups(x: Sample | readonly Sample[], g?: readonly GroupLabel[], emptyGroups?: "drop" | "error"): number[][];
+/** Median (the mean of the two middle values for an even count) */
+export declare function median(x: readonly number[]): number;
+/** Rows of a blocks x treatments table with any NaN dropped (R's complete.cases) */
+export declare function completeRows(y: readonly (readonly number[])[]): number[][];