@numero-uno-jpn/rstats 0.5.0 → 0.6.1

package/dist/htest/groups.js

@@ -0,0 +1,62 @@
+// Grouped data for the k-sample tests: either an array of samples (R's list form) or a sample with a parallel array
+// of group labels (R's x, g form). Pairs with a missing value or label are dropped, and groups are kept in order
+// of the sorted labels (as R orders factor levels).
+/**
+ * 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 function labelledGroups(x, g, emptyGroups = "drop") {
+    if (g === undefined) {
+        const list = x;
+        if (list.length > 0 && typeof list[0] === "number")
+            throw new TypeError("'g' is required when 'x' is a single sample");
+        const all = list.map((s) => Array.from(s).filter((v) => !Number.isNaN(v)));
+        if (emptyGroups === "error" && all.some((s) => s.length === 0))
+            throw new RangeError("all groups must contain data");
+        const labels = [];
+        const groups = [];
+        all.forEach((s, i) => {
+            if (s.length === 0)
+                return;
+            labels.push(String(i + 1));
+            groups.push(s);
+        });
+        return { labels, groups };
+    }
+    const xs = Array.from(x);
+    if (xs.length !== g.length)
+        throw new RangeError("'x' and 'g' must have the same length");
+    const byLabel = new Map();
+    for (let i = 0; i < xs.length; i++) {
+        const v = xs[i];
+        const l = g[i];
+        if (Number.isNaN(v) || (typeof l === "number" && Number.isNaN(l)))
+            continue;
+        let arr = byLabel.get(l);
+        if (arr === undefined)
+            byLabel.set(l, (arr = []));
+        arr.push(v);
+    }
+    const labels = Array.from(byLabel.keys()).sort((a, b) => typeof a === "number" && typeof b === "number" ? a - b : String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0);
+    return { labels: labels.map(String), groups: labels.map((l) => byLabel.get(l)) };
+}
+/** Normalise the two input forms to an array of non-empty groups with NaN removed (see {@link labelledGroups}) */
+export function toGroups(x, g, emptyGroups = "drop") {
+    return labelledGroups(x, g, emptyGroups).groups;
+}
+/** Median (the mean of the two middle values for an even count) */
+export function median(x) {
+    const s = [...x].sort((a, b) => a - b);
+    const n = s.length;
+    return n % 2 === 1 ? s[(n - 1) / 2] : (s[n / 2 - 1] + s[n / 2]) / 2;
+}
+/** Rows of a blocks x treatments table with any NaN dropped (R's complete.cases) */
+export function completeRows(y) {
+    if (y.length === 0)
+        throw new RangeError("'y' must have at least one row");
+    const k = y[0].length;
+    if (y.some((r) => r.length !== k))
+        throw new RangeError("all rows of 'y' must have the same length");
+    return y.filter((r) => r.every((v) => !Number.isNaN(v))).map((r) => Array.from(r));
+}

package/dist/htest/ksTest.d.ts

@@ -0,0 +1,31 @@
+import { type Alternative, type HTest, type Sample } from "./types.js";
+/** Options for {@link ksTest}. */
+export interface KsTestOptions {
+    /**
+     * Alternative hypothesis (unambiguous abbreviations accepted). `"greater"`: the distribution function of `x` lies
+     * above that of `y` (statistic D^+); `"less"`: below (D^-). Default `"two.sided"`.
+     */
+    alternative?: Alternative | "two" | "l" | "g";
+    /**
+     * Exact p-value. Default: exact for one sample of fewer than 100 values without ties, and for two samples with
+     * m n < 10000.
+     */
+    exact?: boolean;
+}
+/**
+ * Result of {@link ksTest}. As in R, `alternative` describes the hypothesis in words ("two-sided", "the CDF of x lies
+ * above the null hypothesis", ...), and `exact` tells whether the p-value is exact.
+ */
+export interface KsTestResult extends Omit<HTest, "alternative"> {
+    alternative: string;
+    exact: boolean;
+}
+/**
+ * Kolmogorov-Smirnov test. Equivalent to R's `ks.test()`, with a distribution function given as a function (for
+ * example `(q) => pnorm(q)`) or a second sample. `NaN` values are dropped.
+ *
+ * @param x Sample.
+ * @param y A continuous distribution function, or a second sample.
+ * @param options See {@link KsTestOptions}.
+ */
+export declare function ksTest(x: Sample, y: Sample | ((q: number) => number), options?: KsTestOptions): KsTestResult;

