@compstats/core 0.2.0

package/dist/core/sampling.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Drawing samples and reading confidence intervals off them — the statistics
+ * of `plot_sampling()` and `plot_sample_ci()` in `../compstatslib/R/`.
+ *
+ * Both demonstrations rest on the same idea: a statistic computed from a
+ * sample is itself a random quantity, and drawing many samples shows how it
+ * scatters. `plot_sampling()` draws repeatedly and accumulates the statistic;
+ * `plot_sample_ci()` draws once and asks how often an interval built from a
+ * sample covers the mean it was drawn from.
+ *
+ * Two rules shape this module, both from the port plan:
+ *
+ * - **The generator is an argument, and one call threads one generator.** R
+ *   reads a global stream, which a pure core cannot. `drawSamples` takes
+ *   exactly `reps * sampleSize` values from the generator it is given, in
+ *   draw order, so a caller who holds the generator can keep drawing where
+ *   the last call stopped. Restarting the generator per repetition would
+ *   return the same sample every time.
+ * - **Accumulation belongs to the caller.** R's `plot_sampling()` returns a
+ *   `vars` list holding every statistic drawn so far, and its interactive
+ *   wrapper hands that back on the next call. This module takes one draw's
+ *   inputs and returns one draw's outputs; nothing is kept between calls.
+ *
+ * Verified against R 4.5.3 in `sampling.test.ts` for the interval arithmetic.
+ * The drawn values cannot be checked against R and are not meant to be: a
+ * seeded JavaScript generator does not reproduce R's Mersenne Twister.
+ */
+import { type Rng } from "./rng";
+/** What one call to `drawSamples` should do. */
+export interface DrawSamplesOptions {
+    /** How many values to take per sample. R's `sample_size`. */
+    readonly sampleSize: number;
+    /** How many samples to draw in this call. R's `reps`, default 1. */
+    readonly reps?: number;
+    /**
+     * The statistic to compute from each sample. R's `theta`, default the mean.
+     * Any function of a sample will do — the median, a trimmed mean, a range.
+     */
+    readonly theta?: (sample: readonly number[]) => number;
+}
+/** One draw: the samples themselves and the statistic of each. */
+export interface SampleDraw {
+    /**
+     * The samples, in draw order. R holds these as the columns of a matrix, so
+     * flattening this array gives the same order R's `as.vector()` does — which
+     * is what to hand `kernelDensity` when pooling them.
+     */
+    readonly samples: readonly (readonly number[])[];
+    /** The statistic of each sample, in the same order. */
+    readonly thetas: readonly number[];
+}
+/** A pair of bounds. */
+export interface Interval {
+    readonly low: number;
+    readonly high: number;
+}
+/** What one sample says about the mean it was drawn from. */
+export interface SampleInterval {
+    /** The sample mean. */
+    readonly mean: number;
+    /** The sample standard deviation, with R's n − 1 denominator. */
+    readonly sd: number;
+    /** The standard error, `sd / sqrt(sampleSize)`. */
+    readonly standardError: number;
+    /** The 95% interval, `mean ± 1.96 * standardError`. */
+    readonly ci95: Interval;
+    /** The 99% interval, `mean ± 2.58 * standardError`. */
+    readonly ci99: Interval;
+    /**
+     * Whether either interval misses the population mean — R's `bad` set, one
+     * sample at a time. R collects the positions where this holds.
+     */
+    readonly excludesPopulationMean: boolean;
+}
+/** How to simulate a population. R's `distr_func` with its `...` bound in. */
+export type DistributionFn = (rng: Rng, n: number) => number[];
+/** What one call to `simulateSampleCi` should do. R's own defaults. */
+export interface SampleCiOptions {
+    /** How many samples to draw. R's `num_samples`, default 100. */
+    readonly numSamples?: number;
+    /** How many values per sample. R's `sample_size`, default 100. */
+    readonly sampleSize?: number;
+    /** How many values in the simulated population. R's `pop_size`, 10000. */
+    readonly popSize?: number;
+    /**
+     * How to draw the population. R's `distr_func`, default `rnorm` with its
+     * own defaults, a standard normal. A caller who wants R's
+     * `plot_sample_ci(distr_func = runif, min = 17, max = 35)` passes
+     * `(rng, n) => runif(rng, n, { min: 17, max: 35 })`, which is what R's
+     * `...` pass-through amounts to.
+     */
+    readonly distribution?: DistributionFn;
+}
+/** The simulated population's statistics and every sample's interval. */
+export interface SampleCiSimulation {
+    /** The mean of the drawn population. R draws its vertical line here. */
+    readonly populationMean: number;
+    /** The spread of the drawn population. R's window is this wide, halved. */
+    readonly populationSd: number;
+    /** One entry per sample, in draw order. */
+    readonly intervals: readonly SampleInterval[];
+}
+/**
+ * Draw samples from a population and compute a statistic from each.
+ *
+ * This is R's `replicate(reps, sample(population, sample_size))` followed by
+ * `apply(samples, FUN = theta, MARGIN = 2)`. Sampling is without replacement,
+ * as R's `sample()` is by default, so a value appears at most once within a
+ * sample — though the same value can appear in several samples.
+ *
+ * @param rng The source of randomness. The call takes exactly
+ *   `reps * sampleSize` values from it.
+ * @param population The values to draw from. The function does not modify
+ *   them.
+ * @param options The sample size, how many samples, and the statistic.
+ * @returns The samples in draw order and the statistic of each.
+ * @throws RangeError If `reps` or `sampleSize` is negative or fractional, or
+ *   if `sampleSize` is larger than the population — the last from
+ *   `sampleWithoutReplacement`, which is where R's own refusal lives.
+ */
+export declare function drawSamples(rng: Rng, population: readonly number[], options: DrawSamplesOptions): SampleDraw;
+/**
+ * Read a confidence interval off each sample.
+ *
+ * The multipliers are R's own literal 1.96 and 2.58, not quantiles of any
+ * distribution. That matters: 2.58 is not `qnorm(0.995)` to more than three
+ * digits, and a port that "corrected" it would draw slightly different bars
+ * from the R original the demonstration is taught beside.
+ *
+ * A sample of one gives NaN throughout, because its standard deviation is
+ * undefined — R reports NA there and drops it from the `bad` set, and NaN
+ * comparisons being false does the same thing here.
+ *
+ * @param samples The samples, each already drawn.
+ * @param populationMean The mean the samples were drawn from, which the
+ *   intervals are asked to cover.
+ * @returns One entry per sample, in the order given.
+ */
+export declare function sampleConfidenceIntervals(samples: readonly (readonly number[])[], populationMean: number): SampleInterval[];
+/**
+ * Simulate a population, sample it many times, and interval each sample.
+ *
+ * This is the whole of `plot_sample_ci()` except the drawing. The population
+ * is simulated rather than given, which is the point of the demonstration:
+ * the true mean is known, so a student can count how many intervals miss it.
+ *
+ * The call takes the population's draws from the generator first, then each
+ * sample's, so a caller replaying one seed gets one simulation.
+ *
+ * @param rng The source of randomness, threaded through the whole call.
+ * @param options The sizes and the population's distribution.
+ * @returns The population's mean and spread, and every sample's interval.
+ * @throws RangeError If a count is negative or fractional, or if the sample
+ *   size is larger than the population.
+ */
+export declare function simulateSampleCi(rng: Rng, options?: SampleCiOptions): SampleCiSimulation;
+//# sourceMappingURL=sampling.d.ts.map

