@mstone6969/graph 0.1.0 → 0.2.0

package/dist/charts/earthscience/HovmollerSample.js

@@ -0,0 +1,40 @@
+import { SampleData } from "../../data/SampleData.js";
+// src/charts/earthscience/HovmollerSample.ts
+var DAYS = 61;
+var STEP = 2;
+var DAY = 864e5;
+var START = Date.UTC(2026, 0, 1);
+/** Near 5 m/s at the equator, the textbook Madden-Julian speed. */
+var EASTWARD = 3.9;
+/** Near −5 m/s, a textbook equatorial Rossby speed. */
+var WESTWARD = -3.9;
+/** Near 1.3 m/s, a textbook poleward speed for boreal-summer intraseasonal bands. */
+var NORTHWARD = 1.2;
+var gauss = (distance, width) => Math.exp(-((distance / width) ** 2));
+var radians = (degrees) => degrees * Math.PI / 180;
+var arc = (a, b) => Math.abs((a - b + 540) % 360 - 180);
+/** Synthetic tropical data for Hovmöller diagrams. It is a sum of invented waves, not a measurement of any kind. */
+var HovmollerSample = class {
+	/**
+	* Long-form rows `{ time, longitude, latitude, value }`, shaped like outgoing longwave radiation in W/m²:
+	* a warm-pool minimum, then an eastward packet, westward waves and a northward band.
+	*/
+	static tropics(seed) {
+		const [one, two, three] = SampleData.points(seed, 3, 1).map((row) => radians(+row.y * 7));
+		const rows = [];
+		for (let day = 0; day < DAYS; day += STEP) for (let longitude = 0; longitude < 360; longitude += 10) for (let latitude = -30; latitude <= 30; latitude += 5) {
+			const mean = 248 - 34 * gauss(arc(longitude, 130), 60) * gauss(latitude, 18);
+			const packet = -24 * gauss(latitude, 14) * gauss(arc(longitude - EASTWARD * day, 40), 110) * Math.cos(radians(2 * (longitude - EASTWARD * day)) + one);
+			const rossby = 10 * gauss(Math.abs(latitude) - 10, 9) * Math.cos(radians(6 * (longitude - WESTWARD * day)) + two);
+			const band = 11 * Math.cos(radians(6 * (latitude - NORTHWARD * day)) + three);
+			rows.push({
+				time: new Date(START + day * DAY),
+				longitude,
+				latitude,
+				value: +(mean + packet + rossby + band).toFixed(1)
+			});
+		}
+		return rows;
+	}
+};
+export { HovmollerSample };

package/dist/charts/earthscience/HovmollerSpeed.js

