@numero-uno-jpn/rstats 0.5.0 → 0.6.1

package/dist/entries/linalg.js

@@ -0,0 +1,11 @@
+// Linear algebra (rStats.js/linalg): matrices are arrays of rows
+export { crossprod, tcrossprod, backsolve, forwardsolve } from "../linalg/basic.js";
+export { norm } from "../linalg/norm.js";
+export { chol, chol2inv } from "../linalg/chol.js";
+export { qr, qrQ, qrR, qrX, qrCoef, qrQy, qrQty, qrResid, qrFitted, qrSolve } from "../linalg/qr.js";
+export { solve, det, determinant, rcond } from "../linalg/solve.js";
+export { svd } from "../linalg/svd.js";
+export { kappa, ginv } from "../linalg/kappa.js";
+export { eigen } from "../linalg/eigen.js";
+export { matMul, add, subtract, multiply, divide, outer, t, diag, cbind, rbind, matrix, kronecker, seq, } from "../linalg/ops.js";
+export { lu, prcomp } from "../linalg/lu.js";

package/dist/entries/numerics.d.ts

@@ -0,0 +1,8 @@
+export { integrate, optimize, uniroot } from "../numerics/integrate.js";
+export type { IntegrateOptions, IntegrateResult, OptimizeOptions, UnirootOptions, UnirootResult } from "../numerics/integrate.js";
+export { approx, barylag, hermiteInterp, spline, splinefun, splinefunH } from "../numerics/interp.js";
+export type { ApproxOptions, SplineMethod, SplineOptions, SplinefunOptions } from "../numerics/interp.js";
+export { ode } from "../numerics/ode.js";
+export type { OdeFunc, OdeOptions } from "../numerics/ode.js";
+export { grad, hessian, jacobian } from "../numerics/deriv.js";
+export type { DerivOptions } from "../numerics/deriv.js";

package/dist/entries/numerics.js

@@ -0,0 +1,6 @@
+// Numerical methods (rStats.js/numerics): integration, optimisation, root finding, interpolation, ODEs and
+// numerical derivatives
+export { integrate, optimize, uniroot } from "../numerics/integrate.js";
+export { approx, barylag, hermiteInterp, spline, splinefun, splinefunH } from "../numerics/interp.js";
+export { ode } from "../numerics/ode.js";
+export { grad, hessian, jacobian } from "../numerics/deriv.js";

package/dist/entries/special.d.ts

@@ -0,0 +1,9 @@
+export { gamma, lgamma } from "../special/gamma.js";
+export { beta, lbeta } from "../special/beta.js";
+export { choose, lchoose, factorial, lfactorial } from "../special/choose.js";
+export type { RCompatibleOptions } from "../special/rCompatible.js";
+export { digamma, trigamma, psigamma } from "../special/psigamma.js";
+export { besselI, besselK, type BesselOptions } from "../special/besselIK.js";
+export { besselJ, besselY } from "../special/besselJY.js";
+export { erf, erfc } from "../special/erf.js";
+export { gammainc, erfinv, erfcinv, perm, type GammaincResult } from "../special/extra.js";

package/dist/entries/special.js

@@ -0,0 +1,9 @@
+// Special functions (rStats.js/special): gamma, beta and Bessel functions, erf, ...
+export { gamma, lgamma } from "../special/gamma.js";
+export { beta, lbeta } from "../special/beta.js";
+export { choose, lchoose, factorial, lfactorial } from "../special/choose.js";
+export { digamma, trigamma, psigamma } from "../special/psigamma.js";
+export { besselI, besselK } from "../special/besselIK.js";
+export { besselJ, besselY } from "../special/besselJY.js";
+export { erf, erfc } from "../special/erf.js";
+export { gammainc, erfinv, erfcinv, perm } from "../special/extra.js";

package/dist/entries/tests.d.ts

