@mark1russell7/rigor-statistics 0.1.19 → 0.1.20

package/README.md

@@ -112,7 +112,7 @@ The default expansion has one product for each pair of levels of two dimensions.
 | `bootstrapTwo(a, b, statistic, options)` | A bootstrap interval of a statistic of two independent samples, for example two arms of a benchmark. Each run draws all of `a`, then all of `b`. |
 | `bootstrapMedianRatio(numerator, denominator, options)` | The interval of `median(numerator) / median(denominator)`. It is the uncertainty of the ratio, not the spread of the samples. |
 | `sampleTotalInterval(values, { population, scale })` | The interval of the total of a population from a uniform sample of `m` of its `n` items without replacement. The deviations get the finite population correction `sqrt(1 - m / n)`. `scale` is `n / m` by default. When `m` is `n`, the interval is the estimate. For a small `m`, the interval is too narrow: at `m = 8` of `n = 40`, the coverage is 0.865. For a total over pairs, use `uStatisticInterval`. |
-| `uStatisticInterval(totals, { order, population, method, level, range })` | The interval of a total over all sets of `r` units of a population, for example the crossings of all pairs. The input is the total of each unit of a sample without replacement. The estimate is `S * C(n, r) / C(m, r)`. The method `"conservative"` uses the Hoeffding bound of a U-statistic with `floor(m / r)` draws and the `range` of the kernel. It holds at each `m`. The method `"tight"` uses the jackknife variance times `1 - m / n`, and the t quantile with `m - 1` degrees of freedom. This variance is exact for a linear kernel and larger for others. When all the totals are equal, the method `"tight"` uses the method `"conservative"`, or it throws without `range`. The result gives the `method` that it used. At `m = 8`, the coverage of `"tight"` is 0.885 to 0.915 for a skewed kernel. The method `"auto"` needs `range`. It uses `"tight"` from `m = U_STATISTIC_TIGHT_MIN_SAMPLE`. No measured `m` gets 0.95 in each cell, so this constant is infinite. |
+| `uStatisticInterval(totals, { order, population, method, level, range })` | The interval of a total over all sets of `r` units of a population, for example the crossings of all pairs. The input is the total of each unit of a sample without replacement. The estimate is `S * C(n, r) / C(m, r)`. The method `"conservative"` uses the Hoeffding bound of a U-statistic with `floor(m / r)` draws and the `range` of the kernel. It holds at each `m`. The method `"tight"` uses the jackknife variance times `1 - m / n`, and the t quantile with `m - 1` degrees of freedom. This variance is exact for a linear kernel and larger for others. When all the totals are equal, the method `"tight"` uses the method `"conservative"`, or it throws without `range`. The result gives the `method` that it used. At `m = 8`, the coverage of `"tight"` is 0.885 to 0.915 for a skewed kernel. The method `"auto"` needs `range`. It uses `"tight"` from `m = U_STATISTIC_TIGHT_MIN_SAMPLE`. The calibration study `u-statistic-interval` sets this constant with `coverageMinSample`. Until a run of the study gives a value, it is infinite. |
 | `leastSquares(x, y, { intercept })` | The ordinary least-squares fit of `y` on the rows of `x`, with a QR decomposition. It gives the coefficients, `residualSd`, `r2`, `n` and `k`. A singular design gives NaN coefficients. |
 | `bootstrapLeastSquares(x, y, options)` | One bootstrap interval for each coefficient of `leastSquares`, from the same draws of whole rows. A singular draw does not count. |
 | `ridgeSolve(gram, moment, lambda, { free })` | The ridge coefficients from the normal equations `X'X` and `X'y`, with a Cholesky factorization. The `free` coefficients have no penalty. A matrix that is not positive definite gives NaN coefficients. |
