@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/signals/EyeDiagramChart.js

@@ -0,0 +1,155 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SignalChart } from "./SignalChart.js";
+import { SignalDsp } from "./SignalDsp.js";
+import { SignalRaster } from "./SignalRaster.js";
+import { SignalSamples } from "./SignalSamples.js";
+import { SignalScales } from "./SignalScales.js";
+import { max, scaleLinear } from "d3";
+// src/charts/signals/EyeDiagramChart.ts
+var EyeDisplay = /* @__PURE__ */ function(EyeDisplay) {
+	EyeDisplay["Traces"] = "traces";
+	EyeDisplay["Density"] = "density";
+	return EyeDisplay;
+}({});
+var OVERSAMPLE = 16;
+var CELL = 3;
+var MOST = 160;
+/** Overlays bit periods of a serial link so that noise and jitter show as a closing eye. */
+var EyeDiagramChart = class extends SignalChart {
+	static meta = {
+		id: "signal-eye-diagram",
+		name: "Eye diagram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Folds a digital signal over its symbol period so that noise, jitter and timing margin read as an eye opening.",
+		tags: [
+			"serdes",
+			"signal integrity",
+			"jitter",
+			"mask test"
+		],
+		sample: (seed) => {
+			const [{ noise }] = SignalSamples.noise(seed, 3200, 1), bits = Array.from({ length: 200 }, (_, i) => noise[i * OVERSAMPLE] > 0 ? 1 : -1);
+			let level = 0;
+			return noise.map((step, i) => {
+				level += (bits[Math.floor(i / OVERSAMPLE)] - level) * .28;
+				return {
+					t: i / OVERSAMPLE,
+					series: "Lane 0",
+					value: +(level + step * .045).toFixed(4)
+				};
+			});
+		},
+		variants: {
+			display: Object.values(EyeDisplay),
+			span: [2, 1],
+			mask: [true, false],
+			measure: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			xLabel: "Time (UI)",
+			yLabel: "Amplitude",
+			grid: false,
+			display: "traces",
+			samplesPerSymbol: OVERSAMPLE,
+			span: 2,
+			mask: true,
+			measure: true
+		};
+	}
+	get legended() {
+		return false;
+	}
+	get levels() {
+		const { v } = this.first, centre = v.reduce((sum, value) => sum + value, 0) / (v.length || 1);
+		const highs = v.filter((value) => value > centre), lows = v.filter((value) => value <= centre);
+		const mean = (values) => values.reduce((sum, value) => sum + value, 0) / (values.length || 1);
+		const high = mean(highs), low = mean(lows);
+		return {
+			high,
+			low,
+			mid: (high + low) / 2
+		};
+	}
+	/** Samples into a symbol at which transitions cross mid level: circular mean over all crossings. */
+	get phase() {
+		const { v } = this.first, per = this.options.samplesPerSymbol, { mid } = this.levels;
+		let sin = 0, cos = 0;
+		for (let i = 1; i < v.length; i++) if ((v[i - 1] - mid) * (v[i] - mid) < 0) {
+			const angle = 2 * Math.PI * i / per;
+			sin += Math.sin(angle);
+			cos += Math.cos(angle);
+		}
+		return Math.round((Math.atan2(sin, cos) / (2 * Math.PI) + 1) % 1 * per);
+	}
+	/** One sweep per symbol, each a list of [ui, value] with transitions on whole UIs. */
+	get sweeps() {
+		const { samplesPerSymbol, span } = this.options, { v } = this.first, per = samplesPerSymbol, length = per * span, out = [];
+		for (let start = this.phase; start + length < v.length && out.length < MOST; start += per) out.push(Array.from({ length: length + 1 }, (_, i) => [i / per, v[start + i]]));
+		return out;
+	}
+	scales(ctx) {
+		const reach = this.peak * 1.2;
+		return {
+			x: scaleLinear([0, this.options.span], [0, ctx.plot.width]),
+			y: scaleLinear([-reach, reach], [ctx.plot.height, 0])
+		};
+	}
+	plotMarks(ctx, { x, y }) {
+		const { display, mask, measure, span } = this.options, sweeps = this.sweeps, color = ctx.palette.color(this.first.name);
+		if (display === "traces") this.stroke(ctx, "sweeps", sweeps, (_, i) => i, (sweep) => this.path(sweep, x, y), () => color, 1).attr("stroke-opacity", .28);
+		else this.density(ctx, sweeps, x, y);
+		const { high, low, mid } = this.levels, centers = Array.from({ length: span }, (_, i) => i + .5), half = (high - low) * .34;
+		if (mask) {
+			const d = centers.map((c) => `M${x(c - .22)} ${y(mid)}L${x(c - .1)} ${y(mid + half)}H${x(c + .1)}L${x(c + .22)} ${y(mid)}L${x(c + .1)} ${y(mid - half)}H${x(c - .1)}Z`).join("");
+			ctx.marks("mask", "path", [d], (_, i) => i).attr("d", (shape) => shape).attr("fill", ctx.theme.surface).attr("fill-opacity", .8).attr("stroke", ctx.theme.ink).attr("stroke-width", 1);
+		}
+		if (measure) this.measure(ctx, sweeps, x, y, centers[0], high, low);
+		this.probe(ctx, (px, py) => ({
+			x: px,
+			tip: {
+				title: `${SignalScales.number(x.invert(px))} UI`,
+				rows: [["Amplitude", SignalScales.number(y.invert(py))], ["Traces", sweeps.length]]
+			},
+			datum: { ui: x.invert(px) }
+		}));
+	}
+	density(ctx, sweeps, x, y) {
+		const { width, height } = ctx.plot, columns = Math.ceil(width / CELL), rows = Math.ceil(height / CELL);
+		const counts = new Array(columns * rows).fill(0);
+		for (const sweep of sweeps) for (let i = 1; i < sweep.length; i++) {
+			const [ax, ay] = [x(sweep[i - 1][0]), y(sweep[i - 1][1])], [bx, by] = [x(sweep[i][0]), y(sweep[i][1])], steps = Math.ceil(Math.max(Math.abs(bx - ax), Math.abs(by - ay)) / CELL) + 1;
+			for (let s = 0; s < steps; s++) {
+				const c = Math.floor((ax + (bx - ax) * s / steps) / CELL), r = Math.floor((ay + (by - ay) * s / steps) / CELL);
+				if (c >= 0 && c < columns && r >= 0 && r < rows) counts[r * columns + c]++;
+			}
+		}
+		const top = max(counts) || 1, cells = [];
+		counts.forEach((count, i) => {
+			if (count) cells.push({
+				x: i % columns * CELL,
+				y: Math.floor(i / columns) * CELL,
+				width: CELL,
+				height: CELL,
+				level: Math.max(.12, Math.sqrt(count / top))
+			});
+		});
+		SignalRaster.paint(ctx, "density", cells, ctx.palette.sequential);
+	}
+	/** Eye height from the inner rails at centre; eye width from where inner traces cross the mid level. */
+	measure(ctx, sweeps, x, y, centre, high, low) {
+		const mid = (high + low) / 2, values = sweeps.map((sweep) => SignalDsp.interpolate(sweep.map((point) => point[0]), sweep.map((point) => point[1]), centre));
+		const upper = Math.min(...values.filter((value) => value >= mid), high), lower = Math.max(...values.filter((value) => value < mid), low);
+		const crossings = sweeps.flatMap((sweep) => sweep.flatMap(([ui, value], i) => i && (sweep[i - 1][1] - mid) * (value - mid) < 0 ? [ui] : []));
+		const left = Math.max(0, ...crossings.filter((ui) => ui < centre)), right = Math.min(centre + .5, ...crossings.filter((ui) => ui >= centre));
+		const d = `M${x(centre)} ${y(upper)}V${y(lower)}M${x(left)} ${y(mid)}H${x(right)}`;
+		ctx.marks("eye-rulers", "path", [d], (_, i) => i).attr("d", (shape) => shape).attr("fill", "none").attr("stroke", ctx.theme.ink).attr("stroke-width", 1);
+		const line = `Height ${SignalScales.number(upper - lower)}  Width ${SignalScales.number(right - left)} UI`;
+		ctx.text(ctx.marks("eye-text", "text", [line], (_, i) => i).attr("x", ctx.plot.width - 4).attr("y", 12).attr("text-anchor", "end").text((text) => text), 11, "ink");
+	}
+};
+export { EyeDiagramChart, EyeDisplay };

