@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/signals/index.js

@@ -0,0 +1,60 @@
+import { SignalAmplitude, SignalFrequencyScale, SignalLayout, SignalWavelet, SignalWindow } from "./SignalEnums.js";
+import { SignalDsp } from "./SignalDsp.js";
+import { SignalScales } from "./SignalScales.js";
+import { SignalChart, SignalParser } from "./SignalChart.js";
+import { AudiogramChart, AudiogramLayout, AudiogramSpacing } from "./AudiogramChart.js";
+import { SignalSamples } from "./SignalSamples.js";
+import { CepstrumAxis, CepstrumChart, CepstrumKind, CepstrumMark } from "./CepstrumChart.js";
+import { SignalRaster } from "./SignalRaster.js";
+import { ConstellationChart, ConstellationDisplay } from "./ConstellationChart.js";
+import { CorrelogramBand, CorrelogramChart, CorrelogramFunction, CorrelogramMark } from "./CorrelogramChart.js";
+import { ECGChart, EcgAnnotation, EcgLayout, EcgView } from "./ECGChart.js";
+import { EnvelopeChart, EnvelopeMethod, EnvelopeShape } from "./EnvelopeChart.js";
+import { EyeDiagramChart, EyeDisplay } from "./EyeDiagramChart.js";
+import { FilterResponseChart, FilterView } from "./FilterResponseChart.js";
+import { ImpulseMark, ImpulseResponseChart, ImpulseTime, ImpulseView } from "./ImpulseResponseChart.js";
+import { LogicAnalyzerChart, LogicDisplay, LogicEdge } from "./LogicAnalyzerChart.js";
+import { OscilloscopeChart, ScopeCoupling, ScopeDisplay, ScopeMode, ScopeTrigger } from "./OscilloscopeChart.js";
+import { SpectralChart } from "./SpectralChart.js";
+import { PeriodogramAbscissa, PeriodogramChart, PeriodogramMethod } from "./PeriodogramChart.js";
+import { Phase3DCoordinates, Phase3DStyle, PhaseSpace3DChart } from "./PhaseSpace3DChart.js";
+import { PhaseCoordinates, PhaseMark, PhaseSpaceChart } from "./PhaseSpaceChart.js";
+import { PolePlane, PoleZeroChart } from "./PoleZeroChart.js";
+import { SeismogramChart, SeismogramFill, SeismogramGain, SeismogramLayout } from "./SeismogramChart.js";
+import { TimeFrequencyChart } from "./TimeFrequencyChart.js";
+import { SignalSpectrogramChart } from "./SpectrogramChart.js";
+import { SpectrumChart, SpectrumMark } from "./SpectrumChart.js";
+import { StemReconstruction, StemSignalChart } from "./StemSignalChart.js";
+import { DiffMetric, DiffView, TimeDomainDiffChart } from "./TimeDomainDiffChart.js";
+import { WaterfallFill, WaterfallOrder, WaterfallProjection, WaterfallSpectrum } from "./WaterfallSpectrum.js";
+import { SurfaceSpectrumStyle, WaterfallSurface3DChart } from "./WaterfallSurface3DChart.js";
+import { WaveformChart, WaveformStyle } from "./WaveformChart.js";
+import { WaveletAxis, WaveletScalogram, WaveletValue } from "./WaveletScalogram.js";
+// src/charts/signals/index.ts
+var signalsCatalog = [
+	WaveformChart,
+	OscilloscopeChart,
+	StemSignalChart,
+	EnvelopeChart,
+	TimeDomainDiffChart,
+	SpectrumChart,
+	PeriodogramChart,
+	SignalSpectrogramChart,
+	WaterfallSpectrum,
+	WaterfallSurface3DChart,
+	WaveletScalogram,
+	CepstrumChart,
+	CorrelogramChart,
+	ImpulseResponseChart,
+	FilterResponseChart,
+	PoleZeroChart,
+	AudiogramChart,
+	SeismogramChart,
+	ECGChart,
+	LogicAnalyzerChart,
+	EyeDiagramChart,
+	ConstellationChart,
+	PhaseSpaceChart,
+	PhaseSpace3DChart
+];
+export { AudiogramChart, AudiogramLayout, AudiogramSpacing, CepstrumAxis, CepstrumChart, CepstrumKind, CepstrumMark, ConstellationChart, ConstellationDisplay, CorrelogramBand, CorrelogramChart, CorrelogramFunction, CorrelogramMark, DiffMetric, DiffView, ECGChart, EcgAnnotation, EcgLayout, EcgView, EnvelopeChart, EnvelopeMethod, EnvelopeShape, EyeDiagramChart, EyeDisplay, FilterResponseChart, FilterView, ImpulseMark, ImpulseResponseChart, ImpulseTime, ImpulseView, LogicAnalyzerChart, LogicDisplay, LogicEdge, OscilloscopeChart, PeriodogramAbscissa, PeriodogramChart, PeriodogramMethod, Phase3DCoordinates, Phase3DStyle, PhaseCoordinates, PhaseMark, PhaseSpace3DChart, PhaseSpaceChart, PolePlane, PoleZeroChart, ScopeCoupling, ScopeDisplay, ScopeMode, ScopeTrigger, SeismogramChart, SeismogramFill, SeismogramGain, SeismogramLayout, SignalAmplitude, SignalChart, SignalDsp, SignalFrequencyScale, SignalLayout, SignalParser, SignalRaster, SignalSamples, SignalScales, SignalSpectrogramChart, SignalWavelet, SignalWindow, SpectralChart, SpectrumChart, SpectrumMark, StemReconstruction, StemSignalChart, SurfaceSpectrumStyle, TimeDomainDiffChart, TimeFrequencyChart, WaterfallFill, WaterfallOrder, WaterfallProjection, WaterfallSpectrum, WaterfallSurface3DChart, WaveformChart, WaveformStyle, WaveletAxis, WaveletScalogram, WaveletValue, signalsCatalog };

