@mark1russell7/rigor-statistics 0.1.29 → 0.2.0

package/README.md

@@ -171,7 +171,9 @@ choosePair(pool, { seed: "duel-1" });             // the next pair of a duel, th
 
 `bradleyTerrySparse` has the model, the prior and the tie models of `bradleyTerry`. Its memory is in proportion to the items plus the distinct pairs. At 10,000 items, the Hessian of `bradleyTerry` has 800 MB. The sparse fit uses a few MB.
 
-- The fit uses MM steps. The first part of a step minimizes a quadratic bound of the strengths (Böhning and Lindsay, 1988). The second part moves each connected group to the prior mean. The third part uses the tie bound of Hunter (2004).
+- The fit uses Newton steps, as `bradleyTerry` does. Preconditioned conjugate gradients solve each Newton system, so the fit does not factor the Hessian. One product with the Hessian reads each pair one time.
+- 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 option `start` of both fits sets the start point. A start from the fit before the last comparisons saves steps, and the optimum does not change.
 - The objective is strongly convex. Thus the norm of the gradient over the smallest prior precision is a bound of the distance from the exact optimum. The fit stops when `bound` is `tolerance` (1e-8) or less.
 - A property test compares the two fits on small logs. The strengths agree to 1e-7, and the distance is at most `bound`.
 - The standard errors are approximate. The variance of an item is `1 / (n * p) + (1 - 1 / n) / h`. Here `n` is the number of items of its connected group, `p` is the prior precision and `h` is the diagonal entry of the Hessian.

package/build/index.d.ts

