@classytic/stage 0.2.0 → 0.4.0

package/dist/physics/rotation/inertia.d.mts

@@ -0,0 +1,164 @@
+import { Worked } from "../../core/worked.mjs";
+import { Node } from "../../math/ast.mjs";
+import { Sweep } from "../integral-sweep.mjs";
+
+//#region src/physics/rotation/inertia.d.ts
+/**
+ * How to DRAW the body and the element sweeping through it.
+ *
+ * This lives in the kernel rather than in each lab on purpose. The element's shape is not
+ * decoration, it IS the derivation: the disc is cut into rings because a ring is the set of points
+ * at one distance from the axis, and the sphere is cut into discs because a disc is a thing whose
+ * moment of inertia we already know. A renderer that invented its own picture could easily draw
+ * strips across a disc, which would look fine and would be a different integral.
+ *
+ * Kept as a small closed vocabulary rather than as drawing instructions, so the kernel stays free
+ * of pixels and a renderer can draw a band however suits its scene.
+ */
+interface ShapeGeometry {
+  /** The body's outline. */
+  readonly body: 'rod' | 'disc' | 'ring' | 'sphere' | 'shell' | 'plate';
+  /** The shape of one element of the integral. */
+  readonly element: 'strip' | 'annulus' | 'slice' | 'band' | 'whole-ring';
+  /** Which way the element travels as the variable runs from `from` to `to`. */
+  readonly sweep: 'along-length' | 'outward-from-axis' | 'along-axis' | 'by-mass';
+  /**
+   * Which symbol sets the body's overall size, so a renderer can scale the scene to fit without
+   * being told separately.
+   */
+  readonly extent: string;
+}
+/** A rigid body declared by how its mass is spread, not by its answer. */
+interface ShapeSpec {
+  readonly id: string;
+  /** "uniform rod", for a lesson heading. */
+  readonly name: string;
+  /** Which axis this is about. Half the exam marks in this topic are about the axis. */
+  readonly axis: string;
+  /** Each symbol and what it means, so a lab can label its controls. */
+  readonly symbols: Readonly<Record<string, string>>;
+  /** The variable integrated over. */
+  readonly variable: string;
+  /**
+   * `dI`, the contribution of one element, as an expression in `variable`. EXPANDED: see the note
+   * at the top of the file about what the integrator will and will not accept.
+   */
+  readonly element: string;
+  /** Where the element expression came from, in words, for the derivation. */
+  readonly elementNote: string;
+  /** Integration limits, as expressions in the symbols. */
+  readonly from: string;
+  readonly to: string;
+  /** The standard result. Used to CHECK the integral, never to replace it. */
+  readonly closedForm: string;
+  /** How the standard result is usually written, in LaTeX. */
+  readonly closedFormTex: string;
+  /** What a lab draws, and how the element moves through it. */
+  readonly geometry: ShapeGeometry;
+}
+interface InertiaResult {
+  readonly shape: ShapeSpec;
+  /** kg m², from the integral. */
+  readonly value: number;
+  /** The same thing from the closed form. Equal to `value`; the tests are what enforce that. */
+  readonly checkValue: number;
+  /** The antiderivative, for a lesson that wants to show the middle of the working. */
+  readonly antiderivative: Node;
+  readonly worked: Worked;
+}
+declare const SHAPES: Readonly<Record<string, ShapeSpec>>;
+declare const shapeIds: () => readonly string[];
+/**
+ * `I = ∫ r² dm` for a declared shape, with the integral shown.
+ *
+ * `values` supplies the symbols: `{ M: 2, R: 0.5 }`. The integral is done symbolically once and
+ * then evaluated at the limits, so what a lesson displays and what a lab computes are the same
+ * object rather than two implementations that agree today.
+ */
+declare function momentOfInertia(shape: ShapeSpec, values: Readonly<Record<string, number>>, sf?: number): InertiaResult;
+/**
+ * The shape's integral as a watchable sweep: the element travelling through the body with the
+ * running total behind it.
+ *
+ * This is where the `r²` stops being a symbol. For a uniform disc, half the moment of inertia comes
+ * from beyond 84% of the radius, and a learner who has watched the meter barely move across the
+ * inner half will not need to be told why a flywheel is heavy at the rim.
+ */
+declare const sweepOf: (shape: ShapeSpec, values: Readonly<Record<string, number>>, samples?: number) => Sweep;
+/** Where a given fraction of the moment of inertia has accumulated by. */
+declare const inertiaComesFrom: (shape: ShapeSpec, values: Readonly<Record<string, number>>, fraction?: number) => number;
+/**
+ * `I = Σ m r²` for point masses, where `r` is the distance from the AXIS, not from the origin.
+ *
+ * That distinction is the whole difficulty. For a mass at (x, y, z) rotating about the z axis the
+ * distance that matters is `√(x² + y²)`: the z coordinate is along the axis and contributes
+ * nothing, however large it is. Students routinely use the full position vector and get an answer
+ * that is too big, and the error is invisible in the common textbook case where every mass happens
+ * to lie in a plane through the origin.
+ *
+ * This is also the definition the continuous shapes are integrals OF, so it belongs beside them: a
+ * disc is this sum with the masses made infinitesimal and the sum made an integral.
+ */
+declare function pointMasses(masses: readonly {
+  label?: string;
+  mass: number;
+  distance: number;
+}[], sf?: number): {
+  value: number;
+  totalMass: number;
+  worked: Worked;
+};
+/** Distance from an axis through the origin along `axis`, for a mass at (x, y, z). */
+declare function distanceFromAxis(position: {
+  x: number;
+  y: number;
+  z: number;
+}, axis?: 'x' | 'y' | 'z'): number;
+/**
+ * Move an axis sideways: `I = I_cm + Mh²`.
+ *
+ * An operation, not a formula to recall, so a lab can let a learner drag the pivot and watch the
+ * number rise. It only works from the CENTRE OF MASS axis, and the error message says so, because
+ * applying it from an arbitrary axis is the standard mistake.
+ */
+declare function parallelAxis(aboutCentreOfMass: number, mass: number, distance: number, sf?: number): {
+  value: number;
+  worked: Worked;
+};
+/**
+ * For a FLAT body only: `I_z = I_x + I_y`.
+ *
+ * The flatness is the whole condition and is where the marks go, so it is in the note rather than
+ * in a comment. This is how the disc's `¼MR²` about a diameter is obtained from its `½MR²` about
+ * the axis, which is exactly the move the textbook makes and never justifies.
+ */
+declare function perpendicularAxis(inPlaneX: number, inPlaneY: number, sf?: number): {
+  value: number;
+  worked: Worked;
+};
+/**
+ * Add rigid bodies that share an axis.
+ *
+ * Moment of inertia is a scalar once the axis is fixed, so assemblies just add. That is what makes
+ * a three-blade fan tractable: one disc plus three rods, each rod moved out by the parallel axis
+ * theorem. A lab that lets a learner build a body out of parts is this function.
+ */
+declare function combine(parts: readonly {
+  label: string;
+  value: number;
+}[], sf?: number): {
+  value: number;
+  worked: Worked;
+};
+/**
+ * `K = √(I/M)`: where a single point mass would have to sit to have the same moment of inertia.
+ *
+ * Worth saying in those words. It is routinely confused with the distance to the centre of mass,
+ * which it is not, and the textbook flags that confusion without explaining it.
+ */
+declare function radiusOfGyration(inertia: number, mass: number, sf?: number): {
+  value: number;
+  worked: Worked;
+};
+//#endregion
+export { InertiaResult, SHAPES, ShapeGeometry, ShapeSpec, combine, distanceFromAxis, inertiaComesFrom, momentOfInertia, parallelAxis, perpendicularAxis, pointMasses, radiusOfGyration, shapeIds, sweepOf };