package/dist/charts/statistics/AttributeControlChart.js

@@ -0,0 +1,115 @@
+import { SampleData } from "../../data/SampleData.js";
+import { ProcessChartBase } from "./ProcessChartBase.js";
+import { ProcessRuleset } from "./ProcessRules.js";
+import { mean, sum } from "d3";
+// src/charts/statistics/AttributeControlChart.ts
+/** Count statistic of an attributes chart. */
+var AttributeStatistic = /* @__PURE__ */ function(AttributeStatistic) {
+	AttributeStatistic["Proportion"] = "p-chart";
+	AttributeStatistic["Count"] = "np-chart";
+	AttributeStatistic["Defects"] = "c-chart";
+	AttributeStatistic["Rate"] = "u-chart";
+	return AttributeStatistic;
+}({});
+/** How limits respond to changing sample sizes. */
+var AttributeLimits = /* @__PURE__ */ function(AttributeLimits) {
+	AttributeLimits["Stepped"] = "stepped-limits";
+	AttributeLimits["Average"] = "average-limits";
+	return AttributeLimits;
+}({});
+/** Control chart for counted defects: p, np, c and u forms, with limits that follow the sample size. */
+var AttributeControlChart = class extends ProcessChartBase {
+	static meta = {
+		id: "attribute-control-chart",
+		name: "Attribute control chart",
+		...ProcessChartBase.family,
+		description: "Tracks defect counts or rates against binomial or Poisson control limits, for pass-fail quality data.",
+		tags: [
+			"spc",
+			"p chart",
+			"np chart",
+			"c chart",
+			"u chart",
+			"laney",
+			"quality"
+		],
+		sample: (seed) => SampleData.points(seed, 48, 1).map((row, i) => ({
+			sample: i + 1,
+			defects: Math.round(+row.size / 2.4) + (i > 40 ? 5 : 0),
+			inspected: Math.round(60 + +row.x * 2)
+		})),
+		variants: {
+			statistic: Object.values(AttributeStatistic),
+			limits: Object.values(AttributeLimits),
+			laney: [false, true],
+			rules: [ProcessRuleset.Limits, ProcessRuleset.WesternElectric],
+			connect: [true, false]
+		},
+		valid: ({ statistic, limits, laney }) => {
+			const scaled = statistic === "p-chart" || statistic === "u-chart";
+			if (laney) return statistic === "p-chart" && limits === "stepped-limits";
+			return scaled || limits === "stepped-limits";
+		}
+	};
+	defaults() {
+		return {
+			defects: "defects",
+			inspected: "inspected",
+			statistic: "p-chart",
+			limits: "stepped-limits",
+			laney: false,
+			rules: ProcessRuleset.Limits,
+			zones: false,
+			connect: true
+		};
+	}
+	statisticName() {
+		return {
+			["p-chart"]: "Proportion defective",
+			["np-chart"]: "Defective units",
+			["c-chart"]: "Defects",
+			["u-chart"]: "Defects per unit"
+		}[this.options.statistic];
+	}
+	axisTitles() {
+		return {
+			x: "Sample",
+			y: this.statisticName()
+		};
+	}
+	points() {
+		const { data, defects, inspected, statistic, limits, laney } = this.options;
+		const rows = this.complete(data, defects, ...statistic === "c-chart" ? [] : [inspected]).filter((row) => statistic === "c-chart" || +row[inspected] > 0);
+		const counts = rows.map((row) => +row[defects]);
+		const sizes = rows.map((row) => statistic === "c-chart" ? 1 : +row[inspected]);
+		const average = mean(sizes) ?? 1, centerRate = sum(counts) / (sum(sizes) || 1);
+		const binomial = statistic === "p-chart" || statistic === "np-chart";
+		const sigmaFor = (n) => Math.sqrt(Math.max(0, binomial ? centerRate * (1 - centerRate) : centerRate) / n);
+		const scaled = statistic === "p-chart" || statistic === "u-chart";
+		const z = counts.map((count, i) => {
+			const sigma = sigmaFor(sizes[i]);
+			return sigma ? (count / sizes[i] - centerRate) / sigma : 0;
+		});
+		const dispersion = laney ? (mean(z.slice(1).map((value, i) => Math.abs(value - z[i]))) ?? 1.128) / 1.128 : 1;
+		return counts.map((count, i) => {
+			const n = limits === "average-limits" ? average : sizes[i];
+			const spread = sigmaFor(n) * dispersion;
+			if (scaled) return {
+				slot: i + 1,
+				value: count / sizes[i],
+				center: centerRate,
+				upper: centerRate + 3 * spread,
+				lower: Math.max(0, centerRate - 3 * spread)
+			};
+			const expected = centerRate * average, reach = 3 * sigmaFor(average) * average;
+			return {
+				slot: i + 1,
+				value: count,
+				center: expected,
+				upper: expected + reach,
+				lower: Math.max(0, expected - reach)
+			};
+		});
+	}
+};
+export { AttributeControlChart, AttributeLimits, AttributeStatistic };

