@numero-uno-jpn/rstats 0.5.0 → 0.6.1

package/dist/htest/wilcoxTest.js

@@ -3,10 +3,15 @@
 //
 // The statistics and normal approximation (mean, tie-corrected variance, direction of the continuity correction) use
 // the same formulas as scipy.stats wilcoxon (zero_method = "wilcox") and mannwhitneyu (scipy/stats/_wilcoxon.py, _mannwhitneyu.py;
-// SciPy commit a087e61, BSD-3-Clause, see THIRD_PARTY_NOTICES.md). Intervals and estimates follow Hodges & Lehmann (1963)
-// and Bauer (1972): the exact method uses order statistics of the Walsh averages (differences for two samples); the normal
-// approximation finds where the standardised statistic crosses the quantile by root finding (src/internal/uniroot.ts).
-// The switch between exact and normal approximation, handling of intervals that cannot be formed, and names follow observed R output.
+// SciPy commit a087e61, BSD-3-Clause, see THIRD_PARTY_NOTICES.md).
+// Intervals and estimates were written for rStats.js from Hodges & Lehmann (Ann. Math. Stat. 34, 1963) and Bauer
+// (JASA 67, 1972) and R's documented behaviour: the exact interval takes order statistics of the Walsh averages
+// (of the differences x_i - y_j for two samples) at ranks from the signed rank (rank sum) quantile, and the estimate is
+// their median; the normal-approximation interval is where the standardised statistic of the shifted data, a step
+// function of the shift, crosses the normal quantiles, found with R's uniroot conventions (src/internal/uniroot.ts,
+// tolerance tolRoot), and the estimate is where it crosses 0 without continuity correction. The switch between exact
+// and normal approximation, the reported confidence level when the requested one is not attainable, intervals that
+// cannot be formed, and names follow R's documented and observed behaviour.
 // - The exact method is used when exact = null and n < 50 (both < 50 for two samples). With ties or zero differences,
 //   the normal approximation is used even when exact = true
 // - Only NaN is removed (R's documentation says non-finite values are removed, but in fact Inf is kept and ranked)
@@ -195,131 +200,112 @@ function signedRank(x0, exactOpt, paired, ctx) {
         : signedRankNormalCI(xo, ctx);
     return { ...result, ...ci };
 }
-/** Interval from order statistics of the Walsh averages (x_i + x_j) / 2 (i <= j) (Bauer 1972) and the Hodges-Lehmann estimate */
+/** Interval with the given finite ends, the other end(s) open according to the alternative */
+function shape(alternative, lower, upper) {
+    if (alternative === "less")
+        return [-Infinity, upper];
+    if (alternative === "greater")
+        return [lower, Infinity];
+    return [lower, upper];
+}
+/** Interval when no interval can be formed: the bounded end(s) are NaN and the confidence level 0 */
+function noInterval(alternative, estimate, estimateNames) {
+    const out = { confInt: shape(alternative, NaN, NaN), confLevel: 0, estimate };
+    if (estimateNames !== undefined)
+        out.estimateNames = estimateNames;
+    return out;
+}
+/** Order-statistic ranks of an exact distribution-free interval: q from the lower-tail quantile (0 replaced by 1) */
+function exactRank(quantile, alternative, a) {
+    const q = quantile(alternative === "two.sided" ? a / 2 : a);
+    return q === 0 ? 1 : q;
+}
+function checkTolRoot(tol) {
+    if (!(tol > 0))
+        throw new RangeError("tolRoot must be positive");
+}
+/**
+ * Exact interval from the order statistics of the Walsh averages (Bauer 1972) and the Hodges-Lehmann estimate, their
+ * median
+ */
 function signedRankExactCI(x, ctx) {
+    const { alternative, confLevel } = ctx;
     const n = x.length;
     const walsh = [];
     for (let i = 0; i < n; i++)
         for (let j = i; j < n; j++)
             walsh.push((x[i] + x[j]) / 2);
     walsh.sort(ascending);
-    const total = walsh.length;
-    const alpha = 1 - ctx.confLevel;
-    let confInt;
-    let achieved;
-    if (ctx.alternative === "two.sided") {
-        const qu = Math.max(1, qsignrank1(alpha / 2, n, true, false));
-        achieved = 2 * psignrank1(qu - 1, n, true, false);
-        confInt = [walsh[qu - 1], walsh[total - qu]];
-    }
-    else {
-        const qu = Math.max(1, qsignrank1(alpha, n, true, false));
-        achieved = psignrank1(qu - 1, n, true, false);
-        confInt =
-            ctx.alternative === "greater"
-                ? [walsh[qu - 1], Infinity]
-                : [-Infinity, walsh[total - qu]];
-    }
-    // An unreachable confidence level is replaced by the achieved level (2 significant digits)
-    const confLevel = achieved - alpha > alpha / 2 ? 1 - signif2(achieved) : ctx.confLevel;
+    const N = walsh.length;
+    const a = 1 - confLevel;
+    const q = exactRank((p) => qsignrank1(p, n, true, false), alternative, a);
+    const tail = psignrank1(q - 1, n, true, false);
+    const achieved = alternative === "two.sided" ? 2 * tail : tail;
     return {
-        confInt,
-        confLevel,
+        confInt: shape(alternative, walsh[q - 1], walsh[N - q]),
+        confLevel: achieved - a > a / 2 ? 1 - signif2(achieved) : confLevel,
         estimate: sortedMedian(walsh),
         estimateNames: "(pseudo)median",
     };
 }