@@ -127,6 +127,8 @@ The default expansion has one product for each pair of levels of two dimensions.
 | `quantileSamples(p, level)` | The fewest independent values that give a quantile an upper bound. At the level 0.95: 72 values for p95, 368 for p99 and 3,688 for p99.9. |
 | `binomialInterval(n, p, level)`, `negativeBinomialInterval(successes, p, level)` | The central interval of a binomial count, and of a count of failures before `successes` successes. Each tail outside holds `(1 - level) / 2` or less. |
 | `holm(pValues, level)` | The Holm correction of a family of tests. |
+| `binomialTest(k, n, p, side)` | The p of the exact one-sided binomial test of `k` successes in `n` trials. The side `"less"` gives `P(X <= k)`, and `"greater"` gives `P(X >= k)`. |
+| `coverageMinSample(cells, { level, alpha, pooledLow })` | The smallest sample size `m` from which an interval method keeps its level, from the hits of seeded cells. A size qualifies when the cells with a sample of that size or more pass two tests. No cell rejects `level` in `binomialTest` after `holm` at `alpha`, and the `wilson` lower end of the pooled hits is `pooledLow` or more. The set is closed upward: the result is the smallest `m` such that each size of `m` or more qualifies. `blocking` gives the largest size that fails. When the largest size fails, the result is `Infinity`. Fix the bar before the run. |
 | `partialConjunction(pValues, need)` | The p of the claim that at least `need` of these tests have a real effect. |
 | `spearman`, `kendallTau`, `ranks` | The rank correlations, with mean ranks for ties. |
 | `compareRatios`, `noiseFloor`, `noiseVerdict` | The comparison with a baseline, the noise floor of the 5-seed rule with a margin of practical effect, and the state of a difference over the seeds. |

package/build/index.d.ts