package/dist/htest/ksTest.js

@@ -0,0 +1,106 @@
+// Kolmogorov-Smirnov tests (R's ks.test): one sample against a continuous distribution function, or two samples.
+//
+// Written for rStats.js (no ported code); the distributions are in src/htest/core (kolmogorov.ts, smirnov.ts).
+// One sample: D+ = max(i/n - F(x_(i))), D- = max(F(x_(i)) - (i - 1)/n); exact p-values (by default for n < 100
+// without ties) from Marsaglia, Tsang and Wang (two-sided) and Birnbaum and Tingey (one-sided), asymptotic ones from
+// Kolmogorov's limit and exp(-2 n D^2). Two samples: the largest differences of the empirical distribution functions,
+// taken only where the pooled sorted values change; exact p-values (by default for m n < 10000, with or without ties)
+// by counting lattice paths, asymptotic ones as for one sample with n replaced by m n / (m + n).
+import { pkolmogorovExact, pkolmogorovLimit, pkolmogorovOneSidedUpper } from "./core/kolmogorov.js";
+import { psmirnovUpper } from "./core/smirnov.js";
+import { matchAlternative } from "./types.js";
+function describe(alternative, oneSample) {
+    if (alternative === "two.sided")
+        return "two-sided";
+    const where = alternative === "less" ? "below" : "above";
+    return `the CDF of x lies ${where} ${oneSample ? "the null hypothesis" : "that of y"}`;
+}
+/**
+ * Kolmogorov-Smirnov test. Equivalent to R's `ks.test()`, with a distribution function given as a function (for
+ * example `(q) => pnorm(q)`) or a second sample. `NaN` values are dropped.
+ *
+ * @param x Sample.
+ * @param y A continuous distribution function, or a second sample.
+ * @param options See {@link KsTestOptions}.
+ */
+export function ksTest(x, y, options = {}) {
+    const xs = Array.from(x)
+        .filter((v) => !Number.isNaN(v))
+        .sort((a, b) => a - b);
+    const n = xs.length;
+    if (n < 1)
+        throw new RangeError("not enough 'x' data");
+    const alternative = matchAlternative(options.alternative);
+    const statisticName = alternative === "two.sided" ? "D" : alternative === "greater" ? "D^+" : "D^-";
+    if (typeof y === "function") {
+        let dplus = -Infinity;
+        let dminus = -Infinity;
+        for (let i = 0; i < n; i++) {
+            const f = y(xs[i]);
+            dplus = Math.max(dplus, (i + 1) / n - f);
+            dminus = Math.max(dminus, f - i / n);
+        }
+        const statistic = alternative === "two.sided" ? Math.max(dplus, dminus) : alternative === "greater" ? dplus : dminus;
+        const ties = new Set(xs).size < n;
+        const exact = options.exact ?? (n < 100 && !ties);
+        let pValue;
+        if (alternative === "two.sided") {
+            pValue = exact ? 1 - pkolmogorovExact(n, statistic) : pkolmogorovLimit(Math.sqrt(n) * statistic, false);
+        }
+        else {
+            pValue = exact ? pkolmogorovOneSidedUpper(n, statistic) : Math.exp(-2 * n * statistic * statistic);
+        }
+        return {
+            method: `${exact ? "Exact" : "Asymptotic"} one-sample Kolmogorov-Smirnov test`,
+            alternative: describe(alternative, true),
+            exact,
+            statistic,
+            statisticName,
+            pValue: Math.min(1, Math.max(0, pValue)),
+        };
+    }
+    const ys = Array.from(y).filter((v) => !Number.isNaN(v));
+    const m = ys.length;
+    if (m < 1)
+        throw new RangeError("not enough 'y' data");
+    // walk the pooled sorted values, recording F_x - F_y after each run of equal values
+    const pooled = xs.map((v) => [v, 0]).concat(ys.map((v) => [v, 1]));
+    pooled.sort((a, b) => a[0] - b[0]);
+    let fx = 0;
+    let fy = 0;
+    let dplus = 0;
+    let dminus = 0;
+    for (let i = 0; i < pooled.length; i++) {
+        if (pooled[i][1] === 0)
+            fx++;
+        else
+            fy++;
+        if (i + 1 < pooled.length && pooled[i + 1][0] === pooled[i][0])
+            continue;
+        const diff = fx / n - fy / m;
+        dplus = Math.max(dplus, diff);
+        dminus = Math.max(dminus, -diff);
+    }
+    const statistic = alternative === "two.sided" ? Math.max(dplus, dminus) : alternative === "greater" ? dplus : dminus;
+    const ties = new Set(pooled.map((p) => p[0])).size < pooled.length;
+    const exact = options.exact ?? n * m < 10000;
+    let pValue;
+    if (exact) {
+        pValue = psmirnovUpper(statistic, n, m, ties ? { alternative, z: pooled.map((p) => p[0]) } : { alternative });
+    }
+    else {
+        const en = (n * m) / (n + m);
+        pValue =
+            alternative === "two.sided"
+                ? pkolmogorovLimit(Math.sqrt(en) * statistic, false)
+                : Math.exp(-2 * en * statistic * statistic);
+    }
+    return {
+        method: `${exact ? "Exact" : "Asymptotic"} two-sample Kolmogorov-Smirnov test`,
+        alternative: describe(alternative, false),
+        exact,
+        statistic,
+        statisticName,
+        pValue: Math.min(1, Math.max(0, pValue)),
+    };
+}

