@mark1russell7/rigor-statistics 0.1.17 → 0.1.19

package/README.md

@@ -111,6 +111,8 @@ The default expansion has one product for each pair of levels of two dimensions.
 | `bootstrapMedian`, `bootstrapClusters` | The interval of the median, and a bootstrap that draws whole clusters (boards, seeds, sites). |
 | `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. |
 | `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. |

package/build/index.d.ts

@@ -154,6 +154,27 @@ export declare function bootstrapMedian(values: readonly number[], options?: Boo
  * are in the order of their first row.
  */
 export declare function bootstrapClusters<T>(rows: readonly T[], cluster: (row: T) => string, statistic: (rows: readonly T[]) => number, options?: BootstrapOptions): Interval;
+interface SampleTotalOptions extends BootstrapOptions {
+  /** The number of items in the whole population, `n`. It is a whole number, and it is not less than the sample. */
+  readonly population: number;
+  /** The factor from the sum of the sample to the total of the population. The default is `population / values.length`. */
+  readonly scale?: number;
+}
+/**
+ * A bootstrap interval of the total of a population from a uniform sample of `m` of its `n` items, drawn without
+ * replacement. The estimate is `scale * sum(values)`. Each run draws `m` values with replacement, as `bootstrap`
+ * does. The deviation of each run from the sum of the sample gets the factor `scale * sqrt(1 - m / n)`, the finite
+ * population correction. When `m` is `n`, the interval is the estimate.
+ *
+ * The sample has 2 values or more, and each value is finite. With the same seed, the result is equal to the
+ * `bootstrap` of the same statistic, to the bit.
+ *
+ * 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%. For a total over the pairs of the items, use `uStatisticInterval`.
+ */
+export declare function sampleTotalInterval(values: readonly number[], options: SampleTotalOptions): Interval;
 /** The smooth laws that `smoothLawScores` compares. Each law has 2 fitted numbers. */
 type SmoothLaw = "uniform" | "normal" | "exponential" | "log-normal" | "pareto";
 /** The value of one law at its fit. */
@@ -1069,5 +1090,124 @@ interface OptionFloorOptions {
  * @returns A whole number of 2 or more.
  */
 export declare function optionFloor(options: OptionFloorOptions): number;
-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, SideP, SmoothLaw, SmoothLawScore, Summary, TableResponseModel, TwoSamplePermutationOptions, TwoSamplePermutationResult };
+/** 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.
+ */
+export declare const U_STATISTIC_TIGHT_MIN_SAMPLE: number;
+/** The options of `uStatisticInterval`. */
+interface UStatisticOptions {
+  /** The order `r` of the kernel: the number of units in each set. It is a whole number of 1 or more. */
+  readonly order: number;
+  /** The number of units in the whole population, `n`. It is a whole number, and it is not less than the sample. */
+  readonly population: number;
+  /** The method of the interval. The methods `"conservative"` and `"auto"` need `range`. */
+  readonly method: UStatisticMethod;
+  /** The level of the interval. The default is 0.95. */
+  readonly level?: number;
+  /** The smallest and the largest value of the kernel. With it, the interval stays in this range. */
+  readonly range?: readonly [low: number, high: number];
+}
+/** The mean of the kernel over all the sets of `r` units of the population, with its interval. */
+interface UStatisticMean {
+  /** The U-statistic: the mean of the kernel over the sets of `r` units of the sample. */
+  readonly estimate: number;
+  readonly low: number;
+  readonly high: number;
+}
+/** The result of `uStatisticInterval`. The total is the mean of the kernel times `subsets`. */
+interface UStatisticInterval {
+  /** The estimate of the total of the population: `S * C(n, r) / C(m, r)`, with `S` the total of the sample. */
+  readonly estimate: number;
+  readonly low: number;
+  readonly high: number;
+  readonly level: number;
+  /** The method that made the interval. It is not `requested` after a fallback or a choice of the method `"auto"`. */
+  readonly method: "conservative" | "tight";
+  /** The method of the options. */
+  readonly requested: UStatisticMethod;
+  /** The mean of the kernel, with its interval. */
+  readonly mean: UStatisticMean;
+  /** The number of sets of `r` units in the population, `C(n, r)`. */
+  readonly subsets: number;
+  /** The standard error of the total. Only an interval of the method `"tight"` has it. */
+  readonly standardError?: number;
+  /** The degrees of freedom of the t quantile, `m - 1`. Only an interval of the method `"tight"` has it. */
+  readonly df?: number;
+}
+/**
+ * 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 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`.
+ *
+ * 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.
+ */
+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 };
 //# 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"],"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/u-statistic.ts"],"mappings":"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"}

package/build/index.js

@@ -201,6 +201,8 @@ function fitRows(x, y, intercept, k) {
 * With the same seed, the draws are equal to the draws of the copies in highways, packing and layout-contract.
 * `bootstrapTwo` draws two independent samples in each run: first the items of `a`, then the items of `b`.
 * `bootstrapLeastSquares` draws whole rows, and gives one interval for each coefficient from the same draws.
+*
+* `sampleTotalInterval` gives the interval of a population total from a sample without replacement.
 */
 /**
 * A percentile bootstrap interval of `statistic` over `data`. A run whose statistic is not finite (NaN or an
@@ -301,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 {
@@ -339,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
@@ -354,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 = {}) {
@@ -385,6 +387,40 @@ function bootstrapClusters(rows, cluster, statistic, options = {}) {
 		estimate
 	};
 }
+/**
+* A bootstrap interval of the total of a population from a uniform sample of `m` of its `n` items, drawn without
+* replacement. The estimate is `scale * sum(values)`. Each run draws `m` values with replacement, as `bootstrap`
+* does. The deviation of each run from the sum of the sample gets the factor `scale * sqrt(1 - m / n)`, the finite
+* population correction. When `m` is `n`, the interval is the estimate.
+*
+* The sample has 2 values or more, and each value is finite. With the same seed, the result is equal to the
+* `bootstrap` of the same statistic, to the bit.
+*
+* 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%. For a total over the pairs of the items, use `uStatisticInterval`.
+*/
+function sampleTotalInterval(values, options) {
+	const name = "sampleTotalInterval";
+	const m = values.length;
+	const n = options.population;
+	if (m < 2) throw new RangeError(`${name}: the sample has 2 values or more, 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}.`);
+	for (const v of values) if (!Number.isFinite(v)) throw new RangeError(`${name}: each value is a finite number, not ${v}.`);
+	const scale = options.scale ?? n / m;
+	if (!(Number.isFinite(scale) && scale > 0)) throw new RangeError(`${name}: scale is a finite number more than 0, not ${scale}.`);
+	const all = sum(values);
+	const estimate = scale * all;
+	const spread = Math.sqrt(1 - m / n) * scale;
+	return bootstrap(values, (drawn) => estimate + spread * (sum(drawn) - all), options);
+}
+/** The sum of the values from the first to the last, as `values.reduce((s, t) => s + t, 0)`. */
+function sum(values) {
+	let s = 0;
+	for (const v of values) s += v;
+	return s;
+}
 // src/distribution.ts
 /**
 * The shape of a sample: the count of its modes, and the smooth law with the highest likelihood. Use them to read the
@@ -2936,6 +2972,182 @@ 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, sd, signTest, signTestPower, sliceResponse, smoothLawScores, sorted, spearman, summarize, surfaceResponse, tQuantile, twoSamplePermutation, whenHolds, wilson, wilsonSampleSize };
+// 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.
+*/
+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 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`.
+*
+* 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, 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 };
 
 //# sourceMappingURL=index.js.map