@mstone6969/graph 0.0.0-stage → 0.2.0

package/dist/charts/statistics/PrecisionRecallCurve.js

@@ -0,0 +1,157 @@
+import { ChartFamily, CurveKind, DataShape, Dimension } from "../../core/enums.js";
+import { ClassifierCurveBase } from "./ClassifierCurveBase.js";
+import { maxIndex } from "d3";
+// src/charts/statistics/PrecisionRecallCurve.ts
+/** How precision is carried between observed recall levels. */
+var PrecisionInterpolation = /* @__PURE__ */ function(PrecisionInterpolation) {
+	PrecisionInterpolation["Step"] = "step";
+	PrecisionInterpolation["Envelope"] = "envelope";
+	PrecisionInterpolation["Linear"] = "linear";
+	return PrecisionInterpolation;
+}({});
+/** For imbalanced problems: how much precision each level of recall costs, without the true negatives ROC relies on. */
+var PrecisionRecallCurve = class extends ClassifierCurveBase {
+	static meta = {
+		id: "precision-recall-curve",
+		name: "Precision-recall curve",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots precision against recall across thresholds, the honest view of a classifier on imbalanced data.",
+		tags: [
+			"classifier",
+			"average precision",
+			"f1",
+			"machine learning"
+		],
+		sample: (seed) => ClassifierCurveBase.scored(seed),
+		variants: {
+			interpolation: Object.values(PrecisionInterpolation),
+			isoF1: [false, true],
+			bestF1: [false, true],
+			fill: [false, true],
+			baseline: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			interpolation: "step",
+			isoF1: false,
+			bestF1: false,
+			fill: false,
+			baseline: true
+		};
+	}
+	axisTitles() {
+		return {
+			x: "Recall",
+			y: "Precision"
+		};
+	}
+	averagePrecision(model) {
+		let previous = 0, total = 0;
+		for (const d of model.sweep) {
+			total += (d.tpr - previous) * d.precision;
+			previous = d.tpr;
+		}
+		return total;
+	}
+	legendMetric(model) {
+		return ["AP", this.averagePrecision(model)];
+	}
+	curve(model) {
+		const points = model.sweep.map((d) => [d.tpr, d.precision]);
+		if (this.options.interpolation === "envelope") {
+			let best = 0;
+			for (let i = points.length - 1; i >= 0; i--) {
+				best = Math.max(best, points[i][1]);
+				points[i][1] = best;
+			}
+		}
+		return points;
+	}
+	scales(ctx) {
+		return {
+			x: this.linear([0, 1], [0, ctx.plot.width]),
+			y: this.linear([0, 1], [ctx.plot.height, 0])
+		};
+	}
+	plotMarks(ctx, axes) {
+		const { interpolation, isoF1, bestF1, fill, baseline } = this.options;
+		const models = this.models(), color = (model) => this.color(ctx, model);
+		const curve = interpolation === "linear" ? CurveKind.Linear : interpolation === "step" ? CurveKind.StepBefore : CurveKind.StepAfter;
+		this.ribbons(ctx, "fill", fill ? models.map((model) => ({
+			key: model.key,
+			color: color(model),
+			opacity: .07,
+			curve,
+			points: this.curve(model).map(([x, y]) => [
+				x,
+				0,
+				y
+			])
+		})) : [], axes);
+		const levels = isoF1 ? [
+			.2,
+			.4,
+			.6,
+			.8
+		] : [];
+		this.traces(ctx, "iso", levels.map((f) => ({
+			key: `F1 = ${f}`,
+			color: ctx.theme.grid,
+			width: 1.5,
+			points: Array.from({ length: 40 }, (_, i) => {
+				const start = f / (2 - f), recall = start + i / 39 * (1 - start);
+				return [recall, f * recall / (2 * recall - f)];
+			})
+		})), axes);
+		this.notes(ctx, "iso-labels", levels.map((f) => ({
+			key: `${f}`,
+			text: `F1 ${f}`,
+			x: ctx.plot.width - 2,
+			y: axes.y(f / (2 - f)) - 4,
+			anchor: "end",
+			tone: "muted"
+		})));
+		this.rules(ctx, "baseline", baseline ? models.slice(0, 1).map((model) => {
+			const rate = model.positives / (model.cases.length || 1);
+			return {
+				key: "prevalence",
+				from: [0, rate],
+				to: [1, rate],
+				dash: "5 4"
+			};
+		}) : [], axes);
+		this.traces(ctx, "curves", models.map((model) => ({
+			key: model.key,
+			color: color(model),
+			curve,
+			points: this.curve(model),
+			tip: {
+				title: model.key,
+				color: color(model),
+				rows: [["Average precision", +this.averagePrecision(model).toFixed(3)], ["Prevalence", +(model.positives / (model.cases.length || 1)).toFixed(3)]]
+			}
+		})), axes);
+		const best = bestF1 ? models.filter((model) => model.sweep.length).map((model) => {
+			const f1 = (precision, recall) => precision + recall ? 2 * precision * recall / (precision + recall) : 0;
+			const d = model.sweep[maxIndex(model.sweep, (rate) => f1(rate.precision, rate.tpr))];
+			return {
+				model,
+				...d,
+				f1: f1(d.precision, d.tpr)
+			};
+		}) : [];
+		this.dots(ctx, "best", best, (d) => [axes.x(d.tpr), axes.y(d.precision)], (d) => color(d.model), (d) => ({
+			title: `${d.model.key} best F1`,
+			color: color(d.model),
+			rows: [["F1", +d.f1.toFixed(3)], ["Threshold", +d.threshold.toFixed(3)]]
+		}), {
+			r: 6,
+			key: (d) => d.model.key
+		});
+	}
+};
+export { PrecisionInterpolation, PrecisionRecallCurve };