package/dist/physics/rotation/inertia.mjs

@@ -0,0 +1,332 @@
+import { evaluate } from "../../math/ast.mjs";
+import { parse } from "../../math/parse.mjs";
+import { integrate, simplify } from "../../math/calculus.mjs";
+import { toLatex } from "../../math/latex.mjs";
+import { calc, texSigFigs } from "../../core/worked.mjs";
+import { positionAtFraction, sweep } from "../integral-sweep.mjs";
+
+//#region src/physics/rotation/inertia.ts
+/**
+* Moment of inertia, DERIVED rather than looked up.
+*
+* Every textbook at this level prints a table of eight standard results to memorise, and derives
+* one or two of them in passing. The table is the problem. A student who memorises `I = ⅖MR²` has
+* no way to check it, no idea why the sphere differs from the disc, and nothing to fall back on
+* when the question is about a shape that is not in the table.
+*
+* So no result here is a constant. A shape is declared as a MASS DISTRIBUTION, and `I` comes out of
+* an integral performed symbolically by `math/calculus`, together with the integral itself so a
+* lesson can show it. The standard table is then an OUTPUT of this module rather than an input to
+* it, which is the whole point.
+*
+* ```
+*   I = ∫ r² dm
+* ```
+*
+* WHY EACH SHAPE ALSO DECLARES ITS CLOSED FORM. It is not a duplicated source of truth, it is a
+* CHECK: the tests integrate the distribution and evaluate the closed form at randomised
+* dimensions and require them to agree, so a mis-stated distribution cannot pass silently.
+* Deriving without verifying would just be a more elaborate way to be wrong.
+*
+* The integrand is written the way a learner would write it, `(R² − x²)²` and not its expansion,
+* because `math/calculus` multiplies out before integrating. An integrand with no closed form at
+* all is still fine for the SWEEP, which falls back to quadrature and says that it did; it is only
+* this function, which quotes a formula, that needs a symbolic answer.
+*
+* Pure: no React, no pixels.
+*/
+const SHAPE_LIST = [
+	{
+		id: "rod-centre",
+		name: "uniform rod",
+		axis: "through its centre, at right angles to its length",
+		symbols: {
+			M: "mass",
+			l: "length"
+		},
+		variable: "x",
+		element: "(M/l)*x^2",
+		elementNote: "a piece of length dx has mass (M/l)dx, and sits a distance x from the axis",
+		from: "-l/2",
+		to: "l/2",
+		closedForm: "M*l^2/12",
+		closedFormTex: "\\tfrac{1}{12}Ml^2",
+		geometry: {
+			body: "rod",
+			element: "strip",
+			sweep: "along-length",
+			extent: "l"
+		}
+	},
+	{
+		id: "rod-end",
+		name: "uniform rod",
+		axis: "through one end, at right angles to its length",
+		symbols: {
+			M: "mass",
+			l: "length"
+		},
+		variable: "x",
+		element: "(M/l)*x^2",
+		elementNote: "the same rod and the same elements; only the limits move, because the axis moved",
+		from: "0",
+		to: "l",
+		closedForm: "M*l^2/3",
+		closedFormTex: "\\tfrac{1}{3}Ml^2",
+		geometry: {
+			body: "rod",
+			element: "strip",
+			sweep: "along-length",
+			extent: "l"
+		}
+	},
+	{
+		id: "disc-axis",
+		name: "uniform disc",
+		axis: "through its centre, perpendicular to its face",
+		symbols: {
+			M: "mass",
+			R: "radius"
+		},
+		variable: "r",
+		element: "(2*M/R^2)*r^3",
+		elementNote: "a ring of radius r and width dr has area 2πr dr, so mass (M/πR²)·2πr dr, all of it a distance r from the axis",
+		from: "0",
+		to: "R",
+		closedForm: "M*R^2/2",
+		closedFormTex: "\\tfrac{1}{2}MR^2",
+		geometry: {
+			body: "disc",
+			element: "annulus",
+			sweep: "outward-from-axis",
+			extent: "R"
+		}
+	},
+	{
+		id: "ring-axis",
+		name: "thin ring",
+		axis: "through its centre, perpendicular to its plane",
+		symbols: {
+			M: "mass",
+			R: "radius"
+		},
+		variable: "m",
+		element: "R^2",
+		elementNote: "every part of the ring is the same distance R from the axis, so no shape is needed at all",
+		from: "0",
+		to: "M",
+		closedForm: "M*R^2",
+		closedFormTex: "MR^2",
+		geometry: {
+			body: "ring",
+			element: "whole-ring",
+			sweep: "by-mass",
+			extent: "R"
+		}
+	},
+	{
+		id: "solid-sphere",
+		name: "solid sphere",
+		axis: "through its centre",
+		symbols: {
+			M: "mass",
+			R: "radius"
+		},
+		variable: "x",
+		element: "(3*M/(8*R^3))*(R^2 - x^2)^2",
+		elementNote: "slice it into discs. The disc at x has radius √(R²−x²), and a disc contributes ½r²dm, which is where the square comes from",
+		from: "-R",
+		to: "R",
+		closedForm: "2*M*R^2/5",
+		closedFormTex: "\\tfrac{2}{5}MR^2",
+		geometry: {
+			body: "sphere",
+			element: "slice",
+			sweep: "along-axis",
+			extent: "R"
+		}
+	},
+	{
+		id: "hollow-sphere",
+		name: "thin spherical shell",
+		axis: "through its centre",
+		symbols: {
+			M: "mass",
+			R: "radius"
+		},
+		variable: "x",
+		element: "(M/(2*R))*(R^2 - x^2)",
+		elementNote: "a band of the shell between x and x+dx has mass (M/2R)dx, which is Archimedes’ result that equal slices of a sphere carry equal surface area, and it sits at radius √(R²−x²)",
+		from: "-R",
+		to: "R",
+		closedForm: "2*M*R^2/3",
+		closedFormTex: "\\tfrac{2}{3}MR^2",
+		geometry: {
+			body: "shell",
+			element: "band",
+			sweep: "along-axis",
+			extent: "R"
+		}
+	},
+	{
+		id: "plate-in-plane",
+		name: "rectangular plate",
+		axis: "in its plane, through the centre, parallel to the side of length b",
+		symbols: {
+			M: "mass",
+			l: "length",
+			b: "breadth"
+		},
+		variable: "x",
+		element: "(M/l)*x^2",
+		elementNote: "strips parallel to the axis. Each strip’s own width does not matter, so this is the rod integral again and b never appears",
+		from: "-l/2",
+		to: "l/2",
+		closedForm: "M*l^2/12",
+		closedFormTex: "\\tfrac{1}{12}Ml^2",
+		geometry: {
+			body: "plate",
+			element: "strip",
+			sweep: "along-length",
+			extent: "l"
+		}
+	}
+];
+const SHAPES = Object.fromEntries(SHAPE_LIST.map((s) => [s.id, s]));
+const shapeIds = () => SHAPE_LIST.map((s) => s.id);
+/**
+* `I = ∫ r² dm` for a declared shape, with the integral shown.
+*
+* `values` supplies the symbols: `{ M: 2, R: 0.5 }`. The integral is done symbolically once and
+* then evaluated at the limits, so what a lesson displays and what a lab computes are the same
+* object rather than two implementations that agree today.
+*/
+function momentOfInertia(shape, values, sf = 3) {
+	for (const symbol of Object.keys(shape.symbols)) if (!(symbol in values)) throw new Error(`${shape.name} (${shape.axis}) needs ${symbol}: ${shape.symbols[symbol]}.`);
+	const element = parse(shape.element);
+	const antiderivative = integrate(element, shape.variable);
+	if (!antiderivative) throw new Error(`Could not integrate ${shape.element} with respect to ${shape.variable}. The integrand must be an expanded polynomial; see the note in inertia.ts.`);
+	const lower = evaluate(parse(shape.from), values);
+	const upper = evaluate(parse(shape.to), values);
+	const at = (point) => evaluate(antiderivative, {
+		...values,
+		[shape.variable]: point
+	});
+	const value = at(upper) - at(lower);
+	const checkValue = evaluate(parse(shape.closedForm), values);
+	const tidy = simplify(antiderivative);
+	return {
+		shape,
+		value,
+		checkValue,
+		antiderivative,
+		worked: calc().step("I = \\int r^2 \\, dm", `${shape.name}, ${shape.axis}`).step(`dI = ${toLatex(element)} \\, d${shape.variable}`, shape.elementNote).step(`I = \\int_{${toLatex(parse(shape.from))}}^{${toLatex(parse(shape.to))}} ${toLatex(element)} \\, d${shape.variable}`, "the same integral the textbook writes, over the whole body").step(`= \\left[ ${toLatex(tidy)} \\right]_{${toLatex(parse(shape.from))}}^{${toLatex(parse(shape.to))}}`).step(`I = ${shape.closedFormTex}`, "which is the standard result, and now it is a conclusion").step(`I = ${texSigFigs(value, sf)}\\ \\mathrm{kg\\,m^2}`, `with ${Object.entries(values).map(([k, v]) => `${k} = ${v}`).join(", ")}`).done(value)
+	};
+}
+/**
+* The shape's integral as a watchable sweep: the element travelling through the body with the
+* running total behind it.
+*
+* This is where the `r²` stops being a symbol. For a uniform disc, half the moment of inertia comes
+* from beyond 84% of the radius, and a learner who has watched the meter barely move across the
+* inner half will not need to be told why a flywheel is heavy at the rim.
+*/
+const sweepOf = (shape, values, samples = 64) => sweep({
+	element: shape.element,
+	variable: shape.variable,
+	from: shape.from,
+	to: shape.to
+}, values, samples);
+/** Where a given fraction of the moment of inertia has accumulated by. */
+const inertiaComesFrom = (shape, values, fraction = .5) => positionAtFraction(sweepOf(shape, values), fraction);
+/**
+* `I = Σ m r²` for point masses, where `r` is the distance from the AXIS, not from the origin.
+*
+* That distinction is the whole difficulty. For a mass at (x, y, z) rotating about the z axis the
+* distance that matters is `√(x² + y²)`: the z coordinate is along the axis and contributes
+* nothing, however large it is. Students routinely use the full position vector and get an answer
+* that is too big, and the error is invisible in the common textbook case where every mass happens
+* to lie in a plane through the origin.
+*
+* This is also the definition the continuous shapes are integrals OF, so it belongs beside them: a
+* disc is this sum with the masses made infinitesimal and the sum made an integral.
+*/
+function pointMasses(masses, sf = 3) {
+	const value = masses.reduce((sum, m) => sum + m.mass * m.distance * m.distance, 0);
+	const totalMass = masses.reduce((sum, m) => sum + m.mass, 0);
+	const w = calc().step("I = \\sum m r^2", "r is the distance from the AXIS, not from the origin: a coordinate along the axis contributes nothing");
+	for (const m of masses) w.step(`${m.label ? `${m.label}: ` : ""}${texSigFigs(m.mass, sf)} \\times ${texSigFigs(m.distance, sf)}^2 = ${texSigFigs(m.mass * m.distance * m.distance, sf)}`);
+	w.step(`I = ${texSigFigs(value, sf)}\\ \\mathrm{kg\\,m^2}`, "total");
+	return {
+		value,
+		totalMass,
+		worked: w.done(value)
+	};
+}
+/** Distance from an axis through the origin along `axis`, for a mass at (x, y, z). */
+function distanceFromAxis(position, axis = "z") {
+	if (axis === "z") return Math.hypot(position.x, position.y);
+	if (axis === "y") return Math.hypot(position.x, position.z);
+	return Math.hypot(position.y, position.z);
+}
+/**
+* Move an axis sideways: `I = I_cm + Mh²`.
+*
+* An operation, not a formula to recall, so a lab can let a learner drag the pivot and watch the
+* number rise. It only works from the CENTRE OF MASS axis, and the error message says so, because
+* applying it from an arbitrary axis is the standard mistake.
+*/
+function parallelAxis(aboutCentreOfMass, mass, distance, sf = 3) {
+	const value = aboutCentreOfMass + mass * distance * distance;
+	return {
+		value,
+		worked: calc().step("I = I_{cm} + Mh^2", "and it must start from the centre-of-mass axis, or it is not true").step(`I = ${texSigFigs(aboutCentreOfMass, sf)} + ${texSigFigs(mass, sf)} \\times ${texSigFigs(distance, sf)}^2`).step(`I = ${texSigFigs(value, sf)}\\ \\mathrm{kg\\,m^2}`, "moving the axis away always increases it").done(value)
+	};
+}
+/**
+* For a FLAT body only: `I_z = I_x + I_y`.
+*
+* The flatness is the whole condition and is where the marks go, so it is in the note rather than
+* in a comment. This is how the disc's `¼MR²` about a diameter is obtained from its `½MR²` about
+* the axis, which is exactly the move the textbook makes and never justifies.
+*/
+function perpendicularAxis(inPlaneX, inPlaneY, sf = 3) {
+	const value = inPlaneX + inPlaneY;
+	return {
+		value,
+		worked: calc().step("I_z = I_x + I_y", "for a LAMINA only: the body must be flat, and the two axes lie in it").step(`I_z = ${texSigFigs(inPlaneX, sf)} + ${texSigFigs(inPlaneY, sf)}`).step(`I_z = ${texSigFigs(value, sf)}\\ \\mathrm{kg\\,m^2}`).done(value)
+	};
+}
+/**
+* Add rigid bodies that share an axis.
+*
+* Moment of inertia is a scalar once the axis is fixed, so assemblies just add. That is what makes
+* a three-blade fan tractable: one disc plus three rods, each rod moved out by the parallel axis
+* theorem. A lab that lets a learner build a body out of parts is this function.
+*/
+function combine(parts, sf = 3) {
+	const value = parts.reduce((sum, p) => sum + p.value, 0);
+	const w = calc().step("I = \\sum I_i", "about ONE axis, they simply add, because each part’s mass is at its own distance from that same axis");
+	for (const p of parts) w.step(`${texSigFigs(p.value, sf)}\\ \\mathrm{kg\\,m^2}`, p.label);
+	w.step(`I = ${texSigFigs(value, sf)}\\ \\mathrm{kg\\,m^2}`, "total");
+	return {
+		value,
+		worked: w.done(value)
+	};
+}
+/**
+* `K = √(I/M)`: where a single point mass would have to sit to have the same moment of inertia.
+*
+* Worth saying in those words. It is routinely confused with the distance to the centre of mass,
+* which it is not, and the textbook flags that confusion without explaining it.
+*/
+function radiusOfGyration(inertia, mass, sf = 3) {
+	const value = Math.sqrt(inertia / mass);
+	return {
+		value,
+		worked: calc().step("I = MK^2 \\;\\Rightarrow\\; K = \\sqrt{I/M}").step(`K = \\sqrt{${texSigFigs(inertia, sf)} / ${texSigFigs(mass, sf)}}`).step(`K = ${texSigFigs(value, sf)}\\ \\mathrm{m}`, "the radius a single point of the same mass would need. It is NOT the distance to the centre of mass").done(value)
+	};
+}
+
+//#endregion
+export { SHAPES, combine, distanceFromAxis, inertiaComesFrom, momentOfInertia, parallelAxis, perpendicularAxis, pointMasses, radiusOfGyration, shapeIds, sweepOf };