package/dist/htest/mantelhaenTest.d.ts

@@ -0,0 +1,26 @@
+import { type Alternative, type HTest } from "./types.js";
+/** Options for {@link mantelhaenTest}. */
+export interface MantelhaenTestOptions {
+    /** Alternative hypothesis (2 x 2 x K only). Default `"two.sided"`. */
+    alternative?: Alternative | "two" | "l" | "g";
+    /** Continuity correction (2 x 2 x K, asymptotic test). Default `true`. */
+    correct?: boolean;
+    /** Exact conditional test (2 x 2 x K). Default `false`. */
+    exact?: boolean;
+    /** Confidence level of the interval for the common odds ratio. Default `0.95`. */
+    confLevel?: number;
+}
+/** Result of {@link mantelhaenTest}. 2 x 2 x K tables add the common odds ratio and its interval. */
+export interface MantelhaenTestResult extends Omit<HTest, "alternative"> {
+    /** Present for 2 x 2 x K tables. */
+    alternative?: Alternative;
+}
+/**
+ * Cochran-Mantel-Haenszel chi-squared test of conditional independence in a set of contingency tables, one per
+ * stratum. Equivalent to R's `mantelhaen.test()` with a three-dimensional array.
+ *
+ * @param strata The K strata, each an I x J table of counts as an array of rows (all of the same shape; I, J >= 2,
+ *   K >= 2 for the asymptotic test).
+ * @param options See {@link MantelhaenTestOptions}.
+ */
+export declare function mantelhaenTest(strata: readonly (readonly (readonly number[])[])[], options?: MantelhaenTestOptions): MantelhaenTestResult;

package/dist/htest/mantelhaenTest.js

