@mark1russell7/rigor-statistics 0.1.22 → 0.1.24

package/README.md

@@ -164,6 +164,7 @@ logLoss([{ p: p.a, hit: true }]);                // the probability of the obser
 | `bootstrap(data, statistic, options)` | A percentile bootstrap interval of any statistic. The options are `runs`, `level` or `ends`, `seed`, `method` and `against`. |
 | The option `against` | The interval also gives `pAbove` and `pBelow`, the bootstrap p of each side of the value, from the same draws. The smallest p is 1 / (`finite` + 1). Give `holm` enough runs: with m tests at level a, `runs` is more than m / a. |
 | `bootstrapMedian`, `bootstrapClusters` | The interval of the median, and a bootstrap that draws whole clusters (boards, seeds, sites). |
+| `bootstrapStrata(strata, statistic, options)` | A stratified bootstrap. Each run draws inside each stratum, so each sample keeps the size of each stratum. |
 | `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`. |
@@ -173,6 +174,7 @@ logLoss([{ p: p.a, hit: true }]);                // the probability of the obser
 | `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. |
 | `signTest(better, worse, sides)`, `signTestPower(n, level)` | The sign test, and the fewest wins out of `n` that the test calls significant. |
 | `pairedPermutation(candidate, baseline, options)` | The paired permutation test (random sign flips). It uses the size of each difference. |
+| `signFlipTest(terms, options)` | The sign-flip test of a sum of terms, for example a weighted mean of differences. Up to `exactMax` terms (16), it reads each sign set, so the p is exact. |
 | `twoSamplePermutation(a, b, options)` | The two-sample permutation test (a split of the pooled values). It reads each split when their count is `runs` or less, so the p is exact. It compares groups of different sizes, and its default statistic is the difference of the medians. |
 | `wilson(k, n, z)` | The Wilson interval of a proportion. |
 | `wilsonSampleSize(target, expected, z, max)` | The smallest number of trials at which the Wilson lower end reaches the target, at the expected proportion. |
@@ -188,6 +190,7 @@ logLoss([{ p: p.a, hit: true }]);                // the probability of the obser
 | `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. |
 | `optionFloor({ sigma, delta, tests, alpha, power })`, `tQuantile(p, df)` | The fewest values for each of two options, so that one test of a Bonferroni family finds a difference of `delta` with the stated power, from the Student t law. It assumes unpaired groups of equal size and equal `sigma`. The quantile of the Student t law. |
+| `normalCdf(x)`, `normalQuantile(p)` | The distribution function of the standard normal law and its quantile (AS 241 of Wichura). Both keep their relative digits in the lower tail, to `p = 1e-300`. |
 | `modeCount(values, { minShare, valleyRatio })` | The count of the modes of a sample, from a kernel density estimate. |
 | `smoothLawScores(values)`, `bestSmoothLaw(values)` | The mean log density of the uniform, normal, exponential, log-normal and Pareto laws at their fits, and the best of them. |
 | `brier`, `calibration` | The Brier score of predictions, and the hit rate of each stated level. |
@@ -287,6 +290,9 @@ The tests prove that these functions give the same numbers as the copies in the
 | `bootstrapMedian` of packing | `bootstrapMedian(sortedValues, { runs, level, seed })`. Give the values sorted, because packing draws from the sorted list. |
 | `bootstrapMedian` of highways | `bootstrap(values, (s) => quantile(s, 0.5), { runs, level, seed })` |
 | `bootstrap` of layout-contract | `bootstrapClusters(rows, (r) => r.cluster, statistic, { runs, seed, ends: [0.025, 0.975] })` |
+| The stratified bootstrap of `verdict` of layout-contract | `bootstrapStrata(families, meanOfMeans, { runs, seed: deriveSeed(seed, "verdict.stratified"), ends })` |
+| The permutation test of `verdict` of layout-contract | `signFlipTest(terms, { exactMax, runs, seed: deriveSeed(seed, "verdict.permutation") })` |
+| `normalQuantile` of lag (Acklam, relative error below 1.2e-9) | `normalQuantile(p)`. The values change by 1.2e-9 or less, because the new function is more exact. A `p` out of 0 to 1 throws. |
 | `signTestP` of packing | `signTest(better, worse)` |
 | `signTestPower` of highways | `signTestPower(n, level)` |
 | `wilson` of packing | `wilson(k, n, z)`. packing rounds the ends to 4 places at the call. |