package/dist/charts/statistics/ProcessChartBase.js

@@ -0,0 +1,130 @@
+import { ChartFamily, CurveKind, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { ProcessRules, ProcessRuleset } from "./ProcessRules.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+// src/charts/statistics/ProcessChartBase.ts
+var DASH = "6 4";
+/** Time-ordered points against a centre line and control limits, with rule breaches flagged. */
+var ProcessChartBase = class extends StatisticalChart {
+	static family = {
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table
+	};
+	/** A stable process that drifts near the end, so breaches appear. */
+	static measurements(seed) {
+		return SampleData.distribution(seed, 125, 1).map((row, i) => ({
+			sample: i + 1,
+			value: +(+row.value + (i > 92 ? 9 : 0)).toFixed(2)
+		}));
+	}
+	statisticName() {
+		return "Value";
+	}
+	flagged(points) {
+		const z = points.map((d) => {
+			const sigma = (d.upper - d.center) / 3;
+			return sigma > 0 ? (d.value - d.center) / sigma : 0;
+		});
+		return ProcessRules.evaluate(z, this.options.rules ?? ProcessRuleset.Limits);
+	}
+	scales(ctx) {
+		const points = this.points();
+		return {
+			x: this.linear([.5, Math.max(1, points.length) + .5], [0, ctx.plot.width]),
+			y: this.linear(this.span(points.flatMap((d) => [
+				d.value,
+				d.upper,
+				d.lower
+			])), [ctx.plot.height, 0])
+		};
+	}
+	/** Marks a chart adds under the points, such as a phase divider. */
+	underlay(_ctx, _points, _axes) {}
+	plotMarks(ctx, axes) {
+		const { connect, zones } = this.options;
+		const points = this.points(), flags = this.flagged(points);
+		const ink = ctx.palette.color(this.statisticName());
+		const level = (d, sigmas) => d.center + (sigmas > 0 ? d.upper - d.center : d.center - d.lower) / 3 * sigmas;
+		const span = (at) => points.flatMap((d) => [[d.slot - .5, ...at(d)], [d.slot + .5, ...at(d)]]);
+		this.ribbons(ctx, "zones", zones ? [2, 1].flatMap((inner) => [{
+			key: `up${inner}`,
+			opacity: .05 * inner + .03,
+			color: ctx.theme.inkMuted,
+			points: span((d) => [level(d, inner), level(d, inner + 1)])
+		}, {
+			key: `down${inner}`,
+			opacity: .05 * inner + .03,
+			color: ctx.theme.inkMuted,
+			points: span((d) => [level(d, -inner - 1), level(d, -inner)])
+		}]) : [], axes);
+		this.underlay(ctx, points, axes);
+		const steps = (at) => points.flatMap((d) => [[d.slot - .5, at(d)], [d.slot + .5, at(d)]]);
+		this.traces(ctx, "limits", points.length ? [
+			{
+				key: "Upper control limit",
+				color: ctx.theme.inkSecondary,
+				dash: DASH,
+				width: 1.5,
+				points: steps((d) => d.upper)
+			},
+			{
+				key: "Lower control limit",
+				color: ctx.theme.inkSecondary,
+				dash: DASH,
+				width: 1.5,
+				points: steps((d) => d.lower)
+			},
+			{
+				key: "Centre line",
+				color: ctx.theme.inkSecondary,
+				width: 1.5,
+				points: steps((d) => d.center)
+			}
+		] : [], axes);
+		this.traces(ctx, "path", connect ? [{
+			key: this.statisticName(),
+			color: ink,
+			curve: CurveKind.Linear,
+			points: points.map((d) => [d.slot, d.value])
+		}] : [], axes);
+		const breached = (d) => flags.has(d.slot - 1);
+		this.dots(ctx, "points", points, (d) => [axes.x(d.slot), axes.y(d.value)], (d) => breached(d) ? ctx.theme.critical : ink, (d) => ({
+			title: d.label ?? `Sample ${d.slot}`,
+			color: breached(d) ? ctx.theme.critical : ink,
+			rows: [
+				[this.statisticName(), +d.value.toFixed(3)],
+				["Centre", +d.center.toFixed(3)],
+				["Limits", `${d.lower.toFixed(2)} to ${d.upper.toFixed(2)}`],
+				...(flags.get(d.slot - 1) ?? []).map((rule) => ["Breach", rule])
+			]
+		}), {
+			r: (d) => breached(d) ? 5 : points.length > 60 ? 3 : 4,
+			key: (d) => d.slot
+		});
+		const first = points[0], x = 4;
+		const fmt = (value) => Math.abs(value) < 10 ? value.toFixed(2) : value.toFixed(1);
+		const below = (value) => axes.y(value) + 13 > ctx.plot.height ? axes.y(value) - 5 : axes.y(value) + 13;
+		this.notes(ctx, "limit-labels", first ? [
+			{
+				key: "ucl",
+				text: `UCL ${fmt(first.upper)}`,
+				x,
+				y: axes.y(first.upper) - 5
+			},
+			{
+				key: "cl",
+				text: `CL ${fmt(first.center)}`,
+				x,
+				y: axes.y(first.center) - 5
+			},
+			{
+				key: "lcl",
+				text: `LCL ${fmt(first.lower)}`,
+				x,
+				y: below(first.lower)
+			}
+		] : []);
+	}
+};
+export { ProcessChartBase };

package/dist/charts/statistics/ProcessRules.js

@@ -0,0 +1,39 @@
+// src/charts/statistics/ProcessRules.ts
+/** Which run tests flag a process as out of control. */
+var ProcessRuleset = /* @__PURE__ */ function(ProcessRuleset) {
+	ProcessRuleset["Limits"] = "limits-only";
+	ProcessRuleset["WesternElectric"] = "western-electric";
+	ProcessRuleset["Nelson"] = "nelson";
+	return ProcessRuleset;
+}({});
+var window = (values, end, size) => values.slice(Math.max(0, end - size + 1), end + 1);
+var count = (values, test) => values.filter(test).length;
+/** Run tests over standardised points, where 3 is the control limit. */
+var ProcessRules = class {
+	/** Returns, for each flagged index, the names of the tests it failed. */
+	static evaluate(z, ruleset) {
+		const flags = /* @__PURE__ */ new Map();
+		const flag = (index, name) => flags.set(index, [...flags.get(index) ?? [], name]);
+		const sameSide = (recent, need, level) => count(recent, (v) => v > level) >= need || count(recent, (v) => v < -level) >= need;
+		z.forEach((value, i) => {
+			if (Math.abs(value) > 3) flag(i, "Beyond limits");
+			if (ruleset === "limits-only") return;
+			if (Math.abs(value) > 2 && sameSide(window(z, i, 3), 2, 2)) flag(i, "2 of 3 beyond 2σ");
+			if (Math.abs(value) > 1 && sameSide(window(z, i, 5), 4, 1)) flag(i, "4 of 5 beyond 1σ");
+			if (i >= 7 && sameSide(window(z, i, 8), 8, 0)) flag(i, "8 on one side");
+			if (ruleset === "western-electric") return;
+			if (i >= 5) {
+				const run = window(z, i, 6), steps = run.slice(1).map((v, k) => v - run[k]);
+				if (steps.every((d) => d > 0) || steps.every((d) => d < 0)) flag(i, "6 trending");
+			}
+			if (i >= 14 && window(z, i, 15).every((v) => Math.abs(v) < 1)) flag(i, "15 hugging centre");
+			if (i >= 13) {
+				const run = window(z, i, 14), steps = run.slice(1).map((v, k) => v - run[k]);
+				if (steps.slice(1).every((d, k) => d * steps[k] < 0)) flag(i, "14 alternating");
+			}
+			if (i >= 7 && window(z, i, 8).every((v) => Math.abs(v) > 1)) flag(i, "8 avoiding centre");
+		});
+		return flags;
+	}
+};
+export { ProcessRules, ProcessRuleset };

package/dist/charts/statistics/QQPlot.js

@@ -0,0 +1,191 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { ReferenceDistribution, ReferenceLaw } from "./ReferenceLaw.js";
+import { RegressionFit } from "./RegressionFit.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+import { ascending, deviation, group, mean, quantileSorted } from "d3";
+// src/charts/statistics/QQPlot.ts
+/** Line a quantile plot is judged against. */
+var QQReferenceLine = /* @__PURE__ */ function(QQReferenceLine) {
+	QQReferenceLine["Quartile"] = "quartile-line";
+	QQReferenceLine["Regression"] = "regression-line";
+	QQReferenceLine["Identity"] = "identity-line";
+	QQReferenceLine["None"] = "no-line";
+	return QQReferenceLine;
+}({});
+/** Sampling envelope around the reference line. */
+var QQEnvelope = /* @__PURE__ */ function(QQEnvelope) {
+	QQEnvelope["None"] = "no-envelope";
+	QQEnvelope["Pointwise"] = "pointwise";
+	QQEnvelope["Simultaneous"] = "simultaneous";
+	return QQEnvelope;
+}({});
+/** Checks whether a sample follows a reference distribution; curvature at the ends reveals skew and heavy tails. */
+var QQPlot = class extends StatisticalChart {
+	static meta = {
+		id: "qq-plot",
+		name: "Q-Q plot",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots sample quantiles against theoretical quantiles to test whether data follows a reference distribution.",
+		tags: [
+			"quantile",
+			"normality",
+			"worm plot",
+			"diagnostic"
+		],
+		sample: (seed) => SampleData.distribution(seed, 70, 3),
+		variants: {
+			distribution: Object.values(ReferenceDistribution),
+			referenceLine: Object.values(QQReferenceLine),
+			envelope: Object.values(QQEnvelope),
+			detrended: [false, true],
+			grouped: [false, true]
+		},
+		valid: ({ referenceLine, envelope, detrended, grouped }) => !(referenceLine === "no-line" && (envelope !== "no-envelope" || detrended)) && !(grouped && envelope !== "no-envelope")
+	};
+	defaults() {
+		return {
+			value: "value",
+			group: "group",
+			distribution: ReferenceDistribution.Normal,
+			referenceLine: "quartile-line",
+			envelope: "no-envelope",
+			detrended: false,
+			grouped: false
+		};
+	}
+	get law() {
+		return ReferenceLaw.of(this.options.distribution);
+	}
+	axisTitles() {
+		return {
+			x: `Theoretical quantiles (${this.options.distribution})`,
+			y: this.options.detrended ? "Deviation from line" : "Sample quantiles"
+		};
+	}
+	build() {
+		const { data, value, group: field, grouped, referenceLine } = this.options;
+		const rows = this.complete(data, value);
+		return (grouped ? [...group(rows, (row) => String(row[field] ?? "Missing"))] : [["Sample", rows]]).filter(([, part]) => part.length).map(([key, part]) => {
+			const sorted = part.map((row) => +row[value]).sort(ascending), n = sorted.length;
+			const identity = referenceLine === "identity-line";
+			const centre = mean(sorted), spread = deviation(sorted) || 1;
+			const shown = identity ? sorted.map((raw) => (raw - centre) / spread * this.law.deviation + this.law.mean) : sorted;
+			const points = sorted.map((raw, i) => {
+				const p = (i + 1 - .375) / (n + .25);
+				return {
+					key,
+					theory: this.law.quantile(p),
+					sample: shown[i],
+					p,
+					raw
+				};
+			});
+			if (identity) return {
+				key,
+				points,
+				intercept: 0,
+				slope: 1,
+				n
+			};
+			if (referenceLine === "regression-line" && n > 1) {
+				const fit = new RegressionFit(points.map((d) => d.theory), shown);
+				const intercept = fit.predict(0);
+				return {
+					key,
+					points,
+					intercept,
+					slope: fit.predict(1) - intercept,
+					n
+				};
+			}
+			return {
+				key,
+				points,
+				n,
+				...ReferenceLaw.quartileFit(this.law, quantileSorted(sorted, .25), quantileSorted(sorted, .75))
+			};
+		});
+	}
+	offset(trace, theory) {
+		return this.options.detrended ? trace.intercept + trace.slope * theory : 0;
+	}
+	scales(ctx) {
+		const points = this.build().flatMap((trace) => trace.points.map((d) => [d.theory, d.sample - this.offset(trace, d.theory)]));
+		return {
+			x: this.linear(this.span(points.map((d) => d[0])), [0, ctx.plot.width]),
+			y: this.linear(this.span(points.map((d) => d[1]), .1), [ctx.plot.height, 0])
+		};
+	}
+	envelope(trace, axes) {
+		const { envelope } = this.options, law = this.law, reach = 1.358 / Math.sqrt(trace.n);
+		const [floor, ceiling] = axes.y.domain();
+		const clamp = (value) => Math.max(floor, Math.min(ceiling, value));
+		const line = (theory) => trace.intercept + trace.slope * theory;
+		return trace.points.map(({ theory, p }) => {
+			const shift = this.offset(trace, theory);
+			if (envelope === "pointwise") {
+				const se = trace.slope * Math.sqrt(p * (1 - p) / trace.n) / Math.max(.001, law.pdf(theory));
+				return [
+					theory,
+					clamp(line(theory) - 1.96 * se - shift),
+					clamp(line(theory) + 1.96 * se - shift)
+				];
+			}
+			const low = p - reach, high = p + reach;
+			return [
+				theory,
+				clamp(low > 0 ? line(law.quantile(low)) - shift : floor),
+				clamp(high < 1 ? line(law.quantile(high)) - shift : ceiling)
+			];
+		});
+	}
+	plotMarks(ctx, axes) {
+		const { referenceLine, envelope, detrended } = this.options;
+		const traces = this.build();
+		const color = (key) => ctx.palette.color(key);
+		this.ribbons(ctx, "bands", envelope === "no-envelope" ? [] : traces.map((trace) => ({
+			key: trace.key,
+			points: this.envelope(trace, axes),
+			color: color(trace.key)
+		})), axes);
+		const [left, right] = axes.x.domain();
+		const [floor, ceiling] = axes.y.domain();
+		const clip = (trace, x) => [x, Math.max(floor, Math.min(ceiling, detrended ? 0 : trace.intercept + trace.slope * x))];
+		const lines = detrended ? [{
+			key: "zero",
+			points: [clip(traces[0], left), clip(traces[0], right)]
+		}] : (referenceLine === "no-line" ? [] : traces).map((trace) => {
+			const ends = [left, right].map((x) => trace.slope ? Math.max(left, Math.min(right, ((x === left ? floor : ceiling) - trace.intercept) / trace.slope)) : x);
+			return {
+				key: trace.key,
+				points: [clip(trace, Math.max(left, ends[0])), clip(trace, Math.min(right, ends[1]))]
+			};
+		});
+		this.traces(ctx, "lines", traces.length ? lines.map((spec) => ({
+			...spec,
+			color: ctx.theme.inkMuted,
+			dash: "5 4",
+			width: 1.5
+		})) : [], axes);
+		const points = traces.flatMap((trace) => trace.points.map((d) => ({
+			...d,
+			shift: this.offset(trace, d.theory)
+		})));
+		this.dots(ctx, "points", points, (d) => [axes.x(d.theory), axes.y(d.sample - d.shift)], (d) => color(d.key), (d) => ({
+			title: d.key,
+			color: color(d.key),
+			rows: [
+				["Value", +d.raw.toFixed(3)],
+				["Theoretical", +d.theory.toFixed(3)],
+				["Percentile", `${(d.p * 100).toFixed(1)}%`]
+			]
+		}), {
+			stagger: 1,
+			key: (d) => `${d.key}/${d.p}`
+		});
+	}
+};
+export { QQEnvelope, QQPlot, QQReferenceLine };

package/dist/charts/statistics/ROCCurve.js

@@ -0,0 +1,186 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { ClassifierCurveBase } from "./ClassifierCurveBase.js";
+import { StatMath } from "./StatMath.js";
+import { deviation, maxIndex, mean, minIndex } from "d3";
+// src/charts/statistics/ROCCurve.ts
+/** How the threshold sweep becomes a curve. */
+var RocSmoothing = /* @__PURE__ */ function(RocSmoothing) {
+	RocSmoothing["Empirical"] = "empirical";
+	RocSmoothing["ConvexHull"] = "convex-hull";
+	RocSmoothing["Binormal"] = "binormal";
+	return RocSmoothing;
+}({});
+/** Which threshold to mark as the recommended operating point. */
+var RocOperatingPoint = /* @__PURE__ */ function(RocOperatingPoint) {
+	RocOperatingPoint["None"] = "no-operating-point";
+	RocOperatingPoint["Youden"] = "youden";
+	RocOperatingPoint["ClosestToCorner"] = "closest-to-corner";
+	return RocOperatingPoint;
+}({});
+/** What fills the region around the curve. */
+var RocFill = /* @__PURE__ */ function(RocFill) {
+	RocFill["None"] = "no-fill";
+	RocFill["Area"] = "area";
+	RocFill["Confidence"] = "confidence";
+	return RocFill;
+}({});
+var FLOOR = .003;
+var hull = (points) => {
+	const out = [];
+	for (const point of points) {
+		while (out.length >= 2) {
+			const a = out[out.length - 2], b = out[out.length - 1];
+			if ((b[0] - a[0]) * (point[1] - a[1]) - (b[1] - a[1]) * (point[0] - a[0]) < 0) break;
+			out.pop();
+		}
+		out.push(point);
+	}
+	return out;
+};
+/** Shows the true-positive against false-positive trade-off of a classifier at every threshold; compare models by AUC. */
+var ROCCurve = class extends ClassifierCurveBase {
+	static meta = {
+		id: "roc-curve",
+		name: "ROC curve",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Traces true-positive against false-positive rate across every threshold to compare binary classifiers.",
+		tags: [
+			"classifier",
+			"auc",
+			"machine learning",
+			"sensitivity",
+			"specificity"
+		],
+		sample: (seed) => ClassifierCurveBase.scored(seed),
+		variants: {
+			smoothing: Object.values(RocSmoothing),
+			operatingPoint: Object.values(RocOperatingPoint),
+			fill: Object.values(RocFill),
+			fprScale: [ScaleKind.Linear, ScaleKind.Log]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			smoothing: "empirical",
+			operatingPoint: "no-operating-point",
+			fill: "no-fill",
+			fprScale: ScaleKind.Linear
+		};
+	}
+	axisTitles() {
+		return {
+			x: "False positive rate",
+			y: "True positive rate"
+		};
+	}
+	legendMetric(model) {
+		return ["AUC", this.auc(model)];
+	}
+	get logged() {
+		return this.options.fprScale === ScaleKind.Log;
+	}
+	curve(model) {
+		const { smoothing } = this.options;
+		const steps = [[0, 0], ...model.sweep.map((d) => [d.fpr, d.tpr])];
+		if (smoothing === "convex-hull") return hull(steps);
+		if (smoothing === "empirical") return steps;
+		const on = model.cases.filter((d) => d.hit).map((d) => d.score), off = model.cases.filter((d) => !d.hit).map((d) => d.score);
+		const a = ((mean(on) ?? 0) - (mean(off) ?? 0)) / (deviation(on) || 1), b = (deviation(off) || 1) / (deviation(on) || 1);
+		return [
+			[0, 0],
+			...Array.from({ length: 60 }, (_, i) => {
+				const fpr = FLOOR ** (1 - (i + 1) / 61);
+				return [fpr, StatMath.normalCdf(a + b * StatMath.normalQuantile(fpr))];
+			}),
+			[1, 1]
+		];
+	}
+	tprAt(points, fpr) {
+		let i = points.findIndex((d) => d[0] >= fpr);
+		if (i <= 0) i = Math.max(1, i < 0 ? points.length - 1 : 1);
+		const a = points[i - 1], b = points[i];
+		return b[0] === a[0] ? b[1] : a[1] + (fpr - a[0]) / (b[0] - a[0]) * (b[1] - a[1]);
+	}
+	/** Clip to the visible axis so a log axis never receives zero. */
+	visible(points) {
+		if (!this.logged) return [...points];
+		const kept = points.filter((d) => d[0] >= FLOOR);
+		return [[FLOOR, this.tprAt(points, FLOOR)], ...kept];
+	}
+	scales(ctx) {
+		return {
+			x: this.logged ? this.logarithmic([FLOOR, 1], [0, ctx.plot.width]) : this.linear([0, 1], [0, ctx.plot.width]),
+			y: this.linear([0, 1], [ctx.plot.height, 0])
+		};
+	}
+	plotMarks(ctx, axes) {
+		const { fill, operatingPoint } = this.options;
+		const models = this.models(), color = (model) => this.color(ctx, model);
+		const grid = (points) => this.logged ? this.visible(points).map((d) => d[0]) : points.map((d) => d[0]);
+		this.ribbons(ctx, "fill", fill === "no-fill" ? [] : models.map((model) => {
+			const curve = this.curve(model);
+			return {
+				key: model.key,
+				color: color(model),
+				opacity: .14,
+				points: fill === "area" ? this.visible(curve).map(([x, y]) => [
+					x,
+					0,
+					y
+				]) : grid(curve).map((x) => {
+					const y = this.tprAt(curve, x), se = 1.96 * Math.sqrt(y * (1 - y) / (model.positives || 1));
+					return [
+						x,
+						Math.max(0, y - se),
+						Math.min(1, y + se)
+					];
+				})
+			};
+		}), axes);
+		const chance = this.logged ? Array.from({ length: 24 }, (_, i) => FLOOR ** (1 - i / 23)).map((x) => [x, x]) : [[0, 0], [1, 1]];
+		this.traces(ctx, "chance", [{
+			key: "Chance",
+			points: chance,
+			color: ctx.theme.inkMuted,
+			dash: "5 4",
+			width: 1.5
+		}], axes);
+		this.traces(ctx, "curves", models.map((model) => ({
+			key: model.key,
+			color: color(model),
+			points: this.visible(this.curve(model)),
+			tip: {
+				title: model.key,
+				color: color(model),
+				rows: [
+					["AUC", +this.auc(model).toFixed(3)],
+					["Positives", model.positives],
+					["Negatives", model.negatives]
+				]
+			}
+		})), axes);
+		const best = operatingPoint === "no-operating-point" ? [] : models.filter((model) => model.sweep.length).map((model) => {
+			const index = operatingPoint === "youden" ? maxIndex(model.sweep, (d) => d.tpr - d.fpr) : minIndex(model.sweep, (d) => (1 - d.tpr) ** 2 + d.fpr ** 2);
+			return {
+				model,
+				...model.sweep[index]
+			};
+		});
+		this.dots(ctx, "operating", best, (d) => [axes.x(Math.max(this.logged ? FLOOR : 0, d.fpr)), axes.y(d.tpr)], (d) => color(d.model), (d) => ({
+			title: `${d.model.key} operating point`,
+			color: color(d.model),
+			rows: [
+				["Threshold", +d.threshold.toFixed(3)],
+				["True positive rate", +d.tpr.toFixed(3)],
+				["False positive rate", +d.fpr.toFixed(3)]
+			]
+		}), {
+			r: 6,
+			key: (d) => d.model.key
+		});
+	}
+};
+export { ROCCurve, RocFill, RocOperatingPoint, RocSmoothing };