package/dist/charts/signals/FilterResponseChart.js

@@ -0,0 +1,264 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { ZoomAxis } from "../../core/ChartViewport.js";
+import { SampleData } from "../../data/SampleData.js";
+import { SignalChart } from "./SignalChart.js";
+import { SignalAmplitude, SignalFrequencyScale } from "./SignalEnums.js";
+import { SignalScales } from "./SignalScales.js";
+import { group, max, min, scaleLinear } from "d3";
+// src/charts/signals/FilterResponseChart.ts
+var FilterView = /* @__PURE__ */ function(FilterView) {
+	FilterView["Bode"] = "bode";
+	FilterView["Magnitude"] = "magnitude";
+	FilterView["Phase"] = "phase";
+	FilterView["GroupDelay"] = "group-delay";
+	FilterView["Nyquist"] = "nyquist";
+	return FilterView;
+}({});
+var unwrapped = (phase) => {
+	const out = [...phase];
+	for (let i = 1; i < out.length; i++) out[i] -= 360 * Math.round((out[i] - out[i - 1]) / 360);
+	return out;
+};
+var SAMPLE_POINTS = 140;
+/** Evaluates a low-pass prototype at `w` (rad/s normalised to cutoff) from its poles. */
+var response = (poles, w) => {
+	let gain = 1, phase = 0;
+	for (const [re, im] of poles) {
+		gain *= Math.hypot(re, im) / Math.hypot(re, w - im);
+		phase -= Math.atan2(w - im, -re);
+	}
+	return [20 * Math.log10(gain), phase * 180 / Math.PI];
+};
+var butterworth = (order) => Array.from({ length: order }, (_, k) => {
+	const angle = Math.PI * (2 * k + 1 + order) / (2 * order);
+	return [Math.cos(angle), Math.sin(angle)];
+});
+var chebyshev = (order, ripple) => {
+	const epsilon = Math.sqrt(10 ** (ripple / 10) - 1), mu = Math.asinh(1 / epsilon) / order;
+	return butterworth(order).map(([re, im]) => [re * Math.sinh(mu), im * Math.cosh(mu)]);
+};
+var BESSEL = [
+	[-.6573, .8302],
+	[-.6573, -.8302],
+	[-.9047, .2711],
+	[-.9047, -.2711]
+].map(([re, im]) => [re * 1.2, im * 1.2]);
+/** Frequency response of a filter or system: Bode plot, group delay or Nyquist diagram. */
+var FilterResponseChart = class extends SignalChart {
+	static meta = {
+		id: "signal-filter-response",
+		name: "Filter response",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Shows the gain, phase and delay of a filter across frequency as a Bode plot, group delay or Nyquist diagram.",
+		tags: [
+			"bode",
+			"nyquist",
+			"group delay",
+			"butterworth",
+			"chebyshev"
+		],
+		sample: (seed) => {
+			const cutoff = 400 + +SampleData.categories(seed, 1, 1)[0].value * 6;
+			return [
+				["Butterworth", butterworth(4)],
+				["Chebyshev", chebyshev(4, 1)],
+				["Bessel", BESSEL]
+			].flatMap(([series, poles]) => {
+				return unwrapped(Array.from({ length: SAMPLE_POINTS }, (_, i) => response(poles, .02 * 500 ** (i / 139))[1])).map((value, i) => {
+					const w = .02 * 500 ** (i / 139), [gain] = response(poles, w);
+					return {
+						frequency: +(w * cutoff).toFixed(2),
+						gain: +gain.toFixed(3),
+						phase: +value.toFixed(2),
+						series
+					};
+				});
+			});
+		},
+		variants: {
+			view: Object.values(FilterView),
+			frequency: [SignalFrequencyScale.Log, SignalFrequencyScale.Linear],
+			amplitude: Object.values(SignalAmplitude),
+			cutoff: [true, false],
+			unwrap: [true, false]
+		},
+		valid: (values) => {
+			const { view, frequency, amplitude, cutoff, unwrap } = values;
+			if (view === "nyquist") return frequency === SignalFrequencyScale.Log && amplitude === SignalAmplitude.Decibel && cutoff === true && unwrap === true;
+			if (view !== "bode" && view !== "magnitude" && amplitude !== SignalAmplitude.Decibel) return false;
+			if (view !== "bode" && view !== "phase" && unwrap !== true) return false;
+			if (view !== "bode" && view !== "magnitude" && cutoff !== true) return false;
+			return true;
+		}
+	};
+	get legended() {
+		return this.sweeps.length > 1;
+	}
+	zoomAxes() {
+		return ZoomAxis.X;
+	}
+	defaults() {
+		return {
+			...super.defaults(),
+			x: "frequency",
+			gain: "gain",
+			phase: "phase",
+			xLabel: "Frequency (Hz)",
+			yLabel: void 0,
+			view: "bode",
+			frequency: SignalFrequencyScale.Log,
+			amplitude: SignalAmplitude.Decibel,
+			cutoff: true,
+			unwrap: true
+		};
+	}
+	constructor(options) {
+		const view = options.view ?? "bode", nyquist = view === "nyquist";
+		const label = {
+			["bode"]: void 0,
+			["magnitude"]: options.amplitude === SignalAmplitude.Linear ? "Gain" : "Gain (dB)",
+			["phase"]: "Phase (°)",
+			["group-delay"]: "Group delay (ms)",
+			["nyquist"]: "Imaginary"
+		}[view];
+		super({
+			yLabel: label,
+			...nyquist ? { xLabel: "Real" } : {},
+			...options
+		});
+	}
+	get sweeps() {
+		const { data, x, gain, phase, series } = this.options;
+		return [...group(data ?? [], (row) => String(row[series] ?? "Filter"))].map(([name, rows]) => {
+			const clean = rows.filter((row) => +row[x] > 0 && Number.isFinite(+row[gain]) && row[gain] !== null).sort((a, b) => +a[x] - +b[x]);
+			const freq = clean.map((row) => +row[x]), rise = unwrapped(clean.map((row) => +row[phase] || 0));
+			const delay = rise.map((_, i) => {
+				const a = Math.max(0, i - 1), b = Math.min(rise.length - 1, i + 1);
+				return freq[b] > freq[a] ? -((rise[b] - rise[a]) / 360 / (freq[b] - freq[a])) * 1e3 : 0;
+			});
+			return {
+				name,
+				freq,
+				gain: clean.map((row) => +row[gain]),
+				phase: rise,
+				delay
+			};
+		});
+	}
+	get bode() {
+		return this.options.view === "bode";
+	}
+	get linearGain() {
+		return this.options.amplitude === SignalAmplitude.Linear;
+	}
+	gain(value) {
+		return this.linearGain ? 10 ** (value / 20) : value;
+	}
+	phase(value) {
+		return this.options.unwrap ? value : ((value + 180) % 360 + 360) % 360 - 180;
+	}
+	split(height) {
+		return Math.round(height * .56);
+	}
+	gainScale(top, bottom) {
+		return this.linearGain ? scaleLinear([0, Math.max(1.2, ...this.sweeps.flatMap((sweep) => sweep.gain.map((value) => this.gain(value))))], [bottom, top]).nice(4) : scaleLinear([Math.max(-140, Math.min(-40, ...this.sweeps.flatMap((sweep) => sweep.gain))), Math.max(6, ...this.sweeps.flatMap((sweep) => sweep.gain))], [bottom, top]).nice(4);
+	}
+	phaseScale(top, bottom) {
+		const all = this.sweeps.flatMap((sweep) => sweep.phase.map((value) => this.phase(value)));
+		const low = Math.floor((min(all) ?? -180) / 90) * 90, high = Math.ceil((max(all) ?? 0) / 90) * 90;
+		const scale = scaleLinear([low, high === low ? low + 90 : high], [bottom, top]);
+		const step = high - low > 360 ? 180 : 90;
+		return SignalScales.labelled(scale, scale.ticks(12).filter((tick) => tick % step === 0), (value) => `${value}`);
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot, { view, frequency } = this.options, sweeps = this.sweeps;
+		if (view === "nyquist") {
+			const extent = Math.max(1.1, ...sweeps.flatMap((sweep) => sweep.gain.map((value) => 10 ** (value / 20)))) * 1.1;
+			const ratio = width / height;
+			return {
+				x: scaleLinear([-extent * ratio, extent * ratio], [0, width]),
+				y: scaleLinear([-extent, extent], [height, 0])
+			};
+		}
+		const freqs = sweeps.flatMap((sweep) => sweep.freq), lo = min(freqs) ?? 1, hi = max(freqs) ?? 10;
+		const x = SignalScales.frequency(frequency, [frequency === SignalFrequencyScale.Linear ? 0 : lo, hi], [0, width]);
+		if (this.bode) return {
+			x,
+			y: this.gainScale(0, this.split(height) - 12)
+		};
+		if (view === "magnitude") return {
+			x,
+			y: this.gainScale(0, height)
+		};
+		if (view === "phase") return {
+			x,
+			y: this.phaseScale(0, height)
+		};
+		const delays = sweeps.flatMap((sweep) => sweep.delay);
+		return {
+			x,
+			y: scaleLinear([0, max(delays) || 1], [height, 0]).nice(4)
+		};
+	}
+	plotMarks(ctx, { x, y }) {
+		const { view, cutoff } = this.options, { width, height } = ctx.plot, sweeps = this.sweeps;
+		const color = (sweep) => ctx.palette.color(sweep.name);
+		if (view === "nyquist") return this.nyquist(ctx, sweeps, x, y);
+		const reading = (sweep) => view === "phase" ? sweep.phase.map((value) => this.phase(value)) : view === "group-delay" ? sweep.delay : sweep.gain.map((value) => this.gain(value));
+		const inRange = (sweep, values) => sweep.freq.map((freq, i) => [freq, values[i]]).filter(([freq]) => x(freq) <= width + .5);
+		if (cutoff && (this.bode || view === "magnitude")) this.cutoff(ctx, sweeps, x, y);
+		this.stroke(ctx, "curve", sweeps, (sweep) => sweep.name, (sweep) => {
+			const [floor, top] = y.domain();
+			return this.path(inRange(sweep, reading(sweep)).map(([freq, value]) => [freq, Math.max(floor, Math.min(top, value))]), x, y);
+		}, color);
+		if (this.bode) {
+			const start = this.split(height) + 12, phase = this.phaseScale(start, height);
+			this.panelAxis(ctx, "phase-axis", phase);
+			ctx.marks("phase-grid", "line", phase.ticks(), (tick) => tick).attr("x1", 0).attr("x2", width).attr("y1", (tick) => phase(tick)).attr("y2", (tick) => phase(tick)).attr("stroke", ctx.theme.grid);
+			this.stroke(ctx, "phase", sweeps, (sweep) => sweep.name, (sweep) => this.path(inRange(sweep, sweep.phase.map((value) => this.phase(value))), x, phase), color);
+		}
+		this.probe(ctx, (px) => {
+			const freq = x.invert(px);
+			return sweeps.length ? {
+				x: px,
+				tip: {
+					title: `${SignalScales.hertz(freq)} Hz`,
+					rows: sweeps.map((sweep) => {
+						const nearest = sweep.freq.reduce((best, value, i) => Math.abs(value - freq) < Math.abs(sweep.freq[best] - freq) ? i : best, 0);
+						return [sweep.name, `${SignalScales.number(sweep.gain[nearest] ?? 0)} dB, ${SignalScales.number(sweep.phase[nearest] ?? 0)}°`];
+					})
+				},
+				datum: { frequency: freq }
+			} : null;
+		});
+	}
+	cutoff(ctx, sweeps, x, y) {
+		const first = sweeps[0];
+		if (!first?.freq.length) return;
+		const reference = first.gain[0], hit = first.gain.findIndex((value) => value <= reference - 3);
+		if (hit <= 0) return;
+		const at = x(first.freq[hit]), bottom = y.range()[0];
+		ctx.marks("passband", "rect", [0]).attr("x", 0).attr("y", 0).attr("width", Math.max(0, at)).attr("height", bottom).attr("fill", ctx.theme.grid).attr("opacity", .4);
+		const dot = ctx.marks("cutoff", "circle", [0]).attr("fill", ctx.palette.color(first.name)).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(dot, {
+			cx: at,
+			cy: y(this.gain(first.gain[hit])),
+			r: 4
+		}, { r: 0 });
+		ctx.text(ctx.marks("cutoff-text", "text", [0]).attr("x", at + (at > ctx.plot.width - 90 ? -8 : 8)).attr("y", 13).attr("text-anchor", at > ctx.plot.width - 90 ? "end" : "start").text(`−3 dB ${SignalScales.hertz(first.freq[hit])} Hz`), 11, "ink");
+	}
+	nyquist(ctx, sweeps, x, y) {
+		const unit = Array.from({ length: 73 }, (_, i) => [Math.cos(i * Math.PI / 36), Math.sin(i * Math.PI / 36)]);
+		ctx.marks("unit", "path", [0]).attr("fill", "none").attr("stroke", ctx.theme.axis).attr("stroke-dasharray", "4 3").attr("d", this.path(unit, x, y));
+		ctx.marks("axes", "path", [0]).attr("fill", "none").attr("stroke", ctx.theme.axis).attr("d", `M${x(0)} 0V${ctx.plot.height}M0 ${y(0)}H${ctx.plot.width}`);
+		const points = (sweep) => sweep.gain.map((gain, i) => {
+			const magnitude = 10 ** (gain / 20), angle = sweep.phase[i] * Math.PI / 180;
+			return [magnitude * Math.cos(angle), magnitude * Math.sin(angle)];
+		});
+		this.stroke(ctx, "curve", sweeps, (sweep) => sweep.name, (sweep) => this.path(points(sweep), x, y), (sweep) => ctx.palette.color(sweep.name));
+		this.stroke(ctx, "mirror", sweeps, (sweep) => sweep.name, (sweep) => this.path(points(sweep).map(([re, im]) => [re, -im]), x, y), (sweep) => ctx.palette.color(sweep.name), 1).attr("stroke-dasharray", "3 3");
+	}
+};
+export { FilterResponseChart, FilterView };

