@mark1russell7/rigor-statistics 0.1.7 → 0.1.8

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.
@@ -695,7 +760,9 @@ 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 band = (inputs) => {
@@ -712,16 +779,21 @@ function frameOf(name, record, measure, vary, options) {
 		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.
 *
@@ -745,7 +817,7 @@ const groupOf = (point) => point.group === void 0 ? {} : { group: point.group };
 */
 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);
 	return {
 		measure,
 		vary,
@@ -763,6 +835,12 @@ function sliceResponse(record, measure, options) {
 			value: p.measures[measure],
 			...groupOf(p)
 		})),
+		absent: missing.map((p) => ({
+			id: p.id,
+			at: p.values[vary],
+			reason: reasonOf(p, measure),
+			...groupOf(p)
+		})),
 		error
 	};
 }
@@ -775,7 +853,7 @@ 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];
 	return {
@@ -795,6 +873,12 @@ function surfaceResponse(record, measure, options) {
 			value: p.measures[measure],
 			...groupOf(p)
 		})),
+		absent: missing.map((p) => ({
+			id: p.id,
+			at: [p.values[xId], p.values[yId]],
+			reason: reasonOf(p, measure),
+			...groupOf(p)
+		})),
 		error
 	};
 }
@@ -951,13 +1035,30 @@ function checkMeasure(value, path, faults) {
 	check(object, "unit", path, isString, "text", faults);
 	check(object, "direction", path, (v) => v === "higher" || v === "lower" || v === "none", `"higher", "lower" or "none"`, 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 +1083,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 +1105,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,9 +1118,12 @@ 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);
 	return faults;
 }
@@ -1230,6 +1335,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 +1388,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 +1408,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 +1427,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 +1569,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 +1695,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 +1722,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 +1737,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 +1749,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 +1766,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 +1808,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 +1828,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 +1849,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 +2327,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, ridgeSolve, sd, signTest, signTestPower, sliceResponse, sorted, spearman, summarize, surfaceResponse, wilson };
 
 //# sourceMappingURL=index.js.map