@mark1russell7/rigor-statistics 0.1.8 → 0.1.9

package/README.md

@@ -71,6 +71,8 @@ To vary a conditional dimension, `sliceResponse` needs its parent at a level ins
 
 The band of a curve is `value ± width × RMSE`, from the held-out error of the folds. On a log scale, the band is a ratio. The band has one width along the curve. It is the mean error of the model.
 
+A measure with the field `range` keeps each view inside it, for example `[0, 1]` for a share. `sliceResponse` and `surfaceResponse` move `value`, `low` and `high` to the nearest end. Such a place has the field `clipped`, and the field `clipped` of the view counts these places. `predictResponse` gives the value that the model fitted, and a fit does not use the range. `parseResponseRecord` refuses a measured value outside the range.
+
 The field `nearest` of each place tells how far the place is from a measurement. It goes from 0 to 1, and 0 means that a point was measured there. A viewer can fade the band away from the data. A table cell with the `fallback` value has `nearest` above 0.
 
 ### The error of one cell
@@ -124,6 +126,8 @@ The default expansion has one product for each pair of levels of two dimensions.
 | `parseResponseRecord(value)` | The examination of unknown data. It gives the record, or one fault with a path for each error. |
 | `predictResponse(model, inputs)`, `heldOutError(record, measure)` | The value of a model at one set of inputs, and the error of the folds of a measure. |
 | `heldOutErrorAt(record, measure, ids)` | The held-out error of a chosen set of points, from the predictions of the option `outOfFold`. |
+| `responseCells(record, vary, steps)` | The number of fitted places of a view, level axes included. It lets a caller bound the time of a view before the view starts. |
+| `whenHolds(dimension, values)` | True when a place has the condition of a dimension. A dimension with no `when` is always present. |
 | `sliceResponse(record, measure, options)`, `surfaceResponse(record, measure, options)` | A fitted curve over one dimension, or a fitted surface over two, with the matching measured points, the matching points with no value, a band and the distance to the nearest measurement. |
 
 Each function throws a RangeError for an empty list, for a NaN and for a parameter out of its range. Thus a missing value cannot make a quiet NaN in a record.

package/build/index.d.ts

@@ -215,6 +215,11 @@ interface ResponseMeasure {
   readonly unit: string;
   /** The better direction of the value. The value `none` means that no direction is better. */
   readonly direction: "higher" | "lower" | "none";
+  /**
+   * The low and the high end of the possible values, for example `[0, 1]` for a share. Each measured value is in this
+   * range. A view clips its fitted values to it, and a fit does not use it.
+   */
+  readonly range?: readonly [number, number];
 }
 /** A declared reason that a measure is absent, for example infeasible, unsupported or out of budget. */
 interface ResponseReason {
@@ -406,6 +411,8 @@ interface ResponseBand {
    * count over the dimensions.
    */
   readonly nearest: number;
+  /** This field is true when the measure has a `range` and the view moved `value`, `low` or `high` into it. */
+  readonly clipped?: true;
 }
 /** One place of a curve. */
 interface ResponseCurvePoint extends ResponseBand {
@@ -440,6 +447,8 @@ interface ResponseSlice {
   /** The points that match the held values and have no value of the measure, each with its reason. */
   readonly absent: readonly ResponseAbsentPoint[];
   readonly error: ResponseHeldOutError;
+  /** The number of places of `curve` with the field `clipped`. */
+  readonly clipped: number;
 }
 /** A measured point of a surface. */
 interface ResponseSurfacePoint {
@@ -472,7 +481,11 @@ interface ResponseSurface {
   /** The points that match the held values and have no value of the measure, each with its reason. */
   readonly absent: readonly ResponseSurfaceAbsentPoint[];
   readonly error: ResponseHeldOutError;
+  /** The number of places of `cells` with the field `clipped`. */
+  readonly clipped: number;
 }
+/** This function gives true when a place has the condition of a dimension. A dimension with no condition is present. */
+export declare function whenHolds(dimension: ResponseDimension, values: Readonly<Record<string, unknown>>): boolean;
 /**
  * This function gives the value of a model at `inputs`, on the scale of the measure. The inputs have a value for each
  * dimension that the model reads. An absent conditional dimension has `null`. A table model gives its `fallback` for a
@@ -525,6 +538,10 @@ export declare function heldOutErrorAt(record: ResponseRecord, measure: string,
  * 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.
  */
@@ -536,6 +553,14 @@ export declare function sliceResponse(record: ResponseRecord, measure: string, o
  * It throws when a conditional dimension varies with its parent, and when two varied dimensions need no common level.
  */
 export declare function surfaceResponse(record: ResponseRecord, measure: string, options: ResponseSurfaceOptions): ResponseSurface;
+/**
+ * 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`.
+ */
+export declare function responseCells(record: Pick<ResponseRecord, "dimensions">, vary: string | readonly [string, string], steps?: number): number;
 /** The largest power of a factor. A larger power of a coordinate from -1 to 1 adds almost nothing to a model. */
 export declare const RESPONSE_MAX_POWER = 8;
 /** One fault of a record. */

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/describe.ts","../src/regression.ts","../src/bootstrap.ts","../src/ridge.ts","../src/response.ts","../src/response-parse.ts","../src/response-fit.ts","../src/tests.ts","../src/rank.ts","../src/discrete.ts","../src/compare.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/describe.ts","../src/regression.ts","../src/bootstrap.ts","../src/ridge.ts","../src/response.ts","../src/response-parse.ts","../src/response-fit.ts","../src/tests.ts","../src/rank.ts","../src/discrete.ts","../src/compare.ts"],"mappings":"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"}

package/build/index.js

@@ -717,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;
@@ -739,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);
@@ -765,14 +771,25 @@ function frameOf(name, record, measure, vary, options) {
 	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 {
@@ -812,23 +829,28 @@ const reasonOf = (point, measure) => point.absent !== void 0 && Object.hasOwn(po
 * 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, 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],
@@ -841,7 +863,8 @@ function sliceResponse(record, measure, options) {
 			reason: reasonOf(p, measure),
 			...groupOf(p)
 		})),
-		error
+		error,
+		clipped: curve.filter((place) => place.clipped === true).length
 	};
 }
 /**
@@ -856,17 +879,18 @@ function surfaceResponse(record, measure, 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]],
@@ -879,9 +903,27 @@ function surfaceResponse(record, measure, options) {
 			reason: reasonOf(p, measure),
 			...groupOf(p)
 		})),
-		error
+		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
@@ -985,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);
@@ -1021,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, [
@@ -1028,12 +1072,21 @@ 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 declared reason. */
 function checkReason(value, path, faults) {
@@ -1125,6 +1178,8 @@ function responseDataFaults(value, required, optional) {
 	const points = list(object["points"], "points", 1, 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. */
@@ -2327,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, 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 };
+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