@mark1russell7/rigor-statistics 0.1.7 → 0.1.9

package/build/index.js

@@ -533,6 +533,10 @@ function predictScaled(model, inputs) {
 	for (const term of model.terms) sum += term.weight * product(term.factors, at, inputs);
 	return sum + 0;
 }
+/** This function changes a measured value to the scale of a model. A log scale with a floor lifts each smaller value. */
+function toModelScale(value, log, floor) {
+	return log ? Math.log10(Math.max(value, floor ?? value)) : value;
+}
 /** This function changes a value from the scale of the model to the scale of the measure. */
 function unscale(model, value) {
 	return model.scale === "log" ? 10 ** value : value;
@@ -581,6 +585,67 @@ function heldOutError(record, measure) {
 		skill: baselineMae > 0 ? 1 - mae / baselineMae : null
 	};
 }
+/** This function gives the stored predictions of a measure in a fold. A fold with no predictions gives `undefined`. */
+function predictionsOf(fold, measure) {
+	return fold.predictions !== void 0 && Object.hasOwn(fold.predictions, measure) ? fold.predictions[measure] : void 0;
+}
+/**
+* This function gives the held-out error of a chosen set of points, on the scale of the model. It uses the stored
+* predictions of the option `outOfFold`. Thus a reader can get the error of one cell. The result has the fields of
+* `heldOutError`, and the set of all the points gives the same values to the rounding of the sums.
+*
+* Each point counts at most once. A point with no value of the measure, or with no prediction, adds nothing to `n`.
+* The baseline of a point is the mean of the training points of its fold.
+*
+* The function throws a RangeError for an unknown measure and for a record with no predictions of the measure. It
+* also throws for an unknown id, for a repeated id, and for a set with no point to score.
+*/
+function heldOutErrorAt(record, measure, ids) {
+	const model = record.models.find((m) => m.measure === measure);
+	if (model === void 0) throw new RangeError(`heldOutErrorAt: the record has no model of the measure "${measure}".`);
+	if (!record.folds.some((fold) => predictionsOf(fold, measure) !== void 0)) throw new RangeError(`heldOutErrorAt: the record has no predictions of the measure "${measure}". Fit it with the option outOfFold.`);
+	const chosen = new Set(ids);
+	if (chosen.size !== ids.length) throw new RangeError("heldOutErrorAt: the list of ids has a repeated id.");
+	const points = new Map(record.points.map((p) => [p.id, p]));
+	for (const id of ids) if (!points.has(id)) throw new RangeError(`heldOutErrorAt: the record has no point "${id}".`);
+	const scaled = (point) => {
+		const value = point.measures[measure];
+		return typeof value === "number" ? toModelScale(value, model.scale === "log", model.floor) : void 0;
+	};
+	let n = 0;
+	let folds = 0;
+	let absolute = 0;
+	let square = 0;
+	let baselineSum = 0;
+	for (const fold of record.folds) {
+		const predicted = predictionsOf(fold, measure);
+		if (predicted === void 0) continue;
+		const scored = fold.heldOut.filter((id) => chosen.has(id) && Object.hasOwn(predicted, id));
+		if (scored.length === 0) continue;
+		const held = new Set(fold.heldOut);
+		const baseline = mean(record.points.flatMap((p) => held.has(p.id) || scaled(p) === void 0 ? [] : [scaled(p)]));
+		folds += 1;
+		for (const id of scored) {
+			const y = scaled(points.get(id));
+			const error = y - predicted[id];
+			n += 1;
+			absolute += Math.abs(error);
+			square += error * error;
+			baselineSum += Math.abs(y - baseline);
+		}
+	}
+	if (n === 0) throw new RangeError(`heldOutErrorAt: no chosen point has a prediction of the measure "${measure}".`);
+	const mae = absolute / n;
+	const baselineMae = baselineSum / n;
+	return {
+		n,
+		folds,
+		mae,
+		rmse: Math.sqrt(square / n),
+		baselineMae,
+		skill: baselineMae > 0 ? 1 - mae / baselineMae : null
+	};
+}
 /**
 * This function gives the usual value of a dimension: a measured median, or the most common level among `among`. A
 * tie gives the first level. A dimension with no measured value gives its low end or its first level.
@@ -652,6 +717,12 @@ function heldValues(name, record, vary, hold, needed) {
 	};
 	return Object.fromEntries(others.map((d) => [d.id, valueOf(d)]));
 }
+/** This function refuses a bad option `steps`. */
+function checkSteps(name, steps) {
+	if (!Number.isSafeInteger(steps) || steps < 2) throw new RangeError(`${name}: steps is a whole number of 2 or more, not ${steps}.`);
+}
+/** This function gives a value inside a range. */
+const clip = (value, [low, high]) => Math.min(high, Math.max(low, value));
 /** This function gives the values of an axis: each level, or `steps` equal distances on the scale of the dimension. */
 function axisValues(dimension, steps) {
 	if (dimension.kind !== "continuous") return dimension.levels;
@@ -674,7 +745,7 @@ function matches(dimension, value, held, tolerance) {
 /** This function examines the request of a view, and it gives the parts that the two views share. */
 function frameOf(name, record, measure, vary, options) {
 	const { hold = {}, steps = 33, tolerance = 0, width = 1 } = options;
-	if (!Number.isSafeInteger(steps) || steps < 2) throw new RangeError(`${name}: steps is a whole number of 2 or more, not ${steps}.`);
+	checkSteps(name, steps);
 	if (!(Number.isFinite(tolerance) && tolerance >= 0)) throw new RangeError(`${name}: tolerance is a finite number of 0 or more, not ${tolerance}.`);
 	if (!(Number.isFinite(width) && width >= 0)) throw new RangeError(`${name}: width is a finite number of 0 or more, not ${width}.`);
 	const model = record.models.find((m) => m.measure === measure);
@@ -695,33 +766,51 @@ function frameOf(name, record, measure, vary, options) {
 	}
 	const others = record.dimensions.filter((d) => !vary.includes(d.id));
 	const held = heldValues(name, record, vary, hold, neededLevels(name, varied, vary));
-	const matched = record.points.filter((p) => typeof p.measures[measure] === "number" && vary.every((id) => p.values[id] !== null) && others.every((d) => matches(d, p.values[d.id], whenHolds(d, p.values) ? held[d.id] : null, tolerance)));
+	const placed = record.points.filter((p) => vary.every((id) => p.values[id] !== null) && others.every((d) => matches(d, p.values[d.id], whenHolds(d, p.values) ? held[d.id] : null, tolerance)));
+	const matched = placed.filter((p) => typeof p.measures[measure] === "number");
+	const missing = placed.filter((p) => typeof p.measures[measure] !== "number");
 	const error = heldOutError(record, measure);
 	const nearest = nearestOf(record.dimensions, record.points, measure);
+	const range = record.measures.find((m) => m.id === measure)?.range;
 	const band = (inputs) => {
 		const place = Object.fromEntries(record.dimensions.map((d) => [d.id, whenHolds(d, inputs) ? inputs[d.id] : null]));
 		const value = predictScaled(model, place);
-		return {
+		const fitted = {
 			value: unscale(model, value),
 			low: unscale(model, value - width * error.rmse),
-			high: unscale(model, value + width * error.rmse),
-			nearest: nearest(place)
+			high: unscale(model, value + width * error.rmse)
+		};
+		const inside = range === void 0 ? fitted : {
+			value: clip(fitted.value, range),
+			low: clip(fitted.low, range),
+			high: clip(fitted.high, range)
+		};
+		const moved = inside.value !== fitted.value || inside.low !== fitted.low || inside.high !== fitted.high;
+		return {
+			...inside,
+			nearest: nearest(place),
+			...moved ? { clipped: true } : {}
 		};
 	};
 	return {
 		held,
 		axes: varied.map((d) => axisValues(d, steps)),
 		matched,
+		missing,
 		error,
 		band
 	};
 }
 /** This function gives the group field of a measured point of a view. */
 const groupOf = (point) => point.group === void 0 ? {} : { group: point.group };
+/** This function gives the declared reason of a point with no value of a measure, or `null` for no stated reason. */
+const reasonOf = (point, measure) => point.absent !== void 0 && Object.hasOwn(point.absent, measure) ? point.absent[measure] : null;
 /**
 * This function gives a view of a measure over one dimension of a parsed record:
 * - `curve`: the fitted value at each level, or at `steps` values of a continuous dimension, with its band.
 * - `points`: the measured points that match the held values. This list is empty when no point matches them.
+* - `absent`: the points that match the held values and have no value of the measure, each with its reason. A chart
+*   can draw each reason apart.
 * - `held`: the value of each other dimension.
 * - `error`: the held-out error.
 *
@@ -740,30 +829,42 @@ const groupOf = (point) => point.group === void 0 ? {} : { group: point.group };
 * distance is on the log scale of the model, so the band is a ratio. The band has one width along all the curve. The
 * band is the mean error of the model, and `nearest` tells how far the place is from a measurement.
 *
+* A measure with a `range` keeps each place inside it. The fields `value`, `low` and `high` move to the nearest end.
+* The place then has the field `clipped`, and the field `clipped` of the view counts these places. The function
+* `predictResponse` gives the value that the model fitted.
+*
 * The function throws a RangeError for an unknown measure or dimension, and for a held value that is not good for its
 * dimension. It also throws for a dimension that is both varied and held, and for a bad option.
 */
 function sliceResponse(record, measure, options) {
 	const { vary } = options;
-	const { held, axes, matched, error, band } = frameOf("sliceResponse", record, measure, [vary], options);
+	const { held, axes, matched, missing, error, band } = frameOf("sliceResponse", record, measure, [vary], options);
+	const curve = axes[0].map((at) => ({
+		at,
+		...band({
+			...held,
+			[vary]: at
+		})
+	}));
 	return {
 		measure,
 		vary,
 		held,
-		curve: axes[0].map((at) => ({
-			at,
-			...band({
-				...held,
-				[vary]: at
-			})
-		})),
+		curve,
 		points: matched.map((p) => ({
 			id: p.id,
 			at: p.values[vary],
 			value: p.measures[measure],
 			...groupOf(p)
 		})),
-		error
+		absent: missing.map((p) => ({
+			id: p.id,
+			at: p.values[vary],
+			reason: reasonOf(p, measure),
+			...groupOf(p)
+		})),
+		error,
+		clipped: curve.filter((place) => place.clipped === true).length
 	};
 }
 /**
@@ -775,29 +876,54 @@ function sliceResponse(record, measure, options) {
 function surfaceResponse(record, measure, options) {
 	const { vary } = options;
 	const [xId, yId] = vary;
-	const { held, axes, matched, error, band } = frameOf("surfaceResponse", record, measure, vary, options);
+	const { held, axes, matched, missing, error, band } = frameOf("surfaceResponse", record, measure, vary, options);
 	const x = axes[0];
 	const y = axes[1];
+	const cells = y.map((b) => x.map((a) => band({
+		...held,
+		[xId]: a,
+		[yId]: b
+	})));
 	return {
 		measure,
 		vary,
 		held,
 		x,
 		y,
-		cells: y.map((b) => x.map((a) => band({
-			...held,
-			[xId]: a,
-			[yId]: b
-		}))),
+		cells,
 		points: matched.map((p) => ({
 			id: p.id,
 			at: [p.values[xId], p.values[yId]],
 			value: p.measures[measure],
 			...groupOf(p)
 		})),
-		error
+		absent: missing.map((p) => ({
+			id: p.id,
+			at: [p.values[xId], p.values[yId]],
+			reason: reasonOf(p, measure),
+			...groupOf(p)
+		})),
+		error,
+		clipped: cells.flat().filter((place) => place.clipped === true).length
 	};
 }
+/**
+* This function gives the number of fitted places of a view before the view starts: the product of the lengths of its
+* axes. A level axis counts its levels, and a continuous axis counts `steps`. The field `nearest` reads each point at
+* each place, so the reads of a view are this count times the number of points. The default of `steps` is the default
+* of a view. The function throws a RangeError for an unknown dimension, for one dimension named two times, and for a
+* bad `steps`.
+*/
+function responseCells(record, vary, steps = 33) {
+	checkSteps("responseCells", steps);
+	const ids = typeof vary === "string" ? [vary] : vary;
+	if (new Set(ids).size !== ids.length) throw new RangeError(`responseCells: the two varied dimensions are one dimension, "${ids[0]}".`);
+	return ids.reduce((count, id) => {
+		const dimension = record.dimensions.find((d) => d.id === id);
+		if (dimension === void 0) throw new RangeError(`responseCells: the record has no dimension "${id}".`);
+		return count * (dimension.kind === "continuous" ? steps : dimension.levels.length);
+	}, 1);
+}
 // src/response-parse.ts
 /**
 * The validator of the format `response-records/1`. The functions here read unknown data and write faults. Thus a page
@@ -901,9 +1027,7 @@ function checkDimension(value, path, faults) {
 		need(!Object.hasOwn(object, "levels"), at(path, "levels"), "a continuous dimension has a range, not levels.", faults);
 		need(!Object.hasOwn(object, "range") || !log || !isNumber(peek(object["range"], "0")) || peek(object["range"], "0") > 0, at(path, "range"), "a log dimension has a range above 0.", faults);
 		need(Object.hasOwn(object, "range"), at(path, "range"), "this field is missing.", faults);
-		const range = object["range"];
-		const good = Array.isArray(range) && range.length === 2 && isNumber(range[0]) && isNumber(range[1]) && range[0] < range[1];
-		if (Object.hasOwn(object, "range")) need(good, at(path, "range"), `this is a low and a high finite number, with low less than high, not ${shown(range)}.`, faults);
+		if (Object.hasOwn(object, "range")) checkRange(object["range"], at(path, "range"), faults);
 	} else if (kind === "ordinal" || kind === "categorical") {
 		need(!Object.hasOwn(object, "range"), at(path, "range"), `a dimension of the kind ${kind} has levels, not a range.`, faults);
 		need(kind === "ordinal" || !Object.hasOwn(object, "log"), at(path, "log"), "a categorical dimension has no log scale.", faults);
@@ -937,6 +1061,10 @@ function checkWhen(value, path, dimensions, faults) {
 	if (!Array.isArray(known)) return;
 	levels.forEach((level, i) => need(known.includes(level), `${at(path, "levels")}[${i}]`, `the dimension ${shown(id)} has no level ${shown(level)}.`, faults));
 }
+/** This function examines a range. */
+function checkRange(range, path, faults) {
+	need(Array.isArray(range) && range.length === 2 && isNumber(range[0]) && isNumber(range[1]) && range[0] < range[1], path, `this is a low and a high finite number, with low less than high, not ${shown(range)}.`, faults);
+}
 /** This function examines one measure. */
 function checkMeasure(value, path, faults) {
 	const object = fields(value, path, [
@@ -944,20 +1072,46 @@ function checkMeasure(value, path, faults) {
 		"label",
 		"unit",
 		"direction"
-	], [], faults);
+	], ["range"], faults);
 	if (object === void 0) return;
 	check(object, "id", path, isId, "text with one character or more", faults);
 	check(object, "label", path, isString, "text", faults);
 	check(object, "unit", path, isString, "text", faults);
 	check(object, "direction", path, (v) => v === "higher" || v === "lower" || v === "none", `"higher", "lower" or "none"`, faults);
+	if (Object.hasOwn(object, "range")) checkRange(object["range"], at(path, "range"), faults);
+}
+/** This function refuses a measured value outside the range of its measure. */
+function checkMeasured(point, path, measures, faults) {
+	for (const { id, range } of measures) {
+		const value = peek(peek(point, "measures"), id);
+		if (range === void 0 || typeof value !== "number") continue;
+		need(value >= range[0] && value <= range[1], at(at(path, "measures"), id), `this value is outside the range of the measure, [${range[0]}, ${range[1]}].`, faults);
+	}
 }
-/** This function examines one point, with the dimensions and the measures of the record. */
-function checkPoint(value, path, dimensions, measures, faults) {
+/** This function examines one declared reason. */
+function checkReason(value, path, faults) {
+	const object = fields(value, path, ["id", "label"], [], faults);
+	if (object === void 0) return;
+	check(object, "id", path, isId, "text with one character or more", faults);
+	check(object, "label", path, isString, "text", faults);
+}
+/** This function examines the reasons of a point: each has a declaration, and each is on a measure with no number. */
+function checkAbsent(value, path, measuresOfPoint, measures, reasons, faults) {
+	const absent = fields(value, path, [], [...measures], faults);
+	if (absent === void 0) return;
+	for (const measure of measures) {
+		if (!Object.hasOwn(absent, measure)) continue;
+		need(reasons.has(absent[measure]), at(path, measure), `the record declares no reason ${shown(absent[measure])}.`, faults);
+		need(typeof peek(measuresOfPoint, measure) !== "number", at(path, measure), "this measure has a number, so it has no reason.", faults);
+	}
+}
+/** This function examines one point, with the dimensions, the measures and the reasons of the record. */
+function checkPoint(value, path, dimensions, measures, reasons, faults) {
 	const object = fields(value, path, [
 		"id",
 		"values",
 		"measures"
-	], ["group"], faults);
+	], ["group", "absent"], faults);
 	if (object === void 0) return;
 	check(object, "id", path, isId, "text with one character or more", faults);
 	check(object, "group", path, isId, "text with one character or more", faults);
@@ -982,6 +1136,7 @@ function checkPoint(value, path, dimensions, measures, faults) {
 			else need(present, at(inside, dimension.id), `this is null when the dimension "${parent}" is ${shown(values[parent])}.`, faults);
 		}
 	}
+	if (Object.hasOwn(object, "absent")) checkAbsent(object["absent"], at(path, "absent"), object["measures"], measures, reasons, faults);
 	if (Object.hasOwn(object, "measures")) {
 		const inside = at(path, "measures");
 		const values = fields(object["measures"], inside, [...measures], [], faults);
@@ -1003,7 +1158,7 @@ function responseDataFaults(value, required, optional) {
 		"measures",
 		"points",
 		...required
-	], optional, faults);
+	], ["reasons", ...optional], faults);
 	if (object === void 0) return faults;
 	check(object, "schema", "", (v) => v === RESPONSE_RECORDS_SCHEMA, `"${RESPONSE_RECORDS_SCHEMA}"`, faults);
 	check(object, "name", "", isId, "text with one character or more", faults);