@@ -938,6 +938,23 @@ interface CountInterval {
  * or less. The two tails are separate sums, so that a small upper tail keeps its digits.
  */
 export declare function binomialInterval(n: number, p: number, level?: number): CountInterval;
+/** The side of `binomialTest`: `"less"` gives `P(X <= k)`, and `"greater"` gives `P(X >= k)`. */
+type BinomialSide = "less" | "greater";
+/**
+ * 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.
+ */
+export declare function binomialTest(k: number, n: number, p: number, side: BinomialSide): number;
 /**
  * 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.
@@ -1090,12 +1107,92 @@ interface OptionFloorOptions {
  * @returns A whole number of 2 or more.
  */
 export declare function optionFloor(options: OptionFloorOptions): number;
+/** One cell of a coverage study: the hits of a method on the true value in `draws` seeded samples of size `sample`. */
+interface CoverageCell {
+  /** The name of the cell, for example `"skewed 120/108"`. The result names the rejected cells with it. */
+  readonly name: string;
+  /** The sample size `m` of the cell, a whole number of 1 or more. */
+  readonly sample: number;
+  /** The count of samples whose interval holds the true value, a whole number from 0 to `draws`. */
+  readonly hits: number;
+  /** The count of samples of the cell, a whole number of 1 or more. */
+  readonly draws: number;
+}
+/** The bar of `coverageMinSample`. Fix it before the run, and do not change it after the run. */
+interface CoverageBar {
+  /** The coverage that the method claims, for example 0.95. Each cell has a one-sided exact binomial test of it. */
+  readonly level: number;
+  /** The level of the Holm family of the cell tests, for example 0.05. */
+  readonly alpha: number;
+  /** The smallest Wilson lower end of the pooled coverage, for example 0.94. */
+  readonly pooledLow: number;
+  /** The z of the Wilson interval. The default is `Z95`. */
+  readonly z?: number;
+}
+/** The reason of one step: `"qualifies"`, or the test or tests that failed. */
+type CoverageReason = "qualifies" | "cell-rejected" | "pooled-low" | "cell-rejected-and-pooled-low";
+/** The result of the bar at one sample size `m`, over each cell with a sample of `m` or more. */
+interface CoverageStep {
+  /** The sample size `m` of the step. */
+  readonly sample: number;
+  /** The count of cells with a sample of `m` or more. */
+  readonly cells: number;
+  /** The names of the cells that reject the coverage `level`, after the Holm correction. */
+  readonly rejected: readonly string[];
+  /** The smallest Holm-adjusted p of the cells of the step. */
+  readonly smallestAdjusted: number;
+  /** The sum of the hits of the cells of the step. */
+  readonly hits: number;
+  /** The sum of the draws of the cells of the step. */
+  readonly draws: number;
+  /** The Wilson interval of the pooled coverage `hits / draws`. */
+  readonly pooled: Proportion;
+  /** The sample size `m` passes the two tests of the bar. */
+  readonly qualifies: boolean;
+  readonly reason: CoverageReason;
+}
+/** The result of `coverageMinSample`. */
+interface CoverageMinSample {
+  /**
+   * The smallest sample size `m` of the cells such that each size of `m` or more passes the bar. It is infinite when
+   * the largest size fails.
+   */
+  readonly minSample: number;
+  /** The largest sample size that fails the bar. It blocks each smaller size. The result has no `blocking` when each size passes. */
+  readonly blocking?: number;
+  /** One step for each sample size of the cells, from the smallest to the largest. */
+  readonly steps: readonly CoverageStep[];
+}
+/**
+ * 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.
+ */
+export declare function coverageMinSample(cells: readonly CoverageCell[], bar: CoverageBar): CoverageMinSample;
 /** The methods of `uStatisticInterval`. The method `"auto"` selects one of the other two for each sample. */
 type UStatisticMethod = "conservative" | "tight" | "auto";
 /**
- * The smallest sample `m` at which the method `"auto"` uses the method `"tight"`. The value comes from the pinned
- * counts of the tests. No measured `m` obeys the rule, so the value is infinite. The TSDoc of `uStatisticInterval`
- * gives the rule and the counts.
+ * 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.
  */
 export declare const U_STATISTIC_TIGHT_MIN_SAMPLE: number;
 /** The options of `uStatisticInterval`. */
@@ -1196,10 +1293,20 @@ interface UStatisticInterval {
  * 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 rule for `U_STATISTIC_TIGHT_MIN_SAMPLE` is the smallest `m` of the table with 190 of 200 or more in each cell.
- * No `m` of the table obeys the rule. The last `m` with a count below 190 is 108, the largest `m` of the table. The
- * table has no larger `m`, so the constant is infinite. Thus the method `"auto"` uses the method `"conservative"` at
- * each `m` less than `n`.
+ * 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.
@@ -1209,5 +1316,5 @@ interface UStatisticInterval {
  * @returns The estimate and the interval of the total, and of the mean of the kernel.
  */
 export declare function uStatisticInterval(totals: readonly number[], options: UStatisticOptions): UStatisticInterval;
-export type { BootstrapOptions, CalibrationLevel, CategoricalDimension, CompareOptions, Comparison, ContinuousDimension, Corrected, CountInterval, Effect, Forecast, Interval, Kappa, LeastSquaresFit, LeastSquaresOptions, MedianInterval, ModeOptions, NoiseOptions, NoiseState, NoiseVerdict, OptionFloorOptions, OrdinalDimension, ParsedResponseRecord, PermutationOptions, PermutationResult, Proportion, QuantileInterval, QuantileMethod, ResponseAbsentPoint, ResponseBand, ResponseCurvePoint, ResponseData, ResponseDimension, ResponseDimensionBase, ResponseFactor, ResponseFault, ResponseFitOptions, ResponseFold, ResponseFoldError, ResponseHeldOutError, ResponseInputValue, ResponseMeasure, ResponseModel, ResponseModelBase, ResponsePoint, ResponseReason, ResponseRecord, ResponseSlice, ResponseSliceOptions, ResponseSlicePoint, ResponseSurface, ResponseSurfaceAbsentPoint, ResponseSurfaceOptions, ResponseSurfacePoint, ResponseTableCell, ResponseValue, ResponseViewOptions, ResponseWhen, RidgeInput, RidgeInputBase, RidgeLevelInput, RidgeNumberInput, RidgeOptions, RidgeRankInput, RidgeResponseModel, RidgeTerm, SampleTotalOptions, SideP, SmoothLaw, SmoothLawScore, Summary, TableResponseModel, TwoSamplePermutationOptions, TwoSamplePermutationResult, UStatisticInterval, UStatisticMean, UStatisticMethod, UStatisticOptions };
+export type { BinomialSide, BootstrapOptions, CalibrationLevel, CategoricalDimension, CompareOptions, Comparison, ContinuousDimension, Corrected, CountInterval, CoverageBar, CoverageCell, CoverageMinSample, CoverageReason, CoverageStep, Effect, Forecast, Interval, Kappa, LeastSquaresFit, LeastSquaresOptions, MedianInterval, ModeOptions, NoiseOptions, NoiseState, NoiseVerdict, OptionFloorOptions, OrdinalDimension, ParsedResponseRecord, PermutationOptions, PermutationResult, Proportion, QuantileInterval, QuantileMethod, ResponseAbsentPoint, ResponseBand, ResponseCurvePoint, ResponseData, ResponseDimension, ResponseDimensionBase, ResponseFactor, ResponseFault, ResponseFitOptions, ResponseFold, ResponseFoldError, ResponseHeldOutError, ResponseInputValue, ResponseMeasure, ResponseModel, ResponseModelBase, ResponsePoint, ResponseReason, ResponseRecord, ResponseSlice, ResponseSliceOptions, ResponseSlicePoint, ResponseSurface, ResponseSurfaceAbsentPoint, ResponseSurfaceOptions, ResponseSurfacePoint, ResponseTableCell, ResponseValue, ResponseViewOptions, ResponseWhen, RidgeInput, RidgeInputBase, RidgeLevelInput, RidgeNumberInput, RidgeOptions, RidgeRankInput, RidgeResponseModel, RidgeTerm, SampleTotalOptions, SideP, SmoothLaw, SmoothLawScore, Summary, TableResponseModel, TwoSamplePermutationOptions, TwoSamplePermutationResult, UStatisticInterval, UStatisticMean, UStatisticMethod, UStatisticOptions };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/describe.ts","../src/regression.ts","../src/bootstrap.ts","../src/distribution.ts","../src/ridge.ts","../src/response.ts","../src/response-parse.ts","../src/response-fit.ts","../src/tests.ts","../src/agreement.ts","../src/rank.ts","../src/discrete.ts","../src/compare.ts","../src/power.ts","../src/u-statistic.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/describe.ts","../src/regression.ts","../src/bootstrap.ts","../src/distribution.ts","../src/ridge.ts","../src/response.ts","../src/response-parse.ts","../src/response-fit.ts","../src/tests.ts","../src/agreement.ts","../src/rank.ts","../src/discrete.ts","../src/compare.ts","../src/power.ts","../src/coverage.ts","../src/u-statistic.ts"],"mappings":"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"}

package/build/index.js

@@ -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,15 +3007,109 @@ function optionFloor(options) {
 	}
 	throw new RangeError(`optionFloor: no count under 10,000,000 for sigma ${sigma} and delta ${delta}.`);
 }
+// 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 value comes from the pinned
-* counts of the tests. No measured `m` obeys the rule, so the value is infinite. The TSDoc of `uStatisticInterval`
-* gives the rule and the counts.
+* 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;
 /**
@@ -3041,10 +3170,20 @@ const U_STATISTIC_TIGHT_MIN_SAMPLE = Number.POSITIVE_INFINITY;
 * 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 rule for `U_STATISTIC_TIGHT_MIN_SAMPLE` is the smallest `m` of the table with 190 of 200 or more in each cell.
-* No `m` of the table obeys the rule. The last `m` with a count below 190 is 108, the largest `m` of the table. The
-* table has no larger `m`, so the constant is infinite. Thus the method `"auto"` uses the method `"conservative"` at
-* each `m` less than `n`.
+* 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.
@@ -3148,6 +3287,6 @@ function choose(n, k) {
 	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, 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, uStatisticInterval, whenHolds, wilson, wilsonSampleSize };
+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