@@ -0,0 +1,21 @@
+export { tTest, type TTestOptions, type TTestResult } from "../htest/tTest.js";
+export { chisqTest, type ChisqTestOptions, type ChisqTestResult } from "../htest/chisqTest.js";
+export { fisherTest, type FisherTestOptions, type FisherTestResult } from "../htest/fisherTest.js";
+export { wilcoxTest, type WilcoxTestOptions, type WilcoxTestResult } from "../htest/wilcoxTest.js";
+export { corTest, type CorMethod, type CorOptions, type CorTestOptions, type CorTestResult } from "../htest/cor.js";
+export { pAdjust, type PAdjustMethod, type PAdjustOptions } from "../htest/pAdjust.js";
+export type { Alternative, Counts, HTest, Sample } from "../htest/types.js";
+export { binomTest, type BinomTestOptions, type BinomTestResult } from "../htest/binomTest.js";
+export { poissonTest, type PoissonTestOptions, type PoissonTestResult } from "../htest/poissonTest.js";
+export { propTest, type PropTestOptions, type PropTestResult } from "../htest/propTest.js";
+export { mcnemarTest, type McnemarTestOptions, type McnemarTestResult } from "../htest/mcnemarTest.js";
+export { varTest, bartlettTest, type VarTestOptions, type VarTestResult, type BartlettTestResult } from "../htest/varTest.js";
+export { kruskalTest, friedmanTest, quadeTest, flignerTest, moodTest, type ChisqStatTestResult, type QuadeTestResult, type MoodTestOptions, } from "../htest/rankTests.js";
+export { onewayTest, shapiroTest, type OnewayTestOptions, type OnewayTestResult } from "../htest/onewayTest.js";
+export { mantelhaenTest, type MantelhaenTestOptions, type MantelhaenTestResult } from "../htest/mantelhaenTest.js";
+export { ansariTest, type AnsariTestOptions } from "../htest/ansariTest.js";
+export { ksTest, type KsTestOptions, type KsTestResult } from "../htest/ksTest.js";
+export { pairwiseTTest, pairwiseWilcoxTest, pairwisePropTest, type PairwiseResult, type PairwiseOptions, type PairwiseTTestOptions, type PairwiseWilcoxTestOptions, type PairwisePropTestOptions, } from "../htest/pairwise.js";
+export { aov, TukeyHSD, zTest, type AovResult, type TukeyHSDOptions, type TukeyHSDResult, type ZTestOptions } from "../htest/aov.js";
+export type { GroupLabel } from "../htest/groups.js";
+export { lm, confint, predict, type LmOptions, type LmResult, type ConfintOptions, type PredictOptions } from "../models/lm.js";

package/dist/entries/tests.js

@@ -0,0 +1,20 @@
+// Hypothesis tests (rStats.js/tests): R's htest results as plain objects
+export { tTest } from "../htest/tTest.js";
+export { chisqTest } from "../htest/chisqTest.js";
+export { fisherTest } from "../htest/fisherTest.js";
+export { wilcoxTest } from "../htest/wilcoxTest.js";
+export { corTest } from "../htest/cor.js";
+export { pAdjust } from "../htest/pAdjust.js";
+export { binomTest } from "../htest/binomTest.js";
+export { poissonTest } from "../htest/poissonTest.js";
+export { propTest } from "../htest/propTest.js";
+export { mcnemarTest } from "../htest/mcnemarTest.js";
+export { varTest, bartlettTest } from "../htest/varTest.js";
+export { kruskalTest, friedmanTest, quadeTest, flignerTest, moodTest, } from "../htest/rankTests.js";
+export { onewayTest, shapiroTest } from "../htest/onewayTest.js";
+export { mantelhaenTest } from "../htest/mantelhaenTest.js";
+export { ansariTest } from "../htest/ansariTest.js";
+export { ksTest } from "../htest/ksTest.js";
+export { pairwiseTTest, pairwiseWilcoxTest, pairwisePropTest, } from "../htest/pairwise.js";
+export { aov, TukeyHSD, zTest } from "../htest/aov.js";
+export { lm, confint, predict } from "../models/lm.js";

package/dist/htest/ansariTest.d.ts

@@ -0,0 +1,13 @@
+import { type Alternative, type HTest, type Sample } from "./types.js";
+/** Options for {@link ansariTest}. */
+export interface AnsariTestOptions {
+    /** Alternative hypothesis (unambiguous abbreviations accepted). Default `"two.sided"`. */
+    alternative?: Alternative | "two" | "l" | "g";
+    /** Exact p-value. Default: exact when both samples have fewer than 50 values and there are no ties. */
+    exact?: boolean;
+}
+/**
+ * Ansari-Bradley test that two samples differ in scale. Equivalent to R's `ansari.test()` (without `conf.int`).
+ * `NaN` values are dropped.
+ */
+export declare function ansariTest(x: Sample, y: Sample, options?: AnsariTestOptions): HTest;