package/dist/core/sampling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.d.ts","sourceRoot":"","sources":["../../src/core/sampling.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,EAAmC,KAAK,GAAG,EAAE,MAAM,OAAO,CAAC;AAalE,gDAAgD;AAChD,MAAM,WAAW,kBAAkB;IACjC,6DAA6D;IAC7D,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,KAAK,MAAM,CAAC;CACxD;AAED,kEAAkE;AAClE,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC;IACjD,uDAAuD;IACvD,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;CACpC;AAED,wBAAwB;AACxB,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,6DAA6D;AAC7D,MAAM,WAAW,cAAc;IAC7B,uBAAuB;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,mDAAmD;IACnD,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,sBAAsB,EAAE,OAAO,CAAC;CAC1C;AAED,8EAA8E;AAC9E,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;AAE/D,uEAAuE;AACvE,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,kEAAkE;IAClE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,cAAc,CAAC;CACxC;AAED,yEAAyE;AACzE,MAAM,WAAW,kBAAkB;IACjC,wEAAwE;IACxE,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,2EAA2E;IAC3E,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,2CAA2C;IAC3C,QAAQ,CAAC,SAAS,EAAE,SAAS,cAAc,EAAE,CAAC;CAC/C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CACzB,GAAG,EAAE,GAAG,EACR,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,EAAE,kBAAkB,GAC1B,UAAU,CAWZ;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,SAAS,CAAC,SAAS,MAAM,EAAE,CAAC,EAAE,EACvC,cAAc,EAAE,MAAM,GACrB,cAAc,EAAE,CAyBlB;AAcD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,GAAG,EACR,OAAO,GAAE,eAAoB,GAC5B,kBAAkB,CAsBpB"}