@@ -0,0 +1,196 @@
+// Cochran-Mantel-Haenszel tests for stratified contingency tables (R's mantelhaen.test).
+//
+// Written for rStats.js from the published methods and R's behaviour:
+// - 2 x 2 x K: the Mantel-Haenszel statistic (|sum a - sum E(a)| - c)^2 / sum Var(a) with E(a) = r1 c1 / t and
+//   Var(a) = r1 r2 c1 c2 / (t^2 (t - 1)) per stratum (Mantel and Haenszel, JNCI 22, 1959), continuity correction
+//   c = 1/2 unless |sum a - sum E(a)| < 1/2; the Mantel-Haenszel common odds ratio sum(a d / t) / sum(b c / t), with
+//   the interval from the variance of its log by Robins, Breslow and Greenland (Biometrics 42, 1986).
+// - 2 x 2 x K exact (exact = TRUE): the conditional distribution of S = sum a given all margins, a convolution of
+//   noncentral hypergeometric distributions with the common odds ratio as noncentrality (src/htest/core/mantelhaen.ts;
+//   Birch, JRSS B 26, 1964). One-sided p-values are tail probabilities under psi = 1; the two-sided p-value adds the
+//   null probabilities no larger than the observed one (relative slack 1e-7), and the estimate and limits are the
+//   conditional MLE and the noncentralities at which a one-sided probability equals alpha.
+// - I x J x K: the generalized statistic (n - m)' V^-1 (n - m) on the first (I - 1)(J - 1) cells summed over strata,
+//   with the hypergeometric covariance V = (t^2 (t - 1))^-1 (t diag(r) - r r') (x) (t diag(c) - c c') per stratum
+//   (Landis, Heyman and Koch, Int. Stat. Review 46, 1978); chi-squared with (I - 1)(J - 1) degrees of freedom.
+import { pgamma1 } from "../distributions/gamma.js";
+import { pnorm, qnorm } from "../distributions/normal.js";
+import { solve } from "../linalg/solve.js";
+import { ddAdd } from "../special/dd.js";
+import { ConvolvedNoncentralHyper, conditionalMLE, lowerLimit, upperLimit } from "./core/mantelhaen.js";
+import { checkConfLevelOpen, matchAlternative } from "./types.js";
+/**
+ * Cochran-Mantel-Haenszel chi-squared test of conditional independence in a set of contingency tables, one per
+ * stratum. Equivalent to R's `mantelhaen.test()` with a three-dimensional array.
+ *
+ * @param strata The K strata, each an I x J table of counts as an array of rows (all of the same shape; I, J >= 2,
+ *   K >= 2 for the asymptotic test).
+ * @param options See {@link MantelhaenTestOptions}.
+ */
+export function mantelhaenTest(strata, options = {}) {
+    const K = strata.length;
+    if (K < 1)
+        throw new RangeError("'x' must have at least one stratum");
+    const I = strata[0].length;
+    const J = strata[0][0]?.length ?? 0;
+    if (I < 2 || J < 2 || K < 2)
+        throw new RangeError("each dimension in table must be >= 2");
+    for (const t of strata) {
+        if (t.length !== I || t.some((r) => r.length !== J))
+            throw new RangeError("all strata must have the same dimensions");
+        if (t.some((r) => r.some((v) => !Number.isFinite(v) || v < 0)))
+            throw new RangeError("all entries of 'x' must be nonnegative and finite");
+    }
+    const totals = strata.map((t) => t.reduce((a, r) => a + r.reduce((b, v) => b + v, 0), 0));
+    if (totals.some((t) => t < 2))
+        throw new RangeError("sample size in each stratum must be > 1");
+    const alternative = matchAlternative(options.alternative);
+    const correct = options.correct ?? true;
+    const exact = options.exact ?? false;
+    const confLevel = options.confLevel ?? 0.95;
+    checkConfLevelOpen(confLevel);
+    if (I === 2 && J === 2) {
+        const tables = strata.map((t) => [[t[0][0], t[0][1]], [t[1][0], t[1][1]]]);
+        return exact ? exact2x2xK(tables, alternative, confLevel) : asymptotic2x2xK(tables, totals, alternative, correct, confLevel);
+    }
+    // as in R, exact applies to 2 x 2 x K tables only and is ignored otherwise
+    return general(strata, totals, I, J);
+}
+function asymptotic2x2xK(tables, totals, alternative, correct, confLevel) {
+    let sa = 0;
+    let se = 0;
+    let sv = 0;
+    let sR = 0;
+    let sS = 0;
+    let sPR = 0;
+    let sPSQR = 0;
+    let sQS = 0;
+    tables.forEach(([[a, b], [c, d]], k) => {
+        const t = totals[k];
+        const r1 = a + b;
+        const r2 = c + d;
+        const c1 = a + c;
+        const c2 = b + d;
+        sa += a;
+        se += (r1 * c1) / t;
+        sv += (r1 * r2 * c1 * c2) / (t * t * (t - 1));
+        const P = (a + d) / t;
+        const Q = (b + c) / t;
+        const R = (a * d) / t;
+        const S = (b * c) / t;
+        sR += R;
+        sS += S;
+        sPR += P * R;
+        sPSQR += P * S + Q * R;
+        sQS += Q * S;
+    });
+    const delta = sa - se;
+    const yates = correct && Math.abs(delta) >= 0.5 ? 0.5 : 0;
+    const statistic = (Math.abs(delta) - yates) ** 2 / sv;
+    const pValue = alternative === "two.sided"
+        ? pgamma1(statistic, 0.5, 2, false, false)
+        : pnorm(Math.sign(delta) * Math.sqrt(statistic), { lowerTail: alternative === "less" });
+    const estimate = sR / sS;
+    const sd = Math.sqrt(sPR / (2 * sR * sR) + sPSQR / (2 * sR * sS) + sQS / (2 * sS * sS));
+    let confInt;
+    if (alternative === "less")
+        confInt = [0, estimate * Math.exp(qnorm(confLevel) * sd)];
+    else if (alternative === "greater")
+        confInt = [estimate * Math.exp(qnorm(confLevel, { lowerTail: false }) * sd), Infinity];
+    else {
+        const z = qnorm((1 + confLevel) / 2);
+        confInt = [estimate * Math.exp(-z * sd), estimate * Math.exp(z * sd)];
+    }
+    return {
+        method: `Mantel-Haenszel chi-squared test ${yates !== 0 ? "with" : "without"} continuity correction`,
+        alternative,
+        statistic,
+        statisticName: "Mantel-Haenszel X-squared",
+        parameter: 1,
+        parameterName: "df",
+        pValue,
+        confInt,
+        confLevel,
+        estimate,
+        estimateNames: "common odds ratio",
+        nullValue: 1,
+        nullValueName: "common odds ratio",
+    };
+}
+/** Exact conditional test on 2 x 2 x K tables: S = sum of the (1, 1) cells given all margins */
+function exact2x2xK(tables, alternative, confLevel) {
+    const h = new ConvolvedNoncentralHyper(tables);
+    const s = tables.reduce((acc, t) => acc + t[0][0], 0);
+    let pValue;
+    if (alternative === "two.sided") {
+        // add the null probabilities of the sums no more likely than the observed one (relative slack 1e-7)
+        const d0 = h.density(1);
+        const cut = d0[s - h.lo] * (1 + 1e-7);
+        let acc = [0, 0];
+        for (const v of d0)
+            if (v <= cut)
+                acc = ddAdd(acc, [v, 0]);
+        pValue = Math.min(1, acc[0]);
+    }
+    else
+        pValue = h.cdf(s, 1, alternative === "greater");
+    let confInt;
+    if (alternative === "less")
+        confInt = [0, upperLimit(h, s, 1 - confLevel)];
+    else if (alternative === "greater")
+        confInt = [lowerLimit(h, s, 1 - confLevel), Infinity];
+    else {
+        const alpha = (1 - confLevel) / 2;
+        confInt = [lowerLimit(h, s, alpha), upperLimit(h, s, alpha)];
+    }
+    return {
+        method: "Exact conditional test of independence in 2 x 2 x k tables",
+        alternative,
+        statistic: s,
+        statisticName: "S",
+        pValue,
+        confInt,
+        confLevel,
+        estimate: conditionalMLE(h, s),
+        estimateNames: "common odds ratio",
+        nullValue: 1,
+        nullValueName: "common odds ratio",
+    };
+}
+function general(strata, totals, I, J) {
+    const p = (I - 1) * (J - 1);
+    const diff = new Array(p).fill(0);
+    const V = Array.from({ length: p }, () => new Array(p).fill(0));
+    strata.forEach((tab, k) => {
+        const t = totals[k];
+        const r = tab.map((row) => row.reduce((a, b) => a + b, 0));
+        const c = Array.from({ length: J }, (_, j) => tab.reduce((a, row) => a + row[j], 0));
+        const f = 1 / (t * t * (t - 1));
+        // cell (i, j) of the first I - 1 rows and J - 1 columns is element i + (I - 1) j (column-major, as in R)
+        for (let j = 0; j < J - 1; j++) {
+            for (let i = 0; i < I - 1; i++) {
+                const u = i + (I - 1) * j;
+                diff[u] += tab[i][j] - (r[i] * c[j]) / t;
+                for (let jj = 0; jj < J - 1; jj++) {
+                    for (let ii = 0; ii < I - 1; ii++) {
+                        const vr = (i === ii ? t * r[i] : 0) - r[i] * r[ii];
+                        const vc = (j === jj ? t * c[j] : 0) - c[j] * c[jj];
+                        V[u][ii + (I - 1) * jj] += f * vr * vc;
+                    }
+                }
+            }
+        }
+    });
+    const sol = solve(V, diff);
+    let statistic = 0;
+    for (let u = 0; u < p; u++)
+        statistic += diff[u] * sol[u];
+    return {
+        method: "Cochran-Mantel-Haenszel test",
+        statistic,
+        statisticName: "Cochran-Mantel-Haenszel M^2",
+        parameter: p,
+        parameterName: "df",
+        pValue: pgamma1(statistic, p / 2, 2, false, false),
+    };
+}