package/dist/htest/ansariTest.js

@@ -0,0 +1,80 @@
+// Ansari-Bradley two-sample test of scale (R's ansari.test, without the optional confidence interval).
+//
+// Written for rStats.js from the published test (Ansari and Bradley, Ann. Math. Stat. 31, 1960; no ported code).
+// Scores min(r, N + 1 - r) of the pooled ranks r (average ranks for ties); the statistic is the sum over the first
+// sample. Small samples without ties use the exact null distribution (src/htest/core/ansari.ts); the two-sided
+// p-value doubles the tail on the statistic's side of the centre floor((m+1)^2/4) + floor(m n / 2)/2 (the centre
+// follows R's ansari.test behaviour). Otherwise the statistic is standardised and compared with the normal, with Ansari
+// and Bradley's mean and the variance of a linear rank statistic from the observed sum of squared scores (the form
+// scipy.stats.ansari also uses).
+import { pnorm } from "../distributions/normal.js";
+import { rank } from "../internal/summary.js";
+import { pansariExact } from "./core/ansari.js";
+import { matchAlternative } from "./types.js";
+/**
+ * Ansari-Bradley test that two samples differ in scale. Equivalent to R's `ansari.test()` (without `conf.int`).
+ * `NaN` values are dropped.
+ */
+export function ansariTest(x, y, options = {}) {
+    const xs = Array.from(x).filter((v) => !Number.isNaN(v));
+    const ys = Array.from(y).filter((v) => !Number.isNaN(v));
+    const m = xs.length;
+    const n = ys.length;
+    if (m < 1)
+        throw new RangeError("not enough 'x' observations");
+    if (n < 1)
+        throw new RangeError("not enough 'y' observations");
+    const alternative = matchAlternative(options.alternative);
+    const N = m + n;
+    const r = rank(xs.concat(ys));
+    const a = r.map((v) => Math.min(v, N - v + 1));
+    let statistic = 0;
+    for (let i = 0; i < m; i++)
+        statistic += a[i];
+    const ties = new Set(r).size < N;
+    const exact = options.exact ?? (m < 50 && n < 50 && !ties);
+    let pValue;
+    if (exact && !ties) {
+        const upperFrom = (q) => pansariExact(q - 1, m, n, false); // P(AB >= q)
+        const lowerTo = (q) => pansariExact(q, m, n, true); // P(AB <= q)
+        if (alternative === "two.sided") {
+            // the smaller tail, judged by the position of the statistic against the centre of the distribution (the centre
+            // follows R's ansari.test behaviour)
+            const centre = Math.floor((m + 1) ** 2 / 4) + Math.floor((m * n) / 2) / 2;
+            pValue = Math.min(1, 2 * (statistic > centre ? upperFrom(statistic) : lowerTo(statistic)));
+        }
+        else if (alternative === "less")
+            pValue = upperFrom(statistic);
+        else
+            pValue = lowerTo(statistic);
+    }
+    else {
+        // mean and variance with the sum of the scores at its value without ties (N (N + 2) / 4 for even N,
+        // (N + 1)^2 / 4 for odd N), and the sum of their squares as observed
+        let sq = 0;
+        for (const v of a)
+            sq += v * v;
+        const even = N % 2 === 0;
+        const mean = even ? (m * (N + 2)) / 4 : (m * (N + 1) ** 2) / (4 * N);
+        const variance = even
+            ? (m * n * (16 * sq - N * (N + 2) ** 2)) / (16 * N * (N - 1))
+            : (m * n * (16 * N * sq - (N + 1) ** 4)) / (16 * N * N * (N - 1));
+        const z = (statistic - mean) / Math.sqrt(variance);
+        // large AB means the first sample is concentrated in the middle: smaller scale
+        pValue =
+            alternative === "two.sided"
+                ? 2 * Math.min(pnorm(z), pnorm(z, { lowerTail: false }))
+                : alternative === "less"
+                    ? pnorm(z, { lowerTail: false })
+                    : pnorm(z);
+    }
+    return {
+        method: "Ansari-Bradley test",
+        alternative,
+        statistic,
+        statisticName: "AB",
+        pValue,
+        nullValue: 1,
+        nullValueName: "ratio of scales",
+    };
+}

