@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/scientific/RoseStrainChart.js

@@ -0,0 +1,305 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { RadialChart } from "../../core/RadialChart.js";
+import { Draft } from "./Draft.js";
+import { ScientificSample } from "./ScientificSample.js";
+import { arc, group, max, range, scaleLinear, scaleSqrt } from "d3";
+// src/charts/scientific/RoseStrainChart.ts
+var RoseSymmetry = /* @__PURE__ */ function(RoseSymmetry) {
+	RoseSymmetry["Axial"] = "axial";
+	RoseSymmetry["Directional"] = "directional";
+	RoseSymmetry["HalfRose"] = "half-rose";
+	return RoseSymmetry;
+}({});
+var RoseRadial = /* @__PURE__ */ function(RoseRadial) {
+	RoseRadial["EqualArea"] = "equal-area";
+	RoseRadial["Linear"] = "equal-length";
+	return RoseRadial;
+}({});
+var RoseForm = /* @__PURE__ */ function(RoseForm) {
+	RoseForm["Wedges"] = "wedges";
+	RoseForm["Kite"] = "kite";
+	RoseForm["Spokes"] = "spokes";
+	return RoseForm;
+}({});
+var rad = Math.PI / 180;
+/** Orientation data such as fractures, foliation or strain markers, binned around the compass. */
+var RoseStrainChart = class extends RadialChart {
+	static meta = {
+		id: "rose-strain",
+		name: "Strain rose diagram",
+		family: ChartFamily.Scientific,
+		dimension: Dimension.Two,
+		shape: DataShape.Table,
+		description: "Bins directional or axial measurements around a compass and fits the strain ellipse of the fabric.",
+		tags: [
+			"structural geology",
+			"orientation",
+			"rose",
+			"strain ellipse"
+		],
+		sample: (seed) => ScientificSample.fabric(seed),
+		variants: {
+			bins: [
+				36,
+				24,
+				12
+			],
+			symmetry: Object.values(RoseSymmetry),
+			radial: Object.values(RoseRadial),
+			form: Object.values(RoseForm),
+			ellipse: [false, true]
+		},
+		valid: (values) => values.symmetry !== "half-rose" || values.ellipse === false
+	};
+	defaults() {
+		return {
+			azimuth: "azimuth",
+			magnitude: "magnitude",
+			set: "set",
+			weighted: false,
+			bins: 36,
+			symmetry: "axial",
+			radial: "equal-area",
+			form: "wedges",
+			ellipse: false
+		};
+	}
+	plotMargin() {
+		return {
+			top: 18,
+			right: 18,
+			bottom: 16,
+			left: 18
+		};
+	}
+	measures() {
+		const { data, azimuth, magnitude, set } = this.options;
+		return data.flatMap((row) => {
+			const a = Draft.number(row[azimuth]);
+			return a === null ? [] : [{
+				azimuth: (a % 360 + 360) % 360,
+				weight: Draft.number(row[magnitude]) ?? 1,
+				set: String(row[set] ?? "Fabric")
+			}];
+		});
+	}
+	binned() {
+		const { bins, symmetry, weighted } = this.options;
+		const half = symmetry === "half-rose";
+		const step = (half ? 180 : 360) / bins, offset = half ? -90 : 0;
+		const measures = this.measures().flatMap((d) => {
+			if (symmetry === "directional") return [d];
+			if (symmetry === "axial") return [d, {
+				...d,
+				azimuth: (d.azimuth + 180) % 360
+			}];
+			const fold = (d.azimuth + 90) % 180 - 90;
+			return [{
+				...d,
+				azimuth: fold
+			}];
+		});
+		return [...group(measures, (d) => d.set)].flatMap(([set, list]) => {
+			const totals = new Array(bins).fill(0);
+			for (const d of list) totals[Math.min(bins - 1, Math.floor((d.azimuth - offset) / step))] += weighted ? d.weight : 1;
+			return totals.map((value, index) => ({
+				index,
+				set,
+				low: offset + index * step,
+				high: offset + (index + 1) * step,
+				value,
+				start: 0,
+				end: value
+			}));
+		});
+	}
+	draw(ctx) {
+		Draft.fresh(ctx, this.meta, this.options);
+		super.draw(ctx);
+	}
+	drawRadial(root, { radius: outer }) {
+		const { symmetry, radial, form, ellipse } = this.options;
+		const half = symmetry === "half-rose";
+		const ctx = half ? root.nest(`translate(0,${outer * .5})`, "half") : root;
+		const radius = half ? Math.min(outer * 1.4, root.plot.width / 2 - 20) : outer - 6;
+		const parts = this.binned();
+		for (const [, list] of group(parts, (d) => d.index)) {
+			let cursor = 0;
+			for (const part of list) {
+				part.start = cursor;
+				cursor += part.value;
+				part.end = cursor;
+			}
+		}
+		const peak = Math.max(1, max(parts, (d) => d.end) ?? 1);
+		const r = radial === "equal-area" ? scaleSqrt([0, peak], [0, radius]) : scaleLinear([0, peak], [0, radius]);
+		const ticks = scaleLinear([0, peak], [0, 1]).ticks(3).filter((tick) => tick > 0);
+		const ring = (value) => {
+			const size = r(value);
+			return half ? `M${-size},0A${size},${size} 0 0 1 ${size},0` : `M${-size},0A${size},${size} 0 1 1 ${size},0A${size},${size} 0 1 1 ${-size},0`;
+		};
+		Draft.paths(ctx, "rings", ticks.map(ring));
+		const spokes = range(half ? -90 : 0, half ? 91 : 360, 45);
+		Draft.rules(ctx, "spokes", spokes.map((angle) => ({
+			x1: 0,
+			y1: 0,
+			x2: Math.sin(angle * rad) * radius,
+			y2: -Math.cos(angle * rad) * radius
+		})));
+		Draft.paths(ctx, "frame", [half ? `${ring(peak)}Z` : ring(peak)], { stroke: ctx.theme.axis });
+		const compass = [{
+			text: "N",
+			x: 0,
+			y: -radius - 6,
+			tone: "ink",
+			weight: 600
+		}, ...half ? [{
+			text: "E",
+			x: radius + 10,
+			y: 4,
+			tone: "muted"
+		}, {
+			text: "W",
+			x: -radius - 10,
+			y: 4,
+			tone: "muted"
+		}] : [
+			{
+				text: "E",
+				x: radius + 10,
+				y: 4,
+				tone: "muted"
+			},
+			{
+				text: "S",
+				x: 0,
+				y: radius + 14,
+				tone: "muted"
+			},
+			{
+				text: "W",
+				x: -radius - 10,
+				y: 4,
+				tone: "muted"
+			}
+		]];
+		Draft.captions(ctx, "compass", compass);
+		Draft.captions(ctx, "scale", ticks.map((tick) => ({
+			text: `${tick}`,
+			x: Math.sin(22.5 * rad) * r(tick) + 2,
+			y: -Math.cos(22.5 * rad) * r(tick) - 2,
+			anchor: "start",
+			size: 10,
+			tone: "muted"
+		})));
+		const tip = (d) => ({
+			title: `${d.low.toFixed(0)}–${d.high.toFixed(0)}°`,
+			color: ctx.palette.color(d.set),
+			rows: [[d.set, +d.value.toFixed(1)]]
+		});
+		const visible = parts.filter((d) => d.value > 0);
+		if (form === "wedges") {
+			const wedge = arc().innerRadius((d) => r(d.start)).outerRadius((d) => r(d.end)).startAngle((d) => d.low * rad).endAngle((d) => d.high * rad).padAngle(.012).padRadius(radius / 2).cornerRadius(1.5);
+			const wedges = ctx.marks("wedges", "path", visible, (d) => `${d.set}/${d.index}`).attr("fill", (d) => ctx.palette.color(d.set));
+			ctx.set(wedges, { d: (d) => wedge(d) ?? "" }, { d: (d) => wedge(d) ?? "" });
+			ctx.hover(wedges, tip);
+		} else if (form === "kite") {
+			const polygons = [...group(parts, (d) => d.set)].map(([set, list]) => {
+				const vertex = (d) => {
+					const angle = (d.low + d.high) / 2 * rad;
+					return [Math.sin(angle) * r(d.value), -Math.cos(angle) * r(d.value)];
+				};
+				return {
+					set,
+					peak: list,
+					d: half ? `${Draft.polyline([
+						[0, 0],
+						...list.map(vertex),
+						[0, 0]
+					])}Z` : Draft.polygon(list.map(vertex))
+				};
+			});
+			const kites = ctx.marks("kites", "path", polygons, (d) => d.set).attr("fill", (d) => ctx.palette.color(d.set)).attr("fill-opacity", .3).attr("stroke", (d) => ctx.palette.color(d.set)).attr("stroke-width", 2).attr("stroke-linejoin", "round");
+			ctx.set(kites, { d: (d) => d.d }, { d: (d) => d.d });
+			ctx.hover(kites, (d) => ({
+				title: d.set,
+				color: ctx.palette.color(d.set),
+				rows: [["Peak bin", max(d.peak, (bin) => bin.value) ?? 0]]
+			}));
+		} else {
+			const mid = (d) => (d.low + d.high) / 2 * rad;
+			const stalks = ctx.marks("spokes-data", "line", visible, (d) => `${d.set}/${d.index}`).attr("stroke", (d) => ctx.palette.color(d.set)).attr("stroke-width", 2).attr("stroke-linecap", "round");
+			const end = {
+				x1: (d) => Math.sin(mid(d)) * r(d.start),
+				y1: (d) => -Math.cos(mid(d)) * r(d.start),
+				x2: (d) => Math.sin(mid(d)) * r(d.end),
+				y2: (d) => -Math.cos(mid(d)) * r(d.end)
+			};
+			ctx.set(stalks, end, {
+				...end,
+				x2: end.x1,
+				y2: end.y1
+			}, 8);
+			ctx.hover(stalks, tip);
+			const heads = ctx.marks("spoke-heads", "circle", visible, (d) => `${d.set}/${d.index}`).attr("fill", (d) => ctx.palette.color(d.set)).attr("stroke", ctx.theme.surface).attr("stroke-width", 1.5);
+			ctx.set(heads, {
+				cx: end.x2,
+				cy: end.y2,
+				r: 3.5
+			}, {
+				cx: end.x2,
+				cy: end.y2,
+				r: 0
+			}, 8);
+			ctx.hover(heads, tip);
+		}
+		if (ellipse && !half) this.ellipse(ctx, radius * .82);
+	}
+	/** The orientation tensor's eigenvectors give the ellipse axes; their ratio its axial strain. */
+	ellipse(ctx, radius) {
+		const measures = this.measures();
+		if (!measures.length) return;
+		let xx = 0, yy = 0, xy = 0;
+		for (const d of measures) {
+			const s = Math.sin(d.azimuth * rad), c = Math.cos(d.azimuth * rad);
+			xx += s * s;
+			yy += c * c;
+			xy += s * c;
+		}
+		const total = measures.length;
+		xx /= total;
+		yy /= total;
+		xy /= total;
+		const root = Math.sqrt(((xx - yy) / 2) ** 2 + xy * xy), major = (xx + yy) / 2 + root, minor = Math.max(.02, (xx + yy) / 2 - root);
+		const angle = .5 * Math.atan2(2 * xy, xx - yy);
+		const ratio = Math.sqrt(major / minor);
+		const a = radius, b = radius / ratio;
+		const points = range(0, 361, 6).map((t) => {
+			const u = a * Math.cos(t * rad), v = b * Math.sin(t * rad);
+			return [u * Math.cos(angle) - v * Math.sin(angle), -(u * Math.sin(angle) + v * Math.cos(angle))];
+		});
+		Draft.paths(ctx, "strain-ellipse", [Draft.polyline(points)], {
+			stroke: ctx.theme.ink,
+			width: 2
+		});
+		Draft.rules(ctx, "strain-axis", [{
+			x1: -a * Math.cos(angle),
+			y1: a * Math.sin(angle),
+			x2: a * Math.cos(angle),
+			y2: -a * Math.sin(angle)
+		}], {
+			stroke: ctx.theme.ink,
+			dash: "4 3",
+			width: 1
+		});
+		Draft.captions(ctx, "strain-ratio", [{
+			text: `Rf ${ratio.toFixed(2)}`,
+			x: ctx.plot.width / 2 - 8,
+			y: -ctx.plot.height / 2 + 12,
+			anchor: "end",
+			tone: "ink",
+			weight: 600
+		}]);
+	}
+};
+export { RoseForm, RoseRadial, RoseStrainChart, RoseSymmetry };