package/dist/htest/mcnemarTest.d.ts

@@ -0,0 +1,26 @@
+import type { HTest } from "./types.js";
+/** Options for {@link mcnemarTest}. */
+export interface McnemarTestOptions {
+    /** Apply the continuity correction (2 x 2 tables only). Default `true`. */
+    correct?: boolean;
+}
+/** Result of {@link mcnemarTest}. Has no `alternative`, as R's `mcnemar.test()` returns none. */
+export interface McnemarTestResult extends Omit<HTest, "alternative"> {
+    /** Degrees of freedom (`parameterName` is `"df"`). */
+    parameter: number;
+}
+/**
+ * McNemar's chi-squared test for symmetry of rows and columns in a square table of counts. Equivalent to R's
+ * `mcnemar.test()` with a matrix, or with two factors given as paired category codes.
+ *
+ * @param x Square table of counts as an array of rows, or the first of two paired samples of category codes.
+ * @param y Second paired sample of category codes, when `x` is a sample. May be omitted (and the options passed in
+ *   its place) when `x` is a table.
+ * @param options See {@link McnemarTestOptions}.
+ *
+ * @example
+ * ```ts
+ * mcnemarTest([[794, 86], [150, 570]]).statistic; // 34.71186
+ * ```
+ */
+export declare function mcnemarTest(x: readonly (readonly number[])[] | readonly (number | string)[], y?: readonly (number | string)[] | McnemarTestOptions, options?: McnemarTestOptions): McnemarTestResult;