package/dist/physics/rotation/torque.d.mts

@@ -0,0 +1,65 @@
+import { Worked } from "../../core/worked.mjs";
+
+//#region src/physics/rotation/torque.d.ts
+/** The linear quantity and its rotational counterpart, for a lesson that prints the mapping. */
+declare const ROTATIONAL_ANALOGUE: readonly {
+  linear: string;
+  rotational: string;
+  relation: string;
+}[];
+/**
+ * The turning effect of one force: `τ = F r sin θ`.
+ *
+ * `θ` is between the force and the line from the axis to where it acts. Only the PERPENDICULAR
+ * component turns anything; a force aimed straight at the hinge has no effect however large it is,
+ * which is why you push a door at its edge and at right angles.
+ */
+declare function torque(force: number, distance: number, angleDeg?: number, sf?: number): {
+  value: number;
+  worked: Worked;
+};
+/**
+ * The moment of a couple: `M = F d`, with `d` the perpendicular distance BETWEEN the two forces.
+ *
+ * Not `F × distance from some axis`, because there is no axis in it. The moment of a couple is the
+ * same about every point in the plane, which is the property that makes it a couple rather than two
+ * separate moments, and it is why the answer never asks you where the pivot is.
+ */
+declare function couple(force: number, separation: number, sf?: number): {
+  value: number;
+  worked: Worked;
+};
+/**
+ * The force a second couple needs to balance the first.
+ *
+ * Two couples balance when their moments are equal and opposite, so a wide couple can be held by a
+ * small force and a narrow one needs a large force. That is the whole of the rectangular-plate
+ * question these chapters set.
+ */
+declare function balancingCouple(known: {
+  force: number;
+  separation: number;
+}, separation: number, sf?: number): {
+  force: number;
+  worked: Worked;
+};
+/**
+ * `τ = Iα`: Newton's second law, rotated.
+ *
+ * Give any two and it returns the third. The same torque produces very different accelerations on
+ * bodies of the same mass shaped differently, which is the thing moment of inertia is FOR.
+ */
+declare function angularAcceleration(torqueValue: number, inertia: number, sf?: number): {
+  alpha: number;
+  worked: Worked;
+};
+/**
+ * The torque needed to change angular momentum at a given rate: `τ = dL/dt`.
+ *
+ * The more fundamental statement, and the one that survives when the moment of inertia itself is
+ * changing, which `τ = Iα` does not. Supplied as a rate rather than as a derivative because that is
+ * how the question arrives: "the angular momentum changes by this much in this time".
+ */
+declare const torqueFromRate: (deltaL: number, deltaT: number) => number;
+//#endregion
+export { ROTATIONAL_ANALOGUE, angularAcceleration, balancingCouple, couple, torque, torqueFromRate };