@@ -0,0 +1,71 @@
+import { HovmollerReference } from "./HovmollerEnums.js";
+// src/charts/earthscience/HovmollerSpeed.ts
+var SECONDS = 86400;
+/** Metres in one degree of a great circle on a sphere of radius 6371 km. */
+var METRES = 2 * Math.PI * 6371e3 / 360;
+var SEARCH = Array.from({ length: 59 }, (_, i) => 1 + i * .5);
+var MEANINGFUL = .05;
+/** Converts wave speeds to slopes, and estimates speeds from a section. */
+var HovmollerSpeed = class HovmollerSpeed {
+	/** Degrees per day at `speed` m/s along a line of latitude. Pass 0 for motion along a meridian. */
+	static degreesPerDay(speed, latitude = 0) {
+		return speed * SECONDS / (METRES * Math.cos(Math.min(85, Math.abs(latitude)) * Math.PI / 180));
+	}
+	/**
+	* Radon-style speed estimate, as used on altimeter and SST sections by Hill et al. (2000) and Cipollini et al. (2001).
+	* Rows are sheared by each trial speed and collapsed along the shear: the speed whose projection keeps the
+	* most variance wins. Variance is reported as adjusted R² of a one-way layout, so shears that happen to make
+	* more bins earn no credit. Stationary signal is removed first, and a best speed at the edge of the search is no peak, so it returns null.
+	*/
+	static fit(field, direction, latitude = 0) {
+		if (field.columns < 4 || field.rows < 4) return null;
+		const flat = field.anomaly(HovmollerReference.TimeMean).anomaly(HovmollerReference.SpaceMean);
+		const scores = SEARCH.map((speed) => HovmollerSpeed.score(flat, direction * this.degreesPerDay(speed, latitude)));
+		const best = scores.reduce((top, score, i) => score.share > scores[top].share ? i : top, 0);
+		if (best === 0 || best === SEARCH.length - 1 || scores[best].share < MEANINGFUL) return null;
+		return {
+			speed: direction * SEARCH[best],
+			rate: direction * this.degreesPerDay(SEARCH[best], latitude),
+			...scores[best]
+		};
+	}
+	static score(field, rate) {
+		const { columns, rows, positions, values, cyclic, spacing } = field;
+		const days = field.days, first = positions[0], turn = 360;
+		const shifts = days.map((day) => rate * day);
+		const lowest = first - Math.max(0, ...shifts);
+		const span = positions.at(-1) - first + Math.max(0, ...shifts) - Math.min(0, ...shifts);
+		const bins = Math.ceil((cyclic ? turn : span) / spacing) + 1;
+		const sum = new Float64Array(bins), count = new Float64Array(bins);
+		const place = (sheared) => cyclic ? ((sheared - first) % turn + turn) % turn : sheared - lowest;
+		let total = 0, square = 0, seen = 0;
+		for (let j = 0; j < rows; j++) for (let i = 0; i < columns; i++) {
+			const value = values[i + j * columns];
+			if (Number.isNaN(value)) continue;
+			const bin = Math.floor(place(positions[i] - shifts[j]) / spacing);
+			sum[bin] += value;
+			count[bin]++;
+			total += value;
+			square += value * value;
+			seen++;
+		}
+		const grand = total * total / (seen || 1), whole = square - grand;
+		let between = -grand, used = 0, peak = 0, origin = first;
+		sum.forEach((part, bin) => {
+			if (!count[bin]) return;
+			between += part * part / count[bin];
+			used++;
+			const mean = Math.abs(part / count[bin]);
+			if (count[bin] >= rows / 2 && mean > peak) {
+				peak = mean;
+				origin = (cyclic ? first : lowest) + (bin + .5) * spacing;
+			}
+		});
+		const free = seen - used;
+		return {
+			share: whole > 0 && free > 0 ? Math.max(0, 1 - (whole - between) / free / (whole / (seen - 1))) : 0,
+			origin
+		};
+	}
+};
+export { HovmollerSpeed };

package/dist/charts/earthscience/index.js

@@ -1,6 +1,14 @@
+import { HovmollerGuides, HovmollerLongitudes, HovmollerReference, HovmollerSection, HovmollerStyle, HovmollerTimeFlow } from "./HovmollerEnums.js";
+import { HovmollerField } from "./HovmollerField.js";
+import { HovmollerSpeed } from "./HovmollerSpeed.js";
+import { HovmollerDiagram } from "./HovmollerDiagram.js";
 import { BaseflowMethod, BaseflowSeparation } from "./BaseflowSeparation.js";
 import { Hydrograph } from "./Hydrograph.js";
 import { TernaryContour, TernaryContourStyle, TernaryLevelRule, TernarySurface } from "./TernaryContour.js";
 // src/charts/earthscience/index.ts
-var earthscienceCatalog = [Hydrograph, TernaryContour];
-export { BaseflowMethod, BaseflowSeparation, Hydrograph, TernaryContour, TernaryContourStyle, TernaryLevelRule, TernarySurface, earthscienceCatalog };
+var earthscienceCatalog = [
+	HovmollerDiagram,
+	Hydrograph,
+	TernaryContour
+];
+export { BaseflowMethod, BaseflowSeparation, HovmollerDiagram, HovmollerField, HovmollerGuides, HovmollerLongitudes, HovmollerReference, HovmollerSection, HovmollerSpeed, HovmollerStyle, HovmollerTimeFlow, Hydrograph, TernaryContour, TernaryContourStyle, TernaryLevelRule, TernarySurface, earthscienceCatalog };

package/dist/charts/engineering/ConstellationDiagram.js

