@classytic/stage 0.2.0 → 0.4.0

package/dist/physics/magnetism/biot-savart.d.mts

@@ -0,0 +1,161 @@
+import { Vec3 } from "../../core/vec3.mjs";
+
+//#region src/physics/magnetism/biot-savart.d.ts
+/** Permeability of free space, in T m A^-1. */
+declare const MU_0: number;
+/**
+ * Closest a field point may sit to a current filament, in metres.
+ *
+ * A filament is a modelling fiction with zero thickness, so B genuinely
+ * diverges on it. We refuse rather than return a huge number, because a huge
+ * number looks like an answer and a student will write it down.
+ */
+declare const MIN_DISTANCE_M = 0.000001;
+/** A polyline carrying a steady current, walked from points[0] to the last. */
+interface CurrentPath {
+  id: string;
+  /** Current in amperes. Negative reverses the sense of travel. */
+  currentA: number;
+  /** Vertices in metres. A segment is drawn between consecutive vertices. */
+  points: Vec3[];
+  /** When true, a closing segment joins the last vertex back to the first. */
+  closed?: boolean;
+}
+interface FieldContribution {
+  pathId: string;
+  field: Vec3;
+  magnitudeT: number;
+}
+interface FieldResult {
+  field: Vec3;
+  magnitudeT: number;
+  /** Per-path breakdown, so a lesson can show superposition rather than assert it. */
+  contributions: FieldContribution[];
+}
+/**
+ * Field at `point` from one straight segment carrying `currentA` from `from` to `to`.
+ *
+ * Exact, not sampled. Integrating dl x r / |r|^3 along a straight line gives
+ *
+ *   B = (mu0 I / 4pi) * (lhat x r1) / |lhat x r1|^2 * (lhat . r1hat - lhat . r2hat)
+ *
+ * where r1, r2 are the vectors from each end to the field point. The right-hand
+ * factor is the (sin theta1 + sin theta2) of the textbook, written so that it
+ * never needs an angle convention.
+ */
+declare function segmentField(from: Vec3, to: Vec3, point: Vec3, currentA: number): Vec3;
+/** Field at a point from one current path. */
+declare function pathField(path: CurrentPath, point: Vec3): Vec3;
+/**
+ * Field at a point from any number of current paths.
+ *
+ * Superposition is the whole reason this is one function and not many: two
+ * wires, a wire and a coil, a Helmholtz pair, all add the same way.
+ */
+declare function fieldAt(paths: readonly CurrentPath[], point: Vec3): FieldResult;
+interface StreamlineOptions {
+  /** Arc length per step, in metres. Smaller is smoother and slower. */
+  stepM?: number;
+  maxSteps?: number;
+  /** +1 follows the field, -1 runs against it. Trace both to get a whole line. */
+  direction?: 1 | -1;
+  /** Abandon the line once it strays this far from the seed. */
+  boundsM?: number;
+  /** Treat the line as closed once it returns this close to its own start. */
+  closeToleranceM?: number;
+}
+interface Streamline {
+  points: Vec3[];
+  /** Why the trace stopped, which is information a lesson can use. */
+  ended: 'closed' | 'left-bounds' | 'hit-current' | 'max-steps';
+}
+/**
+ * Trace one magnetic field line from a seed point.
+ *
+ * A field line is the curve whose tangent is B everywhere, so tracing it means
+ * stepping along the UNIT field: that keeps the step a fixed arc length instead
+ * of a fixed time, so the spacing stays even where the field is strong.
+ * Integrated with RK4, because a field line through a coil turns sharply enough
+ * that Euler visibly spirals outward and a student would be looking at the
+ * integrator's error rather than at the physics.
+ */
+declare function traceFieldLine(paths: readonly CurrentPath[], seed: Vec3, options?: StreamlineOptions): Streamline;
+/**
+ * Trace a full field line through a seed, running both ways from it.
+ *
+ * A magnetic field line has no start and no end, so seeding one and following
+ * it forwards only would draw half a line and imply the seed was special.
+ */
+declare function traceFullFieldLine(paths: readonly CurrentPath[], seed: Vec3, options?: StreamlineOptions): Streamline;
+/** A straight run of wire between two points. */
+declare function straightWire(from: Vec3, to: Vec3, currentA: number, id?: string): CurrentPath;
+/**
+ * A wire long enough to stand in for an infinite one, centred on `through` and
+ * running along `direction`.
+ *
+ * "Infinite" is not a geometry, so a lesson that wants the textbook
+ * mu0 I / 2 pi a has to pick a length. Making that choice visible is the point:
+ * the student can shorten it and watch the answer fall away from the formula.
+ */
+declare function longWire(through: Vec3, direction: Vec3, currentA: number, halfLengthM?: number, id?: string): CurrentPath;
+/**
+ * A circular arc of `arcDeg` in the xy plane, centred on `centre`, radius `radiusM`.
+ *
+ * A full loop is `arcDeg = 360`. Positive current circulates anticlockwise seen
+ * from +z, so by the right-hand rule B points along +z at the centre.
+ */
+declare function circularArc(centre: Vec3, radiusM: number, currentA: number, arcDeg?: number, segments?: number, id?: string): CurrentPath;
+/** A flat coil of `turns` identical loops, treated as `turns` times one loop's current. */
+declare function flatCoil(centre: Vec3, radiusM: number, currentA: number, turns?: number, segments?: number, id?: string): CurrentPath;
+/**
+ * A helical solenoid along z, centred on the origin.
+ *
+ * Wound as a real solenoid is: one continuous helix, not a stack of separate
+ * rings. That matters at the ends, which is exactly where the mu0 n I formula
+ * stops being true and where a student should be able to see it stop.
+ */
+declare function solenoid(radiusM: number, lengthM: number, turns: number, currentA: number, perTurn?: number, id?: string): CurrentPath;
+/**
+ * An IDEAL solenoid: `turns` separate coaxial rings, with no axial current at all.
+ *
+ * This is the model teaching uses, and the difference from `solenoid()` is real
+ * rather than cosmetic. A helix carries a net current ALONG its axis as well as
+ * around it, so it makes a weak circulating field of its own on top of the
+ * axial one. The numbers barely move, but a traced field line drifts out of the
+ * plane and comes back somewhere else, so a diagram of a helix's lines is a
+ * tangle rather than the clean picture the physics deserves.
+ *
+ * Use this to draw and to reason; use `solenoid()` when the question is what a
+ * real winding does, which is what the end-of-coil behaviour is about.
+ */
+declare function solenoidRings(radiusM: number, lengthM: number, turns: number, currentA: number, segments?: number, id?: string): CurrentPath[];
+/** Two coaxial coils one radius apart: the standard uniform-field arrangement. */
+declare function helmholtzPair(radiusM: number, currentA: number, turns?: number, segments?: number): CurrentPath[];
+/** A rectangular loop in the xy plane, centred on the origin. */
+declare function rectangularLoop(widthM: number, heightM: number, currentA: number, id?: string): CurrentPath;
+/** B a perpendicular distance from a very long straight wire: mu0 I / 2 pi a. */
+declare function longWireT(currentA: number, distanceM: number): number;
+/**
+ * B from a finite straight wire: mu0 I / 4 pi a * (sin t1 + sin t2).
+ *
+ * The angles are measured at the field point, from the perpendicular to each
+ * end of the wire.
+ */
+declare function finiteWireT(currentA: number, perpDistanceM: number, angle1Deg: number, angle2Deg: number): number;
+/** B at the centre of a flat circular coil: mu0 N I / 2 r. */
+declare function coilCentreT(currentA: number, radiusM: number, turns?: number): number;
+/** B on the axis of a flat coil, `axialM` from its centre. */
+declare function coilAxisT(currentA: number, radiusM: number, axialM: number, turns?: number): number;
+/**
+ * B at the centre of an arc subtending `arcDeg`: mu0 I theta / 4 pi r.
+ *
+ * A full 360 reduces to the coil-centre formula, which is the cleanest way to
+ * show a student that the two are not separate results.
+ */
+declare function arcCentreT(currentA: number, radiusM: number, arcDeg: number): number;
+/** B inside a long solenoid: mu0 n I, with n in turns per metre. */
+declare function solenoidT(currentA: number, turnsPerMetre: number): number;
+/** B inside a toroid at mean radius r: mu0 N I / 2 pi r. */
+declare function toroidT(currentA: number, turns: number, meanRadiusM: number): number;
+//#endregion
+export { CurrentPath, FieldContribution, FieldResult, MIN_DISTANCE_M, MU_0, Streamline, StreamlineOptions, arcCentreT, circularArc, coilAxisT, coilCentreT, fieldAt, finiteWireT, flatCoil, helmholtzPair, longWire, longWireT, pathField, rectangularLoop, segmentField, solenoid, solenoidRings, solenoidT, straightWire, toroidT, traceFieldLine, traceFullFieldLine };