package/dist/htest/mcnemarTest.js

@@ -0,0 +1,99 @@
+// McNemar's test of symmetry for a square contingency table (R's mcnemar.test).
+//
+// Written for rStats.js from the textbook construction (McNemar, Psychometrika 12, 1947; no ported code):
+// sum over i < j of (n_ij - n_ji)^2 / (n_ij + n_ji), chi-squared with r (r - 1) / 2 degrees of freedom. For a 2 x 2
+// table the continuity correction replaces |n_12 - n_21| by |n_12 - n_21| - 1.
+import { pgamma1 } from "../distributions/gamma.js";
+/**
+ * McNemar's chi-squared test for symmetry of rows and columns in a square table of counts. Equivalent to R's
+ * `mcnemar.test()` with a matrix, or with two factors given as paired category codes.
+ *
+ * @param x Square table of counts as an array of rows, or the first of two paired samples of category codes.
+ * @param y Second paired sample of category codes, when `x` is a sample. May be omitted (and the options passed in
+ *   its place) when `x` is a table.
+ * @param options See {@link McnemarTestOptions}.
+ *
+ * @example
+ * ```ts
+ * mcnemarTest([[794, 86], [150, 570]]).statistic; // 34.71186
+ * ```
+ */
+export function mcnemarTest(x, y, options = {}) {
+    let table;
+    if (x.length > 0 && Array.isArray(x[0])) {
+        if (y !== undefined && !Array.isArray(y))
+            options = y;
+        table = x.map((row) => Array.from(row));
+        const r = table.length;
+        if (r < 2 || table.some((row) => row.length !== r))
+            throw new RangeError("'x' must be square with at least two rows and columns");
+        if (table.some((row) => row.some((v) => !Number.isFinite(v) || v < 0)))
+            throw new RangeError("all entries of 'x' must be nonnegative and finite");
+    }
+    else {
+        if (!Array.isArray(y))
+            throw new TypeError("'y' is required when 'x' is not a table");
+        table = crossTable(x, y);
+    }
+    const correct = options.correct ?? true;
+    const r = table.length;
+    let statistic;
+    // as in R, a symmetric 2 x 2 table gets no correction (it would make the statistic positive)
+    const useCorrection = correct && r === 2 && table[0][1] !== table[1][0];
+    if (useCorrection) {
+        const b = table[0][1];
+        const c = table[1][0];
+        statistic = (Math.abs(b - c) - 1) ** 2 / (b + c);
+    }
+    else {
+        statistic = 0;
+        for (let i = 0; i < r; i++) {
+            for (let j = i + 1; j < r; j++) {
+                const a = table[i][j];
+                const b = table[j][i];
+                statistic += (a - b) ** 2 / (a + b);
+            }
+        }
+    }
+    const df = (r * (r - 1)) / 2;
+    return {
+        method: useCorrection ? "McNemar's Chi-squared test with continuity correction" : "McNemar's Chi-squared test",
+        statistic,
+        statisticName: "McNemar's chi-squared",
+        parameter: df,
+        parameterName: "df",
+        pValue: pgamma1(statistic, df / 2, 2, false, false),
+    };
+}
+/**
+ * Cross-tabulation of two paired samples of category codes (pairs with a missing value dropped), as R tabulates two
+ * factors: the rows are the levels of x and the columns those of y, each sorted (numbers numerically, strings as R
+ * sorts factor levels in the C locale). As in R, both must have the same number of levels, at least 2; the levels
+ * are matched by position, not by value.
+ */
+function crossTable(x, y) {
+    if (x.length !== y.length)
+        throw new RangeError("'x' and 'y' must have the same length");
+    const keep = [];
+    for (let i = 0; i < x.length; i++) {
+        const a = x[i];
+        const b = y[i];
+        if (typeof a === "number" && Number.isNaN(a))
+            continue;
+        if (typeof b === "number" && Number.isNaN(b))
+            continue;
+        keep.push([a, b]);
+    }
+    const levelsOf = (v) => Array.from(new Set(v)).sort((a, b) => typeof a === "number" && typeof b === "number" ? a - b : String(a) < String(b) ? -1 : String(a) > String(b) ? 1 : 0);
+    const lx = levelsOf(keep.map((p) => p[0]));
+    const ly = levelsOf(keep.map((p) => p[1]));
+    if (lx.length < 2 || lx.length !== ly.length) {
+        throw new RangeError("'x' and 'y' must have the same number of levels (minimum 2)");
+    }
+    const ix = new Map(lx.map((v, i) => [v, i]));
+    const iy = new Map(ly.map((v, i) => [v, i]));
+    const t = lx.map(() => new Array(lx.length).fill(0));
+    for (const [a, b] of keep)
+        t[ix.get(a)][iy.get(b)]++;
+    return t;
+}

