@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/statistics/LorenzCurve.js

@@ -0,0 +1,186 @@
+import { ChartFamily, CurveKind, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+import { ascending, group, quantileSorted, sum } from "d3";
+// src/charts/statistics/LorenzCurve.ts
+/** Which concentration curve to draw. */
+var LorenzForm = /* @__PURE__ */ function(LorenzForm) {
+	LorenzForm["Lorenz"] = "lorenz";
+	LorenzForm["Generalized"] = "generalized";
+	LorenzForm["TopShare"] = "top-share";
+	LorenzForm["PenParade"] = "pen-parade";
+	return LorenzForm;
+}({});
+/** Resolution of the curve. */
+var LorenzResolution = /* @__PURE__ */ function(LorenzResolution) {
+	LorenzResolution["Individual"] = "individual";
+	LorenzResolution["Deciles"] = "deciles";
+	LorenzResolution["Quintiles"] = "quintiles";
+	return LorenzResolution;
+}({});
+/** Measures inequality: how far cumulative shares of income, wealth or traffic fall from perfect equality. */
+var LorenzCurve = class extends StatisticalChart {
+	static meta = {
+		id: "lorenz-curve",
+		name: "Lorenz curve",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots the cumulative share of a total held by a growing share of the population, to measure inequality.",
+		tags: [
+			"gini",
+			"inequality",
+			"concentration",
+			"pareto",
+			"economics"
+		],
+		sample: (seed) => SampleData.points(seed, 150, 3).map((row) => ({
+			value: +(Number(row.size) ** (row.group === "Alpha" ? 1 : row.group === "Bravo" ? 1.8 : 2.8)).toFixed(1),
+			group: row.group
+		})),
+		variants: {
+			form: Object.values(LorenzForm),
+			resolution: Object.values(LorenzResolution),
+			fill: [false, true],
+			marker: [false, true],
+			pooled: [false, true]
+		},
+		valid: ({ form, fill }) => !fill || form === "lorenz" || form === "top-share"
+	};
+	defaults() {
+		return {
+			value: "value",
+			group: "group",
+			form: "lorenz",
+			resolution: "individual",
+			fill: false,
+			marker: false,
+			pooled: false
+		};
+	}
+	axisTitles() {
+		const { form } = this.options;
+		return {
+			x: form === "top-share" ? "Share of population, richest first" : "Share of population, poorest first",
+			y: {
+				["lorenz"]: "Share of total",
+				["generalized"]: "Cumulative mean",
+				["top-share"]: "Share of total",
+				["pen-parade"]: "Value"
+			}[form]
+		};
+	}
+	arms() {
+		const { data, value, group: field, form, resolution, pooled } = this.options;
+		const rows = this.complete(data, value).filter((row) => +row[value] >= 0);
+		const split = pooled ? rows.length ? [["All", rows]] : [] : [...group(rows, (row) => String(row[field] ?? "All"))];
+		const buckets = resolution === "deciles" ? 10 : resolution === "quintiles" ? 5 : 0;
+		return split.map(([key, part]) => {
+			const sorted = part.map((row) => +row[value]).sort(ascending);
+			const n = sorted.length, total = sum(sorted) || 1;
+			let running = 0;
+			const cumulative = [0, ...sorted.map((v) => running += v)];
+			const gini = n > 1 ? 1 - (2 * sum(cumulative.slice(1), (c) => c / total) - 1) / n : 0;
+			const shareAt = (p) => {
+				const position = p * n, i = Math.min(n - 1, Math.floor(position));
+				return (cumulative[i] + (position - i) * (sorted[i] ?? 0)) / total;
+			};
+			return {
+				key,
+				points: (buckets ? Array.from({ length: buckets + 1 }, (_, i) => i / buckets) : Array.from({ length: n + 1 }, (_, i) => i / n)).map((p) => {
+					if (form === "lorenz") return [p, shareAt(p)];
+					if (form === "generalized") return [p, shareAt(p) * total / n];
+					if (form === "top-share") return [p, 1 - shareAt(1 - p)];
+					return [p, quantileSorted(sorted, p) ?? 0];
+				}),
+				gini,
+				total,
+				count: n,
+				sorted
+			};
+		});
+	}
+	scales(ctx) {
+		const { form } = this.options;
+		const top = form === "lorenz" || form === "top-share" ? 1 : Math.max(1e-9, ...this.arms().flatMap((arm) => arm.points.map((d) => d[1]))) * 1.04;
+		return {
+			x: this.linear([0, 1], [0, ctx.plot.width]),
+			y: this.linear([0, top], [ctx.plot.height, 0])
+		};
+	}
+	legendItems() {
+		const arms = new Map(this.arms().map((arm) => [arm.key, arm]));
+		return this.palette.items().map((item, i) => ({
+			...item,
+			label: `${item.key} ${i ? "" : "Gini "}${(arms.get(item.key)?.gini ?? 0).toFixed(2).replace(/^0/, "")}`
+		}));
+	}
+	plotMarks(ctx, axes) {
+		const { form, fill, marker, resolution } = this.options;
+		const arms = this.arms(), color = (arm) => ctx.palette.color(arm.key);
+		const share = form === "lorenz" || form === "top-share";
+		const curve = resolution === "individual" ? CurveKind.Linear : form === "pen-parade" ? CurveKind.Monotone : CurveKind.Linear;
+		this.ribbons(ctx, "gini", fill ? arms.map((arm) => ({
+			key: arm.key,
+			color: color(arm),
+			opacity: .1,
+			points: arm.points.map(([x, y]) => [
+				x,
+				Math.min(x, y),
+				Math.max(x, y)
+			])
+		})) : [], axes);
+		this.rules(ctx, "equality", share ? [{
+			key: "equality",
+			from: [0, 0],
+			to: [1, 1],
+			dash: "5 4"
+		}] : [], axes);
+		this.traces(ctx, "curves", arms.map((arm) => ({
+			key: arm.key,
+			color: color(arm),
+			curve,
+			points: arm.points,
+			tip: {
+				title: arm.key,
+				color: color(arm),
+				rows: [
+					["Gini", +arm.gini.toFixed(3)],
+					["Observations", arm.count],
+					["Total", +arm.total.toFixed(1)]
+				]
+			}
+		})), axes);
+		if (resolution !== "individual") this.dots(ctx, "stops", arms.flatMap((arm) => arm.points.map((d, i) => ({
+			arm,
+			d,
+			i
+		}))), ({ d }) => [axes.x(d[0]), axes.y(d[1])], ({ arm }) => color(arm), ({ arm, d }) => ({
+			title: arm.key,
+			color: color(arm),
+			rows: [["Population", `${Math.round(d[0] * 100)}%`], [this.axisTitles().y, +d[1].toFixed(3)]]
+		}), { key: ({ arm, i }) => `${arm.key}/${i}` });
+		else this.dots(ctx, "stops", [], () => [0, 0], () => "", () => ({}));
+		const at = form === "top-share" ? .1 : .9;
+		const nearest = (arm) => arm.points.reduce((best, d) => Math.abs(d[0] - at) < Math.abs(best[0] - at) ? d : best, arm.points[0]);
+		const marked = marker ? arms.filter((arm) => arm.points.length).map((arm) => ({
+			arm,
+			d: nearest(arm)
+		})) : [];
+		this.rules(ctx, "marker-guide", marked.length ? [{
+			key: "guide",
+			from: [at, 0],
+			to: [at, axes.y.domain()[1]],
+			dash: "2 3"
+		}] : [], axes);
+		this.dots(ctx, "marker", marked, ({ d }) => [axes.x(d[0]), axes.y(d[1])], ({ arm }) => color(arm), ({ arm, d }) => ({
+			title: arm.key,
+			color: color(arm),
+			rows: [[form === "top-share" ? "Top 10% hold" : "Bottom 90% hold", share ? `${(d[1] * 100).toFixed(1)}%` : +d[1].toFixed(2)]]
+		}), {
+			r: 6,
+			key: ({ arm }) => arm.key
+		});
+	}
+};
+export { LorenzCurve, LorenzForm, LorenzResolution };

package/dist/charts/statistics/ManhattanPlot.js

@@ -0,0 +1,222 @@
+import { ChartFamily, DataShape, Dimension, ScaleKind } from "../../core/enums.js";
+import { Scales } from "../../core/Scales.js";
+import { SampleData } from "../../data/SampleData.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+import { group, max } from "d3";
+// src/charts/statistics/ManhattanPlot.ts
+/** Width each chromosome gets. */
+var ManhattanSpacing = /* @__PURE__ */ function(ManhattanSpacing) {
+	ManhattanSpacing["Proportional"] = "proportional";
+	ManhattanSpacing["Equal"] = "equal-width";
+	return ManhattanSpacing;
+}({});
+/** How variants are drawn. */
+var ManhattanMarks = /* @__PURE__ */ function(ManhattanMarks) {
+	ManhattanMarks["Dots"] = "dots";
+	ManhattanMarks["Peaks"] = "peaks";
+	return ManhattanMarks;
+}({});
+var WIDE = 8;
+var SUGGESTIVE = 5;
+var shuffle = (i) => i * 7919 % 22;
+/** Genome-wide association results: each variant's significance along the chromosomes, with towers at real signals. */
+var ManhattanPlot = class extends StatisticalChart {
+	static meta = {
+		id: "manhattan-plot",
+		name: "Manhattan plot",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots association p-values along genome position so true signals rise as towers above the noise.",
+		tags: [
+			"gwas",
+			"genomics",
+			"miami plot",
+			"p-value"
+		],
+		sample: (seed) => SampleData.points(seed, 880, 8).map((row, i) => {
+			const chromosome = shuffle(i) + 1, along = i % 40 / 40, base = Math.max(1e-6, (+row.size - 3) / 30);
+			const peak = chromosome === 6 || chromosome === 15 ? Math.exp(-(((along - .5) / .1) ** 2)) : 0;
+			return {
+				snp: `rs${1e3 + i}`,
+				chromosome,
+				position: Math.round(along * (250 - chromosome * 9) * 1e6),
+				pvalue: +(base ** (1 + peak * 40)).toPrecision(4),
+				trait: i % 2 ? "Trait B" : "Trait A"
+			};
+		}),
+		variants: {
+			spacing: Object.values(ManhattanSpacing),
+			marks: Object.values(ManhattanMarks),
+			mirrored: [false, true],
+			scale: [ScaleKind.Linear, ScaleKind.Sqrt],
+			thresholds: [true, false],
+			labels: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			chromosome: "chromosome",
+			position: "position",
+			pvalue: "pvalue",
+			label: "snp",
+			trait: "trait",
+			spacing: "proportional",
+			marks: "dots",
+			mirrored: false,
+			scale: ScaleKind.Linear,
+			thresholds: true,
+			labels: true
+		};
+	}
+	yTicks() {
+		return this.options.scale === ScaleKind.Sqrt ? 4 : super.yTicks();
+	}
+	axisTitles() {
+		return {
+			x: "Chromosome",
+			y: "-log10 p"
+		};
+	}
+	legendItems() {
+		return [];
+	}
+	layout() {
+		const { data, chromosome, position, pvalue, label, trait, spacing, mirrored } = this.options;
+		const rows = this.complete(data, position, pvalue).filter((row) => +row[pvalue] > 0 && row[chromosome] !== null && row[chromosome] !== void 0);
+		const parts = [...group(rows, (row) => String(row[chromosome]))].sort(([a], [b]) => a.localeCompare(b, "en", { numeric: true }));
+		const traits = [...new Set(rows.map((row) => row[trait]))];
+		const points = [], stops = [];
+		const gap = (max(parts, ([, part]) => max(part, (row) => +row[position]) ?? 0) ?? 1) * .03;
+		let offset = 0, index = 0;
+		parts.forEach(([name, part], slot) => {
+			const reach = max(part, (row) => +row[position]) || 1;
+			const width = spacing === "equal-width" ? (max(parts, ([, other]) => max(other, (row) => +row[position]) ?? 0) ?? 1) * .6 : reach;
+			for (const row of part) {
+				const p = +row[pvalue];
+				points.push({
+					index: index++,
+					name: String(row[label] ?? `${name}:${row[position]}`),
+					chromosome: name,
+					slot,
+					at: offset + +row[position] / reach * width,
+					height: -Math.log10(p),
+					flipped: !!mirrored && traits.length > 1 && row[trait] === traits[1],
+					p
+				});
+			}
+			stops.push([offset + width / 2, name]);
+			offset += width + gap;
+		});
+		return {
+			points,
+			stops,
+			end: offset,
+			split: !!mirrored
+		};
+	}
+	scales(ctx) {
+		const { points, stops, end, split } = this.layout();
+		const room = ctx.plot.width / Math.max(1, stops.length);
+		const shown = stops.filter((_, i) => room >= 22 || i % Math.ceil(22 / room) === 0);
+		const x = this.labelled(this.linear([0, end || 1], [0, ctx.plot.width]), shown);
+		const top = Math.max(this.options.thresholds ? 8.6 : 6, ...points.map((d) => d.height)) * 1.06;
+		const y = Scales.continuous(this.options.scale).domain(split ? [-top, top] : [0, top]).range([ctx.plot.height, 0]);
+		if (this.options.scale === ScaleKind.Sqrt && split) return {
+			x,
+			y: this.mirroredRoot(top, ctx.plot.height)
+		};
+		return {
+			x,
+			y
+		};
+	}
+	/** A square-root axis needs a symmetric transform once values go negative. */
+	mirroredRoot(top, height) {
+		const root = (value) => Math.sign(value) * Math.sqrt(Math.abs(value));
+		const inner = this.linear([root(-top), root(top)], [height, 0]);
+		const scale = ((value) => inner(root(value)));
+		const ticks = [
+			-top,
+			-top / 3,
+			0,
+			top / 3,
+			top
+		].map(Math.round);
+		return Object.assign(scale, {
+			domain: () => [-top, top],
+			range: () => [height, 0],
+			copy: () => scale,
+			ticks: () => ticks
+		});
+	}
+	tickFormat(scale) {
+		if ("stops" in scale) return super.tickFormat(scale);
+		return (value) => `${Math.abs(Math.round(+value))}`;
+	}
+	plotMarks(ctx, axes) {
+		const { marks, thresholds, labels } = this.options;
+		const { points, end, split } = this.layout();
+		const near = ctx.palette.color("Odd chromosome"), far = ctx.theme.inkMuted, hit = ctx.palette.color("Significant");
+		const lines = split ? [1, -1] : [1];
+		const dash = "5 4";
+		this.rules(ctx, "thresholds", thresholds ? lines.flatMap((sign) => [{
+			key: `wide${sign}`,
+			from: [0, sign * WIDE],
+			to: [end, sign * WIDE],
+			dash,
+			strong: true
+		}, {
+			key: `suggestive${sign}`,
+			from: [0, sign * SUGGESTIVE],
+			to: [end, sign * SUGGESTIVE],
+			dash: "2 3"
+		}]) : [], axes);
+		this.rules(ctx, "mirror-axis", split ? [{
+			key: "zero",
+			from: [0, 0],
+			to: [end, 0],
+			strong: true
+		}] : [], axes);
+		const signed = (d) => d.flipped ? -d.height : d.height;
+		const significant = (d) => d.height >= WIDE;
+		const color = (d) => significant(d) ? hit : d.slot % 2 ? far : near;
+		const tip = (d) => ({
+			title: d.name,
+			color: color(d),
+			rows: [["Chromosome", d.chromosome], ["p", +d.p.toPrecision(3)]]
+		});
+		const base = axes.y(0);
+		const tallest = /* @__PURE__ */ new Map();
+		for (const d of marks === "peaks" ? points : []) {
+			const key = `${d.flipped}/${Math.round(axes.x(d.at) / 3)}`;
+			if (d.height > (tallest.get(key)?.height ?? -1)) tallest.set(key, d);
+		}
+		const stems = [...tallest.values()];
+		const peak = ctx.marks("peaks", "line", stems, (d) => d.index).attr("stroke", color).attr("stroke-width", 2).attr("stroke-linecap", "round");
+		ctx.set(peak, {
+			x1: (d) => axes.x(d.at),
+			x2: (d) => axes.x(d.at),
+			y1: base,
+			y2: (d) => axes.y(signed(d))
+		});
+		ctx.hover(peak, tip);
+		const dots = marks === "dots" ? [...points].sort((a, b) => a.height - b.height) : [];
+		this.dots(ctx, "points", dots, (d) => [axes.x(d.at), axes.y(signed(d))], color, tip, {
+			r: (d) => significant(d) ? 4 : 2.5,
+			key: (d) => d.index,
+			ring: false,
+			opacity: .85
+		});
+		const leads = labels ? [...group(points.filter(significant), (d) => d.chromosome).values()].map((part) => part.reduce((a, b) => b.height > a.height ? b : a)) : [];
+		this.notes(ctx, "leads", leads.map((d) => ({
+			key: `${d.index}`,
+			text: d.name,
+			x: axes.x(d.at),
+			y: axes.y(signed(d)) + (d.flipped ? 16 : -8),
+			anchor: "middle",
+			tone: "ink"
+		})));
+	}
+};
+export { ManhattanMarks, ManhattanPlot, ManhattanSpacing };

package/dist/charts/statistics/MetaAnalysis.js

@@ -0,0 +1,76 @@
+import { SampleData } from "../../data/SampleData.js";
+import { mean, sum } from "d3";
+// src/charts/statistics/MetaAnalysis.ts
+/** How study effects are pooled. */
+var PoolingModel = /* @__PURE__ */ function(PoolingModel) {
+	PoolingModel["Fixed"] = "fixed-effect";
+	PoolingModel["Random"] = "random-effects";
+	return PoolingModel;
+}({});
+/** Inverse-variance pooling for funnel and forest plots. */
+var MetaAnalysis = class MetaAnalysis {
+	/** Heterogeneous studies around a true effect, with the small-study inflation publication bias leaves. */
+	static studies(seed, count = 24) {
+		return SampleData.points(seed, count, 3).map((row, i) => {
+			const se = +(.04 + +row.size / 33 * .3).toFixed(3), noise = (+row.y - +row.x * .8 - 10) / 9;
+			return {
+				study: `Study ${String.fromCharCode(65 + i % 26)}${i >= 26 ? 2 : ""}`,
+				effect: +(.16 + i % 3 * .12 + se * (.8 + noise * 1.5)).toFixed(3),
+				se,
+				subgroup: row.group
+			};
+		});
+	}
+	static read(rows, fields) {
+		const usable = (cell) => cell !== null && cell !== void 0 && cell !== "" && Number.isFinite(+cell);
+		return (rows ?? []).filter((row) => usable(row[fields.effect]) && usable(row[fields.se]) && +row[fields.se] > 0).map((row, i) => ({
+			name: String(row[fields.study] ?? `Study ${i + 1}`),
+			effect: +row[fields.effect],
+			se: +row[fields.se],
+			subgroup: String(row[fields.subgroup] ?? "All")
+		}));
+	}
+	/** Fixed-effect or DerSimonian-Laird random-effects pooled estimate. */
+	static pool(studies, model) {
+		if (!studies.length) return {
+			effect: 0,
+			se: 0,
+			tau2: 0,
+			weights: []
+		};
+		const fixed = studies.map((d) => 1 / d.se ** 2), total = sum(fixed);
+		const centre = sum(studies, (d, i) => fixed[i] * d.effect) / total;
+		const q = sum(studies, (d, i) => fixed[i] * (d.effect - centre) ** 2);
+		const c = total - sum(fixed, (w) => w * w) / total;
+		const tau2 = model === "random-effects" && c > 0 ? Math.max(0, (q - (studies.length - 1)) / c) : 0;
+		const weights = studies.map((d) => 1 / (d.se ** 2 + tau2)), sumWeights = sum(weights);
+		return {
+			effect: sum(studies, (d, i) => weights[i] * d.effect) / sumWeights,
+			se: Math.sqrt(1 / sumWeights),
+			tau2,
+			weights: weights.map((w) => w / sumWeights)
+		};
+	}
+	/** Mirror images of the suppressed studies, by Duval and Tweedie's L0 trim and fill. */
+	static trimAndFill(studies, model) {
+		if (studies.length < 4) return [];
+		const n = studies.length;
+		const side = (mean(studies, (d) => d.effect) ?? 0) >= MetaAnalysis.pool(studies, model).effect ? 1 : -1;
+		let missing = 0, centre = 0;
+		for (let pass = 0; pass < 12; pass++) {
+			const kept = [...studies].sort((a, b) => side * (a.effect - b.effect)).slice(0, n - missing);
+			centre = MetaAnalysis.pool(kept, model).effect;
+			const ranked = studies.map((d) => d.effect - centre).sort((a, b) => Math.abs(a) - Math.abs(b));
+			const rank = sum(ranked, (gap, i) => side * gap > 0 ? i + 1 : 0);
+			const next = Math.max(0, Math.min(n - 2, Math.round((4 * rank - n * (n + 1)) / (2 * n - 1))));
+			if (next === missing) break;
+			missing = next;
+		}
+		return [...studies].sort((a, b) => side * (b.effect - a.effect)).slice(0, missing).map((d) => ({
+			...d,
+			name: `${d.name} (imputed)`,
+			effect: 2 * centre - d.effect
+		}));
+	}
+};
+export { MetaAnalysis, PoolingModel };

package/dist/charts/statistics/PPPlot.js

@@ -0,0 +1,126 @@
+import { ChartFamily, CurveKind, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { ReferenceDistribution, ReferenceLaw } from "./ReferenceLaw.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+import { ascending, group, quantileSorted } from "d3";
+// src/charts/statistics/PPPlot.ts
+/** How ranks become empirical probabilities. */
+var PlottingPosition = /* @__PURE__ */ function(PlottingPosition) {
+	PlottingPosition["Blom"] = "blom";
+	PlottingPosition["Hazen"] = "hazen";
+	PlottingPosition["Weibull"] = "weibull";
+	return PlottingPosition;
+}({});
+/** How the empirical distribution is drawn. */
+var PPMarks = /* @__PURE__ */ function(PPMarks) {
+	PPMarks["Dots"] = "dots";
+	PPMarks["Step"] = "step";
+	return PPMarks;
+}({});
+var POSITION = {
+	["blom"]: (i, n) => (i - .375) / (n + .25),
+	["hazen"]: (i, n) => (i - .5) / n,
+	["weibull"]: (i, n) => i / (n + 1)
+};
+/** Compares cumulative probabilities with a fitted reference: most sensitive in the centre, where Q-Q plots are least. */
+var PPPlot = class extends StatisticalChart {
+	static meta = {
+		id: "pp-plot",
+		name: "P-P plot",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots empirical against fitted cumulative probability to judge goodness of fit across the middle of a distribution.",
+		tags: [
+			"probability",
+			"goodness of fit",
+			"diagnostic"
+		],
+		sample: (seed) => SampleData.distribution(seed, 60, 3),
+		variants: {
+			distribution: Object.values(ReferenceDistribution),
+			position: Object.values(PlottingPosition),
+			marks: Object.values(PPMarks),
+			band: [false, true],
+			grouped: [false, true]
+		},
+		valid: ({ band, grouped }) => !(band && grouped)
+	};
+	defaults() {
+		return {
+			value: "value",
+			group: "group",
+			distribution: ReferenceDistribution.Normal,
+			position: "blom",
+			marks: "dots",
+			band: false,
+			grouped: false
+		};
+	}
+	axisTitles() {
+		return {
+			x: `Expected probability (${this.options.distribution})`,
+			y: "Empirical probability"
+		};
+	}
+	build() {
+		const { data, value, group: field, grouped, distribution, position } = this.options;
+		const law = ReferenceLaw.of(distribution), rank = POSITION[position];
+		const rows = this.complete(data, value);
+		return (grouped ? [...group(rows, (row) => String(row[field] ?? "Missing"))] : rows.length ? [["Sample", rows]] : []).map(([key, part]) => {
+			const sorted = part.map((row) => +row[value]).sort(ascending), n = sorted.length;
+			const { intercept, slope } = ReferenceLaw.quartileFit(law, quantileSorted(sorted, .25), quantileSorted(sorted, .75));
+			return [key, sorted.map((datum, i) => ({
+				key,
+				value: datum,
+				empirical: rank(i + 1, n),
+				expected: slope ? law.cdf((datum - intercept) / slope) : .5
+			}))];
+		});
+	}
+	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 { band, marks } = this.options;
+		const parts = this.build();
+		const color = (key) => ctx.palette.color(key);
+		const n = parts[0]?.[1].length ?? 1, reach = 1.358 / Math.sqrt(n);
+		this.ribbons(ctx, "band", band && parts.length ? [{
+			key: "ks",
+			color: color(parts[0][0]),
+			points: [0, 1].map((x) => [
+				x,
+				Math.max(0, x - reach),
+				Math.min(1, x + reach)
+			])
+		}] : [], axes);
+		this.rules(ctx, "identity", [{
+			key: "identity",
+			from: [0, 0],
+			to: [1, 1],
+			dash: "5 4"
+		}], axes);
+		const step = marks === "step";
+		this.traces(ctx, "steps", step ? parts.map(([key, points]) => ({
+			key,
+			color: color(key),
+			curve: CurveKind.StepAfter,
+			points: points.map((d) => [d.expected, d.empirical])
+		})) : [], axes);
+		const dots = step ? [] : parts.flatMap(([, points]) => points);
+		this.dots(ctx, "points", dots, (d) => [axes.x(d.expected), axes.y(d.empirical)], (d) => color(d.key), (d) => ({
+			title: d.key,
+			color: color(d.key),
+			rows: [
+				["Value", d.value],
+				["Expected", +d.expected.toFixed(3)],
+				["Empirical", +d.empirical.toFixed(3)]
+			]
+		}), { key: (d) => `${d.key}/${d.empirical}` });
+	}
+};
+export { PPMarks, PPPlot, PlottingPosition };

package/dist/charts/statistics/PartialAutocorrelation.js

@@ -0,0 +1,77 @@
+import { Orientation } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { CorrelogramBase, CorrelogramMarks } from "./CorrelogramBase.js";
+import { RegressionFit } from "./RegressionFit.js";
+import { StatMath } from "./StatMath.js";
+// src/charts/statistics/PartialAutocorrelation.ts
+/** Estimator of partial autocorrelation. */
+var PacfMethod = /* @__PURE__ */ function(PacfMethod) {
+	PacfMethod["YuleWalker"] = "yule-walker";
+	PacfMethod["Burg"] = "burg";
+	PacfMethod["LeastSquares"] = "least-squares";
+	return PacfMethod;
+}({});
+/** Identifies autoregressive order: the correlation left at each lag after removing all shorter lags. */
+var PartialAutocorrelation = class extends CorrelogramBase {
+	static meta = {
+		id: "partial-autocorrelation-plot",
+		name: "Partial autocorrelation",
+		...CorrelogramBase.family,
+		description: "Shows the direct correlation at each lag with shorter lags removed, to choose an autoregressive order.",
+		tags: [
+			"pacf",
+			"correlogram",
+			"time series",
+			"arima"
+		],
+		sample: (seed) => SampleData.timeSeries(seed, 150, 1),
+		variants: {
+			marks: Object.values(CorrelogramMarks),
+			difference: [
+				0,
+				1,
+				2
+			],
+			method: Object.values(PacfMethod),
+			band: [true, false],
+			orientation: [Orientation.Vertical, Orientation.Horizontal]
+		}
+	};
+	defaults() {
+		return {
+			value: "value",
+			series: "series",
+			marks: CorrelogramMarks.Stems,
+			difference: 0,
+			method: "yule-walker",
+			band: true,
+			orientation: Orientation.Vertical
+		};
+	}
+	statisticName() {
+		return "Partial autocorrelation";
+	}
+	leastSquares(values, maxLag) {
+		return Array.from({ length: maxLag }, (_, k) => {
+			const lag = k + 1;
+			const design = values.slice(lag).map((_, t) => [1, ...Array.from({ length: lag }, (_, j) => values[t + lag - 1 - j])]);
+			return RegressionFit.onDesign(design, values.slice(lag)).at(-1);
+		});
+	}
+	estimates() {
+		const { method, band } = this.options;
+		return this.sequences().flatMap(([series, values]) => {
+			if (values.length < 4) return [];
+			const lags = Math.min(this.lags(values.length), 24);
+			const estimates = method === "burg" ? StatMath.pacfBurg(values, lags) : method === "least-squares" ? this.leastSquares(values, lags) : StatMath.pacfYuleWalker(StatMath.acf(values, lags));
+			const limit = band ? 1.96 / Math.sqrt(values.length) : 0;
+			return estimates.map((value, i) => ({
+				series,
+				lag: i + 1,
+				value,
+				limit
+			}));
+		});
+	}
+};
+export { PacfMethod, PartialAutocorrelation };