package/dist/core/special.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Special functions that the statistics in `core/` build on.
+ *
+ * JavaScript has no `lgamma` and no incomplete beta, so the distribution
+ * functions need them here. R gets the same quantities from its own C
+ * routines; this module is the port's replacement.
+ *
+ * Every function is pure. None of them touch the DOM or hold state.
+ */
+/**
+ * The natural log of the gamma function, R's `lgamma()`.
+ *
+ * @param x A positive number.
+ * @returns log Γ(x), or NaN if x is zero or less.
+ */
+export declare function logGamma(x: number): number;
+/**
+ * The natural log of the beta function, R's `lbeta()`.
+ *
+ * The obvious route, `logGamma(a) + logGamma(b) - logGamma(a + b)`, subtracts
+ * numbers near 600 for the degrees of freedom this package plots, and loses
+ * about three digits doing so. Expanding the Lanczos form first cancels the
+ * large terms by hand: the exponential parts collapse to the constant
+ * −(g − ½), and the logarithmic parts become ratios that stay of order one.
+ * What is left has no cancellation at all.
+ *
+ * Both ratios go through `log1p`. Each one sits just below 1, and taking the
+ * quotient first would round away the small part that the log then reads —
+ * a loss that grows with the larger argument, reaching 1e-13 by b = 2500.
+ *
+ * @param a A positive number.
+ * @param b A positive number.
+ * @returns log B(a, b), or NaN if either argument is zero or less.
+ */
+export declare function logBeta(a: number, b: number): number;
+/**
+ * The regularized incomplete beta function I_x(a, b), R's `pbeta()`.
+ *
+ * The continued fraction converges quickly only on one side of the
+ * distribution, so the function evaluates the mirrored form when x sits above
+ * the switch point and takes the complement.
+ *
+ * @param x A value between 0 and 1.
+ * @param a A positive shape.
+ * @param b A positive shape.
+ * @returns The share of the beta density below x, or NaN for a bad shape.
+ */
+export declare function incompleteBeta(x: number, a: number, b: number): number;
+/**
+ * The regularized incomplete beta function, told x and 1 − x separately.
+ *
+ * A caller that can write down both members of the pair should use this
+ * instead of `incompleteBeta`. Once x is within 1e-16 of 1, the double
+ * holding it has no room left for 1 − x, and rebuilding the complement by
+ * subtraction throws away the very digits the answer rests on. `pt()` reads
+ * both straight off t and df, so it gives up nothing.
+ *
+ * The two are treated as an exact pair, not as one value and a derived one:
+ * each logarithm is taken from whichever member still carries its precision.
+ *
+ * @param x A value between 0 and 1.
+ * @param complement The value of 1 − x, computed without subtracting.
+ * @param a A positive shape.
+ * @param b A positive shape.
+ * @returns The share of the beta density below x, or NaN for a bad shape.
+ */
+export declare function incompleteBetaSplit(x: number, complement: number, a: number, b: number): number;
+/**
+ * The standard normal distribution function, R's `pnorm()`.
+ *
+ * Built on the identity Φ(−z) = ½ · Q(½, z²/2), which keeps the far tail
+ * accurate relative to itself rather than losing it against 1. The
+ * non-central t needs Φ(−ncp) down to 1e-72 at the widest slider settings.
+ *
+ * @param z Where to evaluate the distribution.
+ * @returns A probability between 0 and 1, or NaN for a NaN input.
+ */
+export declare function normalCdf(z: number): number;
+/**
+ * The inverse of the regularized incomplete beta function, R's `qbeta()`.
+ *
+ * Newton's method on I_x(a, b) − p, with the exact beta density as the
+ * derivative. Every step keeps a bracket, and a step that leaves the bracket
+ * falls back to bisection, so the loop cannot run away on a poor guess.
+ *
+ * @param p A probability between 0 and 1.
+ * @param a A positive shape.
+ * @param b A positive shape.
+ * @returns The x where I_x(a, b) equals p, or NaN for a bad shape.
+ */
+export declare function inverseIncompleteBeta(p: number, a: number, b: number): number;
+//# sourceMappingURL=special.d.ts.map