package/dist/htest/onewayTest.d.ts

@@ -0,0 +1,26 @@
+import { type GroupLabel } from "./groups.js";
+import type { HTest, Sample } from "./types.js";
+/** Options for {@link onewayTest}. */
+export interface OnewayTestOptions {
+    /** Assume equal variances (the classical F test). Default `false` (Welch's test). */
+    varEqual?: boolean;
+}
+/** Result of {@link onewayTest}: an F statistic with two degrees of freedom. */
+export interface OnewayTestResult extends Omit<HTest, "alternative" | "parameter" | "parameterName"> {
+    /** `[num df, denom df]`. */
+    parameter: [number, number];
+    parameterName: [string, string];
+}
+/**
+ * Test that several normal samples have equal means, without (default) or with the assumption of equal variances.
+ * Equivalent to R's `oneway.test()`.
+ *
+ * @param x An array of samples, or one sample with group labels `g`.
+ * @param g Group labels, parallel to `x` (or the options, when `x` is an array of samples).
+ */
+export declare function onewayTest(x: Sample | readonly Sample[], g?: readonly GroupLabel[] | OnewayTestOptions, options?: OnewayTestOptions): OnewayTestResult;
+/**
+ * Shapiro-Wilk test of normality. Equivalent to R's `shapiro.test()`. `NaN` values are dropped; the sample size must
+ * be between 3 and 5000.
+ */
+export declare function shapiroTest(x: Sample): Omit<HTest, "alternative">;

package/dist/htest/onewayTest.js