package/dist/htest/aov.d.ts

@@ -0,0 +1,85 @@
+import { type GroupLabel } from "./groups.js";
+import { type Alternative, type HTest, type Sample } from "./types.js";
+/** Result of {@link aov}: the one-way ANOVA table, rows "between groups" and "residuals". */
+export interface AovResult {
+    /** Degrees of freedom `[k - 1, N - k]`. */
+    df: [number, number];
+    /** Sums of squares `[between, residual]`. */
+    sumSq: [number, number];
+    /** Mean squares `[between, residual]`. */
+    meanSq: [number, number];
+    /** F statistic. */
+    fValue: number;
+    /** p-value of the F test. */
+    pValue: number;
+}
+/**
+ * One-way analysis of variance. Equivalent to the table of R's `summary(aov(y ~ g))` for one factor.
+ *
+ * @param x An array of samples (groups), or one sample with group labels `g`.
+ * @param g Group labels, parallel to `x`.
+ *
+ * @example
+ * ```ts
+ * const r = aov([[2.9, 3.0, 2.5, 2.6, 3.2], [3.8, 2.7, 4.0, 2.4], [2.8, 3.4, 3.7, 2.2, 2.0]]);
+ * r.fValue; // 0.5600732600732597
+ * r.pValue; // 0.586632991041738
+ * ```
+ */
+export declare function aov(x: Sample | readonly Sample[], g?: readonly GroupLabel[]): AovResult;
+/** Options for {@link TukeyHSD}. */
+export interface TukeyHSDOptions {
+    /** Family-wise confidence level. Default `0.95`. */
+    confLevel?: number;
+}
+/** Result of {@link TukeyHSD}: one entry per pair of groups, in R's order (2-1, 3-1, ..., k-1, 3-2, ...). */
+export interface TukeyHSDResult {
+    /**
+     * Labels of the comparisons, `"a-b"`: the group labels when given, otherwise the positions of the samples in the
+     * list (from 1). Groups without data are left out, as in R.
+     */
+    names: string[];
+    /** The group compared (1-based position among the groups compared, i > j). */
+    i: number[];
+    /** The group it is compared with (1-based index). */
+    j: number[];
+    /** Difference of means, group i minus group j. */
+    diff: number[];
+    /** Lower ends of the simultaneous intervals. */
+    lwr: number[];
+    /** Upper ends. */
+    upr: number[];
+    /** p-values adjusted for the multiple comparisons. */
+    pAdj: number[];
+}
+/**
+ * Tukey's honest significant differences between the group means of a one-way ANOVA (Tukey-Kramer for unequal
+ * sizes). Equivalent to R's `TukeyHSD(aov(y ~ g))`.
+ *
+ * @param x An array of samples (groups), or one sample with group labels `g` (then `options` comes third).
+ */
+export declare function TukeyHSD(x: Sample | readonly Sample[], g?: readonly GroupLabel[] | TukeyHSDOptions, options?: TukeyHSDOptions): TukeyHSDResult;
+/** Options for {@link zTest}. */
+export interface ZTestOptions {
+    /** Known standard deviation of the population of `x` (required). */
+    sigmaX?: number;
+    /** Known standard deviation of the population of `y` (required with `y`). */
+    sigmaY?: number;
+    /** Mean (or difference of means) under the null hypothesis. Default `0`. */
+    mu?: number;
+    /** Alternative hypothesis (unambiguous abbreviations accepted). Default `"two.sided"`. */
+    alternative?: Alternative | "two" | "l" | "g";
+    /** Confidence level of the interval. Default `0.95`. */
+    confLevel?: number;
+}
+/**
+ * z test for the mean of one sample, or the difference of the means of two, with known standard deviations.
+ * Equivalent to `BSDA::z.test()` (the open end of a one-sided interval is ±Infinity here, NA in BSDA). `NaN` values
+ * are dropped.
+ *
+ * @example
+ * ```ts
+ * zTest([5.1, 4.9, 5.6, 5.8, 6.0], { mu: 5, sigmaX: 0.5 }).pValue;
+ * ```
+ */
+export declare function zTest(x: Sample, y?: Sample | ZTestOptions, options?: ZTestOptions): HTest;

package/dist/htest/aov.js