package/dist/core/special.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"special.d.ts","sourceRoot":"","sources":["../../src/core/special.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAsCH;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAW1C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAepD;AA+DD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAWtE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,CAAC,EAAE,MAAM,EACT,UAAU,EAAE,MAAM,EAClB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,CAmBR;AAuED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAM3C;AAwCD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,GACR,MAAM,CAiDR"}

package/dist/core/tdist.d.ts

@@ -0,0 +1,53 @@
+/**
+ * The t distribution: density, cumulative probability, and quantile.
+ *
+ * These are the port of R's `dt()`, `pt()`, and `qt()`. `plot_t_test()` in
+ * `../compstatslib/R/t_statistic_plot.R` draws both hypothesis curves from
+ * them. Verified against R in `tdist.test.ts`.
+ *
+ * All three take an optional non-centrality, as in R. Left out or given as 0,
+ * they run the central path, which `plot_t_test()` draws the null hypothesis
+ * from; given a non-zero value they run the non-central path behind the
+ * alternative-hypothesis curve, where the non-centrality is the t statistic
+ * itself.
+ *
+ * A note on how close this comes to R. The non-central routines follow R's
+ * own `pnt.c` and `dnt.c` step for step, down to the iteration cap and the
+ * error bound. That is on purpose. Both stop the series on an *absolute*
+ * bound, so where they stop is part of the answer, and a tidier stopping rule
+ * would move the last digits away from R rather than toward the truth. It
+ * also means this port inherits R's limits: at a large non-centrality the
+ * series terms are built by repeated subtraction and go to noise once they
+ * fall below about 1e-16, which is what R's own "full precision may not have
+ * been achieved" warning reports. Densities near 1e-50 there agree with R in
+ * absolute terms only.
+ */
+/**
+ * The density of the t distribution, R's `dt()`.
+ *
+ * @param x Where to evaluate the density.
+ * @param df Degrees of freedom. Any positive number, whole or not.
+ * @param ncp The non-centrality. Left out, or 0, gives the central density.
+ * @returns The density, or NaN if df is zero or less.
+ */
+export declare function dt(x: number, df: number, ncp?: number): number;
+/**
+ * The share of the distribution below x, R's `pt()`.
+ *
+ * @param x Where to evaluate the distribution.
+ * @param df Degrees of freedom. Any positive number, whole or not.
+ * @param ncp The non-centrality. Left out, or 0, gives the central case.
+ * @returns A probability between 0 and 1, or NaN if df is zero or less.
+ */
+export declare function pt(x: number, df: number, ncp?: number): number;
+/**
+ * The value with probability p below it, R's `qt()`.
+ *
+ * @param p A probability between 0 and 1. The ends give infinities, as in R.
+ * @param df Degrees of freedom. Any positive number, whole or not.
+ * @param ncp The non-centrality. Left out, or 0, gives the central case.
+ * @returns The quantile, or NaN for a p outside 0 to 1 or a df of zero or
+ *   less.
+ */
+export declare function qt(p: number, df: number, ncp?: number): number;
+//# sourceMappingURL=tdist.d.ts.map

package/dist/core/tdist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tdist.d.ts","sourceRoot":"","sources":["../../src/core/tdist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAuBH;;;;;;;GAOG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAO9D;AAED;;;;;;;GAOG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAO9D;AAED;;;;;;;;GAQG;AACH,wBAAgB,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAO9D"}