package/dist/charts/signals/ImpulseResponseChart.js

@@ -0,0 +1,199 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SignalChart } from "./SignalChart.js";
+import { SignalSamples } from "./SignalSamples.js";
+import { SignalScales } from "./SignalScales.js";
+import { area, scaleLinear, scaleLog } from "d3";
+// src/charts/signals/ImpulseResponseChart.ts
+var ImpulseView = /* @__PURE__ */ function(ImpulseView) {
+	ImpulseView["Impulse"] = "impulse";
+	ImpulseView["Step"] = "step";
+	ImpulseView["EnergyDecay"] = "energy-decay";
+	return ImpulseView;
+}({});
+var ImpulseMark = /* @__PURE__ */ function(ImpulseMark) {
+	ImpulseMark["Line"] = "line";
+	ImpulseMark["Area"] = "area";
+	ImpulseMark["Stem"] = "stem";
+	return ImpulseMark;
+}({});
+var ImpulseTime = /* @__PURE__ */ function(ImpulseTime) {
+	ImpulseTime["Linear"] = "linear";
+	ImpulseTime["Log"] = "log";
+	return ImpulseTime;
+}({});
+var FLOOR = -70;
+var STEMS = 48;
+/** Characterises a system from its response to a click: ringing, settling, or room reverberation. */
+var ImpulseResponseChart = class extends SignalChart {
+	static meta = {
+		id: "signal-impulse-response",
+		name: "Impulse response",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Shows a system response to an impulse, its integrated step response or Schroeder energy decay.",
+		tags: [
+			"step response",
+			"schroeder",
+			"rt60",
+			"settling",
+			"reverberation"
+		],
+		sample: (seed) => SignalSamples.noise(seed, 1200, 2).flatMap(({ name, noise }, channel) => noise.map((step, i) => {
+			const t = (i + 1) / 2400, ring = 1 + channel * .8;
+			return {
+				t: +t.toFixed(5),
+				series: name,
+				value: +(Math.exp(-t * 9 * ring) * Math.sin(2 * Math.PI * 21 * ring * t) + .4 * Math.exp(-t * 26) * Math.sin(2 * Math.PI * 64 * t) + Math.exp(-t * 7) * step * .012).toFixed(5)
+			};
+		})),
+		variants: {
+			view: Object.values(ImpulseView),
+			mark: Object.values(ImpulseMark),
+			time: Object.values(ImpulseTime),
+			annotate: [true, false]
+		},
+		valid: (values) => values.view !== "energy-decay" || values.mark !== "stem"
+	};
+	constructor(options) {
+		super({
+			yLabel: options.view === "energy-decay" ? "Energy (dB)" : options.view === "step" ? "Step response" : "Amplitude",
+			...options
+		});
+	}
+	defaults() {
+		return {
+			...super.defaults(),
+			view: "impulse",
+			mark: "line",
+			time: "linear",
+			annotate: true
+		};
+	}
+	transform(channel) {
+		const { view } = this.options;
+		if (view === "impulse") return channel.v;
+		if (view === "step") {
+			let sum = 0;
+			return channel.v.map((value) => sum += value / channel.rate);
+		}
+		const decay = new Array(channel.v.length);
+		let sum = 0;
+		for (let i = channel.v.length - 1; i >= 0; i--) decay[i] = sum += channel.v[i] ** 2;
+		return decay.map((value) => Math.max(FLOOR, 10 * Math.log10(value / (decay[0] || 1) || 1e-12)));
+	}
+	curves(ctx, width) {
+		const log = this.options.time === "log";
+		return this.channels.map((channel) => {
+			const keep = this.transform(channel).map((value, i) => [channel.t[i], value]).filter(([t]) => !log || t > 0);
+			const thin = this.thin({
+				...channel,
+				t: keep.map((p) => p[0])
+			}, keep.map((p) => p[1]), width);
+			return {
+				name: channel.name,
+				color: ctx.palette.color(channel.name),
+				points: thin
+			};
+		});
+	}
+	scales(ctx) {
+		const { width, height } = ctx.plot, [lo, hi] = this.span;
+		const positive = this.channels.flatMap((channel) => channel.t.filter((t) => t > 0)[0] ?? []), least = positive.length ? Math.min(...positive) : hi / 1e3 || .001;
+		const x = this.options.time === "log" ? scaleLog([least, Math.max(hi, least * 10)], [0, width]) : scaleLinear([lo, hi], [0, width]);
+		if (this.options.time === "log") SignalScales.labelled(x, SignalScales.sparse(x, x.domain()[0], x.domain()[1]), SignalScales.number);
+		if (this.options.view === "energy-decay") return {
+			x,
+			y: scaleLinear([FLOOR, 0], [height, 0])
+		};
+		const all = this.channels.flatMap((channel) => this.transform(channel)), top = Math.max(1e-9, ...all), bottom = Math.min(0, ...all);
+		return {
+			x,
+			y: scaleLinear([bottom * 1.08, top * 1.08], [height, 0]).nice(4)
+		};
+	}
+	plotMarks(ctx, { x, y }) {
+		const { mark, annotate, view } = this.options, { width } = ctx.plot, curves = this.curves(ctx, width);
+		const base = y(view === "energy-decay" ? FLOOR : 0);
+		if (view !== "energy-decay") this.rule(ctx, "zero", [0], y);
+		if (mark === "stem") {
+			this.stems(ctx, x, y, base);
+			if (annotate) this.annotate(ctx, x, y);
+			return;
+		}
+		if (mark === "area") {
+			const shape = area().x((point) => x(point[0])).y0(base).y1((point) => y(point[1]));
+			this.fill(ctx, "fill", curves, (curve) => curve.name, (curve) => shape(curve.points) ?? "", (curve) => curve.color, .22);
+		}
+		this.stroke(ctx, "curve", curves, (curve) => curve.name, (curve) => this.path(curve.points, x, y), (curve) => curve.color);
+		if (annotate) this.annotate(ctx, x, y);
+		this.timeProbe(ctx, x);
+	}
+	stems(ctx, x, y, base) {
+		const list = this.channels.flatMap((channel, c) => {
+			const values = this.transform(channel), count = Math.min(STEMS, Math.floor(ctx.plot.width / (9 * this.channels.length))), reach = channel.t.length;
+			const picks = Array.from({ length: Math.min(count, reach) }, (_, i) => this.options.time === "log" ? Math.min(reach - 1, Math.round(reach ** (i / Math.max(1, count - 1))) - 1) : Math.floor(i * reach / count));
+			return [...new Set(picks)].map((index) => ({
+				key: `${channel.name}${index}`,
+				name: channel.name,
+				t: channel.t[index],
+				value: values[index],
+				shift: (c - (this.channels.length - 1) / 2) * 4
+			}));
+		}).filter((stem) => this.options.time !== "log" || stem.t > 0);
+		const rods = ctx.marks("rods", "line", list, (stem) => stem.key).attr("stroke", (stem) => ctx.palette.color(stem.name)).attr("stroke-width", 2);
+		ctx.set(rods, {
+			x1: (stem) => x(stem.t) + stem.shift,
+			x2: (stem) => x(stem.t) + stem.shift,
+			y1: base,
+			y2: (stem) => y(stem.value)
+		}, { y2: base }, 4);
+		const heads = ctx.marks("heads", "circle", list, (stem) => stem.key).attr("fill", (stem) => ctx.palette.color(stem.name)).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(heads, {
+			cx: (stem) => x(stem.t) + stem.shift,
+			cy: (stem) => y(stem.value),
+			r: 4
+		}, {
+			cy: base,
+			r: 0
+		}, 4);
+		ctx.hover(heads, (stem) => ({
+			title: `${SignalScales.number(stem.t)} s`,
+			color: ctx.palette.color(stem.name),
+			rows: [[stem.name, SignalScales.number(stem.value)]]
+		}));
+	}
+	/** Peak for the impulse, 2% settling time for the step, RT60 by line fit for the energy decay. */
+	annotate(ctx, x, y) {
+		const channel = this.first, values = this.transform(channel), { view } = this.options, { width, height } = ctx.plot;
+		if (values.length < 3) return;
+		let label = "", index = 0;
+		if (view === "impulse") {
+			index = values.reduce((best, value, i) => Math.abs(value) > Math.abs(values[best]) ? i : best, 0);
+			label = `Peak ${SignalScales.number(values[index])} at ${SignalScales.number(channel.t[index])} s`;
+		} else if (view === "step") {
+			const final = values[values.length - 1], tolerance = Math.max(Math.abs(final) * .02, 1e-9);
+			index = values.length - 1;
+			while (index > 0 && Math.abs(values[index] - final) < tolerance) index--;
+			label = `Settles in ${SignalScales.number(channel.t[index])} s`;
+			this.rule(ctx, "band", [final + tolerance, final - tolerance], y, true);
+		} else {
+			const start = values.findIndex((value) => value <= -5), end = values.findIndex((value) => value <= -25);
+			if (start < 0 || end <= start) return;
+			const slope = (values[end] - values[start]) / (channel.t[end] - channel.t[start]);
+			index = end;
+			label = `RT60 ${SignalScales.number(-60 / slope)} s`;
+			ctx.marks("fit", "line", [0]).attr("x1", x(channel.t[start])).attr("x2", x(channel.t[end])).attr("y1", y(values[start])).attr("y2", y(values[end])).attr("stroke", ctx.theme.ink).attr("stroke-width", 2);
+		}
+		const px = x(channel.t[index]), py = y(values[index]), flip = px > width - 150;
+		if (!Number.isFinite(px)) return;
+		const dot = ctx.marks("note", "circle", [0]).attr("fill", ctx.theme.ink).attr("stroke", ctx.theme.surface).attr("stroke-width", 2);
+		ctx.set(dot, {
+			cx: px,
+			cy: py,
+			r: 4
+		}, { r: 0 });
+		ctx.text(ctx.marks("note-text", "text", [0]).attr("x", px + (flip ? -9 : 9)).attr("y", Math.max(11, Math.min(height - 5, py - 7))).attr("text-anchor", flip ? "end" : "start").text(label), 11, "ink");
+	}
+};
+export { ImpulseMark, ImpulseResponseChart, ImpulseTime, ImpulseView };