@@ -14,6 +14,7 @@ var ConstellationModulation = /* @__PURE__ */ function(ConstellationModulation)
 var ConstellationRender = /* @__PURE__ */ function(ConstellationRender) {
 	ConstellationRender["Points"] = "points";
 	ConstellationRender["Density"] = "density";
+	ConstellationRender["Path"] = "symbol-path";
 	return ConstellationRender;
 }({});
 var ConstellationReference = /* @__PURE__ */ function(ConstellationReference) {
@@ -78,7 +79,11 @@ var ConstellationDiagram = class extends EngineeringChart {
 		],
 		sample: sampleSymbols,
 		variants: {
-			render: ["points", "density"],
+			render: [
+				"points",
+				"density",
+				"symbol-path"
+			],
 			reference: [
 				"lattice",
 				"unreferenced",
@@ -90,10 +95,12 @@ var ConstellationDiagram = class extends EngineeringChart {
 				"by-error"
 			],
 			view: ["i-q", "phase-amplitude"],
-			boundaries: [true, false]
+			boundaries: [true, false],
+			ring: [false, true]
 		},
 		valid: (v) => {
-			if (v.view === "phase-amplitude" && v.boundaries) return false;
+			if (v.view === "phase-amplitude" && (v.boundaries || v.ring)) return false;
+			if (v.render === "symbol-path" && v.view === "phase-amplitude") return false;
 			return v.render === "points" || v.encoding === "single" && v.reference !== "error-vectors";
 		}
 	};
@@ -106,7 +113,8 @@ var ConstellationDiagram = class extends EngineeringChart {
 			reference: "lattice",
 			encoding: "single",
 			view: "i-q",
-			boundaries: true
+			boundaries: true,
+			ring: false
 		};
 	}
 	symbols(ideal) {
@@ -123,7 +131,7 @@ var ConstellationDiagram = class extends EngineeringChart {
 		});
 	}
 	draw(ctx) {
-		const { modulation, render, reference, encoding, view, boundaries, xLabel, yLabel } = this.options;
+		const { modulation, render, reference, encoding, view, boundaries, ring, xLabel, yLabel } = this.options;
 		const { width, height } = ctx.plot;
 		const ideal = lattice(modulation);
 		const symbols = this.symbols(ideal);
@@ -168,6 +176,11 @@ var ConstellationDiagram = class extends EngineeringChart {
 				points: cells.cellPolygon(i) ?? []
 			})));
 		}
+		if (ring && !polar) this.guides(ctx, "power-ring", [{
+			key: "ring",
+			dash: "4 3",
+			points: Array.from({ length: 121 }, (_, k) => at([Math.cos(k * Math.PI / 60), Math.sin(k * Math.PI / 60)]))
+		}]);
 		const worst = max(symbols, (s) => s.error) || 1e-9;
 		const seat = (s) => at([s.i, s.q]);
 		if (render === "density") {
@@ -195,6 +208,13 @@ var ConstellationDiagram = class extends EngineeringChart {
 					points: vectors
 				}]);
 			}