package/dist/core/ttest.d.ts

@@ -0,0 +1,146 @@
+/**
+ * The derived quantities of a one-sided t test.
+ *
+ * This is the statistics half of `plot_t_test()` in
+ * `../compstatslib/R/t_statistic_plot.R`. R computes these while drawing,
+ * scattered across `plot_t_test()`, `t_null_plot()`, `t_alt_lines()`, and
+ * `plot_error_matrix()`; here they are one pure result that the plot layer
+ * reads. Verified against R in `ttest.test.ts`.
+ *
+ * What the picture shows: a null distribution centerd at 0 and an alternative
+ * distribution centerd at the t statistic the given difference produces. The
+ * area of the null above the critical value is the significance level; the
+ * area of the alternative above that same point is the power, and what falls
+ * below it is beta.
+ */
+/** The four numbers `plot_t_test()` takes, all optional as in R. */
+export interface TTestOptions {
+    /** The difference the alternative hypothesis claims. */
+    readonly diff?: number;
+    /** The population standard deviation. */
+    readonly sd?: number;
+    /** The sample size. */
+    readonly n?: number;
+    /** The significance level. */
+    readonly alpha?: number;
+}
+/**
+ * R's defaults from the `plot_t_test()` signature.
+ *
+ * These live here rather than in the plot layer so that the plot and
+ * interactive layers read one set of numbers, and so that `tTestStats()` on
+ * its own yields the classroom demo, matching R's no-argument behavior.
+ */
+export declare const DEFAULT_T_TEST_OPTIONS: {
+    readonly diff: 0.5;
+    readonly sd: 4;
+    readonly n: 100;
+    readonly alpha: 0.05;
+};
+/**
+ * A span of the x axis to shade under a curve.
+ *
+ * `from` can be −Infinity. Once the difference is large enough, beta
+ * underflows to exactly 0 and the shading starts at the quantile for 0, which
+ * is unbounded — the whole alternative curve lies in the rejection region.
+ * About one in thirty of the slider settings reaches this. The value is
+ * honest and the plot layer must clamp it to the drawing window; R instead
+ * hands the infinity to `seq()` and stops with an error, so this is one place
+ * the port has to do better rather than follow.
+ */
+export interface FillRange {
+    /** Where the shading starts. May be −Infinity; see above. */
+    readonly from: number;
+    /** Where the shading stops. R runs every fill out to the 0.999 quantile. */
+    readonly to: number;
+}
+/**
+ * The four cells of the error matrix, and which row R rings.
+ *
+ * The numbers here are raw. R prints two of the four through `round(x, 2)`
+ * and the other two untouched: `plot_error_matrix()` writes `alpha` and
+ * `1 - alpha` as they are, but `round(alt_stats[2], 2)` and
+ * `round(alt_stats[1], 2)` for the power and beta cells. That asymmetry is
+ * R's own. Rounding is a display concern, so it belongs to the plot layer;
+ * this type carries full precision and lets the drawing decide.
+ */
+export interface TTestErrorMatrix {
+    /** Top left: rejecting a true null. This is alpha. */
+    readonly typeOne: number;
+    /** Top right: rejecting a false null. This is the power. */
+    readonly correctReject: number;
+    /** Bottom left: keeping a true null. This is 1 − alpha. */
+    readonly correctFailToReject: number;
+    /** Bottom right: keeping a false null. This is beta. */
+    readonly typeTwo: number;
+    /**
+     * Whether R rings the top row rather than the bottom one.
+     *
+     * R's test is `alt_stats[3] < alt_stats[4]`: the point where the alternative
+     * fill begins, against the alternative's median. The fill begins at the
+     * critical value, so this asks whether the critical value sits below the
+     * median — that is, whether the test is more likely than not to reject. When
+     * it is, the top row is the likely outcome and gets the ring.
+     */
+    readonly highlightTopRow: boolean;
+}
+/** Everything `plot_t_test()` derives before it draws anything. */
+export interface TTestStats {
+    /** The difference the statistics were computed from. */
+    readonly diff: number;
+    /** The standard deviation they were computed from. */
+    readonly sd: number;
+    /** The sample size they were computed from. */
+    readonly n: number;
+    /** The significance level they were computed from. */
+    readonly alpha: number;
+    /** Degrees of freedom, n − 1. */
+    readonly df: number;
+    /**
+     * The t statistic, `diff / (sd / √n)`.
+     *
+     * This doubles as the non-centrality of the alternative distribution, which
+     * is what makes the two curves in the picture the same shape shifted.
+     */
+    readonly t: number;
+    /** Where the null distribution starts rejecting, `qt(1 − alpha, df)`. */
+    readonly criticalValue: number;
+    /** The chance of keeping a false null: the alternative below the critical value. */
+    readonly beta: number;
+    /** The chance of rejecting a false null, 1 − beta. */
+    readonly power: number;
+    /** The alternative distribution's midpoint, `qt(0.5, df, ncp)`. */
+    readonly altMedian: number;
+    /** The height of the alternative curve at its midpoint. */
+    readonly altMedianDensity: number;
+    /**
+     * The shaded span under the alternative curve, the power.
+     *
+     * `from` is R's `alt_stats[3]`, `qt(beta, df, ncp)`. That inverts the beta
+     * it was just built from, so it lands back on the critical value — but only
+     * as closely as the two routines invert each other, which is why R's own
+     * numbers differ in the last digits from `criticalValue`.
+     */
+    readonly altFill: FillRange;
+    /**
+     * The shaded span under the null curve, the significance level.
+     *
+     * `from` is the critical value, by the same expression.
+     */
+    readonly nullFill: FillRange;
+    /** The four cells R draws beside the curves. */
+    readonly errorMatrix: TTestErrorMatrix;
+}
+/**
+ * Work out everything the picture needs from the four test parameters.
+ *
+ * A missing option takes R's default, so calling this with nothing yields the
+ * same demo `plot_t_test()` does. Nothing is validated: a sample size of 1
+ * leaves no degrees of freedom and the quantiles come back as NaN, which is
+ * what R does too.
+ *
+ * @param options The test parameters. Any left out take R's defaults.
+ * @returns The derived quantities. No drawing, no state.
+ */
+export declare function tTestStats(options?: TTestOptions): TTestStats;
+//# sourceMappingURL=ttest.d.ts.map