package/dist/physics/magnetism/biot-savart.mjs

@@ -0,0 +1,353 @@
+import { ZERO3, add3, cross3, dot3, mag3, scale3, sub3, v3 } from "../../core/vec3.mjs";
+
+//#region src/physics/magnetism/biot-savart.ts
+/**
+* @classytic/stage/field/magnetostatics — Biot-Savart: the field a current MAKES.
+*
+* The rest of the magnetism engines answer "what does a field DO" (force on a
+* conductor, force on a moving charge, Hall voltage, induced e.m.f.). Nothing
+* answered the other half: given a geometry of current, what is B at a point?
+*
+* Textbooks answer that with a page of special cases -- straight wire, finite
+* wire, circular coil centre, coil axis, arc, solenoid, toroid -- each with its
+* own formula to memorise. They are all the same integral over a different
+* shape. This module integrates that one law over an arbitrary current path, so
+* every one of those cases is the same call with different geometry, and the
+* closed forms below exist to CHECK the integrator rather than to replace it.
+*
+* Accuracy: a straight segment is integrated in closed form, so any polyline
+* (wire, rectangle, square loop, solenoid leg) is exact to floating point. A
+* curve is approximated by a polygon, whose error falls as 1/N^2.
+*/
+/** Permeability of free space, in T m A^-1. */
+const MU_0 = 4 * Math.PI * 1e-7;
+/**
+* Closest a field point may sit to a current filament, in metres.
+*
+* A filament is a modelling fiction with zero thickness, so B genuinely
+* diverges on it. We refuse rather than return a huge number, because a huge
+* number looks like an answer and a student will write it down.
+*/
+const MIN_DISTANCE_M = 1e-6;
+const sub = sub3;
+const radians = (deg) => deg * Math.PI / 180;
+/**
+* Field at `point` from one straight segment carrying `currentA` from `from` to `to`.
+*
+* Exact, not sampled. Integrating dl x r / |r|^3 along a straight line gives
+*
+*   B = (mu0 I / 4pi) * (lhat x r1) / |lhat x r1|^2 * (lhat . r1hat - lhat . r2hat)
+*
+* where r1, r2 are the vectors from each end to the field point. The right-hand
+* factor is the (sin theta1 + sin theta2) of the textbook, written so that it
+* never needs an angle convention.
+*/
+function segmentField(from, to, point, currentA) {
+	const along = sub(to, from);
+	const length = mag3(along);
+	if (length === 0) return ZERO3;
+	const lhat = scale3(along, 1 / length);
+	const r1 = sub(point, from);
+	const r2 = sub(point, to);
+	const d1 = mag3(r1);
+	const d2 = mag3(r2);
+	if (d1 < 1e-6 || d2 < 1e-6) throw new RangeError("The field point sits on the end of a current segment, where B diverges.");
+	const perp = cross3(lhat, r1);
+	const perpSq = dot3(perp, perp);
+	if (perpSq < 1e-6 * 1e-6) return ZERO3;
+	const endSpan = dot3(lhat, r1) / d1 - dot3(lhat, r2) / d2;
+	return scale3(perp, MU_0 * currentA / (4 * Math.PI) * (endSpan / perpSq));
+}
+const segmentsOf = (path) => {
+	const pairs = [];
+	const points = path.points;
+	for (let i = 0; i + 1 < points.length; i += 1) {
+		const from = points[i];
+		const to = points[i + 1];
+		if (from && to) pairs.push([from, to]);
+	}
+	if (path.closed && points.length > 2) {
+		const last = points[points.length - 1];
+		const first = points[0];
+		if (last && first) pairs.push([last, first]);
+	}
+	return pairs;
+};
+/** Field at a point from one current path. */
+function pathField(path, point) {
+	return segmentsOf(path).reduce((total, [from, to]) => add3(total, segmentField(from, to, point, path.currentA)), ZERO3);
+}
+/**
+* Field at a point from any number of current paths.
+*
+* Superposition is the whole reason this is one function and not many: two
+* wires, a wire and a coil, a Helmholtz pair, all add the same way.
+*/
+function fieldAt(paths, point) {
+	const contributions = paths.map((path) => {
+		const field = pathField(path, point);
+		return {
+			pathId: path.id,
+			field,
+			magnitudeT: mag3(field)
+		};
+	});
+	const field = contributions.reduce((total, c) => add3(total, c.field), ZERO3);
+	return {
+		field,
+		magnitudeT: mag3(field),
+		contributions
+	};
+}
+/**
+* Trace one magnetic field line from a seed point.
+*
+* A field line is the curve whose tangent is B everywhere, so tracing it means
+* stepping along the UNIT field: that keeps the step a fixed arc length instead
+* of a fixed time, so the spacing stays even where the field is strong.
+* Integrated with RK4, because a field line through a coil turns sharply enough
+* that Euler visibly spirals outward and a student would be looking at the
+* integrator's error rather than at the physics.
+*/
+function traceFieldLine(paths, seed, options = {}) {
+	const { stepM = .002, maxSteps = 4e3, direction = 1, boundsM = 1, closeToleranceM = stepM } = options;
+	if (stepM <= 0) throw new RangeError("A field line needs a positive step length.");
+	const unitField = (at) => {
+		let b;
+		try {
+			b = fieldAt(paths, at).field;
+		} catch {
+			return null;
+		}
+		const size = mag3(b);
+		if (!Number.isFinite(size) || size === 0) return null;
+		return scale3(b, direction / size);
+	};
+	const points = [seed];
+	let current = seed;
+	for (let step = 0; step < maxSteps; step += 1) {
+		const k1 = unitField(current);
+		if (!k1) return {
+			points,
+			ended: "hit-current"
+		};
+		const k2 = unitField(add3(current, scale3(k1, stepM / 2)));
+		if (!k2) return {
+			points,
+			ended: "hit-current"
+		};
+		const k3 = unitField(add3(current, scale3(k2, stepM / 2)));
+		if (!k3) return {
+			points,
+			ended: "hit-current"
+		};
+		const k4 = unitField(add3(current, scale3(k3, stepM)));
+		if (!k4) return {
+			points,
+			ended: "hit-current"
+		};
+		const advance = scale3(add3(add3(k1, scale3(k2, 2)), add3(scale3(k3, 2), k4)), stepM / 6);
+		current = add3(current, advance);
+		points.push(current);
+		if (mag3(sub(current, seed)) > boundsM) return {
+			points,
+			ended: "left-bounds"
+		};
+		if (step > 8 && mag3(sub(current, seed)) < closeToleranceM) return {
+			points,
+			ended: "closed"
+		};
+	}
+	return {
+		points,
+		ended: "max-steps"
+	};
+}
+/**
+* Trace a full field line through a seed, running both ways from it.
+*
+* A magnetic field line has no start and no end, so seeding one and following
+* it forwards only would draw half a line and imply the seed was special.
+*/
+function traceFullFieldLine(paths, seed, options = {}) {
+	const forward = traceFieldLine(paths, seed, {
+		...options,
+		direction: 1
+	});
+	if (forward.ended === "closed") return forward;
+	return {
+		points: [...traceFieldLine(paths, seed, {
+			...options,
+			direction: -1
+		}).points.slice(1).reverse(), ...forward.points],
+		ended: forward.ended
+	};
+}
+/** A straight run of wire between two points. */
+function straightWire(from, to, currentA, id = "wire") {
+	return {
+		id,
+		currentA,
+		points: [from, to]
+	};
+}
+/**
+* A wire long enough to stand in for an infinite one, centred on `through` and
+* running along `direction`.
+*
+* "Infinite" is not a geometry, so a lesson that wants the textbook
+* mu0 I / 2 pi a has to pick a length. Making that choice visible is the point:
+* the student can shorten it and watch the answer fall away from the formula.
+*/
+function longWire(through, direction, currentA, halfLengthM = 1e4, id = "long-wire") {
+	const unit = mag3(direction);
+	if (unit === 0) throw new RangeError("A wire needs a direction.");
+	const step = scale3(direction, halfLengthM / unit);
+	return {
+		id,
+		currentA,
+		points: [sub(through, step), add3(through, step)]
+	};
+}
+/**
+* A circular arc of `arcDeg` in the xy plane, centred on `centre`, radius `radiusM`.
+*
+* A full loop is `arcDeg = 360`. Positive current circulates anticlockwise seen
+* from +z, so by the right-hand rule B points along +z at the centre.
+*/
+function circularArc(centre, radiusM, currentA, arcDeg = 360, segments = 720, id = "arc") {
+	if (radiusM <= 0) throw new RangeError("A coil needs a positive radius.");
+	if (segments < 3) throw new RangeError("An arc needs at least 3 segments to be worth integrating.");
+	const span = radians(arcDeg);
+	const count = Math.max(3, Math.round(segments * Math.abs(arcDeg) / 360));
+	const points = [];
+	for (let i = 0; i <= count; i += 1) {
+		const t = span * (i / count);
+		points.push(v3(centre.x + radiusM * Math.cos(t), centre.y + radiusM * Math.sin(t), centre.z));
+	}
+	return {
+		id,
+		currentA,
+		points
+	};
+}
+/** A flat coil of `turns` identical loops, treated as `turns` times one loop's current. */
+function flatCoil(centre, radiusM, currentA, turns = 1, segments = 720, id = "coil") {
+	if (!Number.isInteger(turns) || turns < 1) throw new RangeError("A coil needs a whole number of turns.");
+	return circularArc(centre, radiusM, currentA * turns, 360, segments, id);
+}
+/**
+* A helical solenoid along z, centred on the origin.
+*
+* Wound as a real solenoid is: one continuous helix, not a stack of separate
+* rings. That matters at the ends, which is exactly where the mu0 n I formula
+* stops being true and where a student should be able to see it stop.
+*/
+function solenoid(radiusM, lengthM, turns, currentA, perTurn = 32, id = "solenoid") {
+	if (radiusM <= 0 || lengthM <= 0) throw new RangeError("A solenoid needs a positive radius and length.");
+	if (!Number.isInteger(turns) || turns < 1) throw new RangeError("A solenoid needs a whole number of turns.");
+	const steps = turns * perTurn;
+	const points = [];
+	for (let i = 0; i <= steps; i += 1) {
+		const t = i / steps;
+		const angle = 2 * Math.PI * turns * t;
+		points.push(v3(radiusM * Math.cos(angle), radiusM * Math.sin(angle), -lengthM / 2 + lengthM * t));
+	}
+	return {
+		id,
+		currentA,
+		points
+	};
+}
+/**
+* An IDEAL solenoid: `turns` separate coaxial rings, with no axial current at all.
+*
+* This is the model teaching uses, and the difference from `solenoid()` is real
+* rather than cosmetic. A helix carries a net current ALONG its axis as well as
+* around it, so it makes a weak circulating field of its own on top of the
+* axial one. The numbers barely move, but a traced field line drifts out of the
+* plane and comes back somewhere else, so a diagram of a helix's lines is a
+* tangle rather than the clean picture the physics deserves.
+*
+* Use this to draw and to reason; use `solenoid()` when the question is what a
+* real winding does, which is what the end-of-coil behaviour is about.
+*/
+function solenoidRings(radiusM, lengthM, turns, currentA, segments = 180, id = "solenoid") {
+	if (radiusM <= 0 || lengthM <= 0) throw new RangeError("A solenoid needs a positive radius and length.");
+	if (!Number.isInteger(turns) || turns < 1) throw new RangeError("A solenoid needs a whole number of turns.");
+	return Array.from({ length: turns }, (_, i) => {
+		return circularArc(v3(0, 0, -lengthM / 2 + lengthM * (i + .5) / turns), radiusM, currentA, 360, segments, `${id}-${i}`);
+	});
+}
+/** Two coaxial coils one radius apart: the standard uniform-field arrangement. */
+function helmholtzPair(radiusM, currentA, turns = 1, segments = 720) {
+	return [flatCoil(v3(0, 0, -radiusM / 2), radiusM, currentA, turns, segments, "coil-near"), flatCoil(v3(0, 0, radiusM / 2), radiusM, currentA, turns, segments, "coil-far")];
+}
+/** A rectangular loop in the xy plane, centred on the origin. */
+function rectangularLoop(widthM, heightM, currentA, id = "loop") {
+	if (widthM <= 0 || heightM <= 0) throw new RangeError("A loop needs positive sides.");
+	const w = widthM / 2;
+	const h = heightM / 2;
+	return {
+		id,
+		currentA,
+		closed: true,
+		points: [
+			v3(-w, -h, 0),
+			v3(w, -h, 0),
+			v3(w, h, 0),
+			v3(-w, h, 0)
+		]
+	};
+}
+/** B a perpendicular distance from a very long straight wire: mu0 I / 2 pi a. */
+function longWireT(currentA, distanceM) {
+	if (distanceM <= 0) throw new RangeError("Distance from the wire must be positive.");
+	return MU_0 * Math.abs(currentA) / (2 * Math.PI * distanceM);
+}
+/**
+* B from a finite straight wire: mu0 I / 4 pi a * (sin t1 + sin t2).
+*
+* The angles are measured at the field point, from the perpendicular to each
+* end of the wire.
+*/
+function finiteWireT(currentA, perpDistanceM, angle1Deg, angle2Deg) {
+	if (perpDistanceM <= 0) throw new RangeError("Perpendicular distance must be positive.");
+	const span = Math.sin(radians(angle1Deg)) + Math.sin(radians(angle2Deg));
+	return MU_0 * Math.abs(currentA) / (4 * Math.PI * perpDistanceM) * span;
+}
+/** B at the centre of a flat circular coil: mu0 N I / 2 r. */
+function coilCentreT(currentA, radiusM, turns = 1) {
+	if (radiusM <= 0) throw new RangeError("A coil needs a positive radius.");
+	return MU_0 * turns * Math.abs(currentA) / (2 * radiusM);
+}
+/** B on the axis of a flat coil, `axialM` from its centre. */
+function coilAxisT(currentA, radiusM, axialM, turns = 1) {
+	if (radiusM <= 0) throw new RangeError("A coil needs a positive radius.");
+	const denominator = Math.pow(radiusM * radiusM + axialM * axialM, 1.5);
+	return MU_0 * turns * Math.abs(currentA) * radiusM * radiusM / (2 * denominator);
+}
+/**
+* B at the centre of an arc subtending `arcDeg`: mu0 I theta / 4 pi r.
+*
+* A full 360 reduces to the coil-centre formula, which is the cleanest way to
+* show a student that the two are not separate results.
+*/
+function arcCentreT(currentA, radiusM, arcDeg) {
+	if (radiusM <= 0) throw new RangeError("An arc needs a positive radius.");
+	return MU_0 * Math.abs(currentA) * radians(Math.abs(arcDeg)) / (4 * Math.PI * radiusM);
+}
+/** B inside a long solenoid: mu0 n I, with n in turns per metre. */
+function solenoidT(currentA, turnsPerMetre) {
+	if (turnsPerMetre < 0) throw new RangeError("Turns per metre cannot be negative.");
+	return MU_0 * turnsPerMetre * Math.abs(currentA);
+}
+/** B inside a toroid at mean radius r: mu0 N I / 2 pi r. */
+function toroidT(currentA, turns, meanRadiusM) {
+	if (meanRadiusM <= 0) throw new RangeError("A toroid needs a positive mean radius.");
+	if (turns < 0) throw new RangeError("Turns cannot be negative.");
+	return MU_0 * turns * Math.abs(currentA) / (2 * Math.PI * meanRadiusM);
+}
+
+//#endregion
+export { MIN_DISTANCE_M, MU_0, arcCentreT, circularArc, coilAxisT, coilCentreT, fieldAt, finiteWireT, flatCoil, helmholtzPair, longWire, longWireT, pathField, rectangularLoop, segmentField, solenoid, solenoidRings, solenoidT, straightWire, toroidT, traceFieldLine, traceFullFieldLine };