package/dist/charts/statistics/AutocorrelationPlot.js

@@ -0,0 +1,76 @@
+import { Orientation } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { CorrelogramBase, CorrelogramMarks } from "./CorrelogramBase.js";
+import { StatMath } from "./StatMath.js";
+// src/charts/statistics/AutocorrelationPlot.ts
+/** Significance band of an autocorrelation plot. */
+var AutocorrelationBand = /* @__PURE__ */ function(AutocorrelationBand) {
+	AutocorrelationBand["WhiteNoise"] = "white-noise-band";
+	AutocorrelationBand["Bartlett"] = "bartlett-band";
+	AutocorrelationBand["None"] = "no-band";
+	return AutocorrelationBand;
+}({});
+/** Finds the memory, trend and seasonality of a series: spikes at a lag mean values repeat at that spacing. */
+var AutocorrelationPlot = class extends CorrelogramBase {
+	static meta = {
+		id: "autocorrelation-plot",
+		name: "Autocorrelation plot",
+		...CorrelogramBase.family,
+		description: "Shows how strongly a time series correlates with its own past at each lag, to expose trend and seasonality.",
+		tags: [
+			"acf",
+			"correlogram",
+			"time series",
+			"arima"
+		],
+		sample: (seed) => SampleData.timeSeries(seed, 150, 1),
+		variants: {
+			marks: Object.values(CorrelogramMarks),
+			difference: [
+				0,
+				1,
+				2
+			],
+			band: Object.values(AutocorrelationBand),
+			orientation: [Orientation.Vertical, Orientation.Horizontal],
+			logged: [false, true]
+		}
+	};
+	defaults() {
+		return {
+			value: "value",
+			series: "series",
+			marks: CorrelogramMarks.Stems,
+			difference: 0,
+			band: "white-noise-band",
+			orientation: Orientation.Vertical,
+			logged: false
+		};
+	}
+	statisticName() {
+		return "Autocorrelation";
+	}
+	prepare(values) {
+		return this.options.logged && values.every((v) => v > 0) ? values.map(Math.log) : values;
+	}
+	estimates() {
+		const { band } = this.options;
+		return this.sequences().flatMap(([series, values]) => {
+			if (values.length < 3) return [];
+			const rho = StatMath.acf(values, this.lags(values.length)), n = values.length;
+			let running = 0;
+			return rho.slice(1).map((value, i) => {
+				const bartlett = 1.96 * Math.sqrt((1 + 2 * running) / n);
+				running += value * value;
+				const limit = band === "no-band" ? 0 : band === "bartlett-band" ? bartlett : 1.96 / Math.sqrt(n);
+				return {
+					series,
+					lag: i + 1,
+					value,
+					limit
+				};
+			});
+		});
+	}
+};
+export { AutocorrelationBand, AutocorrelationPlot };