package/dist/core/ttest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ttest.d.ts","sourceRoot":"","sources":["../../src/core/ttest.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,oEAAoE;AACpE,MAAM,WAAW,YAAY;IAC3B,wDAAwD;IACxD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,uBAAuB;IACvB,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;IACpB,8BAA8B;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;CAKzB,CAAC;AAEX;;;;;;;;;;GAUG;AACH,MAAM,WAAW,SAAS;IACxB,6DAA6D;IAC7D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,4DAA4D;IAC5D,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,2DAA2D;IAC3D,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,wDAAwD;IACxD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;;;;OAQG;IACH,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AAED,mEAAmE;AACnE,MAAM,WAAW,UAAU;IACzB,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,iCAAiC;IACjC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,EAAE,MAAM,CAAC;IACnB,yEAAyE;IACzE,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,oFAAoF;IACpF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sDAAsD;IACtD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,mEAAmE;IACnE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,2DAA2D;IAC3D,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC;;;;;;;OAOG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC;IAC7B,gDAAgD;IAChD,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC;CACxC;AAKD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,YAAiB,GAAG,UAAU,CAgDjE"}

package/dist/data/moderationData.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The `moderation_data` dataset of the R package.
+ *
+ * Two hundred rows of a moderated relationship, used as the default data of
+ * `plot_moderation_3d()` and `plot_scatter3d()` so that both work with no
+ * arguments. R's `data.R` records the recipe: `x`, `z` and `w` are drawn
+ * independently from a normal distribution with standard deviation 2, and
+ *
+ * ```text
+ * y = 0.5 x + 0.3 z + 0.8 x z + N(0, 1)
+ * ```
+ *
+ * so the effect of `x` on `y` grows with `z` — the interaction the surface
+ * shows as a twist. Column `w` enters no equation: it is noise, and it is
+ * there so an example can carry a control variable that means nothing.
+ *
+ * The values below are the exact doubles of the R data file
+ * (`../compstatslib/data/moderation_data.rda`), printed at 17 significant
+ * digits, which round-trips an IEEE-754 double. **Exported from R, never
+ * regenerated** — the draw used `set.seed(42)` under R's own generator, so a
+ * JavaScript regeneration would produce different numbers and silently change
+ * every default demo. Source of the printed values:
+ * `.claude/plans/moderation-data.tsv`, checked against the column checksums of
+ * `.claude/plans/moderation-fixtures.md` in `moderationData.test.ts`.
+ *
+ * The columns are in the order of the R data frame — `y, x, z, w`, not
+ * alphabetical and not `x, y, z`. That order is load-bearing: `plot_scatter3d()`
+ * with no axis arguments takes the first three numeric columns, which is why
+ * its default plot puts `y` on the horizontal axis.
+ */
+/** The four columns of the R `moderation_data` data frame. */
+export type ModerationData = {
+    readonly y: readonly number[];
+    readonly x: readonly number[];
+    readonly z: readonly number[];
+    readonly w: readonly number[];
+};
+/** The 200 rows of the R `moderation_data` data frame, in file order. */
+export declare const moderationData: ModerationData;
+//# sourceMappingURL=moderationData.d.ts.map