package/dist/physics/magnetism/flux.d.mts

@@ -0,0 +1,94 @@
+import { Vec3 } from "../../core/vec3.mjs";
+import { CurrentPath } from "./biot-savart.mjs";
+
+//#region src/physics/magnetism/flux.d.ts
+type FluxLoop = {
+  kind: 'rectangle';
+  centre: Vec3;
+  normal: Vec3;
+  widthM: number;
+  heightM: number; /** Which in-plane direction the width runs along. Defaults to a stable choice. */
+  widthAxis?: Vec3;
+} | {
+  kind: 'circle';
+  centre: Vec3;
+  normal: Vec3;
+  radiusM: number;
+};
+/** Area of the loop, in square metres. */
+declare const loopArea: (loop: FluxLoop) => number;
+/**
+ * Flux through a flat loop in a UNIFORM field: Phi = B A cos(theta).
+ *
+ * `normalToFieldDeg` is the angle between the loop's normal and the field, the
+ * same convention `coilTorqueNm` uses, so the two never disagree about what the
+ * angle means. The trap is the same one too: a question usually states the
+ * angle from the PLANE, and flux is greatest when the plane is ACROSS the field,
+ * which is exactly where the torque is zero.
+ */
+declare function fluxThroughUniform(fieldT: number, areaM2: number, normalToFieldDeg: number): number;
+/** Flux linkage: the flux each turn sees, times the number of turns. */
+declare function fluxLinkage(turns: number, fluxWb: number): number;
+/**
+ * Magnitude of the average induced e.m.f. from Faraday's law.
+ *
+ * Unsigned on purpose. The direction is Lenz's law, which is a separate
+ * statement about what the induced current opposes, and folding a sign in here
+ * would let a student produce a direction without ever thinking about the
+ * opposition that gives it.
+ */
+declare function inducedEmfV(turns: number, fluxChangeWb: number, timeS: number): number;
+/** How close a sample may come to a current filament before the flux is called divergent. */
+declare const MIN_LOOP_CLEARANCE_M = 0.0001;
+declare function fluxThroughLoop(sources: readonly CurrentPath[], loop: FluxLoop, order?: 8 | 16): number;
+/**
+ * Self-inductance of a coil, in henries: L = N Phi / I.
+ *
+ * Measured by driving the coil with a test current and integrating the flux its
+ * own field puts through one turn. That the answer does not depend on the test
+ * current is the definition of inductance, and it is asserted in the tests
+ * rather than assumed.
+ */
+declare function selfInductanceH(coil: readonly CurrentPath[], oneTurn: FluxLoop, turns: number, testCurrentA?: number, order?: 8 | 16): number;
+/**
+ * Mutual inductance between two circuits, in henries: M = N2 Phi2 / I1.
+ *
+ * The primary's field is integrated through one turn of the secondary. The
+ * reciprocity of this quantity, that driving either side gives the same M, is a
+ * real theorem and a good thing for a lesson to check rather than assert.
+ */
+declare function mutualInductanceH(primary: readonly CurrentPath[], secondaryTurn: FluxLoop, secondaryTurns: number, primaryCurrentA?: number, order?: 8 | 16): number;
+/**
+ * Magnitude of the e.m.f. a changing current induces in its OWN circuit:
+ * E = L di/dt.
+ *
+ * The same physics as Faraday's law with the flux written as L I, and worth
+ * having separately because a question almost never gives you the flux. It
+ * gives you a current that changed and a time it took.
+ */
+declare function emfFromSelfInductance(inductanceH: number, currentChangeA: number, timeS: number): number;
+/**
+ * Magnitude of the e.m.f. a changing current induces in a NEIGHBOURING circuit:
+ * E = M di/dt.
+ *
+ * Identical in form to the self-inductance case, with M in place of L. That the
+ * two are the same equation is the point: a transformer is not a new law, it is
+ * this one with the two coils wound on the same core.
+ */
+declare function emfFromMutualInductance(mutualH: number, currentChangeA: number, timeS: number): number;
+/** Energy stored in an inductor's field, in joules: W = 1/2 L I squared. */
+declare function magneticEnergyJ(inductanceH: number, currentA: number): number;
+/** Ideal-solenoid self-inductance, for checking the integrated answer: mu0 N^2 A / l. */
+declare function solenoidInductanceH(turns: number, areaM2: number, lengthM: number): number;
+/**
+ * Flux through a rectangle lying beside a long straight wire, in closed form.
+ *
+ *   Phi = (mu0 I l / 2 pi) ln(far / near)
+ *
+ * A standard exam result, and the best available check on the surface integral:
+ * the field varies as 1/r right across the loop, so nothing about this case is
+ * forgiving of a sloppy quadrature rule.
+ */
+declare function fluxBesideWire(currentA: number, lengthM: number, nearM: number, farM: number): number;
+//#endregion
+export { FluxLoop, MIN_LOOP_CLEARANCE_M, emfFromMutualInductance, emfFromSelfInductance, fluxBesideWire, fluxLinkage, fluxThroughLoop, fluxThroughUniform, inducedEmfV, loopArea, magneticEnergyJ, mutualInductanceH, selfInductanceH, solenoidInductanceH };