package/dist/charts/statistics/BlandAltmanPlot.js

@@ -0,0 +1,251 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { RegressionFit } from "./RegressionFit.js";
+import { StatMath } from "./StatMath.js";
+import { StatisticalChart } from "./StatisticalChart.js";
+import { ascending, bin, deviation, mean, quantile } from "d3";
+// src/charts/statistics/BlandAltmanPlot.ts
+/** How two measurements of one subject are compared. */
+var AgreementDifference = /* @__PURE__ */ function(AgreementDifference) {
+	AgreementDifference["Absolute"] = "absolute";
+	AgreementDifference["Percent"] = "percent";
+	AgreementDifference["Ratio"] = "ratio";
+	return AgreementDifference;
+}({});
+/** Horizontal axis of a Bland-Altman plot. */
+var AgreementReference = /* @__PURE__ */ function(AgreementReference) {
+	AgreementReference["Mean"] = "mean-of-methods";
+	AgreementReference["First"] = "first-method";
+	return AgreementReference;
+}({});
+/** How limits of agreement are estimated. */
+var AgreementLimits = /* @__PURE__ */ function(AgreementLimits) {
+	AgreementLimits["Parametric"] = "parametric";
+	AgreementLimits["Regression"] = "regression-limits";
+	AgreementLimits["Nonparametric"] = "nonparametric";
+	return AgreementLimits;
+}({});
+/** Asks whether two measurement methods agree well enough to swap, which correlation cannot answer. */
+var BlandAltmanPlot = class extends StatisticalChart {
+	static meta = {
+		id: "bland-altman-plot",
+		name: "Bland-Altman plot",
+		family: ChartFamily.Statistical,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Plots the difference between two measurement methods against their mean, with bias and limits of agreement.",
+		tags: [
+			"method comparison",
+			"agreement",
+			"tukey mean-difference",
+			"clinical"
+		],
+		sample: (seed) => SampleData.points(seed, 60, 3).map((row) => ({
+			a: row.x,
+			b: row.y
+		})),
+		variants: {
+			difference: Object.values(AgreementDifference),
+			reference: Object.values(AgreementReference),
+			limits: Object.values(AgreementLimits),
+			limitConfidence: [false, true],
+			marginal: [false, true]
+		},
+		valid: ({ limits, limitConfidence }) => !(limitConfidence && limits !== "parametric")
+	};
+	defaults() {
+		return {
+			a: "a",
+			b: "b",
+			difference: "absolute",
+			reference: "mean-of-methods",
+			limits: "parametric",
+			limitConfidence: false,
+			marginal: false
+		};
+	}
+	axisTitles() {
+		return {
+			x: this.options.reference === "mean-of-methods" ? "Mean of methods" : "First method",
+			y: {
+				["absolute"]: "Difference",
+				["percent"]: "Difference (%)",
+				["ratio"]: "log ratio"
+			}[this.options.difference]
+		};
+	}
+	points() {
+		const { data, a, b, difference, reference } = this.options;
+		return this.complete(data, a, b).flatMap((row, index) => {
+			const first = +row[a], second = +row[b], middle = (first + second) / 2;
+			if (difference === "ratio" && (first <= 0 || second <= 0)) return [];
+			if (difference === "percent" && middle === 0) return [];
+			const gap = difference === "absolute" ? first - second : difference === "percent" ? (first - second) / middle * 100 : Math.log(first / second);
+			return [{
+				index,
+				a: first,
+				b: second,
+				at: reference === "mean-of-methods" ? middle : first,
+				difference: gap
+			}];
+		});
+	}
+	/** Bias and limits as lines over x, plus the half-width of the confidence interval of each. */
+	bounds(points) {
+		const { limits } = this.options;
+		const values = points.map((d) => d.difference), n = values.length;
+		const bias = mean(values) ?? 0, sd = deviation(values) ?? 0;
+		const t = n > 2 ? StatMath.tQuantile(.975, n - 1) : 1.96;
+		const biasHalf = t * sd / Math.sqrt(n || 1), limitHalf = t * sd * Math.sqrt(3 / (n || 1));
+		if (limits === "nonparametric") {
+			const sorted = [...values].sort(ascending), lower = quantile(sorted, .025) ?? 0, upper = quantile(sorted, .975) ?? 0, centre = quantile(sorted, .5) ?? 0;
+			return {
+				centre: () => centre,
+				lower: () => lower,
+				upper: () => upper,
+				biasHalf,
+				limitHalf
+			};
+		}
+		if (limits === "regression-limits" && n > 3) {
+			const xs = points.map((d) => d.at), fit = new RegressionFit(xs, values);
+			const spread = new RegressionFit(xs, fit.residuals.map((e) => Math.abs(e) * 1.2533));
+			const reach = (x) => 1.96 * Math.max(0, spread.predict(x));
+			return {
+				centre: (x) => fit.predict(x),
+				lower: (x) => fit.predict(x) - reach(x),
+				upper: (x) => fit.predict(x) + reach(x),
+				biasHalf,
+				limitHalf
+			};
+		}
+		return {
+			centre: () => bias,
+			lower: () => bias - 1.96 * sd,
+			upper: () => bias + 1.96 * sd,
+			biasHalf,
+			limitHalf
+		};
+	}
+	scales(ctx) {
+		const points = this.points(), { lower, upper, limitHalf } = this.bounds(points);
+		const [low, high] = this.span(points.map((d) => d.at));
+		const pad = this.options.limitConfidence ? limitHalf : 0;
+		const extents = [low, high].flatMap((x) => [lower(x) - pad, upper(x) + pad]);
+		return {
+			x: this.linear([low, high], [0, ctx.plot.width - (this.options.marginal ? Math.min(64, ctx.plot.width * .16) : 0)]),
+			y: this.linear(this.span([
+				...points.map((d) => d.difference),
+				...extents,
+				0
+			]), [ctx.plot.height, 0])
+		};
+	}
+	plotMarks(ctx, axes) {
+		const { limitConfidence, marginal } = this.options;
+		const points = this.points(), { centre, lower, upper, biasHalf, limitHalf } = this.bounds(points);
+		const [left, right] = axes.x.domain();
+		const ink = ctx.palette.color("Subjects");
+		const band = (line, half, key) => ({
+			key,
+			color: ink,
+			opacity: .12,
+			points: [left, right].map((x) => [
+				x,
+				line(x) - half,
+				line(x) + half
+			])
+		});
+		this.ribbons(ctx, "confidence", limitConfidence ? [
+			band(lower, limitHalf, "lower"),
+			band(centre, biasHalf, "bias"),
+			band(upper, limitHalf, "upper")
+		] : [], axes);
+		const edge = (line) => [[left, line(left)], [right, line(right)]];
+		this.rules(ctx, "zero", [{
+			key: "zero",
+			from: [left, 0],
+			to: [right, 0]
+		}], axes);
+		this.traces(ctx, "bias", [
+			{
+				key: "Bias",
+				color: ctx.theme.ink,
+				points: edge(centre)
+			},
+			{
+				key: "Lower limit",
+				color: ctx.theme.inkSecondary,
+				dash: "6 4",
+				width: 1.5,
+				points: edge(lower)
+			},
+			{
+				key: "Upper limit",
+				color: ctx.theme.inkSecondary,
+				dash: "6 4",
+				width: 1.5,
+				points: edge(upper)
+			}
+		], axes);
+		const outside = (d) => d.difference < lower(d.at) || d.difference > upper(d.at);
+		this.dots(ctx, "points", points, (d) => [axes.x(d.at), axes.y(d.difference)], (d) => outside(d) ? ctx.theme.critical : ink, (d) => ({
+			title: `Subject ${d.index + 1}`,
+			color: ink,
+			rows: [
+				["First method", d.a],
+				["Second method", d.b],
+				["Difference", +d.difference.toFixed(3)]
+			]
+		}), { key: (d) => d.index });
+		const labelAt = axes.x(right) - 4;
+		const fmt = (value) => Math.abs(value) < 10 ? value.toFixed(2) : value.toFixed(1);
+		const [high, low] = this.options.limits === "nonparametric" ? ["97.5th pct", "2.5th pct"] : ["+1.96 SD", "-1.96 SD"];
+		const bias = this.options.limits === "nonparametric" ? "Median" : "Bias";
+		this.notes(ctx, "limit-labels", points.length ? [
+			{
+				key: "upper",
+				text: `${high} ${fmt(upper(right))}`,
+				x: labelAt,
+				y: axes.y(upper(right)) - 5,
+				anchor: "end"
+			},
+			{
+				key: "bias",
+				text: `${bias} ${fmt(centre(right))}`,
+				x: labelAt,
+				y: axes.y(centre(right)) - 5,
+				anchor: "end"
+			},
+			{
+				key: "lower",
+				text: `${low} ${fmt(lower(right))}`,
+				x: labelAt,
+				y: axes.y(lower(right)) + 13,
+				anchor: "end"
+			}
+		] : []);
+		const [floor, ceiling] = axes.y.domain();
+		const bins = marginal ? bin().domain([floor, ceiling]).thresholds(14)(points.map((d) => d.difference)) : [];
+		const top = Math.max(1, ...bins.map((b) => b.length)), start = axes.x(right) + 8, room = ctx.plot.width - start;
+		const bars = ctx.marks("marginal", "rect", bins, (b) => b.x0).attr("fill", ink).attr("fill-opacity", .5).attr("rx", 2);
+		const y = (b) => axes.y(b.x1) + 1, h = (b) => Math.max(1, axes.y(b.x0) - axes.y(b.x1) - 2);
+		ctx.set(bars, {
+			x: start,
+			y,
+			height: h,
+			width: (b) => b.length / top * room
+		}, {
+			x: start,
+			y,
+			height: h,
+			width: 0
+		}, 8);
+		ctx.hover(bars, (b) => ({
+			title: `${fmt(b.x0)} to ${fmt(b.x1)}`,
+			color: ink,
+			rows: [["Subjects", b.length]]
+		}));
+	}
+};
+export { AgreementDifference, AgreementLimits, AgreementReference, BlandAltmanPlot };