@mark1russell7/rigor-statistics 0.1.28 → 0.2.0

package/build/index.js

@@ -3842,9 +3842,29 @@ function ratingToStrength(rating, options = {}) {
 * Ties use the Davidson (1970) model, or count as half a win and half a loss. The fit uses Newton steps with a line search on the negative log posterior. This function is
 * convex, so the steps go to its one minimum.
 */
-const ARMIJO = 1e-4;
-const HALVINGS = 60;
-const ROUNDING = 64 * Number.EPSILON;
+/**
+* This function gives the start of a fit: the log-strengths, and the log of the tie parameter. It throws a RangeError
+* for a start with the wrong number of items. It also throws for a log-strength that is not finite, or a tie parameter
+* of 0 or less.
+*/
+function startOf(name, items, priorMean, start) {
+	if (start === void 0) return {
+		strengths: new Float64Array(items).fill(priorMean),
+		logTie: 0
+	};
+	if (start.strengths.length !== items) throw new RangeError(`${name}: the start has ${start.strengths.length} log-strengths, and the fit has ${items} items.`);
+	const strengths = Float64Array.from(start.strengths);
+	for (const [i, value] of strengths.entries()) if (!Number.isFinite(value)) throw new RangeError(`${name}: the start log-strength of item ${i} is a finite number, not ${start.strengths[i]}.`);
+	const tie = start.tie ?? 1;
+	if (!(tie > 0 && Number.isFinite(tie))) throw new RangeError(`${name}: the start tie parameter is a finite number above 0, not ${tie}.`);
+	return {
+		strengths,
+		logTie: Math.log(tie)
+	};
+}
+const ARMIJO$1 = 1e-4;
+const HALVINGS$1 = 60;
+const ROUNDING$1 = 64 * Number.EPSILON;
 function checkedTerms(n, comparisons, ties) {
 	const terms = [];
 	for (const [i, comparison] of comparisons.entries()) {
@@ -3866,7 +3886,7 @@ function checkedTerms(n, comparisons, ties) {
 	}
 	return terms;
 }
-function positiveOption(label, value) {
+function positiveOption$1(label, value) {
 	if (!(value > 0 && Number.isFinite(value))) throw new RangeError(`bradleyTerry: ${label} is a finite number above 0, not ${value}.`);
 }
 /**
@@ -3883,11 +3903,12 @@ function bradleyTerry(items, comparisons, options = {}) {
 	const maxIterations = options.maxIterations ?? 100;
 	const tolerance = options.tolerance ?? 1e-10;
 	if (!Number.isFinite(priorMean)) throw new RangeError(`bradleyTerry: the prior mean is a finite number, not ${priorMean}.`);
-	positiveOption("the prior SD", priorSd);
-	positiveOption("the tie prior SD", tiePriorSd);
-	positiveOption("the tolerance", tolerance);
+	positiveOption$1("the prior SD", priorSd);
+	positiveOption$1("the tie prior SD", tiePriorSd);
+	positiveOption$1("the tolerance", tolerance);
 	if (ties !== "davidson" && ties !== "half") throw new RangeError(`bradleyTerry: the tie model is "davidson" or "half", not ${String(ties)}.`);
 	if (!Number.isSafeInteger(maxIterations) || maxIterations < 1) throw new RangeError(`bradleyTerry: maxIterations is a whole number of 1 or more, not ${maxIterations}.`);
+	const begin = startOf("bradleyTerry", items, priorMean, options.start);
 	const terms = checkedTerms(items, comparisons, ties);
 	const fitTie = terms.some((t) => t.tie === 1);
 	const k = fitTie ? items + 1 : items;
@@ -3899,8 +3920,9 @@ function bradleyTerry(items, comparisons, options = {}) {
 		priorPrecision: 1 / (priorSd * priorSd),
 		tiePrecision: 1 / (tiePriorSd * tiePriorSd)
 	};
-	const x = new Float64Array(k).fill(priorMean);
-	if (fitTie) x[items] = 0;
+	const x = new Float64Array(k);
+	x.set(begin.strengths);
+	if (fitTie) x[items] = begin.logTie;
 	let iterations = 0;
 	let converged = false;
 	let value = objective(model, x);
@@ -3913,8 +3935,8 @@ function bradleyTerry(items, comparisons, options = {}) {
 		let t = 1;
 		let next = moved(x, step, t);
 		let nextValue = objective(model, next);
-		const slack = ROUNDING * (Math.abs(value) + 1);
-		for (let h = 0; h < HALVINGS && !(nextValue <= value + ARMIJO * t * slope + slack); h++) {
+		const slack = ROUNDING$1 * (Math.abs(value) + 1);
+		for (let h = 0; h < HALVINGS$1 && !(nextValue <= value + ARMIJO$1 * t * slope + slack); h++) {
 			t /= 2;
 			next = moved(x, step, t);
 			nextValue = objective(model, next);
@@ -4056,6 +4078,652 @@ function inverseDiagonal(hessian, k) {
 	}
 	return out;
 }
-export { EMPTY_RUNNING, 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, addToRunning, 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, mergeRunning, modeCount, negativeBinomialInterval, noiseFloor, noiseVerdict, normalCdf, normalQuantile, optionFloor, pairProbabilities, pairedPermutation, parseResponseRecord, partialConjunction, predictResponse, quantile, quantileInterval, quantileSamples, quantileSorted, ranks, ratingToStrength, responseCells, ridgeSolve, runningMean, runningOf, runningSd, sampleTotalInterval, sd, signFlipTest, signTest, signTestPower, sliceResponse, smoothLawScores, sobolIndices, sorted, spearman, strengthToRating, summarize, surfaceResponse, tQuantile, twoSamplePermutation, uStatisticInterval, whenHolds, wilson, wilsonSampleSize };
+// src/bradley-terry-sparse.ts
+/**
+* The sparse Bradley-Terry fit. It has the model, the prior and the tie model of `bradleyTerry`, so the two fits have
+* one optimum. This fit keeps one record for each distinct pair of items, not a matrix of all the items. Thus its
+* memory is in proportion to the items and the pairs. The dense fit of 10,000 items keeps a Hessian of 800 MB.
+*
+* The fit uses Newton steps on the negative log posterior, as `bradleyTerry` does. It does not factor the Hessian.
+* Preconditioned conjugate gradients solve each Newton system, and the diagonal of the Hessian is the preconditioner.
+* One product of the Hessian and a vector reads each pair one time.
+*
+* The prior makes the objective strongly convex, so the Hessian is positive definite. Thus each step of the solve
+* gives a direction that goes down. The solve is loose far from the minimum and tight near it (an inexact Newton
+* method). A line search with the Armijo rule makes the objective smaller at each step. The steps go to the one
+* minimum, and the fit stops when the gradient puts each parameter inside the tolerance of that minimum.
+*/
+/** The largest number of items. The key of a pair is `low * items + high`, and it must be a safe integer. */
+const MAX_ITEMS = Math.floor(Math.sqrt(Number.MAX_SAFE_INTEGER));
+const ROUNDING = 64 * Number.EPSILON;
+const NAME = "bradleyTerrySparse";
+/** The Armijo constant of the line search: a step gives at least this part of the decrease that the slope forecasts. */
+const ARMIJO = 1e-4;
+/** The largest number of halvings of a step in the line search. */
+const HALVINGS = 60;
+/** The largest number of conjugate-gradient steps for one Newton system. */
+const SOLVE_LIMIT = 500;
+function positiveOption(label, value) {
+	if (!(value > 0 && Number.isFinite(value))) throw new RangeError(`${NAME}: ${label} is a finite number above 0, not ${value}.`);
+}
+/** This function checks the comparisons, and sums them for each distinct pair. A comparison with the weight 0 adds nothing. */
+function pairsOf(items, comparisons, ties) {
+	const index = /* @__PURE__ */ new Map();
+	const low = [];
+	const high = [];
+	const total = [];
+	const net = [];
+	const tie = [];
+	for (const [i, comparison] of comparisons.entries()) {
+		const { a, b, outcome } = comparison;
+		const w = comparison.weight ?? 1;
+		for (const item of [a, b]) if (!Number.isSafeInteger(item) || item < 0 || item >= items) throw new RangeError(`${NAME}: comparison ${i} has the index ${item}, and the indexes are whole numbers from 0 to ${items - 1}.`);
+		if (a === b) throw new RangeError(`${NAME}: comparison ${i} compares the item ${a} with itself.`);
+		if (outcome !== "a" && outcome !== "b" && outcome !== "tie") throw new RangeError(`${NAME}: comparison ${i} has the outcome ${String(outcome)}.`);
+		if (!(w >= 0 && Number.isFinite(w))) throw new RangeError(`${NAME}: comparison ${i} has the weight ${w}, and a weight is a finite number of 0 or more.`);
+		if (w === 0) continue;
+		const lo = Math.min(a, b);
+		const hi = Math.max(a, b);
+		const key = lo * items + hi;
+		let p = index.get(key);
+		if (p === void 0) {
+			p = low.length;
+			index.set(key, p);
+			low.push(lo);
+			high.push(hi);
+			total.push(0);
+			net.push(0);
+			tie.push(0);
+		}
+		total[p] = total[p] + w;
+		if (outcome === "tie") {
+			if (ties === "davidson") tie[p] = tie[p] + w;
+		} else {
+			const winner = outcome === "a" ? a : b;
+			net[p] = net[p] + (winner === lo ? w : -w);
+		}
+	}
+	return {
+		count: low.length,
+		low: Int32Array.from(low),
+		high: Int32Array.from(high),
+		total: Float64Array.from(total),
+		net: Float64Array.from(net),
+		ties: Float64Array.from(tie)
+	};
+}
+/** The connected groups of the items: the group of each item, and the size of each group. */
+function groupsOf(items, pairs) {
+	const parent = new Int32Array(items);
+	for (let i = 0; i < items; i++) parent[i] = i;
+	const root = (i) => {
+		let r = i;
+		while (parent[r] !== r) r = parent[r];
+		for (let j = i; parent[j] !== r;) {
+			const next = parent[j];
+			parent[j] = r;
+			j = next;
+		}
+		return r;
+	};
+	for (let p = 0; p < pairs.count; p++) {
+		const x = root(pairs.low[p]);
+		const y = root(pairs.high[p]);
+		if (x !== y) parent[Math.max(x, y)] = Math.min(x, y);
+	}
+	const group = new Int32Array(items).fill(-1);
+	const ids = new Int32Array(items).fill(-1);
+	let count = 0;
+	for (let i = 0; i < items; i++) {
+		const r = root(i);
+		if (ids[r] === -1) ids[r] = count++;
+		group[i] = ids[r];
+	}
+	const size = new Float64Array(count);
+	for (let i = 0; i < items; i++) size[group[i]] = size[group[i]] + 1;
+	return {
+		group,
+		size,
+		count
+	};
+}
+/**
+* The probabilities of the three outcomes of a pair with the difference `d` of the log-strengths, and the log of the
+* denominator `exp(d / 2) + exp(-d / 2) + nu`. The function writes them into `out`, so the loops make no objects.
+*/
+function outcomes(d, logNu, out) {
+	const half = d / 2;
+	const top = Math.max(Math.abs(half), logNu);
+	const ea = Math.exp(half - top);
+	const eb = Math.exp(-half - top);
+	const et = Math.exp(logNu - top);
+	const sum = ea + eb + et;
+	out[0] = ea / sum;
+	out[1] = eb / sum;
+	out[2] = et / sum;
+	out[3] = top + Math.log(sum);
+}
+/** This function makes an empty point for `items` items and `count` pairs. */
+function pointOf(items, count) {
+	return {
+		s: new Float64Array(items),
+		lambda: 0,
+		value: 0,
+		logLikelihood: 0,
+		gradient: new Float64Array(items),
+		tieGradient: 0,
+		norm: 0,
+		curvature: new Float64Array(count),
+		diagonal: new Float64Array(items),
+		cross: new Float64Array(items),
+		tieCurvature: 0
+	};
+}
+/** This function writes the objective, the gradient and the Hessian at the parameters of `point` into `point`. */
+function evaluate(problem, point, out) {
+	const { items, pairs, fitTie, priorMean, p, tau, tieWeight } = problem;
+	const { s, gradient, curvature, diagonal, cross, lambda } = point;
+	const logNu = fitTie ? lambda : Number.NEGATIVE_INFINITY;
+	let prior = 0;
+	for (let i = 0; i < items; i++) {
+		const offset = s[i] - priorMean;
+		prior += offset * offset;
+		gradient[i] = p * offset;
+		diagonal[i] = p;
+		cross[i] = 0;
+	}
+	let logLikelihood = fitTie ? tieWeight * lambda : 0;
+	let tieGradient = fitTie ? tau * lambda - tieWeight : 0;
+	let tieCurvature = fitTie ? tau : 0;
+	for (let q = 0; q < pairs.count; q++) {
+		const lo = pairs.low[q];
+		const hi = pairs.high[q];
+		const total = pairs.total[q];
+		const net = pairs.net[q];
+		const d = s[lo] - s[hi];
+		outcomes(d, logNu, out);
+		const pa = out[0];
+		const pb = out[1];
+		const pt = out[2];
+		const half = (pa - pb) / 2;
+		logLikelihood += net / 2 * d - total * out[3];
+		const g = total * half - net / 2;
+		gradient[lo] = gradient[lo] + g;
+		gradient[hi] = gradient[hi] - g;
+		const c = total * (pa * pb + pt * (1 - pt) / 4);
+		curvature[q] = c;
+		diagonal[lo] = diagonal[lo] + c;
+		diagonal[hi] = diagonal[hi] + c;
+		if (fitTie) {
+			tieGradient += total * pt;
+			tieCurvature += total * pt * (1 - pt);
+			const b = -total * pt * half;
+			cross[lo] = cross[lo] + b;
+			cross[hi] = cross[hi] - b;
+		}
+	}
+	let norm = tieGradient * tieGradient;
+	for (let i = 0; i < items; i++) norm += gradient[i] ** 2;
+	point.value = p * prior / 2 + (fitTie ? tau * lambda * lambda / 2 : 0) - logLikelihood;
+	point.logLikelihood = logLikelihood;
+	point.tieGradient = tieGradient;
+	point.tieCurvature = tieCurvature;
+	point.norm = Math.sqrt(norm);
+}
+/**
+* This function writes the product of the Hessian at `point` and the vector (`v`, `vTie`) into `out`. It gives the
+* tie part of the product. The product reads each pair one time, and it makes no arrays.
+*/
+function multiply(problem, point, v, vTie, out) {
+	const { items, pairs, fitTie, p } = problem;
+	const { curvature, cross } = point;
+	for (let i = 0; i < items; i++) out[i] = p * v[i] + cross[i] * vTie;
+	for (let q = 0; q < pairs.count; q++) {
+		const lo = pairs.low[q];
+		const hi = pairs.high[q];
+		const t = curvature[q] * (v[lo] - v[hi]);
+		out[lo] = out[lo] + t;
+		out[hi] = out[hi] - t;
+	}
+	if (!fitTie) return 0;
+	let tie = point.tieCurvature * vTie;
+	for (let i = 0; i < items; i++) tie += cross[i] * v[i];
+	return tie;
+}
+/**
+* This function solves the Newton system `H x = -g` at `point` with preconditioned conjugate gradients. It writes the
+* log-strength part of `x` into `step`, and it gives the tie part. The solve stops when the norm of the residual is
+* `forcing` times the norm of the gradient or less. The solve starts at 0, so each step of it gives a descent direction.
+*/
+function newtonStep(problem, point, forcing, step, work) {
+	const { items, fitTie } = problem;
+	const { residual: r, scaled: z, direction: d, product: ad } = work;
+	const { gradient, diagonal } = point;
+	let rz = 0;
+	for (let i = 0; i < items; i++) {
+		const ri = -gradient[i];
+		const zi = ri / diagonal[i];
+		r[i] = ri;
+		z[i] = zi;
+		d[i] = zi;
+		rz += ri * zi;
+	}
+	let rTie = fitTie ? -point.tieGradient : 0;
+	let dTie = fitTie ? rTie / point.tieCurvature : 0;
+	rz += rTie * dTie;
+	step.fill(0);
+	let stepTie = 0;
+	const target = forcing * point.norm;
+	const limit = Math.min(SOLVE_LIMIT, items + 1);
+	for (let k = 0; k < limit; k++) {
+		const adTie = multiply(problem, point, d, dTie, ad);
+		let dad = dTie * adTie;
+		for (let i = 0; i < items; i++) dad += d[i] * ad[i];
+		if (!(dad > 0)) break;
+		const alpha = rz / dad;
+		let residual = 0;
+		for (let i = 0; i < items; i++) {
+			step[i] = step[i] + alpha * d[i];
+			const ri = r[i] - alpha * ad[i];
+			r[i] = ri;
+			residual += ri * ri;
+		}
+		stepTie += alpha * dTie;
+		rTie -= alpha * adTie;
+		residual += rTie * rTie;
+		if (Math.sqrt(residual) <= target) break;
+		let next = 0;
+		for (let i = 0; i < items; i++) {
+			const zi = r[i] / diagonal[i];
+			z[i] = zi;
+			next += r[i] * zi;
+		}
+		const zTie = fitTie ? rTie / point.tieCurvature : 0;
+		next += rTie * zTie;
+		const beta = next / rz;
+		rz = next;
+		for (let i = 0; i < items; i++) d[i] = z[i] + beta * d[i];
+		dTie = zTie + beta * dTie;
+	}
+	return stepTie;
+}
+/**
+* The sparse Bradley-Terry fit of `comparisons` among `items` items. It has the model, the options and the checks of
+* `bradleyTerry`, and its memory is in proportion to `items` plus the distinct pairs. The function does not sort or
+* change its inputs. It throws a RangeError for a bad index, a bad outcome, a bad weight and a bad option.
+*/
+function bradleyTerrySparse(items, comparisons, options = {}) {
+	if (!Number.isSafeInteger(items) || items < 1 || items > MAX_ITEMS) throw new RangeError(`${NAME}: the number of items is a whole number from 1 to ${MAX_ITEMS}, not ${items}.`);
+	const priorMean = options.priorMean ?? 0;
+	const priorSd = options.priorSd ?? 1;
+	const ties = options.ties ?? "davidson";
+	const tiePriorSd = options.tiePriorSd ?? 10;
+	const maxIterations = options.maxIterations ?? 100;
+	const tolerance = options.tolerance ?? 1e-8;
+	if (!Number.isFinite(priorMean)) throw new RangeError(`${NAME}: the prior mean is a finite number, not ${priorMean}.`);
+	positiveOption("the prior SD", priorSd);
+	positiveOption("the tie prior SD", tiePriorSd);
+	positiveOption("the tolerance", tolerance);
+	if (ties !== "davidson" && ties !== "half") throw new RangeError(`${NAME}: the tie model is "davidson" or "half", not ${String(ties)}.`);
+	if (!Number.isSafeInteger(maxIterations) || maxIterations < 1) throw new RangeError(`${NAME}: maxIterations is a whole number of 1 or more, not ${maxIterations}.`);
+	const begin = startOf(NAME, items, priorMean, options.start);
+	const pairs = pairsOf(items, comparisons, ties);
+	let tieWeight = 0;
+	let totalWeight = 0;
+	for (let q = 0; q < pairs.count; q++) {
+		tieWeight += pairs.ties[q];
+		totalWeight += pairs.total[q];
+	}
+	const p = 1 / (priorSd * priorSd);
+	const tau = 1 / (tiePriorSd * tiePriorSd);
+	const problem = {
+		items,
+		pairs,
+		fitTie: tieWeight > 0,
+		priorMean,
+		p,
+		tau,
+		tieWeight
+	};
+	const smallest = problem.fitTie ? Math.min(p, tau) : p;
+	const floor = 4 * Number.EPSILON * (totalWeight + 1);
+	let current = pointOf(items, pairs.count);
+	let trial = pointOf(items, pairs.count);
+	current.s.set(begin.strengths);
+	current.lambda = problem.fitTie ? begin.logTie : 0;
+	const out = /* @__PURE__ */ new Float64Array(4);
+	const step = new Float64Array(items);
+	const work = {
+		residual: new Float64Array(items),
+		scaled: new Float64Array(items),
+		direction: new Float64Array(items),
+		product: new Float64Array(items)
+	};
+	evaluate(problem, current, out);
+	let iterations = 0;
+	let bound = current.norm / smallest;
+	let rounded = current.norm <= floor;
+	while (!(bound <= tolerance || rounded) && iterations < maxIterations) {
+		iterations++;
+		const forcing = Math.min(.5, Math.sqrt(current.norm));
+		const stepTie = newtonStep(problem, current, forcing, step, work);
+		let slope = stepTie * current.tieGradient;
+		for (let i = 0; i < items; i++) slope += step[i] * current.gradient[i];
+		const slack = ROUNDING * (Math.abs(current.value) + 1);
+		let t = 1;
+		let accepted = false;
+		for (let h = 0; h <= HALVINGS && !accepted; h++) {
+			for (let i = 0; i < items; i++) trial.s[i] = current.s[i] + t * step[i];
+			trial.lambda = current.lambda + t * stepTie;
+			evaluate(problem, trial, out);
+			accepted = trial.value <= current.value + ARMIJO * t * slope + slack;
+			if (!accepted) t /= 2;
+		}
+		if (!accepted) break;
+		[current, trial] = [trial, current];
+		bound = current.norm / smallest;
+		rounded = current.norm <= floor;
+	}
+	const { group, size } = groupsOf(items, pairs);
+	const se = Array.from(current.s, (_, i) => {
+		const n = size[group[i]];
+		return Math.sqrt(1 / (n * p) + (1 - 1 / n) / current.diagonal[i]);
+	});
+	return {
+		strengths: Array.from(current.s),
+		se,
+		tie: problem.fitTie ? Math.exp(current.lambda) : 0,
+		logLikelihood: current.logLikelihood,
+		iterations,
+		converged: bound <= tolerance || rounded,
+		bound,
+		pairs: pairs.count
+	};
+}
+// src/rating-models.ts
+/**
+* The rating models of a log of picks. The Elo and the Glicko-2 replays read the picks in their order. The
+* Bradley-Terry fit reads the whole log at one time. The choice of a model compares the log-loss of each model on the
+* last picks of the log. Each function is pure: the same log gives the same result.
+*/
+/** The score of the first item of a pick: 1 for a win, 0.5 for a tie and 0 for a loss. */
+const SCORE = {
+	a: 1,
+	b: 0,
+	tie: .5
+};
+/** This function checks the indexes and the outcomes of `comparisons`. With `ordered`, it also refuses a weight other than 1. */
+function checkedPicks(name, items, comparisons, ordered) {
+	if (!Number.isSafeInteger(items) || items < 0) throw new RangeError(`${name}: the number of items is a whole number of 0 or more, not ${items}.`);
+	for (const [i, { a, b, outcome, weight }] of comparisons.entries()) {
+		for (const index of [a, b]) if (!Number.isSafeInteger(index) || index < 0 || index >= items) throw new RangeError(`${name}: pick ${i} has the index ${index}, and the indexes are whole numbers from 0 to ${items - 1}.`);
+		if (a === b) throw new RangeError(`${name}: pick ${i} compares the item ${a} with itself.`);
+		if (outcome !== "a" && outcome !== "b" && outcome !== "tie") throw new RangeError(`${name}: pick ${i} has the outcome ${String(outcome)}.`);
+		if (ordered && weight !== void 0 && weight !== 1) throw new RangeError(`${name}: pick ${i} has the weight ${weight}. An ordered replay makes one update for each pick, so each weight is 1.`);
+	}
+}
+/**
+* The Elo ratings of `items` items after each pick of `comparisons`, in the order of the list. Each item starts at
+* `start`. The update of each pick is `eloUpdate` with the options. The order of the picks changes the result.
+*/
+function eloReplay(items, comparisons, options = {}) {
+	checkedPicks("eloReplay", items, comparisons, true);
+	const start = options.start ?? 1500;
+	if (!Number.isFinite(start)) throw new RangeError(`eloReplay: the start rating is a finite number, not ${start}.`);
+	eloUpdate(start, start, .5, options);
+	const ratings = new Array(items).fill(start);
+	for (const { a, b, outcome } of comparisons) {
+		const next = eloUpdate(ratings[a], ratings[b], SCORE[outcome], options);
+		ratings[a] = next.a;
+		ratings[b] = next.b;
+	}
+	return ratings;
+}
+/**
+* The Glicko-2 ratings of `items` items after each pick of `comparisons`, in the order of the list. Each pick is one
+* rating period of its two items. Each item of a pick gets `glicko2Update` against the rating of the other item before
+* the pick. An item that is not in a pick does not change in that period. The order of the picks changes the result.
+*/
+function glicko2Replay(items, comparisons, options = {}) {
+	checkedPicks("glicko2Replay", items, comparisons, true);
+	const start = options.start ?? {
+		rating: 1500,
+		rd: 350,
+		volatility: .06
+	};
+	glicko2Update(start, [], options);
+	const players = Array.from({ length: items }, () => ({
+		rating: start.rating,
+		rd: start.rd,
+		volatility: start.volatility
+	}));
+	for (const { a, b, outcome } of comparisons) {
+		const pa = players[a];
+		const pb = players[b];
+		players[a] = glicko2Update(pa, [{
+			rating: pb.rating,
+			rd: pb.rd,
+			score: SCORE[outcome]
+		}], options);
+		players[b] = glicko2Update(pb, [{
+			rating: pa.rating,
+			rd: pa.rd,
+			score: 1 - SCORE[outcome]
+		}], options);
+	}
+	return players;
+}
+/** The default largest number of items of the dense Bradley-Terry fit in `fitRatings`. */
+const BRADLEY_TERRY_DENSE_LIMIT = 200;
+/**
+* The log-strengths of `items` items with one rating model. The model `"bradley-terry"` uses `bradleyTerry`, or
+* `bradleyTerrySparse` above `denseLimit` items. The models `"elo"` and `"glicko2"` use `eloReplay` and
+* `glicko2Replay`, and they refuse a weight other than 1. A log of 0 items gives empty lists.
+*/
+function fitRatings(model, items, comparisons, options = {}) {
+	checkedPicks("fitRatings", items, comparisons, model !== "bradley-terry");
+	const denseLimit = options.denseLimit ?? 200;
+	if (!(denseLimit >= 0)) throw new RangeError(`fitRatings: denseLimit is a number of 0 or more, not ${denseLimit}.`);
+	if (items === 0) return {
+		strengths: [],
+		se: [],
+		tie: 0
+	};
+	switch (model) {
+		case "bradley-terry": {
+			const fit = items <= denseLimit ? bradleyTerry(items, comparisons, options.bradleyTerry) : bradleyTerrySparse(items, comparisons, options.bradleyTerry);
+			return {
+				strengths: fit.strengths,
+				se: fit.se,
+				tie: fit.tie
+			};
+		}
+		case "elo": {
+			const ratings = eloReplay(items, comparisons, options.elo);
+			return {
+				strengths: ratings.map((rating) => ratingToStrength(rating, options.elo)),
+				se: ratings.map(() => void 0),
+				tie: 0
+			};
+		}
+		case "glicko2": {
+			const players = glicko2Replay(items, comparisons, options.glicko2);
+			return {
+				strengths: players.map((player) => ratingToStrength(player.rating)),
+				se: players.map((player) => ratingToStrength(1500 + player.rd)),
+				tie: 0
+			};
+		}
+		default: throw new RangeError(`fitRatings: the model is "bradley-terry", "elo" or "glicko2", not ${String(model)}.`);
+	}
+}
+/** The lowest probability of a forecast. An outcome with a probability of 0 gives a log-loss of Infinity. */
+const FORECAST_FLOOR = 1e-9;
+/**
+* The choice of a rating model by the log-loss on held-out picks. Each model learns from the first picks of the log
+* and forecasts the last `holdout` part. All models use the tie parameter of the Bradley-Terry fit of the first picks.
+* Thus the strengths are the only difference. Two equal scores keep the order of `models`. Each pick has the weight 1.
+*/
+function selectRatingModel(items, comparisons, options = {}) {
+	checkedPicks("selectRatingModel", items, comparisons, true);
+	const holdout = options.holdout ?? .2;
+	const minimum = options.minimum ?? 30;
+	const models = options.models ?? [
+		"bradley-terry",
+		"elo",
+		"glicko2"
+	];
+	if (!(holdout > 0 && holdout < 1)) throw new RangeError(`selectRatingModel: the holdout is above 0 and below 1, not ${holdout}.`);
+	if (!Number.isSafeInteger(minimum) || minimum < 0) throw new RangeError(`selectRatingModel: the minimum is a whole number of 0 or more, not ${minimum}.`);
+	if (models.length === 0) throw new RangeError("selectRatingModel: the list of models is empty.");
+	for (const model of models) if (model !== "bradley-terry" && model !== "elo" && model !== "glicko2") throw new RangeError(`selectRatingModel: a model is "bradley-terry", "elo" or "glicko2", not ${String(model)}.`);
+	const tested = Math.floor(comparisons.length * holdout);
+	if (comparisons.length < minimum || tested < 1) return {
+		model: "bradley-terry",
+		scores: [],
+		trained: comparisons.length,
+		tested: 0
+	};
+	const train = comparisons.slice(0, comparisons.length - tested);
+	const test = comparisons.slice(comparisons.length - tested);
+	const bradley = fitRatings("bradley-terry", items, train, options);
+	const scores = models.map((model) => {
+		const { strengths } = model === "bradley-terry" ? bradley : fitRatings(model, items, train, options);
+		return {
+			model,
+			logLoss: logLoss(test.map(({ a, b, outcome }) => {
+				const p = pairProbabilities(strengths[a], strengths[b], bradley.tie)[outcome];
+				return {
+					p: Math.max(p, FORECAST_FLOOR),
+					hit: true
+				};
+			}))
+		};
+	});
+	scores.sort((x, y) => x.logLoss - y.logLoss);
+	return {
+		model: scores[0].model,
+		scores,
+		trained: train.length,
+		tested
+	};
+}
+// src/pair-choice.ts
+/**
+* The choice of the next pair of a duel. A good pair has a result that is not sure: two items with near ratings, or
+* items with few picks. The choice uses a seed of `@mark1russell7/rigor-generators`, so a seed gives the same pair again.
+*/
+/**
+* The uncertainty of an item with no standard error and no picks, in rating points. It is the first RD of Glicko-2.
+* An item with no standard error has the uncertainty `350 / sqrt(1 + picks)`.
+*/
+const RATING_START_UNCERTAINTY = 350;
+/** The largest pool of items for a full search of a pair that is not recent. */
+const PAIR_FULL_SEARCH = 64;
+/** The uncertainty of a rating, in rating points: its standard error, or `RATING_START_UNCERTAINTY / sqrt(1 + picks)`. */
+function ratingUncertainty(item) {
+	return item.se ?? 350 / Math.sqrt(1 + item.picks);
+}
+/**
+* The expected information of a pick between two items: `p * (1 - p) * (ua^2 + ub^2)`. Here `p` is `eloExpected` of
+* the two ratings, and `ua` and `ub` are the uncertainties. The value is high when the result is not sure (a `p` near
+* 0.5) and the two ratings are not sure.
+*/
+function pairInformation(a, b, options = {}) {
+	const p = eloExpected(a.rating, b.rating, options);
+	return p * (1 - p) * (ratingUncertainty(a) ** 2 + ratingUncertainty(b) ** 2);
+}
+const pairKey = (a, b) => a < b ? `${a}\u0000${b}` : `${b}\u0000${a}`;
+/**
+* The indexes of the second items to examine: the neighbors in the order, and random items. Only the indexes in
+* `allowed` are candidates.
+*/
+function candidatesOf(first, allowed, size, count, draw) {
+	if (allowed.size <= count) return [...allowed].sort((x, y) => x - y);
+	const chosen = /* @__PURE__ */ new Set();
+	const near = Math.ceil(count / 2);
+	for (let step = 1; chosen.size < near && step < size; step++) {
+		if (allowed.has(first - step)) chosen.add(first - step);
+		if (chosen.size < near && allowed.has(first + step)) chosen.add(first + step);
+	}
+	while (chosen.size < count) {
+		const index = draw(size);
+		if (allowed.has(index)) chosen.add(index);
+	}
+	return [...chosen];
+}
+/**
+* The choice of the next pair of a duel from a pool of rated items. The pool goes in the order of the ratings, from
+* the highest. These are the steps:
+*
+* 1. A draw selects the first item. The weight of an item is `1 / (1 + picks)`, so the items with few picks come first.
+*    An item with no permitted pair leaves the draw.
+* 2. The second item is the candidate with the most information. The candidates are the neighbors of the first item in
+*    the order, and random items, each in a permitted pair. A recent pair loses to each pair that is not recent.
+* 3. A draw selects the left and the right side, so the side does not change the picks.
+*
+* In a pool of `PAIR_FULL_SEARCH` items or fewer, a recent pair comes only when each permitted pair is recent. The
+* function gives `undefined` when there is no permitted pair. Each step has its own stream of the seed.
+*/
+function choosePair(items, options) {
+	const candidates = options.candidates ?? 24;
+	if (!Number.isSafeInteger(candidates) || candidates < 1) throw new RangeError(`choosePair: candidates is a whole number of 1 or more, not ${candidates}.`);
+	for (const item of items) {
+		if (!Number.isFinite(item.rating)) throw new RangeError(`choosePair: the item ${item.id} has the rating ${item.rating}, and a rating is a finite number.`);
+		if (!Number.isSafeInteger(item.picks) || item.picks < 0) throw new RangeError(`choosePair: the item ${item.id} has ${item.picks} picks, and a count of picks is a whole number of 0 or more.`);
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const pool = items.filter((item) => !seen.has(item.id) && seen.add(item.id)).sort((x, y) => y.rating - x.rating);
+	if (pool.length < 2) return void 0;
+	const draw = random(options.seed);
+	const recent = new Set((options.recent ?? []).map(([a, b]) => pairKey(a, b)));
+	const at = (i) => pool[i];
+	const isRecent = (i, j) => recent.has(pairKey(at(i).id, at(j).id));
+	const information = options.information ?? ((a, b) => pairInformation(a, b));
+	const informationOf = (i, j) => {
+		const value = information(at(i), at(j));
+		if (value !== void 0 && !Number.isFinite(value)) throw new RangeError(`choosePair: the information of ${at(i).id} and ${at(j).id} is ${value}, and it is a finite number or undefined.`);
+		return value;
+	};
+	const jitter = draw.fork("jitter");
+	let best;
+	const consider = (i, j, score) => {
+		if (score === void 0) return;
+		const option = {
+			i,
+			j,
+			fresh: !isRecent(i, j),
+			score,
+			tie: jitter.next()
+		};
+		if (best === void 0 || option.fresh && !best.fresh || option.fresh === best.fresh && (option.score > best.score || option.score === best.score && option.tie > best.tie)) best = option;
+	};
+	const weights = pool.map((item) => 1 / (1 + item.picks));
+	const firstDraw = draw.fork("first");
+	let first = -1;
+	const scores = /* @__PURE__ */ new Map();
+	while (first < 0 && weights.some((weight) => weight > 0)) {
+		const index = firstDraw.weighted(weights);
+		for (let j = 0; j < pool.length; j++) {
+			const score = j === index ? void 0 : informationOf(index, j);
+			if (score !== void 0) scores.set(j, score);
+		}
+		if (scores.size > 0) first = index;
+		else weights[index] = 0;
+	}
+	if (first < 0) return void 0;
+	const second = draw.fork("second");
+	const allowed = new Set(scores.keys());
+	for (const j of candidatesOf(first, allowed, pool.length, candidates, (n) => second.below(n))) consider(first, j, scores.get(j));
+	if (!best.fresh && pool.length <= 64) for (let i = 0; i < pool.length; i++) for (let j = i + 1; j < pool.length; j++) consider(i, j, informationOf(i, j));
+	const { i, j, score } = best;
+	const [left, right] = draw.fork("side").chance(.5) ? [at(j), at(i)] : [at(i), at(j)];
+	return {
+		a: left.id,
+		b: right.id,
+		information: score
+	};
+}
+export { BRADLEY_TERRY_DENSE_LIMIT, EMPTY_RUNNING, KENDALL_EXACT, PAIR_FULL_SEARCH, RATING_START_UNCERTAINTY, 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, addToRunning, bestSmoothLaw, binomialInterval, binomialTest, bootstrap, bootstrapClusters, bootstrapLeastSquares, bootstrapMedian, bootstrapMedianRatio, bootstrapStrata, bootstrapTwo, bradleyTerry, bradleyTerrySparse, brier, calibration, choosePair, cohenKappa, compareRatios, coverageMinSample, eloExpected, eloReplay, eloUpdate, fitRatings, fitResponse, glicko2Idle, glicko2Replay, glicko2Update, heldOutError, heldOutErrorAt, holm, kendallTau, leastSquares, logLoss, mean, median, medianInterval, mergeRunning, modeCount, negativeBinomialInterval, noiseFloor, noiseVerdict, normalCdf, normalQuantile, optionFloor, pairInformation, pairProbabilities, pairedPermutation, parseResponseRecord, partialConjunction, predictResponse, quantile, quantileInterval, quantileSamples, quantileSorted, ranks, ratingToStrength, ratingUncertainty, responseCells, ridgeSolve, runningMean, runningOf, runningSd, sampleTotalInterval, sd, selectRatingModel, signFlipTest, signTest, signTestPower, sliceResponse, smoothLawScores, sobolIndices, sorted, spearman, strengthToRating, summarize, surfaceResponse, tQuantile, twoSamplePermutation, uStatisticInterval, whenHolds, wilson, wilsonSampleSize };
 
 //# sourceMappingURL=index.js.map