@@ -0,0 +1,178 @@
+// One-way analysis of variance (the table of R's summary(aov(y ~ g))), Tukey's honest significant differences (R's
+// TukeyHSD) and the z test with known standard deviations (as BSDA's z.test).
+//
+// Written for rStats.js from the textbook formulas. The sums of squares are accumulated in
+// double-double: between groups sum n_i (m_i - m)^2, within groups sum (x - m_i)^2, so a within sum that is exactly
+// 0 stays 0 (F = Inf; R's QR leaves rounding residue there). TukeyHSD uses the Tukey-Kramer standard error
+// sqrt(MSE / 2 (1/n_i + 1/n_j)) with the studentized range distribution for the interval and the adjusted p-value.
+// zTest is the textbook z test (standard error sigma / sqrt(n), or sqrt(sigma_x^2/n_x + sigma_y^2/n_y) for two
+// samples, normal quantiles for the interval around the estimate); its input checks (at least 3 observations,
+// confLevel allowed in the closed [0, 1]) follow BSDA's documented/observed behaviour, with messages of our own.
+import { pf1 } from "../distributions/f.js";
+import { pnorm, qnorm } from "../distributions/normal.js";
+import { ptukey, qtukey } from "../distributions/tukey.js";
+import { meanDD } from "../internal/summary.js";
+import { ddAdd, ddMul, ddSub } from "../special/dd.js";
+import { labelledGroups, toGroups } from "./groups.js";
+import { matchAlternative } from "./types.js";
+function sums(groups) {
+    const all = groups.flat();
+    const m = meanDD(all);
+    let ssb = [0, 0];
+    let ssw = [0, 0];
+    const means = [];
+    for (const g of groups) {
+        const mi = meanDD(g);
+        means.push(mi[0]);
+        const d = ddSub(mi, m);
+        ssb = ddAdd(ssb, ddMul(ddMul(d, d), [g.length, 0]));
+        for (const v of g) {
+            const e = ddSub([v, 0], mi);
+            ssw = ddAdd(ssw, ddMul(e, e));
+        }
+    }
+    return { ssb: ssb[0], ssw: ssw[0], means };
+}
+/**
+ * One-way analysis of variance. Equivalent to the table of R's `summary(aov(y ~ g))` for one factor.
+ *
+ * @param x An array of samples (groups), or one sample with group labels `g`.
+ * @param g Group labels, parallel to `x`.
+ *
+ * @example
+ * ```ts
+ * const r = aov([[2.9, 3.0, 2.5, 2.6, 3.2], [3.8, 2.7, 4.0, 2.4], [2.8, 3.4, 3.7, 2.2, 2.0]]);
+ * r.fValue; // 0.5600732600732597
+ * r.pValue; // 0.586632991041738
+ * ```
+ */
+export function aov(x, g) {
+    const groups = toGroups(x, g);
+    const k = groups.length;
+    if (k < 2)
+        throw new RangeError("contrasts can be applied only to factors with 2 or more levels");
+    const N = groups.reduce((a, s) => a + s.length, 0);
+    const { ssb, ssw } = sums(groups);
+    const df1 = k - 1;
+    const df2 = N - k;
+    const msb = ssb / df1;
+    const msw = ssw / df2;
+    const fValue = msb / msw;
+    return {
+        df: [df1, df2],
+        sumSq: [ssb, ssw],
+        meanSq: [msb, msw],
+        fValue,
+        pValue: df2 > 0 ? pf1(fValue, df1, df2, false, false) : NaN,
+    };
+}
+/**
+ * Tukey's honest significant differences between the group means of a one-way ANOVA (Tukey-Kramer for unequal
+ * sizes). Equivalent to R's `TukeyHSD(aov(y ~ g))`.
+ *
+ * @param x An array of samples (groups), or one sample with group labels `g` (then `options` comes third).
+ */
+export function TukeyHSD(x, g, options = {}) {
+    let labels;
+    if (g !== undefined && !Array.isArray(g))
+        options = g;
+    else
+        labels = g;
+    // names follow the groups: a label (or list position) whose values are all missing has no group, as R drops the
+    // unused factor level
+    const { labels: names, groups } = labelledGroups(x, labels);
+    const k = groups.length;
+    if (k < 2)
+        throw new RangeError("contrasts can be applied only to factors with 2 or more levels");
+    const confLevel = options.confLevel ?? 0.95;
+    const N = groups.reduce((a, s) => a + s.length, 0);
+    const df = N - k;
+    const { ssw, means } = sums(groups);
+    const mse = ssw / df;
+    const q = qtukey(confLevel, k, df);
+    const out = { names: [], i: [], j: [], diff: [], lwr: [], upr: [], pAdj: [] };
+    for (let b = 0; b < k - 1; b++) {
+        for (let a = b + 1; a < k; a++) {
+            const diff = means[a] - means[b];
+            const se = Math.sqrt((mse / 2) * (1 / groups[a].length + 1 / groups[b].length));
+            out.names.push(`${names[a]}-${names[b]}`);
+            out.i.push(a + 1);
+            out.j.push(b + 1);
+            out.diff.push(diff);
+            out.lwr.push(diff - q * se);
+            out.upr.push(diff + q * se);
+            out.pAdj.push(ptukey(Math.abs(diff) / se, k, df, { lowerTail: false }));
+        }
+    }
+    return out;
+}
+/**
+ * z test for the mean of one sample, or the difference of the means of two, with known standard deviations.
+ * Equivalent to `BSDA::z.test()` (the open end of a one-sided interval is ±Infinity here, NA in BSDA). `NaN` values
+ * are dropped.
+ *
+ * @example
+ * ```ts
+ * zTest([5.1, 4.9, 5.6, 5.8, 6.0], { mu: 5, sigmaX: 0.5 }).pValue;
+ * ```
+ */
+export function zTest(x, y, options = {}) {
+    let ys;
+    if (y !== undefined && !ArrayBuffer.isView(y) && !Array.isArray(y))
+        options = y;
+    else
+        ys = y;
+    const { sigmaX, sigmaY } = options;
+    const mu = options.mu ?? 0;
+    if (sigmaX === undefined && ys === undefined)
+        throw new RangeError("sigmaX (the known standard deviation of x) is required");
+    if (sigmaX === undefined || (ys !== undefined && sigmaY === undefined)) {
+        throw new RangeError("sigmaX and sigmaY are both required for two samples");
+    }
+    if (Number.isNaN(mu))
+        throw new RangeError("mu must be a number");
+    const alternative = matchAlternative(options.alternative);
+    const confLevel = options.confLevel ?? 0.95;
+    if (!(confLevel >= 0 && confLevel <= 1))
+        throw new RangeError("confLevel must be between 0 and 1");
+    const xs = Array.from(x).filter((v) => !Number.isNaN(v));
+    const yv = ys === undefined ? undefined : Array.from(ys).filter((v) => !Number.isNaN(v));
+    if (xs.length < 3)
+        throw new RangeError("x needs at least 3 non-missing values");
+    if (yv !== undefined && yv.length < 3)
+        throw new RangeError("y needs at least 3 non-missing values");
+    const meanX = meanDD(xs)[0];
+    const meanY = yv === undefined ? NaN : meanDD(yv)[0];
+    const se = yv === undefined ? sigmaX / Math.sqrt(xs.length) : Math.sqrt(sigmaX ** 2 / xs.length + sigmaY ** 2 / yv.length);
+    const target = yv === undefined ? meanX : meanX - meanY;
+    const z = (target - mu) / se;
+    let pValue;
+    let confInt;
+    if (alternative === "less") {
+        pValue = pnorm(z);
+        confInt = [-Infinity, target + qnorm(confLevel) * se];
+    }
+    else if (alternative === "greater") {
+        pValue = pnorm(z, { lowerTail: false });
+        confInt = [target - qnorm(confLevel) * se, Infinity];
+    }
+    else {
+        pValue = 2 * pnorm(-Math.abs(z));
+        const half = qnorm(1 - (1 - confLevel) / 2) * se;
+        confInt = [target - half, target + half];
+    }
+    const twoSample = yv !== undefined;
+    return {
+        method: twoSample ? "Two-sample z-Test" : "One-sample z-Test",
+        alternative,
+        statistic: z,
+        statisticName: "z",
+        pValue,
+        confInt,
+        confLevel,
+        estimate: twoSample ? [meanX, meanY] : meanX,
+        estimateNames: twoSample ? ["mean of x", "mean of y"] : "mean of x",
+        nullValue: mu,
+        nullValueName: twoSample ? "difference in means" : "mean",
+    };
+}