package/dist/data/moderationData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moderationData.d.ts","sourceRoot":"","sources":["../../src/data/moderationData.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,8DAA8D;AAC9D,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,QAAQ,CAAC,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B,CAAC;AAEF,yEAAyE;AACzE,eAAO,MAAM,cAAc,EAAE,cAyZ5B,CAAC"}

package/dist/data/pcaDegenerate.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The `pca_degenerate` dataset of the R package.
+ *
+ * A small two-column dataset that shows a degenerate PCA case: the two
+ * components carry almost the same variance (sdev 17.86 and 17.41), so the
+ * principal axes are barely distinguishable and the arrows of `plot_pca()`
+ * come out nearly the same length in nearly perpendicular directions.
+ *
+ * The 16 rows below are the exact doubles of the R data file
+ * (`../compstatslib/data/pca_degenerate.rda`), printed at 17 significant
+ * digits, which round-trips an IEEE-754 double. **Exported from R, never
+ * regenerated** — a JavaScript regeneration would silently change the demo.
+ * Source of the printed values: `.claude/plans/pca-fixtures.md`, section F1.
+ */
+import type { Point } from "../core/regression";
+/** The 16 rows of the R `pca_degenerate` data frame, in file order. */
+export declare const pcaDegenerate: readonly Point[];
+//# sourceMappingURL=pcaDegenerate.d.ts.map