package/dist/charts/scientific/ScientificSample.js

@@ -0,0 +1,413 @@
+import { SampleData } from "../../data/SampleData.js";
+// src/charts/scientific/ScientificSample.ts
+/** Domain-shaped reshapes of `SampleData`. Every value below derives from its seeded noise. */
+var ScientificSample = class {
+	static normal(seed, count) {
+		return SampleData.distribution(seed, count, 1).map((row) => (+row.value - 40) / 8);
+	}
+	static uniform(seed, count) {
+		return SampleData.points(seed, count, 1).map((row) => (+row.size - 3) / 30);
+	}
+	/** `{ a, b, c, size, group }`, three compositional clusters. */
+	static compositions(seed, count = 90) {
+		const centres = [
+			[
+				.62,
+				.22,
+				.16
+			],
+			[
+				.18,
+				.62,
+				.2
+			],
+			[
+				.2,
+				.2,
+				.6
+			]
+		];
+		return SampleData.points(seed, count, 3).map((row, i) => {
+			const centre = centres[i % 3], noise = this.normal(seed + i, 3);
+			const parts = centre.map((value, k) => value * Math.exp(noise[k] * .38));
+			const total = parts[0] + parts[1] + parts[2];
+			return {
+				a: +(parts[0] / total).toFixed(4),
+				b: +(parts[1] / total).toFixed(4),
+				c: +(parts[2] / total).toFixed(4),
+				size: row.size,
+				group: row.group
+			};
+		});
+	}
+	/** Water samples in meq/L: `{ sample, group, Ca, Mg, Na, K, HCO3, CO3, SO4, Cl, Fe, tds }`. */
+	static waters(seed, count = 24) {
+		const types = [
+			{
+				Ca: 5.2,
+				Mg: 2.1,
+				Na: .9,
+				K: .1,
+				HCO3: 6.4,
+				CO3: .1,
+				SO4: 1,
+				Cl: .8,
+				Fe: .5
+			},
+			{
+				Ca: .8,
+				Mg: .6,
+				Na: 8.5,
+				K: .3,
+				HCO3: 2,
+				CO3: .4,
+				SO4: 1.2,
+				Cl: 8,
+				Fe: .2
+			},
+			{
+				Ca: 3.2,
+				Mg: 4.5,
+				Na: 2,
+				K: .2,
+				HCO3: 1.5,
+				CO3: .1,
+				SO4: 7,
+				Cl: 1.4,
+				Fe: .9
+			}
+		];
+		return SampleData.points(seed, count, 3).map((row, i) => {
+			const type = types[i % 3], noise = this.normal(seed * 7 + i, 9);
+			const ions = Object.fromEntries(Object.entries(type).map(([ion, value], k) => [ion, +(value * Math.exp(noise[k] * .55)).toFixed(3)]));
+			return {
+				sample: `W${i + 1}`,
+				group: row.group,
+				...ions,
+				tds: +(Object.values(ions).reduce((a, b) => a + b, 0) * 34).toFixed(0)
+			};
+		});
+	}
+	/** Stars: `{ name, temperature, luminosity, radius, group }`. */
+	static stars(seed) {
+		const count = 260, u = this.uniform(seed, count), n = this.normal(seed, count);
+		return u.map((v, i) => {
+			const noise = n[i];
+			let logT, logL, group;
+			if (i % 13 === 0) {
+				logT = 3.75 + v * .65;
+				logL = -3.4 + v * 1.8 + noise * .2;
+				group = "White dwarfs";
+			} else if (i % 7 === 0) {
+				logT = 3.52 + v * .25;
+				logL = 1.3 + (3.76 - logT) * 4 + noise * .35;
+				group = "Giants";
+			} else if (i % 11 === 0) {
+				logT = 3.55 + v * .8;
+				logL = 4.4 + v * .6 + noise * .2;
+				group = "Supergiants";
+			} else {
+				logT = 3.46 + v ** 1.6 * 1.02;
+				logL = 5.6 * (logT - 3.763) + noise * .22;
+				group = "Main sequence";
+			}
+			const temperature = Math.round(10 ** logT), luminosity = +(10 ** logL).toPrecision(4);
+			return {
+				name: `HD ${1e4 + i * 37}`,
+				temperature,
+				luminosity,
+				radius: +(Math.sqrt(luminosity) / (temperature / 5772) ** 2).toPrecision(3),
+				group
+			};
+		});
+	}
+	/** Fault planes by right-hand rule: `{ strike, dip, set }`. */
+	static planes(seed, count = 60) {
+		const sets = [
+			{
+				strike: 32,
+				dip: 62,
+				set: "Bedding"
+			},
+			{
+				strike: 128,
+				dip: 44,
+				set: "Joints"
+			},
+			{
+				strike: 238,
+				dip: 76,
+				set: "Faults"
+			}
+		];
+		const n = this.normal(seed, count * 2);
+		return Array.from({ length: count }, (_, i) => {
+			const set = sets[i % 3];
+			return {
+				strike: +((set.strike + n[i * 2] * 13 + 360) % 360).toFixed(1),
+				dip: +Math.max(2, Math.min(88, set.dip + n[i * 2 + 1] * 8)).toFixed(1),
+				set: set.set
+			};
+		});
+	}
+	/** Radiosonde-like sounding: `{ pressure, height, temperature, dewpoint, u, v }`, bottom up. */
+	static sounding(seed) {
+		const levels = [
+			1e3,
+			950,
+			925,
+			900,
+			850,
+			800,
+			750,
+			700,
+			650,
+			600,
+			550,
+			500,
+			450,
+			400,
+			350,
+			300,
+			250,
+			200,
+			150,
+			100
+		];
+		const n = this.normal(seed, levels.length * 3);
+		return levels.map((pressure, i) => {
+			const height = Math.round(44331 * (1 - (pressure / 1013.25) ** .1903));
+			const temperature = Math.max(26 - height * .0066, -58 + (height - 12e3) * 8e-4) + n[i * 3] * .7;
+			const deficit = 2 + Math.abs(n[i * 3 + 1]) * 2.5 + (i > 4 ? 4 + i * .7 : i * .7);
+			const turn = 1.45 - height / 12e3 * 1.75, speed = 7 + height / 1e3 * 3 + n[i * 3 + 2];
+			return {
+				pressure,
+				height,
+				temperature: +temperature.toFixed(1),
+				dewpoint: +(temperature - deficit).toFixed(1),
+				u: +(speed * Math.cos(turn)).toFixed(1),
+				v: +(speed * Math.sin(turn)).toFixed(1)
+			};
+		});
+	}
+	/** Monthly normals: `{ station, month, temperature, tmin, tmax, precipitation }`. */
+	static climate(seed) {
+		const stations = [
+			{
+				station: "Monsoon Ridge",
+				mean: 13,
+				swing: 13,
+				peak: 7,
+				wet: 24,
+				surge: 190,
+				dry: 7
+			},
+			{
+				station: "Harbor Coast",
+				mean: 16,
+				swing: 7,
+				peak: 8,
+				wet: 70,
+				surge: -48,
+				dry: 3
+			},
+			{
+				station: "Basin Steppe",
+				mean: 9,
+				swing: 16,
+				peak: 7,
+				wet: 26,
+				surge: 22,
+				dry: 5
+			}
+		];
+		const n = this.normal(seed, 72);
+		return stations.flatMap((site, s) => Array.from({ length: 12 }, (_, m) => {
+			const month = m + 1, phase = Math.cos((month - site.peak) / 12 * 2 * Math.PI), bump = Math.exp(-(((month - site.peak) / 1.8) ** 2));
+			const temperature = site.mean + site.swing * phase + n[s * 12 + m] * .5;
+			const rain = Math.max(2, site.wet * (.45 + .4 * Math.cos((month - site.dry) / 6 * Math.PI) ** 2) + site.surge * bump + n[36 + s * 12 + m] * 5);
+			return {
+				station: site.station,
+				month,
+				temperature: +temperature.toFixed(1),
+				tmin: +(temperature - 6.5).toFixed(1),
+				tmax: +(temperature + 7).toFixed(1),
+				precipitation: +rain.toFixed(1)
+			};
+		}));
+	}
+	/** Model skill: `{ model, run, correlation, deviation }`, plus the observed reference. */
+	static skill(seed) {
+		const u = this.uniform(seed, 20), n = this.normal(seed, 20);
+		const reference = 4.2;
+		const rows = [{
+			model: "Observed",
+			run: "Reference",
+			correlation: 1,
+			deviation: reference
+		}];
+		for (let i = 0; i < 7; i++) {
+			const base = .52 + u[i] * .38, spread = reference * (.7 + u[i + 7] * .75);
+			rows.push({
+				model: `M${i + 1}`,
+				run: "Baseline",
+				correlation: +base.toFixed(3),
+				deviation: +spread.toFixed(2)
+			});
+			rows.push({
+				model: `M${i + 1}`,
+				run: "Updated",
+				correlation: +Math.min(.985, base + .07 + n[i] * .02).toFixed(3),
+				deviation: +(reference + (spread - reference) * .55).toFixed(2)
+			});
+		}
+		return rows;
+	}
+	/** Oriented strain markers: `{ azimuth, magnitude, set }`. */
+	static fabric(seed, count = 180) {
+		const u = this.uniform(seed, count), n = this.normal(seed, count);
+		return u.map((v, i) => {
+			const set = i % 3 === 2 ? "Conjugate" : "Primary";
+			return {
+				azimuth: +((((set === "Primary" ? 52 : 141) + n[i] * (set === "Primary" ? 17 : 12) + (i % 2 ? 180 : 0)) % 360 + 360) % 360).toFixed(1),
+				magnitude: +(1 + v * 3).toFixed(2),
+				set
+			};
+		});
+	}
+	/** Paired fragmentation spectra: `{ mz, intensity, spectrum }`. */
+	static spectra(seed) {
+		const u = this.uniform(seed, 96), n = this.normal(seed, 48);
+		return ["Sample", "Library"].flatMap((spectrum, s) => Array.from({ length: 24 }, (_, i) => {
+			const mz = 43 + i * 11 + Math.floor(u[i] * 9);
+			const tall = i === 6 || i === 15 ? 1 : i % 5 === 0 ? .55 : .12;
+			const intensity = Math.max(.5, 1e3 * tall * (.4 + u[24 + i] * .6) * (s ? 1 + n[i] * .12 : 1));
+			return {
+				mz: mz + .08 * (i % 3),
+				intensity: +intensity.toFixed(1),
+				spectrum
+			};
+		}));
+	}
+	/** Detector traces: `{ time, signal, trace }`, peak trains on a drifting baseline. */
+	static chromatogram(seed) {
+		const count = 420, u = this.uniform(seed, 40), walk = SampleData.timeSeries(seed, count, 1).map((row) => +row.value);
+		return ["Standard", "Sample"].flatMap((trace, s) => {
+			const peaks = Array.from({ length: 8 }, (_, p) => ({
+				at: 2.2 + p * 2.05 + u[p] * .8,
+				tall: 180 + u[p + 8] ** 2 * 800 * (s ? .6 + u[p + 16] * .7 : 1),
+				wide: .1 + u[p + 24] * .13
+			}));
+			return Array.from({ length: count }, (_, i) => {
+				const time = i / 419 * 20;
+				const drift = 25 + time * 3.5 + (walk[i] - walk[0]) * .5;
+				const signal = peaks.reduce((sum, peak) => sum + peak.tall * Math.exp(-(((time - peak.at) / peak.wide) ** 2) / 2), drift);
+				return {
+					time: +time.toFixed(3),
+					signal: +signal.toFixed(2),
+					trace
+				};
+			});
+		});
+	}
+	/** Phase boundaries as `{ boundary, x, y }`: water-like P–T curves, a eutectic and a solid-solution lens. */
+	static phases(seed) {
+		const n = this.normal(seed, 4), jitter = (scale) => 1 + n[0] * scale;
+		const steps = (count) => Array.from({ length: count }, (_, i) => i / (count - 1));
+		const tripleK = 273.16, criticalK = 647.1, tripleP = .611, criticalP = 22064 * jitter(.01);
+		const slope = Math.log(criticalP / tripleP) / (1 / tripleK - 1 / criticalK);
+		return [
+			...steps(12).map((t) => {
+				const T = 213 + t * 60.160000000000025;
+				return {
+					boundary: "sublimation",
+					x: +(T - 273.15).toFixed(2),
+					y: +(tripleP * Math.exp(6134 * (T - tripleK) / (T * tripleK))).toPrecision(4)
+				};
+			}),
+			...steps(8).map((t) => {
+				const P = tripleP + t ** 2 * 28e3;
+				return {
+					boundary: "fusion",
+					x: +(.01 - (P - tripleP) / 13500).toFixed(3),
+					y: +P.toPrecision(5)
+				};
+			}),
+			...steps(20).map((t) => {
+				const T = tripleK + t * 373.94;
+				return {
+					boundary: "vaporization",
+					x: +(T - 273.15).toFixed(2),
+					y: +(tripleP * Math.exp(slope * (1 / tripleK - 1 / T))).toPrecision(5)
+				};
+			}),
+			...steps(12).map((t) => ({
+				boundary: "liquidus-a",
+				x: +(t * 60).toFixed(2),
+				y: +(1084 - 304 * t ** 1.35).toFixed(1)
+			})),
+			...steps(10).map((t) => ({
+				boundary: "liquidus-b",
+				x: +(60 + t * 40).toFixed(2),
+				y: +(780 + 182 * t ** .8).toFixed(1)
+			})),
+			...steps(2).map((t) => ({
+				boundary: "solidus",
+				x: t * 100,
+				y: 780
+			})),
+			...steps(14).map((t) => ({
+				boundary: "lens-liquidus",
+				x: +(t * 100).toFixed(2),
+				y: +(1085 + 370 * t - 120 * Math.sin(Math.PI * t) * -.6).toFixed(1)
+			})),
+			...steps(14).map((t) => ({
+				boundary: "lens-solidus",
+				x: +(t * 100).toFixed(2),
+				y: +(1085 + 370 * t - 120 * Math.sin(Math.PI * t) * .6).toFixed(1)
+			}))
+		];
+	}
+	/** Gel bands: `{ lane, size, intensity }`; size in base pairs. */
+	static gel(seed) {
+		const u = this.uniform(seed, 60);
+		const bands = [
+			3e3,
+			1800,
+			1200,
+			900,
+			650,
+			400,
+			250,
+			120
+		];
+		return Array.from({ length: 6 }, (_, lane) => bands.filter((_, b) => u[lane * 8 + b] > .42).map((size, b) => ({
+			lane: `S${lane + 1}`,
+			size,
+			intensity: +(.25 + u[(lane * 8 + b + 3) % 60] * .75).toFixed(3)
+		}))).flat();
+	}
+	/** Signal samples `{ time, value }`: a rising chirp with a harmonic over noise. */
+	static signal(seed, count = 4096, rate = 8e3) {
+		return this.normal(seed, count).map((n, i) => {
+			const t = i / rate, sweep = 2 * Math.PI * (200 * t + 750 * t * t * rate / count);
+			return {
+				time: +t.toFixed(5),
+				value: +(Math.sin(sweep) + .45 * Math.sin(2 * sweep) + .3 * Math.sin(2 * Math.PI * 2600 * t) * (i > count / 2 ? 1 : 0) + n * .02).toFixed(4)
+			};
+		});
+	}
+	/** Aligned DNA sequences: `{ sequence, count }`, a seeded motif. */
+	static sequences(seed, count = 40) {
+		const motif = "TATAAAGGCTGCATCA";
+		const u = this.uniform(seed, 16 * count * 2);
+		const strength = [...motif].map((_, i) => .35 + .6 * Math.abs(Math.sin(i * 1.1 + seed)));
+		return Array.from({ length: count }, (_, s) => ({
+			sequence: [...motif].map((base, i) => {
+				return u[s * 16 + i] < strength[i] ? base : "ACGT"[Math.floor(u[count * 16 + s * 16 + i] * 4)];
+			}).join(""),
+			count: 1 + s % 3
+		}));
+	}
+};
+export { ScientificSample };