@mark1russell7/rigor-statistics 0.1.18 → 0.1.20

package/build/index.js

@@ -303,7 +303,7 @@ function sides(values, against) {
 	};
 }
 /** The interval of the finite statistics of the runs. When no run is finite, low and high are equal to the estimate. */
-function ends(values, estimate, s, seed) {
+function ends$1(values, estimate, s, seed) {
 	const { runs, level } = s;
 	const p = sides(values, s.against);
 	if (values.length === 0) return {
@@ -341,7 +341,7 @@ function percentile(name, options, run, all) {
 		const v = run(r);
 		if (Number.isFinite(v)) values.push(v);
 	}
-	return ends(values, all(), s, r.seed);
+	return ends$1(values, all(), s, r.seed);
 }
 /**
 * The percentile bootstrap of `k` statistics from the same draws. Each run gives `k` statistics. Each statistic
@@ -356,7 +356,7 @@ function percentiles(name, options, k, run, all) {
 		for (let j = 0; j < k; j++) if (Number.isFinite(v[j])) values[j].push(v[j]);
 	}
 	const estimate = all();
-	return values.map((list, j) => ends(list, estimate[j], s, r.seed));
+	return values.map((list, j) => ends$1(list, estimate[j], s, r.seed));
 }
 /** A bootstrap interval of the median. */
 function bootstrapMedian(values, options = {}) {
@@ -399,7 +399,7 @@ function bootstrapClusters(rows, cluster, statistic, options = {}) {
 * The interval is narrow for a small sample. The draws give the variance of the sample with the divisor `m`, not
 * `m - 1`, so the width gets the factor `sqrt((m - 1) / m)`. The skew of the values adds to the miss. In the tests,
 * 400 samples of `m = 8` of `n = 40` hold the total 346 times (Wilson 0.828 to 0.895). At `m = 100` of `n = 200`,
-* the coverage agrees with 95%.
+* the coverage agrees with 95%. For a total over the pairs of the items, use `uStatisticInterval`.
 */
 function sampleTotalInterval(values, options) {
 	const name = "sampleTotalInterval";
@@ -2247,7 +2247,7 @@ function fitResponse(data, options = {}) {
 * The tests of a difference: the sign test, the paired permutation test, the Wilson interval of a proportion and
 * the Holm correction for several tests.
 */
-function whole$1(name, value) {
+function whole$2(name, value) {
 	if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name}: ${value} is not a whole number of 0 or more.`);
 }
 /** The log of each binomial term C(n, k) / 2^n, for each k from 0 to n. */
@@ -2275,8 +2275,8 @@ function upperTail(k, n) {
 * two times the tail of the larger count, at most 1. The one-sided p is equal to `signTestP` of packing.
 */
 function signTest(better, worse, sides = 1) {
-	whole$1("signTest", better);
-	whole$1("signTest", worse);
+	whole$2("signTest", better);
+	whole$2("signTest", worse);
 	const n = better + worse;
 	if (n === 0) return 1;
 	if (sides === 1) return upperTail(better, n);
@@ -2287,7 +2287,7 @@ function signTest(better, worse, sides = 1) {
 * n wins out of n are not enough. Use it before a run, to know how many inputs a claim needs.
 */
 function signTestPower(n, level = .05, sides = 2) {
-	whole$1("signTestPower", n);
+	whole$2("signTestPower", n);
 	for (let k = Math.ceil(n / 2); k <= n; k++) if (signTest(k, n - k, sides) < level) return k;
 }
 /** The z of a two-sided 95% interval. */
@@ -2297,8 +2297,8 @@ const Z95 = 1.959963984540054;
 * a proportion near 0 or 1, where the normal interval does not. For n = 0 the interval is 0 to 1.
 */
 function wilson(k, n, z = Z95) {
-	whole$1("wilson", k);
-	whole$1("wilson", n);
+	whole$2("wilson", k);
+	whole$2("wilson", n);
 	if (k > n) throw new RangeError(`wilson: k ${k} is more than n ${n}.`);
 	if (n === 0) return {
 		low: 0,
@@ -2345,7 +2345,7 @@ function holm(pValues, level = .05) {
 */
 function partialConjunction(pValues, need) {
 	for (const p of pValues) if (!(p >= 0 && p <= 1)) throw new RangeError(`partialConjunction: each p is from 0 to 1, not ${p}.`);
-	whole$1("partialConjunction", need);
+	whole$2("partialConjunction", need);
 	const m = pValues.length;
 	if (need < 1 || need > m) throw new RangeError(`partialConjunction: need is from 1 to the count of tests ${m}, not ${need}.`);
 	const sorted = [...pValues].sort((a, b) => a - b);
@@ -2448,7 +2448,7 @@ function twoSamplePermutation(a, b, options = {}) {
 */
 function wilsonSampleSize(target, expected, z = Z95, max = 1e6) {
 	if (!(target >= 0 && target <= 1 && expected >= 0 && expected <= 1)) throw new RangeError(`wilsonSampleSize: target ${target} and expected ${expected} must be from 0 to 1.`);
-	whole$1("wilsonSampleSize", max);
+	whole$2("wilsonSampleSize", max);
 	if (expected <= target) return void 0;
 	for (let n = 1; n <= max; n++) if (wilson(Math.round(expected * n), n, z).low >= target) return n;
 }
@@ -2566,7 +2566,7 @@ function kendallTau(a, b, seed = 1) {
 * The intervals that come from a discrete distribution. The interval of a median or of a quantile comes from the order
 * statistics. The central interval of a count comes from a binomial or a negative binomial distribution.
 */
-function whole(name, value) {
+function whole$1(name, value) {
 	if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${name}: ${value} is not a whole number of 0 or more.`);
 }
 function levelOf(name, level) {
@@ -2675,7 +2675,7 @@ function quantileSamples(p, level = .95) {
 * or less. The two tails are separate sums, so that a small upper tail keeps its digits.
 */
 function binomialInterval(n, p, level = .95) {
-	whole("binomialInterval", n);
+	whole$1("binomialInterval", n);
 	if (!(p >= 0 && p <= 1)) throw new RangeError(`binomialInterval: p is from 0 to 1, not ${p}.`);
 	const tail = levelOf("binomialInterval", level);
 	const terms = binomialTerms(n, p);
@@ -2700,12 +2700,47 @@ function binomialInterval(n, p, level = .95) {
 	};
 }
 /**
+* This function gives the p of the exact one-sided binomial test of `k` successes in `n` trials, with
+* X ~ Binomial(n, p). The side `"less"` gives `P(X <= k)`. A small value rejects the claim "the chance is `p` or
+* more". The side `"greater"` gives `P(X >= k)`. A small value rejects the claim "the chance is `p` or less".
+*
+* The sum starts at the largest term of the tail, so a small tail keeps its digits. At `p = 1/2`, the side
+* `"greater"` is equal to the one-sided `signTest(k, n - k)`.
+*
+* @param k - The count of successes, a whole number from 0 to `n`.
+* @param n - The count of trials, a whole number of 0 or more.
+* @param p - The chance of a success under the claim, from 0 to 1.
+* @param side - The side of the tail.
+* @returns The p of the test, from 0 to 1.
+*/
+function binomialTest(k, n, p, side) {
+	whole$1("binomialTest", k);
+	whole$1("binomialTest", n);
+	if (k > n) throw new RangeError(`binomialTest: k ${k} is more than n ${n}.`);
+	if (!(p >= 0 && p <= 1)) throw new RangeError(`binomialTest: p is from 0 to 1, not ${p}.`);
+	if (side !== "less" && side !== "greater") throw new RangeError(`binomialTest: side is "less" or "greater", not ${String(side)}.`);
+	const [from, to] = side === "less" ? [0, k] : [k, n];
+	if (from === 0 && to === n) return 1;
+	if (p === 0) return from === 0 ? 1 : 0;
+	if (p === 1) return to === n ? 1 : 0;
+	const [logP, logQ] = [Math.log(p), Math.log1p(-p)];
+	const logs = [];
+	let logChoose = 0;
+	for (let i = 0; i <= to; i++) {
+		if (i > 0) logChoose += Math.log((n - i + 1) / i);
+		if (i >= from) logs.push(logChoose + i * logP + (n - i) * logQ);
+	}
+	const top = Math.max(...logs);
+	const sum = logs.reduce((s, l) => s + Math.exp(l - top), 0);
+	return Math.min(1, Math.exp(top) * sum);
+}
+/**
 * The central interval of a negative binomial count. X is the count of failures before `successes` successes, and
 * `p` is the chance of a success at each try. `low` is the smallest k with P(X <= k) > (1 - level) / 2.
 * `high` is the smallest k with P(X <= k) >= 1 - (1 - level) / 2.
 */
 function negativeBinomialInterval(successes, p, level = .95) {
-	whole("negativeBinomialInterval", successes);
+	whole$1("negativeBinomialInterval", successes);
 	if (!(p > 0 && p <= 1)) throw new RangeError(`negativeBinomialInterval: p is more than 0 and 1 or less, not ${p}.`);
 	const tail = levelOf("negativeBinomialInterval", level);
 	const logQ = Math.log1p(-p);
@@ -2972,6 +3007,286 @@ function optionFloor(options) {
 	}
 	throw new RangeError(`optionFloor: no count under 10,000,000 for sigma ${sigma} and delta ${delta}.`);
 }
-export { KENDALL_EXACT, RESPONSE_LAMBDAS, RESPONSE_MAX_POWER, RESPONSE_MAX_TERMS, RESPONSE_RECORDS_SCHEMA, Z95, bestSmoothLaw, binomialInterval, bootstrap, bootstrapClusters, bootstrapLeastSquares, bootstrapMedian, bootstrapMedianRatio, bootstrapTwo, brier, calibration, cohenKappa, compareRatios, fitResponse, heldOutError, heldOutErrorAt, holm, kendallTau, leastSquares, mean, median, medianInterval, modeCount, negativeBinomialInterval, noiseFloor, noiseVerdict, optionFloor, pairedPermutation, parseResponseRecord, partialConjunction, predictResponse, quantile, quantileInterval, quantileSamples, quantileSorted, ranks, responseCells, ridgeSolve, sampleTotalInterval, sd, signTest, signTestPower, sliceResponse, smoothLawScores, sorted, spearman, summarize, surfaceResponse, tQuantile, twoSamplePermutation, whenHolds, wilson, wilsonSampleSize };
+// src/coverage.ts
+/**
+* The rule that finds the smallest sample at which an interval method keeps its level. The input is the hits of the
+* method on the true value in seeded cells. The bar is fixed before the run.
+*/
+function whole(name, value, min) {
+	if (!Number.isSafeInteger(value) || value < min) throw new RangeError(`coverageMinSample: ${name} is a whole number of ${min} or more, not ${value}.`);
+}
+/**
+* This function applies a fixed bar of coverage to the cells of a study. It gives the smallest sample size `m` from
+* which an interval method keeps its level. The method qualifies at `m` when the cells with a sample of `m` or more
+* pass two tests:
+*
+* 1. No cell rejects the coverage `level`. Each cell has the exact one-sided binomial test `P(X <= hits)`, with
+*    X ~ Binomial(draws, level). The family of these tests gets the Holm correction at `alpha`.
+* 2. The Wilson lower end of the pooled coverage, the sum of the hits over the sum of the draws, is `pooledLow`
+*    or more.
+*
+* Each step tells the result of the two tests at its `m`. A step does not depend on the steps of other sizes. At a
+* small `m`, the pool also holds the cells of the larger sizes. Thus a small `m` can pass while a larger `m` fails
+* alone, for example near `m = n`.
+*
+* Thus the set of sizes is closed upward. The result is the smallest `m` of the cells such that each size of `m` or
+* more qualifies. The field `blocking` gives the largest size that fails. When the largest size fails, the result is
+* infinite.
+*
+* @param cells - The hits and the draws of each cell. Each cell has its own sample size.
+* @param bar - The level, the alpha of the Holm family and the pooled lower end.
+* @returns The smallest size from which each size qualifies, the size that blocks, and the result at each size.
+*/
+function coverageMinSample(cells, bar) {
+	const { level, alpha, pooledLow } = bar;
+	const z = bar.z ?? 1.959963984540054;
+	if (!(level > 0 && level < 1)) throw new RangeError(`coverageMinSample: level is more than 0 and less than 1, not ${level}.`);
+	if (!(alpha > 0 && alpha < 1)) throw new RangeError(`coverageMinSample: alpha is more than 0 and less than 1, not ${alpha}.`);
+	if (!(pooledLow >= 0 && pooledLow <= 1)) throw new RangeError(`coverageMinSample: pooledLow is from 0 to 1, not ${pooledLow}.`);
+	if (!(z > 0 && Number.isFinite(z))) throw new RangeError(`coverageMinSample: z is a finite number more than 0, not ${z}.`);
+	for (const cell of cells) {
+		whole("sample", cell.sample, 1);
+		whole("draws", cell.draws, 1);
+		whole("hits", cell.hits, 0);
+		if (cell.hits > cell.draws) throw new RangeError(`coverageMinSample: the hits ${cell.hits} of the cell ${cell.name} are more than its draws ${cell.draws}.`);
+	}
+	const p = cells.map((cell) => binomialTest(cell.hits, cell.draws, level, "less"));
+	const steps = [...new Set(cells.map((cell) => cell.sample))].sort((a, b) => a - b).map((m) => {
+		const at = cells.map((cell, i) => ({
+			cell,
+			p: p[i]
+		})).filter(({ cell }) => cell.sample >= m);
+		const corrected = holm(at.map(({ p: value }) => value), alpha);
+		const rejected = at.filter((_, i) => corrected[i]?.reject === true).map(({ cell }) => cell.name);
+		const smallestAdjusted = Math.min(...corrected.map((c) => c.adjusted));
+		let hits = 0;
+		let draws = 0;
+		for (const { cell } of at) {
+			hits += cell.hits;
+			draws += cell.draws;
+		}
+		const pooled = wilson(hits, draws, z);
+		const cellOk = rejected.length === 0;
+		const pooledOk = pooled.low >= pooledLow;
+		const reason = cellOk ? pooledOk ? "qualifies" : "pooled-low" : pooledOk ? "cell-rejected" : "cell-rejected-and-pooled-low";
+		return {
+			sample: m,
+			cells: at.length,
+			rejected,
+			smallestAdjusted,
+			hits,
+			draws,
+			pooled,
+			qualifies: cellOk && pooledOk,
+			reason
+		};
+	});
+	let minSample = Number.POSITIVE_INFINITY;
+	let blocking;
+	for (let i = steps.length - 1; i >= 0; i--) {
+		const step = steps[i];
+		if (!step.qualifies) {
+			blocking = step.sample;
+			break;
+		}
+		minSample = step.sample;
+	}
+	return blocking === void 0 ? {
+		minSample,
+		steps
+	} : {
+		minSample,
+		blocking,
+		steps
+	};
+}
+// src/u-statistic.ts
+/**
+* The interval of a U-statistic from a uniform sample of `m` of `n` units, drawn without replacement. A kernel `h`
+* gives a value to each set of `r` units. The total of the population is the sum of `h` over all its sets of `r`.
+*/
+/**
+* The smallest sample `m` at which the method `"auto"` uses the method `"tight"`. The calibration study
+* `u-statistic-interval` gives the value with `coverageMinSample`. The value is the smallest `m` of the grid such that
+* each `m` of the grid from this value up passes the bar. Until a run of the study gives a value, the value is
+* infinite. The TSDoc of `uStatisticInterval` gives the bar of the study.
+*/
+const U_STATISTIC_TIGHT_MIN_SAMPLE = Number.POSITIVE_INFINITY;
+/**
+* This function gives the interval of a total over all the sets of `r` units of a population. The data is a uniform
+* sample of `m` of the `n` units, without replacement. An example is the count of crossings between all pairs of
+* routes. The input is the total of each sampled unit: the sum of the kernel over the sets of `r` sampled units
+* that hold the unit. Thus the sum of the totals is `r * S`, with `S` the total of the sample. The kernel is
+* symmetric.
+*
+* The estimate is `S * C(n, r) / C(m, r)`. It is the U-statistic `U = S / C(m, r)` times `C(n, r)`. At `r = 1`,
+* the estimate is `n / m` times the sum of the sample. When `m` is `n`, the interval is the estimate.
+*
+* The method `"conservative"` uses the inequality of Hoeffding (1963) for U-statistics, with `k = floor(m / r)`. The
+* half width of the mean is `(b - a) * sqrt(ln(2 / (1 - level)) / (2 k))`, with `[a, b]` the range of the kernel.
+* The bound is also true for a sample without replacement (Ai, Kuželka and Wang 2022, Blanc 2023 Theorem 6).
+* Thus the interval holds at each `m`. It is wide at a small `m`.
+*
+* The method `"tight"` uses the jackknife variance of `U`, from the totals only, times the finite population
+* correction `1 - m / n`. The interval is `U` plus or minus the t quantile with `m - 1` degrees of freedom, times
+* the standard error.
+*
+* The correction comes from the inclusion probabilities of a sample without replacement. The variance of the linear
+* part of `U` (its Hájek projection) gets exactly the factor `1 - m / n`. The variance of the remainder gets a
+* smaller factor, near `(1 - m / n)^2`, relative to an independent sample. For `r = 2` this factor is
+* `(n - m)(n - m - 1) / ((n - 2)(n - 3))`. Thus this estimate of the variance is exact for a linear kernel, and
+* larger than the variance for other kernels. The tests read the two facts over all samples of small populations.
+*
+* The method `"tight"` does not give an interval of width 0 when `m` is less than `n`. When all the totals are
+* equal, the jackknife variance is 0. Then the function uses the method `"conservative"` for the sample, and the
+* result has `method: "conservative"`. Without `range`, the function throws a `RangeError` for this sample.
+*
+* The method `"tight"` has no proof of its coverage. The tests use 200 samples of made-up populations at the level
+* 0.95. The table gives the hits of 200 for each population `n` and sample `m`. Each count includes the fallback.
+*
+* | n / m | sparse | crossings | skewed |
+* | --- | --- | --- | --- |
+* | 40 / 8 | 200 | 200 | 183 |
+* | 40 / 10 | 200 | 200 | 187 |
+* | 40 / 12 | 200 | 183 | 189 |
+* | 40 / 20 | 180 | 183 | 188 |
+* | 40 / 36 | 192 | 189 | 193 |
+* | 60 / 8 | 200 | 200 | 181 |
+* | 60 / 10 | 200 | 200 | 180 |
+* | 60 / 12 | 200 | 195 | 186 |
+* | 60 / 20 | 184 | 190 | 183 |
+* | 60 / 40 | 186 | 193 | 180 |
+* | 120 / 8 | 200 | 200 | 177 |
+* | 120 / 10 | 200 | 192 | 175 |
+* | 120 / 12 | 200 | 189 | 178 |
+* | 120 / 20 | 191 | 193 | 182 |
+* | 120 / 40 | 194 | 192 | 185 |
+* | 120 / 60 | 195 | 189 | 185 |
+* | 120 / 108 | 187 | 185 | 190 |
+*
+* The sparse kernel holds 2% to 3% of the pairs. The skewed kernel has a few large values. At `m = 8`, the skewed
+* kernel gets 177 to 183 of 200, a coverage of 0.885 to 0.915. No row has 190 or more in each kernel.
+*
+* The method `"auto"` needs `range`. It uses the method `"tight"` when `m` is `U_STATISTIC_TIGHT_MIN_SAMPLE` or more
+* and the variance is more than 0. Otherwise, it uses the method `"conservative"`.
+*
+* The calibration study `u-statistic-interval` sets `U_STATISTIC_TIGHT_MIN_SAMPLE`. Its bar was fixed before its run.
+* The study draws 1000 samples in each cell of the 3 kernels and the 17 cells of the table. The method `"tight"`
+* qualifies at `m` when the cells with a sample of `m` or more pass two tests.
+*
+* First, no cell rejects the coverage 0.95 in a one-sided exact binomial test at alpha 0.05, with the Holm
+* correction over these cells. Second, the Wilson lower end of the pooled coverage of these cells is 0.94 or more.
+* `coverageMinSample` applies this bar.
+*
+* The set of sizes is closed upward. The constant is the smallest `m` of the grid such that each `m` of the grid from
+* this value up qualifies. A small `m` pools the good cells of the larger sizes, so it can pass while a larger `m`
+* fails alone. The upward rule keeps the method `"auto"` away from a size that failed.
+*
+* When the largest `m` fails, the constant is infinite. Until a run of the study gives a value, the constant is infinite. Thus the method `"auto"`
+* uses the method `"conservative"` at each `m` less than `n`.
+*
+* With `range`, the interval of the mean stays in `[a, b]`, and each total is in the range of a sum of
+* `C(m - 1, r - 1)` kernel values.
+*
+* @param totals - The total of each unit of the sample. The sample has more units than `r`.
+* @param options - The order, the population, the method, the level and the range of the kernel.
+* @returns The estimate and the interval of the total, and of the mean of the kernel.
+*/
+function uStatisticInterval(totals, options) {
+	const name = "uStatisticInterval";
+	const { order: r, population: n, method: requested } = options;
+	const m = totals.length;
+	const level = options.level ?? .95;
+	if (!Number.isSafeInteger(r) || r < 1) throw new RangeError(`${name}: order is a whole number of 1 or more, not ${r}.`);
+	if (m <= r) throw new RangeError(`${name}: the sample has more units than the order ${r}, not ${m}.`);
+	if (!Number.isSafeInteger(n) || n < m) throw new RangeError(`${name}: population is a whole number of ${m} (the sample) or more, not ${n}.`);
+	if (requested !== "conservative" && requested !== "tight" && requested !== "auto") throw new RangeError(`${name}: method is "conservative", "tight" or "auto", not ${String(requested)}.`);
+	if (!(level > 0 && level < 1)) throw new RangeError(`${name}: level is more than 0 and less than 1, not ${level}.`);
+	for (const t of totals) if (!Number.isFinite(t)) throw new RangeError(`${name}: each total is a finite number, not ${t}.`);
+	const range = options.range;
+	if (range !== void 0) {
+		const [a, b] = range;
+		if (!(Number.isFinite(a) && Number.isFinite(b) && a < b)) throw new RangeError(`${name}: range is two finite numbers a < b, not ${a} and ${b}.`);
+		const sets = choose(m - 1, r - 1);
+		const slack = 1e-9 * Math.max(Math.abs(a), Math.abs(b)) * sets;
+		for (const t of totals) if (t < a * sets - slack || t > b * sets + slack) throw new RangeError(`${name}: each total is from ${a * sets} to ${b * sets} for this range, not ${t}.`);
+	} else if (requested !== "tight") throw new RangeError(`${name}: the method "${requested}" needs the range of the kernel.`);
+	let sum = 0;
+	for (const t of totals) sum += t;
+	const s = sum / r;
+	const subsets = choose(n, r);
+	const sampleSets = choose(m, r);
+	const estimate = s * subsets / sampleSets;
+	const u = s / sampleSets;
+	const base = {
+		estimate,
+		level,
+		requested,
+		subsets
+	};
+	const centre = sum / m;
+	let squares = 0;
+	for (const t of totals) squares += (t - centre) ** 2;
+	const variance = totals.every((t) => t === totals[0]) ? 0 : (1 - m / n) * ((m - 1) / m) * squares / choose(m - 1, r) ** 2;
+	if (m === n) {
+		const method = requested === "conservative" || requested === "auto" && m < U_STATISTIC_TIGHT_MIN_SAMPLE ? "conservative" : "tight";
+		return {
+			...base,
+			low: estimate,
+			high: estimate,
+			method,
+			mean: {
+				estimate: u,
+				low: u,
+				high: u
+			},
+			...method === "tight" ? {
+				standardError: 0,
+				df: m - 1
+			} : {}
+		};
+	}
+	if ((requested === "tight" || requested === "auto" && m >= U_STATISTIC_TIGHT_MIN_SAMPLE) && variance > 0) {
+		const df = m - 1;
+		const se = Math.sqrt(variance);
+		const half = tQuantile(1 - (1 - level) / 2, df) * se;
+		return {
+			...base,
+			method: "tight",
+			...ends(u, u - half, u + half, range, subsets),
+			standardError: se * subsets,
+			df
+		};
+	}
+	if (range === void 0) throw new RangeError(`${name}: the jackknife variance is 0, because all the totals are equal. Give the range, or use the method "conservative".`);
+	const k = Math.floor(m / r);
+	const half = (range[1] - range[0]) * Math.sqrt(Math.log(2 / (1 - level)) / (2 * k));
+	return {
+		...base,
+		method: "conservative",
+		...ends(u, u - half, u + half, range, subsets)
+	};
+}
+/** This function gives the interval of the mean in the range, if there is a range, and scales it to the total. */
+function ends(u, lowMean, highMean, range, subsets) {
+	const low = range ? Math.max(range[0], lowMean) : lowMean;
+	const high = range ? Math.min(range[1], highMean) : highMean;
+	return {
+		low: low * subsets,
+		high: high * subsets,
+		mean: {
+			estimate: u,
+			low,
+			high
+		}
+	};
+}
+/** The binomial coefficient `C(n, k)`, as a product. Each step is a whole number, so it is exact below 2^53. */
+function choose(n, k) {
+	let c = 1;
+	for (let j = 0; j < k; j++) c = c * (n - j) / (j + 1);
+	return c;
+}
+export { KENDALL_EXACT, RESPONSE_LAMBDAS, RESPONSE_MAX_POWER, RESPONSE_MAX_TERMS, RESPONSE_RECORDS_SCHEMA, U_STATISTIC_TIGHT_MIN_SAMPLE, Z95, bestSmoothLaw, binomialInterval, binomialTest, bootstrap, bootstrapClusters, bootstrapLeastSquares, bootstrapMedian, bootstrapMedianRatio, bootstrapTwo, brier, calibration, cohenKappa, compareRatios, coverageMinSample, fitResponse, heldOutError, heldOutErrorAt, holm, kendallTau, leastSquares, mean, median, medianInterval, modeCount, negativeBinomialInterval, noiseFloor, noiseVerdict, optionFloor, pairedPermutation, parseResponseRecord, partialConjunction, predictResponse, quantile, quantileInterval, quantileSamples, quantileSorted, ranks, responseCells, ridgeSolve, sampleTotalInterval, sd, signTest, signTestPower, sliceResponse, smoothLawScores, sorted, spearman, summarize, surfaceResponse, tQuantile, twoSamplePermutation, uStatisticInterval, whenHolds, wilson, wilsonSampleSize };
 
 //# sourceMappingURL=index.js.map