package/dist/htest/binomTest.d.ts

@@ -0,0 +1,36 @@
+import { type Alternative, type HTest } from "./types.js";
+/** Options for {@link binomTest}. */
+export interface BinomTestOptions {
+    /** Hypothesized probability of success. Default `0.5`. */
+    p?: number;
+    /** Alternative hypothesis (unambiguous abbreviations accepted). Default `"two.sided"`. */
+    alternative?: Alternative | "two" | "l" | "g";
+    /** Confidence level of the interval. Default `0.95`. */
+    confLevel?: number;
+}
+/** Result of {@link binomTest}. */
+export interface BinomTestResult extends HTest {
+    /** Number of trials (`parameterName` is `"number of trials"`). */
+    parameter: number;
+    /** Clopper-Pearson interval for the probability of success. */
+    confInt: [number, number];
+    confLevel: number;
+    /** Observed proportion of successes. */
+    estimate: number;
+    nullValue: number;
+}
+/**
+ * Exact test of a simple null hypothesis about the probability of success in Bernoulli trials. Equivalent to R's
+ * `binom.test()`.
+ *
+ * @param x Number of successes, or `[successes, failures]`.
+ * @param n Number of trials (ignored when `x` has two elements; may then be omitted and the options passed in its
+ *   place).
+ * @param options See {@link BinomTestOptions}.
+ *
+ * @example
+ * ```ts
+ * binomTest(682, 925, { p: 0.75 }).pValue; // 0.3824916
+ * ```
+ */
+export declare function binomTest(x: number | readonly [number, number], n?: number | BinomTestOptions, options?: BinomTestOptions): BinomTestResult;