package/build/index.d.ts

@@ -155,6 +155,14 @@ 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;
+/**
+ * A stratified bootstrap: each run draws, inside each stratum, as many items as the stratum has, with replacement.
+ * So each sample keeps the size of each stratum. Use it when the strata are fixed by the design, for example the
+ * families of the inputs of a benchmark. The draws of one run go through the strata in the order of the list. With one
+ * stratum, the draws are equal to the draws of `bootstrap` with the same seed. The estimate is the statistic of all
+ * the strata. A run whose statistic is not finite does not count.
+ */
+export declare function bootstrapStrata<T>(strata: readonly (readonly T[])[], statistic: (samples: readonly (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;
@@ -902,6 +910,40 @@ interface PermutationResult {
  * the size of each difference, which the sign test does not. A pair with a difference of 0 adds nothing.
  */
 export declare function pairedPermutation(candidate: readonly number[], baseline: readonly number[], options?: PermutationOptions): PermutationResult;
+/** The default of the option `exactMax` of `signFlipTest`. */
+export declare const SIGN_FLIP_EXACT_MAX = 16;
+/** The largest value of the option `exactMax` of `signFlipTest`: 2^24 sign sets. */
+export declare const SIGN_FLIP_EXACT_LIMIT = 24;
+/** The options of `signFlipTest`. */
+interface SignFlipOptions {
+  /** The largest count of terms for which the test reads each of the `2^n` sign sets. The default is 16. The most is 24. */
+  readonly exactMax?: number;
+  /** The count of random sign sets above `exactMax`. The default is 10 000. */
+  readonly runs?: number;
+  /** The default is 1. */
+  readonly seed?: number | string;
+}
+/** The result of `signFlipTest`. */
+interface SignFlipResult {
+  /** The absolute value of the sum of the terms. */
+  readonly observed: number;
+  /** The two-sided p. */
+  readonly p: number;
+  /** This field is true when the test read each sign set, so the p has no noise from the draws. */
+  readonly exact: boolean;
+  /** The count of the sign sets that the test read: `2^n` when it is exact, otherwise the count of the draws. */
+  readonly runs: number;
+}
+/**
+ * The sign-flip test of a sum of terms. Under the null, each term has the sign + or - with equal chance. The statistic
+ * is the absolute value of the sum. A weighted mean of paired differences is such a sum: give the terms `w[i] * d[i]`.
+ *
+ * Up to `exactMax` terms, the test reads each sign set. The p is the share of the sets that are as far from 0 or
+ * farther. The observed set is one of them. Above `exactMax`, the test draws `runs` sets, and the p is (1 + the extreme
+ * draws) / (1 + runs). A sum within `1e-12` of the sum of the absolute terms counts as extreme, so rounding does not
+ * hide a tie.
+ */
+export declare function signFlipTest(terms: readonly number[], options?: SignFlipOptions): SignFlipResult;
 /** The options of `twoSamplePermutation`. */
 interface TwoSamplePermutationOptions {
   /** The largest number of splits that the test reads. The default is 10 000. */
@@ -1194,6 +1236,20 @@ interface OptionFloorOptions {
  * @returns A whole number of 2 or more.
  */
 export declare function optionFloor(options: OptionFloorOptions): number;
+/**
+ * This function gives the distribution function of the standard normal law, `P(Z <= x)`. Its relative error is below
+ * 1e-14, also in the lower tail: `normalCdf(-37)` is approximately 5.7e-300, not 0.
+ *
+ * @param x - A number. `-Infinity` gives 0 and `Infinity` gives 1.
+ */
+export declare function normalCdf(x: number): number;
+/**
+ * This function gives the quantile of the standard normal law, the `x` with `normalCdf(x) = p`. It uses PPND16 of
+ * Wichura (algorithm AS 241). Its relative error is near 1e-16 for each `p` from 1e-300 to 1 - 1e-16.
+ *
+ * @param p - The share of the law below the result, from 0 to 1. A `p` of 0 gives `-Infinity` and 1 gives `Infinity`.
+ */
+export declare function normalQuantile(p: number): 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. */
@@ -1554,5 +1610,5 @@ interface BradleyTerryFit {
  * outcome, a bad weight and a bad option.
  */
 export declare function bradleyTerry(items: number, comparisons: readonly PairComparison[], options?: BradleyTerryOptions): BradleyTerryFit;
-export type { BinomialSide, BootstrapOptions, BradleyTerryFit, BradleyTerryOptions, CalibrationLevel, CategoricalDimension, CompareOptions, Comparison, ContinuousDimension, Corrected, CountInterval, CoverageBar, CoverageCell, CoverageMinSample, CoverageReason, CoverageStep, Effect, EloOptions, EloUpdate, Forecast, Glicko2Game, Glicko2Options, Glicko2Rating, Interval, Kappa, LeastSquaresFit, LeastSquaresOptions, MedianInterval, ModeOptions, NoiseOptions, NoiseState, NoiseVerdict, OptionFloorOptions, OrdinalDimension, PairComparison, PairOutcome, PairProbabilities, ParsedResponseRecord, PermutationOptions, PermutationResult, Proportion, QuantileInterval, QuantileMethod, RatingScale, 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, SobolIndex, SobolIndices, SobolOptions, Summary, TableResponseModel, TieModel, TwoSamplePermutationOptions, TwoSamplePermutationResult, UStatisticInterval, UStatisticMean, UStatisticMethod, UStatisticOptions };
+export type { BinomialSide, BootstrapOptions, BradleyTerryFit, BradleyTerryOptions, CalibrationLevel, CategoricalDimension, CompareOptions, Comparison, ContinuousDimension, Corrected, CountInterval, CoverageBar, CoverageCell, CoverageMinSample, CoverageReason, CoverageStep, Effect, EloOptions, EloUpdate, Forecast, Glicko2Game, Glicko2Options, Glicko2Rating, Interval, Kappa, LeastSquaresFit, LeastSquaresOptions, MedianInterval, ModeOptions, NoiseOptions, NoiseState, NoiseVerdict, OptionFloorOptions, OrdinalDimension, PairComparison, PairOutcome, PairProbabilities, ParsedResponseRecord, PermutationOptions, PermutationResult, Proportion, QuantileInterval, QuantileMethod, RatingScale, 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, SignFlipOptions, SignFlipResult, SmoothLaw, SmoothLawScore, SobolIndex, SobolIndices, SobolOptions, Summary, TableResponseModel, TieModel, 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/response-sobol.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","../src/rating.ts","../src/bradley-terry.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/response-sobol.ts","../src/tests.ts","../src/agreement.ts","../src/rank.ts","../src/discrete.ts","../src/compare.ts","../src/power.ts","../src/normal.ts","../src/coverage.ts","../src/u-statistic.ts","../src/rating.ts","../src/bradley-terry.ts"],"mappings":"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"}

package/build/index.js

@@ -388,6 +388,26 @@ function bootstrapClusters(rows, cluster, statistic, options = {}) {
 	};
 }
 /**
+* A stratified bootstrap: each run draws, inside each stratum, as many items as the stratum has, with replacement.
+* So each sample keeps the size of each stratum. Use it when the strata are fixed by the design, for example the
+* families of the inputs of a benchmark. The draws of one run go through the strata in the order of the list. With one
+* stratum, the draws are equal to the draws of `bootstrap` with the same seed. The estimate is the statistic of all
+* the strata. A run whose statistic is not finite does not count.
+*/
+function bootstrapStrata(strata, statistic, options = {}) {
+	if (strata.length === 0) throw new RangeError("bootstrapStrata: there is no stratum.");
+	for (const [i, stratum] of strata.entries()) if (stratum.length === 0) throw new RangeError(`bootstrapStrata: the stratum ${i} is empty.`);
+	const samples = strata.map((stratum) => new Array(stratum.length));
+	return percentile("bootstrapStrata", options, (r) => {
+		for (const [k, stratum] of strata.entries()) {
+			const sample = samples[k];
+			const n = stratum.length;
+			for (let i = 0; i < n; i++) sample[i] = stratum[r.below(n)];
+		}
+		return statistic(samples);
+	}, () => statistic(strata));
+}
+/**
 * 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
@@ -2537,6 +2557,57 @@ function pairedPermutation(candidate, baseline, options = {}) {
 		runs
 	};
 }
+/** The default of the option `exactMax` of `signFlipTest`. */
+const SIGN_FLIP_EXACT_MAX = 16;
+/** The largest value of the option `exactMax` of `signFlipTest`: 2^24 sign sets. */
+const SIGN_FLIP_EXACT_LIMIT = 24;
+/**
+* The sign-flip test of a sum of terms. Under the null, each term has the sign + or - with equal chance. The statistic
+* is the absolute value of the sum. A weighted mean of paired differences is such a sum: give the terms `w[i] * d[i]`.
+*
+* Up to `exactMax` terms, the test reads each sign set. The p is the share of the sets that are as far from 0 or
+* farther. The observed set is one of them. Above `exactMax`, the test draws `runs` sets, and the p is (1 + the extreme
+* draws) / (1 + runs). A sum within `1e-12` of the sum of the absolute terms counts as extreme, so rounding does not
+* hide a tie.
+*/
+function signFlipTest(terms, options = {}) {
+	const exactMax = options.exactMax ?? 16;
+	if (!Number.isInteger(exactMax) || exactMax < 0 || exactMax > 24) throw new RangeError(`signFlipTest: exactMax is a whole number from 0 to 24, not ${exactMax}.`);
+	for (const [i, t] of terms.entries()) if (!Number.isFinite(t)) throw new RangeError(`signFlipTest: the term ${i} is ${t}, not a finite number.`);
+	const n = terms.length;
+	const observed = Math.abs(terms.reduce((sum, t) => sum + t, 0));
+	const slack = 1e-12 * terms.reduce((sum, t) => sum + Math.abs(t), 0);
+	if (n <= exactMax) {
+		const total = 2 ** n;
+		let hits = 0;
+		for (let mask = 0; mask < total; mask++) {
+			let sum = 0;
+			for (let i = 0; i < n; i++) sum += mask & 1 << i ? -terms[i] : terms[i];
+			if (Math.abs(sum) >= observed - slack) hits++;
+		}
+		return {
+			observed,
+			p: hits / total,
+			exact: true,
+			runs: total
+		};
+	}
+	const runs = options.runs ?? 1e4;
+	if (!Number.isSafeInteger(runs) || runs < 1) throw new RangeError(`signFlipTest: runs is a whole number of 1 or more, not ${runs}.`);
+	const r = random(options.seed ?? 1);
+	let hits = 0;
+	for (let run = 0; run < runs; run++) {
+		let sum = 0;
+		for (let i = 0; i < n; i++) sum += r.next() < .5 ? -terms[i] : terms[i];
+		if (Math.abs(sum) >= observed - slack) hits++;
+	}
+	return {
+		observed,
+		p: (1 + hits) / (1 + runs),
+		exact: false,
+		runs
+	};
+}
 /** This function gives the count of the ways to choose `k` of `n`, or Infinity when the count is over `limit`. */
 function choices(n, k, limit) {
 	const small = Math.min(k, n - k);
@@ -3180,6 +3251,162 @@ function optionFloor(options) {
 	}
 	throw new RangeError(`optionFloor: no count under 10,000,000 for sigma ${sigma} and delta ${delta}.`);
 }
+// src/normal.ts
+/**
+* The standard normal law: its distribution function `normalCdf` and its quantile `normalQuantile`. The two functions
+* keep their relative digits in the far tails, so a small tail probability does not become 0.
+*/
+const SQRT_PI = Math.sqrt(Math.PI);
+/** The series of `erf(z)` with positive terms, `2/√π · e^(-z²) · Σ (2z²)^n · z / (1·3·…·(2n+1))`, for a small `z` of 0 or more. */
+function erfSeries(z) {
+	const twoZ2 = 2 * z * z;
+	let term = z;
+	let sum = z;
+	for (let n = 1; n < 500 && term > sum * 1e-17; n++) {
+		term *= twoZ2 / (2 * n + 1);
+		sum += term;
+	}
+	return 2 / SQRT_PI * expMinusSquare(z) * sum;
+}
+/**
+* The continued fraction of `erfc(z)`, `e^(-z²)/√π · 1/(z + (1/2)/(z + 1/(z + (3/2)/(z + …))))`, by the method of
+* Lentz, for a `z` of 1.5 or more.
+*/
+function erfcFraction(z) {
+	const tiny = 1e-300;
+	let f = z;
+	let c = z;
+	let d = 0;
+	for (let n = 1; n < 5e3; n++) {
+		const a = n / 2;
+		d = z + a * d;
+		d = 1 / (Math.abs(d) < tiny ? tiny : d);
+		c = z + a / c;
+		if (Math.abs(c) < tiny) c = tiny;
+		const delta = c * d;
+		f *= delta;
+		if (Math.abs(delta - 1) < 1e-16) break;
+	}
+	return expMinusSquare(z) / (SQRT_PI * f);
+}
+/**
+* The value of `e^(-z²)` with its relative digits for a large `z`. The rounding of `z²` costs `z²` ulps, so the
+* function splits `z` into `hi + lo`. `hi` has 4 bits after the point, so `hi²` is exact.
+*/
+function expMinusSquare(z) {
+	const hi = Math.round(z * 16) / 16;
+	const lo = z - hi;
+	return Math.exp(-hi * hi) * Math.exp(-lo * (z + hi));
+}
+/** The complementary error function `erfc(z) = 1 - erf(z)`, with its relative digits for a large `z`. */
+function erfc(z) {
+	if (z < 0) return 2 - erfc(-z);
+	return z < 1.5 ? 1 - erfSeries(z) : erfcFraction(z);
+}
+/**
+* This function gives the distribution function of the standard normal law, `P(Z <= x)`. Its relative error is below
+* 1e-14, also in the lower tail: `normalCdf(-37)` is approximately 5.7e-300, not 0.
+*
+* @param x - A number. `-Infinity` gives 0 and `Infinity` gives 1.
+*/
+function normalCdf(x) {
+	if (Number.isNaN(x)) throw new RangeError("normalCdf: x is NaN.");
+	if (x === Number.NEGATIVE_INFINITY) return 0;
+	if (x === Number.POSITIVE_INFINITY) return 1;
+	return erfc(-x / Math.SQRT2) / 2;
+}
+const A = [
+	3.3871328727963665,
+	133.14166789178438,
+	1971.5909503065513,
+	13731.69376550946,
+	45921.95393154987,
+	67265.7709270087,
+	33430.57558358813,
+	2509.0809287301227
+];
+const B = [
+	1,
+	42.31333070160091,
+	687.1870074920579,
+	5394.196021424751,
+	21213.794301586597,
+	39307.89580009271,
+	28729.085735721943,
+	5226.495278852854
+];
+const C = [
+	1.4234371107496835,
+	4.630337846156546,
+	5.769497221460691,
+	3.6478483247632045,
+	1.2704582524523684,
+	.2417807251774506,
+	.022723844989269184,
+	.0007745450142783414
+];
+const D = [
+	1,
+	2.053191626637759,
+	1.6763848301838038,
+	.6897673349851,
+	.14810397642748008,
+	.015198666563616457,
+	.0005475938084995345,
+	1.0507500716444169e-9
+];
+const E = [
+	6.657904643501103,
+	5.463784911164114,
+	1.7848265399172913,
+	.29656057182850487,
+	.026532189526576124,
+	.0012426609473880784,
+	27115555687434876e-21,
+	2.0103343992922881e-7
+];
+const F = [
+	1,
+	.599832206555888,
+	.1369298809227358,
+	.014875361290850615,
+	.0007868691311456133,
+	18463183175100548e-21,
+	1.421511758316446e-7,
+	20442631033899397e-31
+];
+/** The value of a polynomial with the coefficients `c[0] + c[1] x + …`, by the rule of Horner. */
+function poly(c, x) {
+	let value = 0;
+	for (let i = c.length - 1; i >= 0; i--) value = value * x + c[i];
+	return value;
+}
+/**
+* This function gives the quantile of the standard normal law, the `x` with `normalCdf(x) = p`. It uses PPND16 of
+* Wichura (algorithm AS 241). Its relative error is near 1e-16 for each `p` from 1e-300 to 1 - 1e-16.
+*
+* @param p - The share of the law below the result, from 0 to 1. A `p` of 0 gives `-Infinity` and 1 gives `Infinity`.
+*/
+function normalQuantile(p) {
+	if (!(p >= 0 && p <= 1)) throw new RangeError(`normalQuantile: p is from 0 to 1, not ${p}.`);
+	if (p === 0) return Number.NEGATIVE_INFINITY;
+	if (p === 1) return Number.POSITIVE_INFINITY;
+	const q = p - .5;
+	if (Math.abs(q) <= .425) {
+		const r = .180625 - q * q;
+		return q * poly(A, r) / poly(B, r);
+	}
+	let r = Math.sqrt(-Math.log(q < 0 ? p : 1 - p));
+	let value;
+	if (r <= 5) {
+		r -= 1.6;
+		value = poly(C, r) / poly(D, r);
+	} else {
+		r -= 5;
+		value = poly(E, r) / poly(F, r);
+	}
+	return q < 0 ? -value : value;
+}
 // 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
@@ -3870,6 +4097,6 @@ function inverseDiagonal(hessian, k) {
 	}
 	return out;
 }
-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, bradleyTerry, brier, calibration, cohenKappa, compareRatios, coverageMinSample, eloExpected, eloUpdate, fitResponse, glicko2Idle, glicko2Update, heldOutError, heldOutErrorAt, holm, kendallTau, leastSquares, logLoss, mean, median, medianInterval, modeCount, negativeBinomialInterval, noiseFloor, noiseVerdict, optionFloor, pairProbabilities, pairedPermutation, parseResponseRecord, partialConjunction, predictResponse, quantile, quantileInterval, quantileSamples, quantileSorted, ranks, ratingToStrength, responseCells, ridgeSolve, sampleTotalInterval, sd, signTest, signTestPower, sliceResponse, smoothLawScores, sobolIndices, sorted, spearman, strengthToRating, summarize, surfaceResponse, tQuantile, twoSamplePermutation, uStatisticInterval, whenHolds, wilson, wilsonSampleSize };
+export { KENDALL_EXACT, RESPONSE_LAMBDAS, RESPONSE_MAX_POWER, RESPONSE_MAX_TERMS, RESPONSE_RECORDS_SCHEMA, SIGN_FLIP_EXACT_LIMIT, SIGN_FLIP_EXACT_MAX, U_STATISTIC_TIGHT_MIN_SAMPLE, Z95, bestSmoothLaw, binomialInterval, binomialTest, bootstrap, bootstrapClusters, bootstrapLeastSquares, bootstrapMedian, bootstrapMedianRatio, bootstrapStrata, bootstrapTwo, bradleyTerry, brier, calibration, cohenKappa, compareRatios, coverageMinSample, eloExpected, eloUpdate, fitResponse, glicko2Idle, glicko2Update, heldOutError, heldOutErrorAt, holm, kendallTau, leastSquares, logLoss, mean, median, medianInterval, modeCount, negativeBinomialInterval, noiseFloor, noiseVerdict, normalCdf, normalQuantile, optionFloor, pairProbabilities, pairedPermutation, parseResponseRecord, partialConjunction, predictResponse, quantile, quantileInterval, quantileSamples, quantileSorted, ranks, ratingToStrength, responseCells, ridgeSolve, sampleTotalInterval, sd, signFlipTest, signTest, signTestPower, sliceResponse, smoothLawScores, sobolIndices, sorted, spearman, strengthToRating, summarize, surfaceResponse, tQuantile, twoSamplePermutation, uStatisticInterval, whenHolds, wilson, wilsonSampleSize };
 
 //# sourceMappingURL=index.js.map