+			const shown = render === "symbol-path" ? symbols.slice(0, 64) : symbols;
+			if (render === "symbol-path") this.traces(ctx, "symbol-path", [{
+				key: "path",
+				color: ctx.palette.color("Symbols"),
+				width: 1,
+				points: shown.map(seat)
+			}]);
 			const quadrants = encoding === "by-quadrant";
 			if (quadrants) [
 				"Q1",
@@ -204,7 +224,7 @@ var ConstellationDiagram = class extends EngineeringChart {
 			].forEach(ctx.palette.color);
 			const quadrant = (s) => s.i >= 0 ? s.q >= 0 ? 0 : 3 : s.q >= 0 ? 1 : 2;
 			const byError = encoding === "by-error";
-			const marks = ctx.marks("symbols", "path", symbols).attr("fill-opacity", .75).attr("fill", (s) => {
+			const marks = ctx.marks("symbols", "path", shown).attr("fill-opacity", .75).attr("fill", (s) => {
 				if (byError) return ctx.palette.sequential(.2 + .8 * s.error / worst);
 				return ctx.palette.color(quadrants ? `Q${quadrant(s) + 1}` : "Symbols");
 			});

package/dist/charts/engineering/EyeDiagram.js

@@ -225,9 +225,10 @@ var EyeDiagram = class extends EngineeringChart {
 				height: eyeHeight
 			});
 		}
+		const left = max(cross, (c) => c.at < center ? c.at : void 0) ?? 0, right = min(cross, (c) => c.at >= center ? c.at : void 0) ?? span;
 		this.annotate(eye, "eye-note", opening > 0 ? [{
 			key: "h",
-			text: `Opening ${opening.toPrecision(2)}`,
+			text: `Opening ${opening.toPrecision(2)}, width ${(right - left).toFixed(2)} UI`,
 			x: x(center),
 			y: y(threshold) + (mask ? 30 : 4),
 			anchor: "middle",

package/dist/charts/engineering/PoleZeroPlot.js

@@ -35,12 +35,15 @@ var PoleZeroPlot = class extends SPlaneChart {
 			plane: [
 				"s-plane",
 				"z-matched",
-				"z-bilinear"
+				"z-bilinear",
+				"z-plane"
 			],
 			guides: [true, false],
 			stability: [true, false],
-			upperHalf: [false, true]
-		}
+			upperHalf: [false, true],
+			pairs: [false, true]
+		},
+		valid: ({ upperHalf, pairs }) => !(upperHalf && pairs)
 	};
 	defaults() {
 		return {
@@ -48,19 +51,23 @@ var PoleZeroPlot = class extends SPlaneChart {
 			plane: "s-plane",
 			guides: true,
 			stability: true,
-			upperHalf: false
+			upperHalf: false,
+			pairs: false
 		};
 	}
+	matched(period) {
+		return ([re, im]) => ComplexMath.polar(Math.exp(re * period), im * period);
+	}
 	mapper(roots) {
 		const { plane, samplePeriod } = this.options;
 		const fastest = Math.max(1e-6, ...roots.map((root) => Math.hypot(root.real, root.imaginary)));
 		const period = samplePeriod ?? 1 / fastest;
-		if (plane === "z-matched") return ([re, im]) => ComplexMath.polar(Math.exp(re * period), im * period);
+		if (plane === "z-matched") return this.matched(period);
 		if (plane === "z-bilinear") return ([re, im]) => ComplexMath.div([1 + re * period / 2, im * period / 2], [1 - re * period / 2, -im * period / 2]);
 		return (s) => s;
 	}
 	draw(ctx) {
-		const { plane, guides, stability, upperHalf, xLabel, yLabel } = this.options;
+		const { plane, guides, stability, upperHalf, pairs, xLabel, yLabel } = this.options;
 		const { width, height } = ctx.plot;
 		const roots = this.roots();
 		const discrete = plane !== "s-plane";
@@ -98,11 +105,13 @@ var PoleZeroPlot = class extends SPlaneChart {
 			points: this.within(ring(1), width, height)
 		}]);
 		if (guides) {
-			const period = Math.max(...roots.map((root) => Math.hypot(root.real, root.imaginary)), 1);
+			const onZ = plane === "z-plane";
+			const period = onZ ? 1 : Math.max(...roots.map((root) => Math.hypot(root.real, root.imaginary)), 1);
+			const trace = onZ ? this.matched(1) : map;
 			const traced = this.dampingGrid(discrete ? period * 3 : Math.max(-left, y.domain()[1]) * 1.3).map((guide) => ({
 				...guide,
 				dash: "2 3",
-				points: this.within(guide.points.map((p) => at(map(p))), width, height)
+				points: this.within(guide.points.map((p) => at(trace(p))), width, height)
 			}));
 			this.guides(ctx, "damping", traced);
 			this.annotate(ctx, "damping-notes", traced.filter((g) => g.label).flatMap((g) => {
@@ -118,6 +127,21 @@ var PoleZeroPlot = class extends SPlaneChart {
 			}));
 		}
 		const seat = new Map(roots.map((root, i) => [root, at(placed[i])]));
+		if (pairs) {
+			const links = roots.flatMap((root) => {
+				const twin = root.imaginary > 1e-6 ? roots.find((other) => other.kind === root.kind && other.system === root.system && Math.abs(other.real - root.real) < 1e-6 && Math.abs(other.imaginary + root.imaginary) < 1e-6) : void 0;
+				return twin ? [
+					seat.get(root),
+					seat.get(twin),
+					[NaN, NaN]
+				] : [];
+			});
+			this.guides(ctx, "conjugate-pairs", [{
+				key: "pairs",
+				dash: "3 3",
+				points: links
+			}]);
+		}
 		this.rootMarks(ctx, "roots", upperHalf ? roots.filter((_, i) => placed[i][1] >= -1e-9) : roots, (root) => seat.get(root));
 	}
 };