@@ -1613,6 +1613,19 @@ interface BradleyTerryOptions {
   readonly maxIterations?: number;
   /** The fit stops when the full Newton step moves no parameter more than this value. The default is 1e-10. */
   readonly tolerance?: number;
+  /**
+   * The point where the fit starts. The default is the prior mean for each log-strength, and 1 for the tie parameter.
+   * A start near the optimum saves steps. An example is the fit of the log before its last comparisons. The optimum
+   * does not change.
+   */
+  readonly start?: BradleyTerryStart;
+}
+/** The start of a Bradley-Terry fit: a log-strength for each item, and the Davidson tie parameter. */
+interface BradleyTerryStart {
+  /** The log-strength of each item, in the order of the indexes. Each value is a finite number. */
+  readonly strengths: readonly number[];
+  /** The Davidson tie parameter, a finite number above 0. The default is 1. A fit with no Davidson tie does not use it. */
+  readonly tie?: number;
 }
 /** The result of `bradleyTerry`. The lists have one value for each item, in the order of the indexes. */
 interface BradleyTerryFit {
@@ -1640,7 +1653,7 @@ interface BradleyTerryFit {
 export declare function bradleyTerry(items: number, comparisons: readonly PairComparison[], options?: BradleyTerryOptions): BradleyTerryFit;
 /** The options of `bradleyTerrySparse`. The prior and the tie model are the same as in `bradleyTerry`. */
 interface BradleyTerrySparseOptions extends BradleyTerryOptions {
-  /** The largest number of MM steps. The default is 10000. */
+  /** The largest number of Newton steps. The default is 100. */
   readonly maxIterations?: number;
   /**
    * The largest distance of the parameters from the exact optimum at the stop. The default is 1e-8. The distance is the
@@ -1657,7 +1670,7 @@ interface BradleyTerrySparseFit extends BradleyTerryFit {
    * has the prior SD, as in `bradleyTerry`.
    */
   readonly se: number[];
-  /** The number of MM steps. */
+  /** The number of Newton steps. */
   readonly iterations: number;
   /**
    * True when `bound` is the tolerance or less, or when the gradient is at the rounding level of floating point. At the
@@ -1825,5 +1838,5 @@ interface PairChoice {
  * function gives `undefined` when there is no permitted pair. Each step has its own stream of the seed.
  */
 export declare function choosePair<T extends RatedItem>(items: readonly T[], options: PairChoiceOptions<T>): PairChoice | undefined;
-export { type BinomialSide, type BootstrapOptions, type BradleyTerryFit, type BradleyTerryOptions, type BradleyTerrySparseFit, type BradleyTerrySparseOptions, type CalibrationLevel, type CategoricalDimension, type CompareOptions, type Comparison, type ContinuousDimension, type Corrected, type CountInterval, type CoverageBar, type CoverageCell, type CoverageMinSample, type CoverageReason, type CoverageStep, type Effect, type EloOptions, type EloReplayOptions, type EloUpdate, type Forecast, type Glicko2Game, type Glicko2Options, type Glicko2Rating, type Glicko2ReplayOptions, type Interval, type Kappa, type LeastSquaresFit, type LeastSquaresOptions, type MedianInterval, type ModeOptions, type NoiseOptions, type NoiseState, type NoiseVerdict, type OptionFloorOptions, type OrdinalDimension, type PairChoice, type PairChoiceOptions, type PairComparison, type PairOutcome, type PairProbabilities, type ParsedResponseRecord, type PermutationOptions, type PermutationResult, type Proportion, type QuantileInterval, type QuantileMethod, type RatedItem, type RatingFit, type RatingFitOptions, type RatingModel, type RatingModelChoice, type RatingModelOptions, type RatingModelScore, type RatingScale, type ResponseAbsentPoint, type ResponseBand, type ResponseCurvePoint, type ResponseData, type ResponseDimension, type ResponseDimensionBase, type ResponseFactor, type ResponseFault, type ResponseFitOptions, type ResponseFold, type ResponseFoldError, type ResponseHeldOutError, type ResponseInputValue, type ResponseMeasure, type ResponseModel, type ResponseModelBase, type ResponsePoint, type ResponseReason, type ResponseRecord, type ResponseSlice, type ResponseSliceOptions, type ResponseSlicePoint, type ResponseSurface, type ResponseSurfaceAbsentPoint, type ResponseSurfaceOptions, type ResponseSurfacePoint, type ResponseTableCell, type ResponseValue, type ResponseViewOptions, type ResponseWhen, type RidgeInput, type RidgeInputBase, type RidgeLevelInput, type RidgeNumberInput, type RidgeOptions, type RidgeRankInput, type RidgeResponseModel, type RidgeTerm, type RunningSummary, type SampleTotalOptions, type SideP, type SignFlipOptions, type SignFlipResult, type SmoothLaw, type SmoothLawScore, type SobolIndex, type SobolIndices, type SobolOptions, type Summary, type TableResponseModel, type TieModel, type TwoSamplePermutationOptions, type TwoSamplePermutationResult, type UStatisticInterval, type UStatisticMean, type UStatisticMethod, type UStatisticOptions, normalCdf, normalQuantile };
+export { type BinomialSide, type BootstrapOptions, type BradleyTerryFit, type BradleyTerryOptions, type BradleyTerrySparseFit, type BradleyTerrySparseOptions, type BradleyTerryStart, type CalibrationLevel, type CategoricalDimension, type CompareOptions, type Comparison, type ContinuousDimension, type Corrected, type CountInterval, type CoverageBar, type CoverageCell, type CoverageMinSample, type CoverageReason, type CoverageStep, type Effect, type EloOptions, type EloReplayOptions, type EloUpdate, type Forecast, type Glicko2Game, type Glicko2Options, type Glicko2Rating, type Glicko2ReplayOptions, type Interval, type Kappa, type LeastSquaresFit, type LeastSquaresOptions, type MedianInterval, type ModeOptions, type NoiseOptions, type NoiseState, type NoiseVerdict, type OptionFloorOptions, type OrdinalDimension, type PairChoice, type PairChoiceOptions, type PairComparison, type PairOutcome, type PairProbabilities, type ParsedResponseRecord, type PermutationOptions, type PermutationResult, type Proportion, type QuantileInterval, type QuantileMethod, type RatedItem, type RatingFit, type RatingFitOptions, type RatingModel, type RatingModelChoice, type RatingModelOptions, type RatingModelScore, type RatingScale, type ResponseAbsentPoint, type ResponseBand, type ResponseCurvePoint, type ResponseData, type ResponseDimension, type ResponseDimensionBase, type ResponseFactor, type ResponseFault, type ResponseFitOptions, type ResponseFold, type ResponseFoldError, type ResponseHeldOutError, type ResponseInputValue, type ResponseMeasure, type ResponseModel, type ResponseModelBase, type ResponsePoint, type ResponseReason, type ResponseRecord, type ResponseSlice, type ResponseSliceOptions, type ResponseSlicePoint, type ResponseSurface, type ResponseSurfaceAbsentPoint, type ResponseSurfaceOptions, type ResponseSurfacePoint, type ResponseTableCell, type ResponseValue, type ResponseViewOptions, type ResponseWhen, type RidgeInput, type RidgeInputBase, type RidgeLevelInput, type RidgeNumberInput, type RidgeOptions, type RidgeRankInput, type RidgeResponseModel, type RidgeTerm, type RunningSummary, type SampleTotalOptions, type SideP, type SignFlipOptions, type SignFlipResult, type SmoothLaw, type SmoothLawScore, type SobolIndex, type SobolIndices, type SobolOptions, type Summary, type TableResponseModel, type TieModel, type TwoSamplePermutationOptions, type TwoSamplePermutationResult, type UStatisticInterval, type UStatisticMean, type UStatisticMethod, type UStatisticOptions, normalCdf, normalQuantile };
 //# 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/running.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","../src/bradley-terry-sparse.ts","../src/rating-models.ts","../src/pair-choice.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/describe.ts","../src/running.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","../src/bradley-terry-sparse.ts","../src/rating-models.ts","../src/pair-choice.ts"],"mappings":"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"}

package/build/index.js

@@ -3842,8 +3842,28 @@ 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;
+/**
+* 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 = [];
@@ -3888,6 +3908,7 @@ function bradleyTerry(items, comparisons, options = {}) {
 	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);
@@ -3914,7 +3936,7 @@ function bradleyTerry(items, comparisons, options = {}) {
 		let next = moved(x, step, t);
 		let nextValue = objective(model, next);
 		const slack = ROUNDING$1 * (Math.abs(value) + 1);
-		for (let h = 0; h < HALVINGS && !(nextValue <= value + ARMIJO * t * slope + slack); h++) {
+		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);
@@ -4057,10 +4079,30 @@ function inverseDiagonal(hessian, k) {
 	return out;
 }
 // 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}.`);
 }
@@ -4161,22 +4203,149 @@ function outcomes(d, logNu, out) {
 	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);
+}
 /**
-* The minimum over `z` of `s * exp(z) + tau * (lambda + z) ^ 2 / 2 - t * z`: the root of
-* `s * exp(z) + tau * z = t - tau * lambda`. The left side increases and is convex. Newton steps from a point right of
-* the root thus go down to the root, and they do not go past it.
+* 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 tieStep(s, t, tau, lambda) {
-	const c = t - tau * lambda;
-	if (s === 0) return c / tau;
-	let z = c > 0 ? Math.max(0, Math.log(c / s)) : 0;
-	for (let step = 0; step < 200; step++) {
-		const ez = s * Math.exp(z);
-		const move = (ez + tau * z - c) / (ez + tau);
-		z -= move;
-		if (!(Math.abs(move) > ROUNDING * (1 + Math.abs(z)))) break;
+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;
 	}
-	return z;
+	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
@@ -4189,7 +4358,7 @@ function bradleyTerrySparse(items, comparisons, options = {}) {
 	const priorSd = options.priorSd ?? 1;
 	const ties = options.ties ?? "davidson";
 	const tiePriorSd = options.tiePriorSd ?? 10;
-	const maxIterations = options.maxIterations ?? 1e4;
+	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);
@@ -4197,88 +4366,74 @@ function bradleyTerrySparse(items, comparisons, options = {}) {
 	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);
-	const { group, size, count: groupCount } = groupsOf(items, pairs);
-	const p = 1 / (priorSd * priorSd);
-	const tau = 1 / (tiePriorSd * tiePriorSd);
 	let tieWeight = 0;
 	let totalWeight = 0;
-	const weight = new Float64Array(items);
 	for (let q = 0; q < pairs.count; q++) {
 		tieWeight += pairs.ties[q];
 		totalWeight += pairs.total[q];
-		weight[pairs.low[q]] = weight[pairs.low[q]] + pairs.total[q];
-		weight[pairs.high[q]] = weight[pairs.high[q]] + pairs.total[q];
 	}
-	const fitTie = tieWeight > 0;
-	const smallest = fitTie ? Math.min(p, tau) : p;
+	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);
-	const s = new Float64Array(items).fill(priorMean);
-	const gradient = new Float64Array(items);
-	const sums = new Float64Array(groupCount);
+	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);
-	let lambda = 0;
+	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 = Number.POSITIVE_INFINITY;
-	let rounded = false;
-	for (;;) {
-		const logNu = fitTie ? lambda : Number.NEGATIVE_INFINITY;
-		for (let i = 0; i < items; i++) gradient[i] = p * (s[i] - priorMean);
-		let tieGradient = fitTie ? tau * lambda - tieWeight : 0;
-		for (let q = 0; q < pairs.count; q++) {
-			const lo = pairs.low[q];
-			const hi = pairs.high[q];
-			const total = pairs.total[q];
-			outcomes(s[lo] - s[hi], logNu, out);
-			const g = total * ((out[0] - out[1]) / 2) - pairs.net[q] / 2;
-			gradient[lo] = gradient[lo] + g;
-			gradient[hi] = gradient[hi] - g;
-			if (fitTie) tieGradient += total * out[2];
-		}
-		let norm = tieGradient * tieGradient;
-		for (let i = 0; i < items; i++) norm += gradient[i] ** 2;
-		norm = Math.sqrt(norm);
-		bound = norm / smallest;
-		rounded = norm <= floor;
-		if (bound <= tolerance || rounded || iterations >= maxIterations) break;
+	let bound = current.norm / smallest;
+	let rounded = current.norm <= floor;
+	while (!(bound <= tolerance || rounded) && iterations < maxIterations) {
 		iterations++;
-		for (let i = 0; i < items; i++) s[i] = s[i] - gradient[i] / (weight[i] / 2 + p);
-		sums.fill(0);
-		for (let i = 0; i < items; i++) sums[group[i]] = sums[group[i]] + s[i];
-		for (let i = 0; i < items; i++) s[i] = s[i] + priorMean - sums[group[i]] / size[group[i]];
-		if (fitTie) {
-			let expected = 0;
-			for (let q = 0; q < pairs.count; q++) {
-				outcomes(s[pairs.low[q]] - s[pairs.high[q]], lambda, out);
-				expected += pairs.total[q] * out[2];
-			}
-			lambda += tieStep(expected, tieWeight, tau, lambda);
+		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 logNu = fitTie ? lambda : Number.NEGATIVE_INFINITY;
-	const diagonal = new Float64Array(items).fill(p);
-	let logLikelihood = 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 d = s[lo] - s[hi];
-		outcomes(d, logNu, out);
-		const half = (out[0] - out[1]) / 2;
-		const curvature = total * ((out[0] + out[1]) / 4 - half * half);
-		diagonal[lo] = diagonal[lo] + curvature;
-		diagonal[hi] = diagonal[hi] + curvature;
-		logLikelihood += pairs.net[q] / 2 * d - total * out[3] + (fitTie ? pairs.ties[q] * lambda : 0);
-	}
-	const se = Array.from(s, (_, i) => {
+	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) / diagonal[i]);
+		return Math.sqrt(1 / (n * p) + (1 - 1 / n) / current.diagonal[i]);
 	});
 	return {
-		strengths: Array.from(s),
+		strengths: Array.from(current.s),
 		se,
-		tie: fitTie ? Math.exp(lambda) : 0,
-		logLikelihood,
+		tie: problem.fitTie ? Math.exp(current.lambda) : 0,
+		logLikelihood: current.logLikelihood,
 		iterations,
 		converged: bound <= tolerance || rounded,
 		bound,