package/dist/data/pcaDegenerate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcaDegenerate.d.ts","sourceRoot":"","sources":["../../src/data/pcaDegenerate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAEhD,uEAAuE;AACvE,eAAO,MAAM,aAAa,EAAE,SAAS,KAAK,EAiBzC,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,66 @@
+export { machinePrecision } from "./core/precision";
+export { mean, meanAbsoluteDeviation, median, quantile, quantiles, sd, } from "./core/arith";
+export { bwNrd0, kernelDensity } from "./core/kde";
+export type { KernelDensityEstimate, KernelDensityOptions, } from "./core/kde";
+export { histogram, nclassSturges } from "./core/histogram";
+export type { Histogram, HistogramOptions } from "./core/histogram";
+export { rPretty } from "./core/pretty";
+export type { RPrettyOptions } from "./core/pretty";
+export { drawSamples, sampleConfidenceIntervals, simulateSampleCi, } from "./core/sampling";
+export type { DistributionFn, DrawSamplesOptions, Interval, SampleCiOptions, SampleCiSimulation, SampleDraw, SampleInterval, } from "./core/sampling";
+export { frameRows, isNumericColumn, numericColumns, requireNumericColumn, } from "./core/frame";
+export type { Column, DataFrame } from "./core/frame";
+export { moderationSurface } from "./core/moderation";
+export type { ModerationOptions, ModerationSurface, ModerationTerm, } from "./core/moderation";
+export { linearRegression } from "./core/regression";
+export type { Point, RegressionFit } from "./core/regression";
+export { determinant, invertMatrix } from "./core/matrix";
+export type { Matrix2, MatrixInversion, Singularity } from "./core/matrix";
+export { principalComponents } from "./core/pca";
+export type { Loadings, PcaResult } from "./core/pca";
+export { DEFAULT_LOGIT_EPSILON, DEFAULT_LOGIT_MAX_ITERATIONS, logisticRegression, predictLogit, } from "./core/logit";
+export type { LogitFit, LogitOptions } from "./core/logit";
+export { DEFAULT_LEAST_SQUARES_TOLERANCE, leastSquares } from "./core/ols";
+export type { LeastSquaresFit, LeastSquaresOptions } from "./core/ols";
+export { rcauchy, rlnorm, rnorm, rt, runif, sampleWithoutReplacement, seededRng, } from "./core/rng";
+export type { Rng, RcauchyOptions, RlnormOptions, RnormOptions, RunifOptions, } from "./core/rng";
+export { dt, pt, qt } from "./core/tdist";
+export { DEFAULT_T_TEST_OPTIONS, tTestStats } from "./core/ttest";
+export type { FillRange, TTestErrorMatrix, TTestOptions, TTestStats, } from "./core/ttest";
+export { incompleteBeta, incompleteBetaSplit, inverseIncompleteBeta, logBeta, logGamma, normalCdf, } from "./core/special";
+export { moderationData } from "./data/moderationData";
+export type { ModerationData } from "./data/moderationData";
+export { pcaDegenerate } from "./data/pcaDegenerate";
+export { resolveTarget } from "./plot/target";
+export type { Context2D, PlotTarget, RenderTarget } from "./plot/target";
+export { DEFAULT_MARGINS, createScale, drawAxes, pixelInArea, prettyTicks, } from "./plot/axes";
+export type { AxesOptions, Extent, Margins, PlotArea, Scale, ScaleOptions, } from "./plot/axes";
+export { matrixInverseScale, plotMatrixInverse } from "./plot/matrixInverse";
+export { logitScale, plotLogit } from "./plot/logit";
+export type { LegendLocation, PlotLogitOptions } from "./plot/logit";
+export { plotSampleCi, sampleCiScale } from "./plot/sampleCi";
+export type { PlotSampleCiOptions } from "./plot/sampleCi";
+export { plotSampling, samplingScale } from "./plot/sampling";
+export type { PlotSamplingOptions, PlotSamplingResult, SamplingPanel, SamplingState, } from "./plot/sampling";
+export { pcaScale, plotPca } from "./plot/pca";
+export type { PlotPcaOptions } from "./plot/pca";
+export { plotRegression, regressionScale } from "./plot/regression";
+export type { PlotRegressionOptions } from "./plot/regression";
+export { formatNumber, formatStat } from "./plot/format";
+export { plotTTest, tTestScale } from "./plot/tTest";
+export type { PlotTTestOptions } from "./plot/tTest";
+export { eventPixel, resolveControlTarget, resolveInteractiveTarget, } from "./interactive/target";
+export type { ClickSource, ControlTarget, InteractiveTarget, PanelTarget, ResolvedPanel, SplitTarget, } from "./interactive/target";
+export { DEFAULT_MATRIX_INVERSE_VALUES, interactiveMatrixInverse, } from "./interactive/matrixInverse";
+export type { InteractiveMatrixInverseHandle, InteractiveMatrixInverseOptions, } from "./interactive/matrixInverse";
+export { interactiveSampling } from "./interactive/sampling";
+export type { InteractiveSamplingHandle, InteractiveSamplingOptions, SamplingValues, } from "./interactive/sampling";
+export { interactiveTTest } from "./interactive/tTest";
+export type { InteractiveTTestHandle, InteractiveTTestOptions, TTestValues, } from "./interactive/tTest";
+export { interactiveLogit } from "./interactive/logit";
+export type { InteractiveLogitHandle, InteractiveLogitOptions, } from "./interactive/logit";
+export { interactivePca } from "./interactive/pca";
+export type { InteractivePcaHandle, InteractivePcaOptions, InteractivePcaResult, } from "./interactive/pca";
+export { interactiveRegression } from "./interactive/regression";
+export type { InteractiveRegressionHandle, InteractiveRegressionOptions, } from "./interactive/regression";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}