package/dist/htest/binomTest.js

@@ -0,0 +1,121 @@
+// Exact binomial test (R's binom.test).
+//
+// Written for rStats.js from the textbook construction and R's documented behaviour. The two-sided p-value adds the
+// probabilities of all outcomes no more likely than the observed one, with a relative slack of 1e-7 on that
+// comparison so that outcomes of equal probability are not split by rounding (R's convention). The observed side is
+// taken as a tail of the distribution function and the opposite side as the tail made of the outcomes that pass the
+// comparison (counted one by one). The confidence interval is Clopper and Pearson's (Biometrika 26, 1934), from beta
+// quantiles.
+import { dbinom1, pbinom1 } from "../distributions/binomial.js";
+import { qbeta1 } from "../distributions/beta.js";
+import { checkConfLevelOpen, matchAlternative } from "./types.js";
+/** Relative slack when comparing outcome probabilities with the observed one */
+const SLACK = 1 + 1e-7;
+function isCount(v) {
+    return Number.isFinite(v) && v >= 0 && Math.abs(v - Math.round(v)) <= 1e-7 * Math.max(1, Math.abs(v));
+}
+/**
+ * Two-sided p-value: the total probability of the outcomes no more likely than x (within the relative slack). The
+ * observed side is one tail of the distribution function; on the opposite side the qualifying outcomes are counted,
+ * and as they are the most extreme ones there, their mass is again a tail probability.
+ */
+function twoSidedP(x, n, p) {
+    if (p === 0)
+        return x === 0 ? 1 : 0;
+    if (p === 1)
+        return x === n ? 1 : 0;
+    const mean = n * p;
+    if (x === mean)
+        return 1;
+    const cut = dbinom1(x, n, p, false) * SLACK;
+    let count = 0;
+    if (x < mean) {
+        for (let i = Math.ceil(mean); i <= n; i++)
+            if (dbinom1(i, n, p, false) <= cut)
+                count++;
+        const other = count === 0 ? 0 : pbinom1(n - count, n, p, false, false);
+        return Math.min(1, pbinom1(x, n, p, true, false) + other);
+    }
+    for (let i = 0; i <= Math.floor(mean); i++)
+        if (dbinom1(i, n, p, false) <= cut)
+            count++;
+    const other = count === 0 ? 0 : pbinom1(count - 1, n, p, true, false);
+    return Math.min(1, pbinom1(x - 1, n, p, false, false) + other);
+}
+/**
+ * Exact test of a simple null hypothesis about the probability of success in Bernoulli trials. Equivalent to R's
+ * `binom.test()`.
+ *
+ * @param x Number of successes, or `[successes, failures]`.
+ * @param n Number of trials (ignored when `x` has two elements; may then be omitted and the options passed in its
+ *   place).
+ * @param options See {@link BinomTestOptions}.
+ *
+ * @example
+ * ```ts
+ * binomTest(682, 925, { p: 0.75 }).pValue; // 0.3824916
+ * ```
+ */
+export function binomTest(x, n, options = {}) {
+    let xs;
+    let ns;
+    if (typeof x !== "number") {
+        if (x.length !== 2)
+            throw new RangeError("incorrect length of 'x'");
+        if (n !== undefined && typeof n !== "number")
+            options = n;
+        if (!isCount(x[0]) || !isCount(x[1]))
+            throw new RangeError("'x' must be nonnegative and integer");
+        xs = Math.round(x[0]);
+        ns = Math.round(x[0]) + Math.round(x[1]);
+    }
+    else {
+        if (typeof n !== "number")
+            throw new TypeError("'n' is required when 'x' is a single number");
+        if (!isCount(x))
+            throw new RangeError("'x' must be nonnegative and integer");
+        xs = Math.round(x);
+        if (!(isCount(n) && Math.round(n) >= xs && n > 0))
+            throw new RangeError("'n' must be a positive integer >= 'x'");
+        ns = Math.round(n);
+    }
+    const p = options.p ?? 0.5;
+    if (!(p >= 0 && p <= 1))
+        throw new RangeError("'p' must be a single number between 0 and 1");
+    const alternative = matchAlternative(options.alternative);
+    const confLevel = options.confLevel ?? 0.95;
+    checkConfLevelOpen(confLevel);
+    let pValue;
+    if (alternative === "less")
+        pValue = pbinom1(xs, ns, p, true, false);
+    else if (alternative === "greater")
+        pValue = pbinom1(xs - 1, ns, p, false, false);
+    else
+        pValue = twoSidedP(xs, ns, p);
+    const lower = (alpha) => (xs === 0 ? 0 : qbeta1(alpha, xs, ns - xs + 1, true, false));
+    const upper = (alpha) => (xs === ns ? 1 : qbeta1(1 - alpha, xs + 1, ns - xs, true, false));
+    let confInt;
+    if (alternative === "less")
+        confInt = [0, upper(1 - confLevel)];
+    else if (alternative === "greater")
+        confInt = [lower(1 - confLevel), 1];
+    else {
+        const alpha = (1 - confLevel) / 2;
+        confInt = [lower(alpha), upper(alpha)];
+    }
+    return {
+        method: "Exact binomial test",
+        alternative,
+        statistic: xs,
+        statisticName: "number of successes",
+        parameter: ns,
+        parameterName: "number of trials",
+        pValue,
+        confInt,
+        confLevel,
+        estimate: xs / ns,
+        estimateNames: "probability of success",
+        nullValue: p,
+        nullValueName: "probability of success",
+    };
+}