@@ -0,0 +1,97 @@
+// One-way analysis of means (R's oneway.test) and the Shapiro-Wilk normality test (R's shapiro.test).
+//
+// Written for rStats.js from the published formulas (no ported code). oneway.test: with equal variances the classical
+// F = (sum n_i (m_i - m)^2 / (k - 1)) / (sum (n_i - 1) s_i^2 / (N - k)); otherwise Welch's (Biometrika 38, 1951)
+// weighted statistic with w_i = n_i / s_i^2, F = sum w_i (m_i - m_w)^2 / ((k - 1)(1 + 2 (k - 2) c)),
+// c = sum (1 - w_i / sum w)^2 / (n_i - 1) / (k^2 - 1), on (k - 1, 1 / (3 c)) degrees of freedom.
+// shapiro.test: W and its p-value from src/htest/core/shapiro.ts (Royston's AS R94).
+import { pf1 } from "../distributions/f.js";
+import { mean, variance } from "../internal/summary.js";
+import { swilkOneMinusW, swilkPValueFromOneMinusW } from "./core/shapiro.js";
+import { toGroups } from "./groups.js";
+/**
+ * Test that several normal samples have equal means, without (default) or with the assumption of equal variances.
+ * Equivalent to R's `oneway.test()`.
+ *
+ * @param x An array of samples, or one sample with group labels `g`.
+ * @param g Group labels, parallel to `x` (or the options, when `x` is an array of samples).
+ */
+export function onewayTest(x, g, options = {}) {
+    let labels;
+    if (g !== undefined && !Array.isArray(g))
+        options = g;
+    else
+        labels = g;
+    const groups = toGroups(x, labels);
+    const varEqual = options.varEqual ?? false;
+    const k = groups.length;
+    if (k < 2)
+        throw new RangeError("not enough groups");
+    const ni = groups.map((s) => s.length);
+    if (ni.some((n) => n < 2))
+        throw new RangeError("not enough observations");
+    const mi = groups.map(mean);
+    const vi = groups.map(variance);
+    const N = ni.reduce((a, b) => a + b, 0);
+    let statistic;
+    let df2;
+    if (varEqual) {
+        const m = mean(groups.flat());
+        let between = 0;
+        let within = 0;
+        for (let i = 0; i < k; i++) {
+            between += ni[i] * (mi[i] - m) ** 2;
+            within += (ni[i] - 1) * vi[i];
+        }
+        df2 = N - k;
+        statistic = between / (k - 1) / (within / df2);
+    }
+    else {
+        const wi = ni.map((n, i) => n / vi[i]);
+        const sw = wi.reduce((a, b) => a + b, 0);
+        let c = 0;
+        let mw = 0;
+        for (let i = 0; i < k; i++) {
+            c += (1 - wi[i] / sw) ** 2 / (ni[i] - 1);
+            mw += wi[i] * mi[i];
+        }
+        c /= k * k - 1;
+        mw /= sw;
+        let num = 0;
+        for (let i = 0; i < k; i++)
+            num += wi[i] * (mi[i] - mw) ** 2;
+        statistic = num / ((k - 1) * (1 + 2 * (k - 2) * c));
+        df2 = 1 / (3 * c);
+    }
+    return {
+        method: varEqual ? "One-way analysis of means" : "One-way analysis of means (not assuming equal variances)",
+        statistic,
+        statisticName: "F",
+        parameter: [k - 1, df2],
+        parameterName: ["num df", "denom df"],
+        pValue: pf1(statistic, k - 1, df2, false, false),
+    };
+}
+/**
+ * Shapiro-Wilk test of normality. Equivalent to R's `shapiro.test()`. `NaN` values are dropped; the sample size must
+ * be between 3 and 5000.
+ */
+export function shapiroTest(x) {
+    const xs = Array.from(x)
+        .filter((v) => !Number.isNaN(v))
+        .sort((a, b) => a - b);
+    const n = xs.length;
+    if (n < 3 || n > 5000)
+        throw new RangeError("sample size must be between 3 and 5000");
+    if (!Number.isFinite(xs[0]) || !Number.isFinite(xs[n - 1]))
+        throw new RangeError("'x' must be finite");
+    if (xs[n - 1] === xs[0])
+        throw new RangeError("all 'x' values are identical");
+    const w1 = swilkOneMinusW(xs);
+    return {
+        method: "Shapiro-Wilk normality test",
+        statistic: 1 - w1,
+        statisticName: "W",
+        pValue: swilkPValueFromOneMinusW(w1, n),
+    };
+}