@@ -1016,10 +1171,15 @@ function responseDataFaults(value, required, optional) {
 	const measures = Object.hasOwn(object, "measures") ? list(object["measures"], "measures", 1, faults) : [];
 	measures.forEach((m, i) => checkMeasure(m, `measures[${i}]`, faults));
 	const measureIds = uniqueIds(measures, "measures", faults);
+	const reasons = Object.hasOwn(object, "reasons") ? list(object["reasons"], "reasons", 0, faults) : [];
+	reasons.forEach((r, i) => checkReason(r, `reasons[${i}]`, faults));
+	const reasonIds = uniqueIds(reasons, "reasons", faults);
 	if (faults.length > 0) return faults;
 	const points = list(object["points"], "points", 1, faults);
-	points.forEach((p, i) => checkPoint(p, `points[${i}]`, dimensions, measureIds, faults));
+	points.forEach((p, i) => checkPoint(p, `points[${i}]`, dimensions, measureIds, reasonIds, faults));
 	uniqueIds(points, "points", faults);
+	if (faults.length > 0) return faults;
+	points.forEach((p, i) => checkMeasured(p, `points[${i}]`, measures, faults));
 	return faults;
 }
 /** This function examines one input of a ridge model against the dimensions of the record. */
@@ -1230,6 +1390,24 @@ function checkFoldError(value, path, count, faults) {
 		"baselineMae"
 	]) check(object, key, path, isNotNegative, "a finite number of 0 or more", faults);
 }