package/dist/htest/cor.d.ts

@@ -1,3 +1,4 @@
+import { type DD } from "../special/dd.js";
 import { type Alternative, type HTest, type Sample } from "./types.js";
 /** Correlation coefficient: Pearson's r, Kendall's tau or Spearman's rho. */
 export type CorMethod = "pearson" | "kendall" | "spearman";
@@ -52,6 +53,18 @@ export interface CorTestResult extends HTest {
  * @returns The correlation coefficient.
  */
 export declare function cor(x: Sample, y: Sample, options?: CorOptions): number;
+/** Pearson's correlation coefficient in double-double (so 1 - r is computed without cancellation near perfect correlation) */
+export declare function pearsonDD(x: readonly number[], y: readonly number[]): DD;
+interface KendallStats {
+    /** Number of concordant pairs minus number of discordant pairs */
+    s: number;
+    tau: number;
+    ties: boolean;
+    tx: number[];
+    ty: number[];
+}
+/** Count concordant and discordant pairs (O(n^2)). Two Infs are tied */
+export declare function kendall(x: readonly number[], y: readonly number[]): KendallStats;
 /**
  * Test for correlation between paired samples. Equivalent to R's `cor.test()`.
  *
@@ -79,3 +92,4 @@ export declare function cor(x: Sample, y: Sample, options?: CorOptions): number;
  * ```
  */
 export declare function corTest(x: Sample, y: Sample, options?: CorTestOptions): CorTestResult;
+export {};