-/** When the interval cannot be formed (NaN endpoints, confidence level 0) */
-function emptyInterval(alternative) {
-    if (alternative === "less")
-        return [-Infinity, NaN];
-    if (alternative === "greater")
-        return [NaN, Infinity];
-    return [NaN, NaN];
-}
-/** Normal-approximation interval and estimate: root finding for where the standardised statistic crosses the quantile */
+/**
+ * Normal-approximation interval: the shifts d at which the standardised signed rank statistic of x - d crosses the
+ * normal quantiles, and the estimate where it crosses 0 (found with uniroot, tolerance tolRoot)
+ */
 function signedRankNormalCI(x, ctx) {
-    const { alternative, tolRoot } = ctx;
+    const { alternative, correct, confLevel, tolRoot } = ctx;
     const n = x.length;
     if (n === 0)
-        return { confInt: emptyInterval(alternative), confLevel: 0, estimate: NaN };
-    let mumin = Infinity;
-    let mumax = -Infinity;
-    for (const v of x) {
-        mumin = Math.min(mumin, v);
-        mumax = Math.max(mumax, v);
-    }
-    // With infinite endpoints, or a single point / all values equal, no interval can be formed (the estimate is the midrange)
-    if (!Number.isFinite(mumin) ||
-        !Number.isFinite(mumax) ||
-        n === 1 ||
-        mumin === mumax) {
-        return {
-            confInt: emptyInterval(alternative),
-            confLevel: 0,
-            estimate: (mumin + mumax) / 2,
-            estimateNames: "midrange",
-        };
+        return noInterval(alternative, NaN);
+    const lo = Math.min(...x);
+    const hi = Math.max(...x);
+    if (!Number.isFinite(lo) || !Number.isFinite(hi) || n === 1 || lo === hi) {
+        return noInterval(alternative, (lo + hi) / 2, "midrange");
     }
-    // Standardised statistic of x - d minus zq (a decreasing step function of d)
-    const wdiff = (d, zq, correct) => {
-        const xd = x.map((v) => v - d).filter((v) => v !== 0);
-        const [, dz, sigma] = signedRankStat(xd);
-        return (dz - correction(dz, alternative, correct)) / sigma - zq;
+    const stat = (d, corr) => {
+        const [, centre, sigma] = signedRankStat(x.map((v) => v - d).filter((v) => v !== 0));
+        return (centre - correction(centre, alternative, corr)) / sigma;
     };
-    const root = (zq, correct) => {
-        const f = (d) => wdiff(d, zq, correct);
-        if (!(tolRoot > 0))
-            throw new RangeError("tolRoot must be positive");
-        return uniroot(f, mumin, mumax, { tol: tolRoot });
+    const sLo = stat(lo, correct);
+    const sHi = stat(hi, correct);
+    const zUpper = (p) => -qnorm(p);
+    const reachable = (a) => {
+        if (alternative === "greater")
+            return !(sLo < zUpper(a));
+        if (alternative === "less")
+            return !(sHi > qnorm(a / 2));
+        return !(sLo < zUpper(a / 2)) && !(sHi > qnorm(a / 2));
     };
-    let alpha = 1 - ctx.confLevel;
-    let raised = false;
-    // If an interval endpoint falls outside the range, double α
-    for (;;) {
-        let ok;
-        if (alternative === "two.sided") {
-            ok =
-                !(wdiff(mumin, qnorm(alpha / 2, { lowerTail: false }), ctx.correct) < 0) && !(wdiff(mumax, qnorm(alpha / 2), ctx.correct) > 0);
-        }
-        else if (alternative === "greater") {
-            ok = !(wdiff(mumin, qnorm(alpha, { lowerTail: false }), ctx.correct) < 0);
-        }
-        else {
-            // R uses the α/2 quantile for the "less" check as well
-            ok = !(wdiff(mumax, qnorm(alpha / 2), ctx.correct) > 0);
-        }
-        if (ok || alpha >= 1)
-            break;
-        alpha *= 2;
-        raised = true;
+    let a = 1 - confLevel;
+    let enlarged = false;
+    while (!reachable(a) && a < 1) {
+        a *= 2;
+        enlarged = true;
     }
-    const confLevel = raised ? 1 - Math.min(1, alpha) : ctx.confLevel;
+    checkTolRoot(tolRoot);
+    const crossing = (z) => uniroot((d) => stat(d, correct) - z, lo, hi, { tol: tolRoot, fLower: sLo - z, fUpper: sHi - z });
     let confInt;
-    if (alpha >= 1) {
-        const m = sortedMedian([...x].sort(ascending));
-        confInt =
-            alternative === "less"
-                ? [-Infinity, m]
-                : alternative === "greater"
-                    ? [m, Infinity]
-                    : [m, m];
-    }
-    else if (alternative === "two.sided") {
-        confInt = [
-            root(qnorm(alpha / 2, { lowerTail: false }), ctx.correct),
-            root(qnorm(alpha / 2), ctx.correct),
-        ];
+    if (a >= 1) {
+        const med = sortedMedian([...x].sort(ascending));
+        confInt = shape(alternative, med, med);
     }
-    else if (alternative === "greater") {
-        confInt = [root(qnorm(alpha, { lowerTail: false }), ctx.correct), Infinity];
-    }
-    else {
-        confInt = [-Infinity, root(qnorm(alpha), ctx.correct)];
-    }
-    // The estimate has no continuity correction (its direction depends on alternative)
-    const estimate = root(0, false);
-    return { confInt, confLevel, estimate, estimateNames: "(pseudo)median" };
+    else if (alternative === "greater")
+        confInt = [crossing(zUpper(a)), Infinity];
+    else if (alternative === "less")
+        confInt = [-Infinity, crossing(qnorm(a))];
+    else
+        confInt = [crossing(zUpper(a / 2)), crossing(qnorm(a / 2))];
+    const estimate = uniroot((d) => stat(d, false), lo, hi, {
+        tol: tolRoot,
+        fLower: stat(lo, false),
+        fUpper: stat(hi, false),
+    });
+    return {
+        confInt,
+        confLevel: enlarged ? 1 - Math.min(1, a) : confLevel,
+        estimate,
+        estimateNames: "(pseudo)median",
+    };
 }
 // ---- Two-sample (rank sum test) ----
 /** Rank sum statistic of x - d and y: [W, W - expectation, standard deviation] */
@@ -380,92 +366,68 @@ function rankSum(x, y, exactOpt, ctx) {
     const ci = useExact ? rankSumExactCI(x, y, ctx) : rankSumNormalCI(x, y, ctx);
     return { ...result, ...ci };
 }
-/** Interval from order statistics of the differences x_i - y_j, and the Hodges-Lehmann estimate */
+/** Exact interval from the order statistics of the differences x_i - y_j and their median as the estimate */
 function rankSumExactCI(x, y, ctx) {
+    const { alternative, confLevel } = ctx;
     const nx = x.length;
     const ny = y.length;
     const diffs = [];
-    for (const a of x)
-        for (const b of y)
-            diffs.push(a - b);
+    for (const xi of x)
+        for (const yj of y)
+            diffs.push(xi - yj);
     diffs.sort(ascending);
-    const total = diffs.length;
-    const alpha = 1 - ctx.confLevel;
-    let confInt;
-    let achieved;
-    if (ctx.alternative === "two.sided") {
-        const qu = Math.max(1, qwilcox1(alpha / 2, nx, ny, true, false));
-        achieved = 2 * pwilcox1(qu - 1, nx, ny, true, false);
-        confInt = [diffs[qu - 1], diffs[total - qu]];
-    }
-    else {
-        const qu = Math.max(1, qwilcox1(alpha, nx, ny, true, false));
-        achieved = pwilcox1(qu - 1, nx, ny, true, false);
-        confInt =
-            ctx.alternative === "greater"
-                ? [diffs[qu - 1], Infinity]
-                : [-Infinity, diffs[total - qu]];
-    }
-    // An unreachable confidence level is replaced by the achieved level (unlike the signed rank case, not rounded)
-    const confLevel = achieved - alpha > alpha / 2 ? 1 - achieved : ctx.confLevel;
+    const M = diffs.length;
+    const a = 1 - confLevel;
+    const q = exactRank((p) => qwilcox1(p, nx, ny, true, false), alternative, a);
+    const tail = pwilcox1(q - 1, nx, ny, true, false);
+    const achieved = alternative === "two.sided" ? 2 * tail : tail;
     return {
-        confInt,
-        confLevel,
+        confInt: shape(alternative, diffs[q - 1], diffs[M - q]),
+        confLevel: achieved - a > a / 2 ? 1 - achieved : confLevel,
         estimate: sortedMedian(diffs),
         estimateNames: "difference in location",
     };
 }
+/**
+ * Normal-approximation interval: the shifts d at which the standardised rank sum statistic of (x - d, y) crosses the
+ * normal quantiles (clamped to the range of the differences), and the estimate where it crosses 0
+ */
 function rankSumNormalCI(x, y, ctx) {
-    const { alternative, tolRoot } = ctx;
-    let mumin = Infinity;
-    let mumax = -Infinity;
-    for (const a of x) {
-        for (const b of y) {
-            mumin = Math.min(mumin, a - b);
-            mumax = Math.max(mumax, a - b);
-        }
-    }
-    if (!Number.isFinite(mumin) || !Number.isFinite(mumax)) {
+    const { alternative, correct, confLevel, tolRoot } = ctx;
+    const lo = Math.min(...x) - Math.max(...y);
+    const hi = Math.max(...x) - Math.min(...y);
+    if (!Number.isFinite(lo) || !Number.isFinite(hi)) {
         throw new Error("cannot compute the confidence interval because the differences are not finite");
     }
-    const wdiff = (d, zq, correct) => {
-        const [, dz, sigma] = rankSumStat(x.map((v) => v - d), y);
-        return (dz - correction(dz, alternative, correct)) / sigma - zq;
+    const stat = (d, corr) => {
+        const [, centre, sigma] = rankSumStat(x.map((v) => v - d), y);
+        return (centre - correction(centre, alternative, corr)) / sigma;
     };
-    // If the quantile is not reached at the ends, return the ends
-    const root = (zq, correct) => {
-        const f = (d) => wdiff(d, zq, correct);
-        const fLower = f(mumin);
-        const fUpper = f(mumax);
-        if (Number.isNaN(fLower) || Number.isNaN(fUpper)) {
+    const crossing = (z, corr) => {
+        const fLo = stat(lo, corr) - z;
+        const fHi = stat(hi, corr) - z;
+        if (Number.isNaN(fLo) || Number.isNaN(fHi)) {
             throw new Error("cannot compute the confidence interval because all observations are tied");
         }
-        if (fLower <= 0)
-            return mumin;
-        if (fUpper >= 0)
-            return mumax;
-        if (!(tolRoot > 0))
-            throw new RangeError("tolRoot must be positive");
-        return uniroot(f, mumin, mumax, { tol: tolRoot, fLower, fUpper });
+        if (fLo <= 0)
+            return lo;
+        if (fHi >= 0)
+            return hi;
+        checkTolRoot(tolRoot);
+        return uniroot((d) => stat(d, corr) - z, lo, hi, { tol: tolRoot, fLower: fLo, fUpper: fHi });
     };
-    const alpha = 1 - ctx.confLevel;
+    const a = 1 - confLevel;
     let confInt;
-    if (alternative === "two.sided") {
-        confInt = [
-            root(qnorm(alpha / 2, { lowerTail: false }), ctx.correct),
-            root(qnorm(alpha / 2), ctx.correct),
-        ];
-    }
-    else if (alternative === "greater") {
-        confInt = [root(qnorm(alpha, { lowerTail: false }), ctx.correct), Infinity];
-    }
-    else {
-        confInt = [-Infinity, root(qnorm(alpha), ctx.correct)];
-    }
+    if (alternative === "greater")
+        confInt = [crossing(-qnorm(a), correct), Infinity];
+    else if (alternative === "less")
+        confInt = [-Infinity, crossing(qnorm(a), correct)];
+    else
+        confInt = [crossing(-qnorm(a / 2), correct), crossing(qnorm(a / 2), correct)];
     return {
         confInt,
-        confLevel: ctx.confLevel,
-        estimate: root(0, false),
+        confLevel,
+        estimate: crossing(0, false),
         estimateNames: "difference in location",
     };
 }

package/dist/index.d.ts

@@ -1,50 +1,6 @@
-export { gamma, lgamma } from "./special/gamma.js";
-export { beta, lbeta } from "./special/beta.js";
-export { dnorm, pnorm, qnorm, type NormalOptions } from "./distributions/normal.js";
-export { dgamma, pgamma, qgamma, type GammaParams } from "./distributions/gamma.js";
-export { dchisq, pchisq, qchisq } from "./distributions/chisq.js";
-export { dpois, ppois, qpois } from "./distributions/poisson.js";
-export { dbeta, pbeta, qbeta } from "./distributions/beta.js";
-export { dbinom, pbinom, qbinom } from "./distributions/binomial.js";
-export { dt, pt, qt } from "./distributions/t.js";
-export { df, pf, qf } from "./distributions/f.js";
-export { dunif, punif, qunif, type UniformParams } from "./distributions/uniform.js";
-export { dexp, pexp, qexp, type ExponentialParams } from "./distributions/exponential.js";
-export { dlnorm, plnorm, qlnorm, type LognormalParams } from "./distributions/lognormal.js";
-export { dlogis, plogis, qlogis, type LocationScaleParams } from "./distributions/logistic.js";
-export { dcauchy, pcauchy, qcauchy } from "./distributions/cauchy.js";
-export { dweibull, pweibull, qweibull, type WeibullParams } from "./distributions/weibull.js";
-export { dgeom, pgeom, qgeom } from "./distributions/geometric.js";
-export { dnbinom, pnbinom, qnbinom, type NegBinomialParams } from "./distributions/negbinomial.js";
-export { dhyper, phyper, qhyper } from "./distributions/hypergeometric.js";
-export { dsignrank, psignrank, qsignrank } from "./distributions/signrank.js";
-export { dwilcox, pwilcox, qwilcox } from "./distributions/wilcox.js";
-export { ptukey, qtukey, type TukeyOptions } from "./distributions/tukey.js";
-export type { DensityOptions, TailOptions } from "./internal/dpq.js";
-export type { NoncentralOption } from "./internal/noncentral.js";
-export type { Vectorizable, VectorResult } from "./internal/vectorize.js";
-export { setSeed, getRandomSeed, setRandomSeed } from "./random/rng.js";
-export { runif, rnorm, rexp, rlnorm, rlogis, rcauchy, rweibull } from "./random/continuous.js";
-export { rgamma, rchisq, rt, rf } from "./random/gamma.js";
-export { rbeta } from "./random/beta.js";
-export { rpois, rgeom, rnbinom } from "./random/poisson.js";
-export { rbinom, rmultinom } from "./random/binomial.js";
-export { rsignrank, rwilcox } from "./random/rank.js";
-export { sample, sampleInt, type SampleOptions } from "./random/sample.js";
-export { rhyper } from "./random/hyper.js";
-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 { cor, 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 { crossprod, tcrossprod, backsolve, forwardsolve, type BacksolveOptions } from "./linalg/basic.js";
-export { norm, type NormOptions, type NormType } from "./linalg/norm.js";
-export { chol, chol2inv, type CholOptions, type CholPivotResult, type Chol2InvOptions } from "./linalg/chol.js";
-export { qr, qrQ, qrR, qrX, qrCoef, qrQy, qrQty, qrResid, qrFitted, qrSolve, type QR, type QROptions, type QRQOptions } from "./linalg/qr.js";
-export { solve, det, determinant, rcond, type SolveOptions, type Determinant, type RcondOptions } from "./linalg/solve.js";
-export { svd, type SvdOptions, type SvdResult } from "./linalg/svd.js";
-export { kappa, ginv, type KappaOptions } from "./linalg/kappa.js";
-export { eigen, type EigenOptions, type EigenResult } from "./linalg/eigen.js";
-export type { MatrixInput, VectorOrMatrix } from "./linalg/matrix.js";
+export * from "./entries/special.js";
+export * from "./entries/distributions.js";
+export * from "./entries/tests.js";
+export * from "./entries/linalg.js";
+export * from "./entries/descriptive.js";
+export * from "./entries/numerics.js";

package/dist/index.js

@@ -1,50 +1,8 @@
-// Special functions
-export { gamma, lgamma } from "./special/gamma.js";
-export { beta, lbeta } from "./special/beta.js";
-// Distributions
-export { dnorm, pnorm, qnorm } from "./distributions/normal.js";
-export { dgamma, pgamma, qgamma } from "./distributions/gamma.js";
-export { dchisq, pchisq, qchisq } from "./distributions/chisq.js";
-export { dpois, ppois, qpois } from "./distributions/poisson.js";
-export { dbeta, pbeta, qbeta } from "./distributions/beta.js";
-export { dbinom, pbinom, qbinom } from "./distributions/binomial.js";
-export { dt, pt, qt } from "./distributions/t.js";
-export { df, pf, qf } from "./distributions/f.js";
-export { dunif, punif, qunif } from "./distributions/uniform.js";
-export { dexp, pexp, qexp } from "./distributions/exponential.js";
-export { dlnorm, plnorm, qlnorm } from "./distributions/lognormal.js";
-export { dlogis, plogis, qlogis } from "./distributions/logistic.js";
-export { dcauchy, pcauchy, qcauchy } from "./distributions/cauchy.js";
-export { dweibull, pweibull, qweibull } from "./distributions/weibull.js";
-export { dgeom, pgeom, qgeom } from "./distributions/geometric.js";
-export { dnbinom, pnbinom, qnbinom } from "./distributions/negbinomial.js";
-export { dhyper, phyper, qhyper } from "./distributions/hypergeometric.js";
-export { dsignrank, psignrank, qsignrank } from "./distributions/signrank.js";
-export { dwilcox, pwilcox, qwilcox } from "./distributions/wilcox.js";
-export { ptukey, qtukey } from "./distributions/tukey.js";
-// Random numbers (same streams as R's set.seed)
-export { setSeed, getRandomSeed, setRandomSeed } from "./random/rng.js";
-export { runif, rnorm, rexp, rlnorm, rlogis, rcauchy, rweibull } from "./random/continuous.js";
-export { rgamma, rchisq, rt, rf } from "./random/gamma.js";
-export { rbeta } from "./random/beta.js";
-export { rpois, rgeom, rnbinom } from "./random/poisson.js";
-export { rbinom, rmultinom } from "./random/binomial.js";
-export { rsignrank, rwilcox } from "./random/rank.js";
-export { sample, sampleInt } from "./random/sample.js";
-export { rhyper } from "./random/hyper.js";
-// Hypothesis tests (same content as R's htest, returned 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 { cor, corTest } from "./htest/cor.js";
-export { pAdjust } from "./htest/pAdjust.js";
-// Linear algebra (the core of scipy.linalg; names and results follow R; 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";
+// rStats.js: R's numerical core in TypeScript. Each area is also available on its own as a subpath export
+// (rStats.js/distributions, /tests, /linalg, /descriptive, /numerics, /special; see src/entries/).
+export * from "./entries/special.js";
+export * from "./entries/distributions.js";
+export * from "./entries/tests.js";
+export * from "./entries/linalg.js";
+export * from "./entries/descriptive.js";
+export * from "./entries/numerics.js";

package/dist/integrate/quadpack.d.ts

@@ -0,0 +1,29 @@
+export type Integrand = (x: number) => number;
+/** Result of dqagse / dqagie */
+export interface QuadResult {
+    result: number;
+    abserr: number;
+    /** Number of integrand evaluations */
+    neval: number;
+    /**
+     * 0 normal termination; 1 maximum number of subdivisions; 2 roundoff error; 3 bad integrand behaviour;
+     * 4 roundoff error in the extrapolation table; 5 divergent or slowly convergent; 6 invalid input
+     */
+    ier: number;
+    /** Number of subintervals produced */
+    last: number;
+}
+/**
+ * Integral of f over the finite interval [a, b] (QUADPACK dqagse: 21-point Gauss-Kronrod rule, bisection of the
+ * interval with the largest error, epsilon-algorithm extrapolation).
+ *
+ * @param limit - Maximum number of subintervals (R's `subdivisions`).
+ */
+export declare function dqagse(f: Integrand, a: number, b: number, epsabs: number, epsrel: number, limit: number): QuadResult;
+/**
+ * Integral of f over an infinite range (QUADPACK dqagie): (bound, inf) for inf = 1, (-inf, bound) for inf = -1,
+ * (-inf, inf) for inf = 2, mapped to (0, 1] by x = bound + (1 - t) / t.
+ *
+ * @param limit - Maximum number of subintervals (R's `subdivisions`).
+ */
+export declare function dqagie(f: Integrand, bound: number, inf: -1 | 1 | 2, epsabs: number, epsrel: number, limit: number): QuadResult;