@mstone6969/graph 0.0.0-stage → 0.1.0

package/dist/charts/mathematical/StrangeAttractor3D.js

@@ -0,0 +1,251 @@
+import { Chart3D } from "../../core/Chart3D.js";
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { MathNumerics } from "./MathNumerics.js";
+import { scaleLinear } from "d3";
+import { BufferGeometry, CatmullRomCurve3, Color, Float32BufferAttribute, InstancedMesh, Line, LineBasicMaterial, Mesh, MeshStandardMaterial, Object3D, SphereGeometry, TubeGeometry, Vector3 } from "three";
+// src/charts/mathematical/StrangeAttractor3D.ts
+var AttractorSystem = /* @__PURE__ */ function(AttractorSystem) {
+	AttractorSystem["Lorenz"] = "lorenz";
+	AttractorSystem["Rossler"] = "rossler";
+	AttractorSystem["Aizawa"] = "aizawa";
+	AttractorSystem["Thomas"] = "thomas";
+	AttractorSystem["Halvorsen"] = "halvorsen";
+	AttractorSystem["ChenLee"] = "chen-lee";
+	return AttractorSystem;
+}({});
+var AttractorRender = /* @__PURE__ */ function(AttractorRender) {
+	AttractorRender["Tube"] = "tube";
+	AttractorRender["Line"] = "line";
+	AttractorRender["Beads"] = "beads";
+	return AttractorRender;
+}({});
+var SYSTEMS = {
+	["lorenz"]: {
+		flow: (x, y, z) => [
+			10 * (y - x),
+			x * (28 - z) - y,
+			x * y - 8 / 3 * z
+		],
+		start: [
+			1,
+			1,
+			20
+		],
+		dt: .006,
+		steps: 6e3
+	},
+	["rossler"]: {
+		flow: (x, y, z) => [
+			-y - z,
+			x + .2 * y,
+			.2 + z * (x - 5.7)
+		],
+		start: [
+			1,
+			1,
+			0
+		],
+		dt: .03,
+		steps: 6e3
+	},
+	["aizawa"]: {
+		flow: (x, y, z) => [
+			(z - .7) * x - 3.5 * y,
+			3.5 * x + (z - .7) * y,
+			.6 + .95 * z - z ** 3 / 3 - (x * x + y * y) * (1 + .25 * z) + .1 * z * x ** 3
+		],
+		start: [
+			.1,
+			0,
+			.1
+		],
+		dt: .012,
+		steps: 7e3
+	},
+	["thomas"]: {
+		flow: (x, y, z) => [
+			Math.sin(y) - .19 * x,
+			Math.sin(z) - .19 * y,
+			Math.sin(x) - .19 * z
+		],
+		start: [
+			1.1,
+			1.1,
+			-.1
+		],
+		dt: .06,
+		steps: 7e3
+	},
+	["halvorsen"]: {
+		flow: (x, y, z) => [
+			-1.4 * x - 4 * y - 4 * z - y * y,
+			-1.4 * y - 4 * z - 4 * x - z * z,
+			-1.4 * z - 4 * x - 4 * y - x * x
+		],
+		start: [
+			-1.5,
+			0,
+			0
+		],
+		dt: .006,
+		steps: 6e3
+	},
+	["chen-lee"]: {
+		flow: (x, y, z) => [
+			5 * x - y * z,
+			-10 * y + x * z,
+			-3.8 * z + x * y / 3
+		],
+		start: [
+			1,
+			1,
+			1
+		],
+		dt: .005,
+		steps: 7e3
+	}
+};
+var SETTLE = 400;
+/** Chaotic flows in three dimensions: trajectories that never repeat yet stay on one shape, with colour tracing time. */
+var StrangeAttractor3D = class extends Chart3D {
+	static meta = {
+		id: "strange-attractor-3d",
+		name: "Strange attractor",
+		family: ChartFamily.Mathematical,
+		dimension: Dimension.Three,
+		shape: DataShape.Function,
+		description: "Integrates a chaotic three-dimensional system and draws its trajectory as a tube, a line or a stream of beads.",
+		tags: [
+			"lorenz",
+			"chaos",
+			"dynamical system",
+			"butterfly"
+		],
+		sample: (seed) => MathNumerics.fit(SampleData.points(seed, 3, 3), "x", "y", [[-.3, .3], [-.3, .3]]).map(([x, y]) => ({
+			x,
+			y
+		})),
+		variants: {
+			system: Object.values(AttractorSystem),
+			render: Object.values(AttractorRender),
+			trajectories: [
+				1,
+				2,
+				3
+			]
+		}
+	};
+	defaults() {
+		return {
+			system: "lorenz",
+			render: "tube",
+			trajectories: 1,
+			x: "x",
+			y: "y",
+			azimuth: 50,
+			elevation: 14,
+			distance: 3.6
+		};
+	}
+	integrate(nudge) {
+		const { flow, start, dt, steps } = SYSTEMS[this.options.system];
+		let [x, y, z] = [
+			start[0] + nudge[0],
+			start[1] + nudge[1],
+			start[2]
+		];
+		const out = [];
+		const add = (a, b, c, k, h) => [
+			a + h * k[0],
+			b + h * k[1],
+			c + h * k[2]
+		];
+		for (let i = 0; i < steps + SETTLE; i++) {
+			const k1 = flow(x, y, z), k2 = flow(...add(x, y, z, k1, dt / 2)), k3 = flow(...add(x, y, z, k2, dt / 2)), k4 = flow(...add(x, y, z, k3, dt));
+			x += dt * (k1[0] + 2 * k2[0] + 2 * k3[0] + k4[0]) / 6;
+			y += dt * (k1[1] + 2 * k2[1] + 2 * k3[1] + k4[1]) / 6;
+			z += dt * (k1[2] + 2 * k2[2] + 2 * k3[2] + k4[2]) / 6;
+			if (!Number.isFinite(x + y + z)) break;
+			if (i >= SETTLE) out.push(new Vector3(x, z, y));
+		}
+		return out;
+	}
+	build(ctx) {
+		const { data, trajectories, render, x, y } = this.options;
+		const paths = Array.from({ length: trajectories }, (_, i) => {
+			const row = data[i];
+			return [Number.isFinite(+row?.[x]) ? +row[x] : i * .1, Number.isFinite(+row?.[y]) ? +row[y] : 0];
+		}).map((nudge) => this.integrate(nudge)).filter((path) => path.length > 1);
+		const all = paths.flat();
+		if (!all.length) return;
+		const span = (axis) => {
+			const values = all.map((p) => p[axis]), a = Math.min(...values.slice(0, 4e3), ...values.slice(-4e3)), b = Math.max(...values.slice(0, 4e3), ...values.slice(-4e3));
+			return [
+				a,
+				b,
+				(a + b) / 2
+			];
+		};
+		const [x0, x1, cx] = span("x"), [y0, y1, cy] = span("y"), [z0, z1, cz] = span("z");
+		const unit = 1.9 / Math.max(x1 - x0, y1 - y0, z1 - z0, 1e-6);
+		const fit = (p) => new Vector3((p.x - cx) * unit, (p.y - cy) * unit, (p.z - cz) * unit);
+		const multi = paths.length > 1;
+		const tint = (path, t) => new Color(multi ? ctx.palette.color(`Start ${path + 1}`) : ctx.palette.sequential(.25 + .75 * t));
+		paths.forEach((raw, index) => {
+			const path = raw.map(fit);
+			const tag = () => ({
+				title: multi ? `Trajectory ${index + 1}` : "Trajectory",
+				rows: [["Steps", path.length]]
+			});
+			if (render === "line") {
+				const geometry = new BufferGeometry().setFromPoints(path);
+				const colors = path.flatMap((_, i) => tint(index, i / path.length).toArray());
+				geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
+				const line = new Line(geometry, new LineBasicMaterial({ vertexColors: true }));
+				ctx.reveal((progress) => geometry.setDrawRange(0, Math.floor(path.length * progress)), 2.4);
+				ctx.root.add(line);
+			} else if (render === "beads") {
+				const every = Math.ceil(path.length / 1400);
+				const picked = path.filter((_, i) => i % every === 0);
+				const beads = new InstancedMesh(new SphereGeometry(.012, 8, 6), new MeshStandardMaterial({ roughness: .4 }), picked.length);
+				const dummy = new Object3D();
+				beads.castShadow = true;
+				picked.forEach((p, i) => {
+					dummy.position.copy(p);
+					dummy.updateMatrix();
+					beads.setMatrixAt(i, dummy.matrix);
+					beads.setColorAt(i, tint(index, i / picked.length));
+				});
+				ctx.reveal((progress) => {
+					beads.count = Math.max(1, Math.floor(picked.length * progress));
+				}, 2.4);
+				ctx.root.add(beads);
+				ctx.pick(beads, tag);
+			} else {
+				const every = Math.ceil(path.length / 1300);
+				const curve = new CatmullRomCurve3(path.filter((_, i) => i % every === 0));
+				const segments = 1600, sides = 6;
+				const geometry = new TubeGeometry(curve, segments, multi ? .009 : .012, sides, false);
+				const colors = [];
+				for (let i = 0; i <= segments; i++) for (let j = 0; j <= sides; j++) colors.push(...tint(index, i / segments).toArray());
+				geometry.setAttribute("color", new Float32BufferAttribute(colors, 3));
+				const tube = new Mesh(geometry, new MeshStandardMaterial({
+					vertexColors: true,
+					roughness: .42,
+					metalness: .05
+				}));
+				tube.castShadow = true;
+				const total = geometry.index?.count ?? 0;
+				ctx.reveal((progress) => geometry.setDrawRange(0, Math.floor(total * progress)), 2.4);
+				ctx.root.add(tube);
+				ctx.pick(tube, tag);
+			}
+		});
+		const spin = scaleLinear([0, 60], [0, Math.PI * 2]);
+		ctx.onFrame((t) => {
+			if (!this.options.autoRotate) ctx.root.rotation.y = spin(t) * .25;
+		});
+	}
+};
+export { AttractorRender, AttractorSystem, StrangeAttractor3D };