+/** This function examines the stored predictions of a fold against its held-out points and its errors. */
+function checkPredictions(value, path, held, errors, measures, faults) {
+	const predictions = fields(value, path, [], measures, faults);
+	if (predictions === void 0) return;
+	for (const measure of measures) {
+		if (!Object.hasOwn(predictions, measure)) continue;
+		const inside = at(path, measure);
+		const stored = fields(predictions[measure], inside, [], Object.keys(peek(predictions, measure) ?? {}), faults);
+		if (stored === void 0) continue;
+		need(peek(errors, measure) !== void 0, inside, "this fold has no error of this measure.", faults);
+		const scored = new Set(held.filter((p) => typeof p.measures[measure] === "number").map((p) => p.id));
+		for (const id of Object.keys(stored)) {
+			need(scored.has(id), at(inside, id), `this fold has no held-out point ${shown(id)} with a value of the measure.`, faults);
+			check(stored, id, inside, isNumber, "a finite number", faults);
+		}
+		for (const id of scored) need(Object.hasOwn(stored, id), at(inside, id), "this held-out point has no prediction.", faults);
+	}
+}
 /** This function adds the points of a fold to `foldOfPoint`, and it gives them. Each bad id gives a fault. */
 function heldPoints(value, path, f, points, foldOfPoint, faults) {
 	const held = [];
@@ -1265,15 +1443,18 @@ function checkFolds(value, data, faults) {
 	const sizes = groupSizes(data.points);
 	const foldOfPoint = /* @__PURE__ */ new Map();
 	const covered = /* @__PURE__ */ new Set();
-	list(value, "folds", 1, faults).forEach((item, f) => {
+	const folds = list(value, "folds", 1, faults);
+	const predicted = measures.filter((m) => folds.some((fold) => peek(peek(fold, "predictions"), m) !== void 0));
+	folds.forEach((item, f) => {
 		const path = `folds[${f}]`;
-		const object = fields(item, path, ["heldOut", "errors"], [], faults);
+		const object = fields(item, path, ["heldOut", "errors"], ["predictions"], faults);
 		if (object === void 0) return;
 		const held = Object.hasOwn(object, "heldOut") ? heldPoints(object["heldOut"], at(path, "heldOut"), f, points, foldOfPoint, faults) : [];
 		for (const [group, count] of groupSizes(held)) {
 			const size = sizes.get(group);
 			need(count === size, at(path, "heldOut"), `the ${group} has ${count} of its ${size} points in this fold, so it is on both sides of the split.`, faults);
 		}
+		if (Object.hasOwn(object, "predictions")) checkPredictions(object["predictions"], at(path, "predictions"), held, object["errors"], measures, faults);
 		if (!Object.hasOwn(object, "errors")) return;
 		const errors = fields(object["errors"], at(path, "errors"), [], measures, faults);
 		if (errors === void 0) return;
@@ -1282,6 +1463,7 @@ function checkFolds(value, data, faults) {
 			const count = held.filter((p) => p.measures[measure] !== null).length;
 			checkFoldError(errors[measure], at(at(path, "errors"), measure), count, faults);
 			if (count > 0) covered.add(measure);
+			need(!predicted.includes(measure) || peek(object["predictions"], measure) !== void 0, at(path, "predictions"), `another fold has predictions of the measure "${measure}", so this fold needs them too.`, faults);
 		}
 	});
 	for (const measure of measures) need(covered.has(measure), "folds", `no fold has a held-out error of the measure "${measure}".`, faults);
@@ -1300,6 +1482,15 @@ function checkFolds(value, data, faults) {
 * - All the points of a group are in one fold, or all are in no fold. Thus no group is on both sides of a split.
 * - The count `n` of an error is the number of held-out points with a value of the measure.
 * - Each measure has an error in one fold or more.
+*
+* These rules apply to the predictions of a fold:
+* - Each prediction is a finite number of a held-out point of the fold with a value of the measure.
+* - The fold has a prediction of each such point, and an error of the measure.
+* - When one fold has predictions of a measure, each fold with an error of the measure has them.
+*
+* These rules apply to the reasons of a point:
+* - Each reason is on a known measure with no number. A measure with `null` and no reason is good.
+* - Each reason has a declaration in the field `reasons` of the record.
 */
 function parseResponseRecord(value) {
 	try {
@@ -1433,6 +1624,15 @@ function expansion(dimensions, degree, interactions) {
 	});
 	return terms;
 }
+/** This function gives the terms that are not 0 at one point or more. A fold gives a term with no point the weight 0. */
+function seenTerms(terms, dimensions, points) {
+	const inputs = checkedInputs(dimensions, terms);
+	const places = points.map((point) => ({
+		at: coordinates(inputs, point.values),
+		values: point.values
+	}));
+	return terms.filter((term) => places.some(({ at, values }) => product(term, at, values) !== 0));
+}
 /** This function gives the inputs of a ridge fit: one for each dimension of a term. It throws for a bad term. */
 function checkedInputs(dimensions, terms) {
 	const used = new Set(terms.flatMap((t) => t.map((f) => f.dimension)));
@@ -1550,19 +1750,23 @@ function tableLearner(rows, dimensions) {
 		return (r) => cells.get(keys[r]) ?? fallback;
 	};
 }
-/** This function gives the error of a fold. A fold with no held-out row or no training row has no error. */
-function foldError(rows, fold, learner) {
+/** This function gives the score of a fold. A fold with no held-out row or no training row has no score. */
+function foldScore(rows, fold, learner) {
 	const train = rows.filter((row) => row.fold !== fold).map((row) => row.y);
 	const held = rows.flatMap((row, r) => row.fold === fold ? [r] : []);
 	if (held.length === 0 || train.length === 0) return void 0;
 	const predict = learner(fold);
 	const baseline = mean(train);
-	const errors = held.map((r) => rows[r].y - predict(r));
+	const predicted = held.map((r) => predict(r));
+	const errors = held.map((r, i) => rows[r].y - predicted[i]);
 	return {
-		n: held.length,
-		mae: mean(errors.map(Math.abs)),
-		rmse: Math.sqrt(mean(errors.map((e) => e * e))),
-		baselineMae: mean(held.map((r) => Math.abs(rows[r].y - baseline)))
+		error: {
+			n: held.length,
+			mae: mean(errors.map(Math.abs)),
+			rmse: Math.sqrt(mean(errors.map((e) => e * e))),
+			baselineMae: mean(held.map((r) => Math.abs(rows[r].y - baseline)))
+		},
+		predictions: Object.fromEntries(held.map((r, i) => [rows[r].point.id, predicted[i]]))
 	};
 }
 /** This function gives the rows of a measure. It throws a RangeError for a value that a log scale cannot read. */
@@ -1573,12 +1777,12 @@ function rowsOf(points, measure, log, floor, foldOf) {
 		if (log && floor === void 0 && value <= 0) throw new RangeError(`fitResponse: the point "${point.id}" has the value ${value} of the log measure "${measure}". Give logFloor.`);
 		return [{
 			point,
-			y: log ? Math.log10(Math.max(value, floor ?? value)) : value,
+			y: toModelScale(value, log, floor),
 			fold: foldOf.get(groupKey(point))
 		}];
 	});
 }
-/** This function gives the model of one measure on all its rows, and the error of each fold. */
+/** This function gives the model of one measure on all its rows, and the score of each fold. */
 function fitMeasure(rows, measure, log, floor, plan) {
 	if (rows.length === 0) throw new RangeError(`fitResponse: no point has a value of the measure "${measure.id}".`);
 	const base = {
@@ -1588,8 +1792,8 @@ function fitMeasure(rows, measure, log, floor, plan) {
 	};
 	const ridge = plan.kind === "ridge" ? ridgeLearner(rows, plan) : void 0;
 	const learner = ridge?.learner ?? tableLearner(rows, plan.ids);
-	const errors = Array.from({ length: plan.folds }, (_, f) => foldError(rows, f, learner));
-	if (errors.every((e) => e === void 0)) throw new RangeError(`fitResponse: all the values of the measure "${measure.id}" are in one fold. Give more groups.`);
+	const scores = Array.from({ length: plan.folds }, (_, f) => foldScore(rows, f, learner));
+	if (scores.every((s) => s === void 0)) throw new RangeError(`fitResponse: all the values of the measure "${measure.id}" are in one fold. Give more groups.`);
 	const conditional = plan.conditional.length === 0 ? {} : { conditional: plan.conditional };
 	if (ridge === void 0) return {
 		model: {
@@ -1600,7 +1804,7 @@ function fitMeasure(rows, measure, log, floor, plan) {
 			cells: tableCells(rows, plan.ids),
 			fallback: mean(rows.map((r) => r.y))
 		},
-		errors
+		scores
 	};
 	const { lambda, beta } = ridge.final();
 	if (!beta.every(Number.isFinite)) throw new RangeError(`fitResponse: the fit of the measure "${measure.id}" with lambda ${lambda} is singular. Give a larger lambda.`);
@@ -1617,7 +1821,7 @@ function fitMeasure(rows, measure, log, floor, plan) {
 			intercept: beta[0],
 			terms
 		},
-		errors
+		scores
 	};
 }
 /** This function examines the options that do not depend on the data, and it gives the number of folds and the penalties. */
@@ -1659,7 +1863,10 @@ function kindOf(dimensions, model) {
 * The penalty: each fold of a ridge fit chooses from `lambdas` with the other folds. Thus the held-out error of a
 * fold is not optimistic. The model of the record chooses with all the folds.
 *
-* The errors: a fold scores the model of the other folds on its held-out points, on the scale of the model.
+* The errors: a fold scores the model of the other folds on its held-out points, on the scale of the model. With the
+* option `outOfFold`, the fold also stores the prediction of each of these points.
+*
+* The reasons: a measure with a stated reason is `null` for the fit. The field `reasons` of the data stays in the record.
 *
 * The result does not depend on the order of the points, except for the field `points`, which keeps the order of
 * the data. The same data and options give the same bytes in one JavaScript engine.
@@ -1676,8 +1883,10 @@ function fitResponse(data, options = {}) {
 	const log = new Set(options.log ?? []);
 	for (const id of log) if (!measures.some((m) => m.id === id)) throw new RangeError(`fitResponse: the option log names the unknown measure "${id}".`);
 	const kind = kindOf(dimensions, options.model ?? "auto");
-	const terms = kind === "table" ? [] : options.terms ?? expansion(dimensions, degree, options.interactions ?? true);
-	if (terms.length + 1 > 1024) throw new RangeError(`fitResponse: the expansion has ${terms.length} terms, and the limit is 1023. Set interactions to false, or give terms.`);
+	const interactions = options.interactions ?? true;
+	const expanded = kind === "table" ? [] : options.terms ?? expansion(dimensions, degree, interactions !== false);
+	const terms = interactions === "seen" && options.terms === void 0 ? seenTerms(expanded, dimensions, data.points) : expanded;
+	if (terms.length + 1 > 1024) throw new RangeError(`fitResponse: the expansion has ${terms.length} terms, and the limit is 1023. Set interactions to false or "seen", or give terms.`);
 	const inputs = checkedInputs(dimensions, terms);
 	const points = [...data.points].sort((a, b) => byText(a.id, b.id));
 	const groups = [...new Set(points.map(groupKey))].sort(byText);
@@ -1695,18 +1904,24 @@ function fitResponse(data, options = {}) {
 		inputs
 	};
 	const fits = measures.map((m) => fitMeasure(rowsOf(points, m.id, log.has(m.id), options.logFloor, foldOf), m, log.has(m.id), options.logFloor, plan));
-	const foldRecords = Array.from({ length: folds }, (_, f) => ({
-		heldOut: points.filter((p) => foldOf.get(groupKey(p)) === f).map((p) => p.id),
-		errors: Object.fromEntries(measures.flatMap((m, i) => {
-			const error = fits[i]?.errors[f];
-			return error === void 0 ? [] : [[m.id, error]];
-		}))
-	}));
+	const foldRecords = Array.from({ length: folds }, (_, f) => {
+		const scored = measures.flatMap((m, i) => {
+			const score = fits[i]?.scores[f];
+			return score === void 0 ? [] : [[m.id, score]];
+		});
+		return {
+			heldOut: points.filter((p) => foldOf.get(groupKey(p)) === f).map((p) => p.id),
+			errors: Object.fromEntries(scored.map(([id, score]) => [id, score.error])),
+			...options.outOfFold === true ? { predictions: Object.fromEntries(scored.map(([id, score]) => [id, score.predictions])) } : {}
+		};
+	});
+	const reasons = data.reasons === void 0 ? {} : { reasons: data.reasons };
 	return {
 		schema: RESPONSE_RECORDS_SCHEMA,
 		name: data.name,
 		dimensions,
 		measures,
+		...reasons,
 		points: data.points,
 		models: fits.map((fit) => fit.model),
 		folds: foldRecords
@@ -2167,6 +2382,6 @@ function calibration(forecasts) {
 		interval: wilson(hits, n)
 	}));
 }
-export { KENDALL_EXACT, RESPONSE_LAMBDAS, RESPONSE_MAX_POWER, RESPONSE_MAX_TERMS, RESPONSE_RECORDS_SCHEMA, Z95, binomialInterval, bootstrap, bootstrapClusters, bootstrapLeastSquares, bootstrapMedian, bootstrapMedianRatio, bootstrapTwo, brier, calibration, compareRatios, fitResponse, heldOutError, holm, kendallTau, leastSquares, mean, median, medianInterval, negativeBinomialInterval, noiseFloor, noiseVerdict, pairedPermutation, parseResponseRecord, predictResponse, quantile, quantileSorted, ranks, ridgeSolve, sd, signTest, signTestPower, sliceResponse, sorted, spearman, summarize, surfaceResponse, wilson };
+export { KENDALL_EXACT, RESPONSE_LAMBDAS, RESPONSE_MAX_POWER, RESPONSE_MAX_TERMS, RESPONSE_RECORDS_SCHEMA, Z95, binomialInterval, bootstrap, bootstrapClusters, bootstrapLeastSquares, bootstrapMedian, bootstrapMedianRatio, bootstrapTwo, brier, calibration, compareRatios, fitResponse, heldOutError, heldOutErrorAt, holm, kendallTau, leastSquares, mean, median, medianInterval, negativeBinomialInterval, noiseFloor, noiseVerdict, pairedPermutation, parseResponseRecord, predictResponse, quantile, quantileSorted, ranks, responseCells, ridgeSolve, sd, signTest, signTestPower, sliceResponse, sorted, spearman, summarize, surfaceResponse, whenHolds, wilson };
 
 //# sourceMappingURL=index.js.map