package/dist/charts/mathematical/StreamlineChart.js

@@ -0,0 +1,159 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { FieldForm, FieldPlot } from "./FieldPlot.js";
+import { MathMarks } from "./MathMarks.js";
+import { MathNumerics } from "./MathNumerics.js";
+import { mean } from "d3";
+// src/charts/mathematical/StreamlineChart.ts
+/** Even spacing fills the plane uniformly; lattice seeds give short "curly vectors". */
+var StreamSeeding = /* @__PURE__ */ function(StreamSeeding) {
+	StreamSeeding["Even"] = "even";
+	StreamSeeding["Lattice"] = "lattice";
+	return StreamSeeding;
+}({});
+var STEP = 2;
+/** Integrated flow lines with the Jobard-Lefer spacing rule: the tidiest way to read circulation and topology of a field. */
+var StreamlineChart = class extends FieldPlot {
+	static meta = {
+		id: "streamline",
+		name: "Streamline chart",
+		family: ChartFamily.Mathematical,
+		dimension: Dimension.Two,
+		shape: DataShape.Function,
+		description: "Follows a vector field along evenly spaced flow lines, with colour and width carrying speed.",
+		tags: [
+			"flow",
+			"stream plot",
+			"fluid",
+			"curly vectors"
+		],
+		sample: (seed) => {
+			const rows = SampleData.points(seed, 4, 2);
+			return MathNumerics.fit(rows, "x", "y", [[-2.2, 2.2], [-1.5, 1.5]]).map(([x, y], i) => ({
+				x,
+				y,
+				charge: i % 2 ? -1 : 1
+			}));
+		},
+		variants: {
+			form: Object.values(FieldForm),
+			seeding: Object.values(StreamSeeding),
+			taper: [false, true],
+			arrows: [true, false]
+		}
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			seeding: "even",
+			taper: false,
+			arrows: true,
+			separation: 16
+		};
+	}
+	walk(field, plane, start, sign, limit, stop) {
+		const { x, y, width, height } = plane;
+		const sx = Math.abs(x(1) - x(0)), sy = Math.abs(y(0) - y(1));
+		const velocity = (px, py) => {
+			const [u, v] = field(x.invert(px), y.invert(py));
+			return [u * sx, -v * sy];
+		};
+		const points = [start], speeds = [];
+		let [px, py] = start;
+		for (let n = 0; n < limit; n++) {
+			const [a, b] = velocity(px, py), m = Math.hypot(a, b);
+			if (!Number.isFinite(m) || m < 1e-6) break;
+			const [c, d] = velocity(px + sign * STEP * a / m / 2, py + sign * STEP * b / m / 2), k = Math.hypot(c, d) || 1;
+			px += sign * STEP * c / k;
+			py += sign * STEP * d / k;
+			if (px < 0 || py < 0 || px > width || py > height || stop([px, py], n)) break;
+			points.push([px, py]);
+			speeds.push(m);
+		}
+		return {
+			points,
+			speeds
+		};
+	}
+	streams(field, plane) {
+		const { width, height } = plane;
+		const gap = this.options.separation;
+		const out = [];
+		if (this.options.seeding === "lattice") {
+			const cols = Math.floor(width / (gap * 1.6)), rows = Math.floor(height / (gap * 1.6));
+			for (let j = 0; j < rows; j++) for (let i = 0; i < cols; i++) {
+				const start = [(i + .5) / cols * width, (j + .5) / rows * height];
+				const { points, speeds } = this.walk(field, plane, start, 1, 12, () => false);
+				if (points.length > 2) out.push({
+					key: i + j * cols,
+					pixels: points,
+					speeds
+				});
+			}
+			return out;
+		}
+		const cell = gap / 2;
+		const cols = Math.ceil(width / cell) + 1, rows = Math.ceil(height / cell) + 1;
+		const taken = new Int32Array(cols * rows).fill(-1);
+		const index = ([px, py]) => Math.floor(px / cell) + Math.floor(py / cell) * cols;
+		const blocked = ([px, py], self) => {
+			const ci = Math.floor(px / cell), cj = Math.floor(py / cell);
+			for (let j = cj - 1; j <= cj + 1; j++) for (let i = ci - 1; i <= ci + 1; i++) {
+				if (i < 0 || j < 0 || i >= cols || j >= rows) continue;
+				const owner = taken[i + j * cols];
+				if (owner >= 0 && owner !== self) return true;
+			}
+			return false;
+		};
+		const seedStep = gap * .8;
+		let id = 0;
+		for (let py = seedStep / 2; py < height; py += seedStep) for (let px = seedStep / 2; px < width; px += seedStep) {
+			const seed = [px, py];
+			if (blocked(seed, id)) continue;
+			const stop = (p) => blocked(p, id);
+			const forward = this.walk(field, plane, seed, 1, 800, stop);
+			const backward = this.walk(field, plane, seed, -1, 800, stop);
+			const pixels = [...backward.points.slice(1).reverse(), ...forward.points];
+			if (pixels.length < 12) continue;
+			for (const point of pixels) taken[index(point)] = id;
+			out.push({
+				key: id,
+				pixels,
+				speeds: [...backward.speeds.reverse(), ...forward.speeds]
+			});
+			id++;
+		}
+		return out;
+	}
+	plotPlane(ctx, plane) {
+		const { taper, arrows } = this.options;
+		const field = this.field();
+		const streams = this.streams(field, plane);
+		const sorted = streams.flatMap((s) => s.speeds).sort((a, b) => a - b);
+		const top = sorted[Math.floor(sorted.length * .95)] || 1;
+		const level = (speed) => Math.min(1, Math.sqrt(speed / top));
+		const tone = (d) => ctx.palette.sequential(.3 + .7 * level(mean(d.speeds) ?? 0));
+		const ribbon = (d) => {
+			const left = [], right = [];
+			d.pixels.forEach((p, i) => {
+				const a = d.pixels[Math.max(0, i - 1)], b = d.pixels[Math.min(d.pixels.length - 1, i + 1)];
+				const n = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1;
+				const w = .5 + 2 * level(d.speeds[Math.min(i, d.speeds.length - 1)] ?? 0);
+				left.push([p[0] - (b[1] - a[1]) / n * w, p[1] + (b[0] - a[0]) / n * w]);
+				right.push([p[0] + (b[1] - a[1]) / n * w, p[1] - (b[0] - a[0]) / n * w]);
+			});
+			return MathMarks.line([...left, ...right.reverse()], true);
+		};
+		const shape = (d) => taper ? ribbon(d) : MathMarks.line(d.pixels);
+		const lines = ctx.marks("stream-line", "path", streams, (d) => d.key).attr("fill", (d) => taper ? tone(d) : "none").attr("stroke", (d) => taper ? "none" : tone(d)).attr("stroke-width", 1.75).attr("stroke-linecap", "round").attr("stroke-linejoin", "round");
+		ctx.set(lines, { d: shape }, { d: shape });
+		if (!taper) ctx.drawOn(lines);
+		ctx.hover(lines, (d) => ({
+			title: "Streamline",
+			rows: [["Mean speed", MathNumerics.format(mean(d.speeds) ?? 0)], ["Peak speed", MathNumerics.format(Math.max(...d.speeds))]]
+		}));
+		const heads = ctx.marks("stream-head", "path", arrows ? streams : [], (d) => d.key).attr("fill", tone);
+		ctx.set(heads, { d: (d) => MathMarks.headsAlong(d.pixels, Math.max(1, Math.round(d.pixels.length / 90)), d.pixels.length > 30 ? 7 : 5) });
+	}
+};
+export { StreamSeeding, StreamlineChart };

package/dist/charts/mathematical/TaylorSeriesChart.js

@@ -0,0 +1,175 @@
+import { ChartFamily, DataShape, Dimension } from "../../core/enums.js";
+import { SampleData } from "../../data/SampleData.js";
+import { MathMarks } from "./MathMarks.js";
+import { MathNumerics } from "./MathNumerics.js";
+import { MathPlane, PlaneFrame } from "./MathPlane.js";
+// src/charts/mathematical/TaylorSeriesChart.ts
+var TaylorFunction = /* @__PURE__ */ function(TaylorFunction) {
+	TaylorFunction["Sine"] = "sine";
+	TaylorFunction["Exponential"] = "exponential";
+	TaylorFunction["Logarithm"] = "logarithm";
+	TaylorFunction["Geometric"] = "geometric";
+	TaylorFunction["Arctangent"] = "arctangent";
+	TaylorFunction["Gaussian"] = "gaussian";
+	return TaylorFunction;
+}({});
+/** Stacked degrees over the function, or the remaining error of each degree. */
+var TaylorView = /* @__PURE__ */ function(TaylorView) {
+	TaylorView["Approximants"] = "approximants";
+	TaylorView["Error"] = "error";
+	return TaylorView;
+}({});
+var factorial = (n) => n < 2 ? 1 : n * factorial(n - 1);
+var SERIES = {
+	["sine"]: {
+		f: Math.sin,
+		label: "sin x",
+		domain: [-Math.PI * 2.4, Math.PI * 2.4],
+		range: [-2.6, 2.6],
+		rho: Infinity,
+		coefficient: (n) => n % 2 ? (-1) ** ((n - 1) / 2) / factorial(n) : 0
+	},
+	["exponential"]: {
+		f: Math.exp,
+		label: "eˣ",
+		domain: [-4, 3.4],
+		range: [-3, 24],
+		rho: Infinity,
+		coefficient: (n) => 1 / factorial(n)
+	},
+	["logarithm"]: {
+		f: Math.log1p,
+		label: "ln(1 + x)",
+		domain: [-1.4, 2.6],
+		range: [-3, 2.4],
+		rho: 1,
+		coefficient: (n) => n ? (-1) ** (n + 1) / n : 0
+	},
+	["geometric"]: {
+		f: (x) => 1 / (1 - x),
+		label: "1 / (1 − x)",
+		domain: [-2.2, 1.9],
+		range: [-4, 8],
+		rho: 1,
+		coefficient: () => 1
+	},
+	["arctangent"]: {
+		f: Math.atan,
+		label: "arctan x",
+		domain: [-2.6, 2.6],
+		range: [-2.8, 2.8],
+		rho: 1,
+		coefficient: (n) => n % 2 ? (-1) ** ((n - 1) / 2) / n : 0
+	},
+	["gaussian"]: {
+		f: (x) => Math.exp(-x * x),
+		label: "e^(−x²)",
+		domain: [-3, 3],
+		range: [-1.4, 2],
+		rho: Infinity,
+		coefficient: (n) => n % 2 ? 0 : (-1) ** (n / 2) / factorial(n / 2)
+	}
+};
+/** Polynomials closing in on a function near a point, and where they stop working: the radius of convergence made visible. */
+var TaylorSeriesChart = class extends MathPlane {
+	static meta = {
+		id: "taylor-series",
+		name: "Taylor series chart",
+		family: ChartFamily.Mathematical,
+		dimension: Dimension.Two,
+		shape: DataShape.Function,
+		description: "Overlays Maclaurin polynomials of rising degree on a function, or plots the error each degree leaves.",
+		tags: [
+			"maclaurin",
+			"approximation",
+			"polynomial",
+			"convergence"
+		],
+		sample: (seed) => SampleData.categories(seed, 4, 1).map((_, i) => ({ order: 2 * i + 1 + (i > 2 ? 2 : 0) })),
+		variants: {
+			fn: Object.values(TaylorFunction),
+			view: Object.values(TaylorView),
+			radius: [true, false],
+			frame: [PlaneFrame.Box, PlaneFrame.Cross]
+		},
+		valid: (v) => !(v.radius === false && ![
+			"logarithm",
+			"geometric",
+			"arctangent"
+		].includes(v.fn))
+	};
+	defaults() {
+		return {
+			...super.defaults(),
+			fn: "sine",
+			view: "approximants",
+			radius: true,
+			order: "order"
+		};
+	}
+	get series() {
+		return SERIES[this.options.fn];
+	}
+	orders() {
+		const { data, order } = this.options;
+		const list = data.map((row) => Math.round(+row[order])).filter((n) => Number.isFinite(n) && n >= 0 && n <= 40);
+		return [...new Set(list)].sort((a, b) => a - b);
+	}
+	polynomial(degree) {
+		const { coefficient } = this.series;
+		const terms = Array.from({ length: degree + 1 }, (_, n) => coefficient(n));
+		return (x) => terms.reduceRight((sum, c) => sum * x + c, 0);
+	}
+	extent() {
+		const { domain, range } = this.series;
+		return [domain, this.options.view === "error" ? [-7, 1.5] : range];
+	}
+	plotPlane(ctx, plane) {
+		const { view, radius } = this.options;
+		const { x, y, box, width, height } = plane;
+		const { f, rho, label } = this.series;
+		const degrees = this.orders();
+		const pixels = (runs) => runs.map((run) => MathMarks.line(run.map((p) => [x(p[0]), y(p[1])]))).join("");
+		const error = view === "error";
+		const bands = radius && Number.isFinite(rho) ? [{
+			key: "l",
+			x: 0,
+			w: Math.max(0, x(Math.max(-rho, box[0][0])))
+		}, {
+			key: "r",
+			x: x(Math.min(rho, box[0][1])),
+			w: Math.max(0, width - x(Math.min(rho, box[0][1])))
+		}].filter((band) => band.w > 0) : [];
+		const outside = ctx.marks("tay-outside", "rect", bands, (d) => d.key).attr("fill", ctx.theme.grid).attr("fill-opacity", .6);
+		ctx.set(outside, {
+			x: (d) => d.x,
+			y: 0,
+			width: (d) => d.w,
+			height
+		});
+		ctx.hover(outside, () => ({
+			title: "Outside the radius of convergence",
+			rows: [["|x| >", rho]]
+		}));
+		const curveOf = (degree) => {
+			const p = this.polynomial(degree);
+			return error ? (v) => Math.log10(Math.abs(p(v) - f(v)) + 1e-9) : p;
+		};
+		const lines = degrees.map((degree) => ({
+			degree,
+			name: `degree ${degree}`,
+			fn: curveOf(degree)
+		}));
+		const color = (d) => ctx.palette.color(d.name);
+		const paths = MathMarks.stroke(ctx.marks("tay-poly", "path", lines, (d) => d.degree), color, 1.75);
+		MathMarks.reveal(ctx, paths, (d) => pixels(MathNumerics.clip(MathNumerics.trace(d.fn, box[0], 700), box[1])));
+		const target = MathMarks.stroke(ctx.marks("tay-function", "path", error ? [] : [0]), ctx.theme.ink, 2.5);
+		ctx.set(target, { d: () => pixels(MathNumerics.clip(MathNumerics.trace(f, box[0], 700), box[1])) });
+		this.probe(ctx, plane, (v) => ({
+			title: `x = ${MathNumerics.format(v)}`,
+			rows: [[label, MathNumerics.format(f(v))], ...lines.map((line) => [line.name, MathNumerics.format(error ? Math.abs(this.polynomial(line.degree)(v) - f(v)) : line.fn(v))])]
+		}));
+		ctx.text(ctx.marks("tay-note", "text", [error ? `log₁₀ |error|, ${label}` : label]).attr("x", 6).attr("y", 13).text((d) => d), 11, "ink");
+	}
+};
+export { TaylorFunction, TaylorSeriesChart, TaylorView };