@classytic/stage 0.2.0 → 0.4.0

package/dist/physics/energy/centre-of-mass.mjs

@@ -0,0 +1,180 @@
+import { calc, texSigFigs } from "../../core/worked.mjs";
+import { G_EARTH } from "../kinematics/free-fall.mjs";
+import { sweep } from "../integral-sweep.mjs";
+
+//#region src/physics/energy/centre-of-mass.ts
+/**
+* Work on things that are not point masses: stacks of bricks, hanging chains, a well full of water.
+*
+* ONE IDEA COVERS ALL OF THEM, and it is the idea that makes this family stop being a set of tricks:
+*
+*   **The work done against gravity on an extended body is `mg` times the rise of its CENTRE OF
+*   MASS.** Not the rise of its top, not the rise of its bottom, and not the distance anything
+*   travelled along the floor.
+*
+* Once that is in place, every question below is the same question. Standing a brick on its end
+* raises its centre from half its thickness to half its length. Stacking eight bricks raises each
+* one by a different amount and you add them. Hauling a chain up a well raises its centre by half
+* the depth while the bucket on the end rises the whole depth, so they are counted separately.
+* Emptying a tank raises each layer by a different amount, so the sum becomes an integral, and the
+* integral is just the centre of mass again with the arithmetic done properly.
+*
+* THE FACTOR OF TWO. Nearly every wrong answer in this family is out by a factor close to two, and
+* it is always the same mistake: using the full depth where the centre of mass only moved half of
+* it. It is worth being caught by that once, deliberately, which is why {@link columnDrain} reports
+* the naive answer alongside the right one.
+*
+* Pure: no React, no pixels.
+*/
+/**
+* The general statement: work against gravity is `mg` times the rise of the centre of mass.
+*
+* Everything else in this file is this function with the two heights worked out for a particular
+* shape. Having it exist separately is the point, because it is what a learner should reach for when
+* they meet a shape nobody has tabulated.
+*/
+function centreOfMassLift(mass, fromHeight, toHeight, g = G_EARTH, sf = 4) {
+	const rise = toHeight - fromHeight;
+	const value = mass * g * rise;
+	return {
+		rise,
+		value,
+		worked: calc().step("W = mg\\,\\Delta \\bar{h}", "the rise of the CENTRE OF MASS. Not of the top of the object, and not of the bottom").step(`\\Delta \\bar{h} = ${texSigFigs(toHeight, sf)} - ${texSigFigs(fromHeight, sf)} = ${texSigFigs(rise, sf)}\\ \\mathrm{m}`).step(`W = ${texSigFigs(mass, sf)} \\times ${texSigFigs(g, sf)} \\times ${texSigFigs(rise, sf)} = ${texSigFigs(value, sf)}\\ \\mathrm{J}`).done(value)
+	};
+}
+/**
+* Standing a uniform block on a different face: the brick question.
+*
+* A uniform body's centre of mass sits at the middle, so lying on a face it is half the THICKNESS
+* above the table, and stood on end it is half the LENGTH. The rise is half the difference, and the
+* other two dimensions never enter, which surprises people who were carefully multiplying all three.
+*/
+function standBlockOnEnd(mass, lyingDimension, standingDimension, g = G_EARTH, sf = 4) {
+	const from = lyingDimension / 2;
+	const to = standingDimension / 2;
+	const lift = centreOfMassLift(mass, from, to, g, sf);
+	const worked = calc().step("\\bar{h} = \\tfrac{1}{2} \\times (\\text{height of the face it is resting on})", "a uniform block has its centre of mass exactly in the middle, so it sits half its current height above the table").step(`\\bar{h}_{\\text{before}} = \\frac{${texSigFigs(lyingDimension, sf)}}{2} = ${texSigFigs(from, sf)}\\ \\mathrm{m}, \\quad \\bar{h}_{\\text{after}} = \\frac{${texSigFigs(standingDimension, sf)}}{2} = ${texSigFigs(to, sf)}\\ \\mathrm{m}`).step(`\\Delta\\bar{h} = ${texSigFigs(lift.rise, sf)}\\ \\mathrm{m}`, "the third dimension never appears. Tipping a brick does not care how wide it is").step(`W = mg\\,\\Delta\\bar{h} = ${texSigFigs(lift.value, sf)}\\ \\mathrm{J}`).done(lift.value);
+	return {
+		rise: lift.rise,
+		value: lift.value,
+		worked
+	};
+}
+/**
+* Tipping a hinged rod (or a hinged plank) through an angle from the vertical.
+*
+* The centre of mass of a uniform rod is at its midpoint, so it traces a circle of radius `l/2`, and
+* the rise is `(l/2)(1 − cos θ)`: the pendulum geometry again, with the length halved because the
+* mass is spread rather than hanging at the end. That reuse is worth naming out loud, because a
+* learner who sees the same `(1 − cos θ)` in a swing and in a toppling rod has genuinely learned the
+* geometry rather than two formulas.
+*/
+function tiltRod(mass, length, angleFromVerticalDeg, g = G_EARTH, sf = 4) {
+	const rad = angleFromVerticalDeg * Math.PI / 180;
+	const rise = length / 2 * (1 - Math.cos(rad));
+	const value = mass * g * rise;
+	return {
+		rise,
+		value,
+		worked: calc().step("\\bar{h} = \\frac{l}{2}", "a uniform rod carries its centre of mass at the midpoint, so that is the only point whose height matters").step("\\Delta\\bar{h} = \\frac{l}{2}(1 - \\cos\\theta)", "the same (1 - cos theta) as a pendulum, with l/2 in place of l because the mass sits at the middle, not at the end").step(`\\Delta\\bar{h} = \\frac{${texSigFigs(length, sf)}}{2}(1 - \\cos ${texSigFigs(angleFromVerticalDeg, sf)}^\\circ) = ${texSigFigs(rise, sf)}\\ \\mathrm{m}`).step(`W = ${texSigFigs(value, sf)}\\ \\mathrm{J}`).done(value)
+	};
+}
+/**
+* Building a column out of `count` identical bricks that all start lying on the ground.
+*
+* DERIVED, NOT QUOTED. The textbook prints `W = ⁿC₂ mgh` and a binomial coefficient appearing in a
+* mechanics problem looks like a conjuring trick. It is not: the bottom brick does not move, the
+* next rises `h`, the next `2h`, and adding `0 + 1 + 2 + ... + (n−1)` gives `n(n−1)/2`, which is the
+* triangle number and which happens to equal `ⁿC₂`. The coefficient is a coincidence of arithmetic,
+* not a combinatorial insight, and saying so is more honest than letting it look profound.
+*
+* `height` is the thickness of one brick, which is how far each brick sits above the one below it.
+*/
+function stackColumn(count, massEach, height, g = G_EARTH, sf = 4) {
+	if (!Number.isInteger(count) || count < 1) throw new Error("A stack is built from a whole number of bricks, and at least one.");
+	const rises = Array.from({ length: count }, (_, i) => i * height);
+	const triangleNumber = count * (count - 1) / 2;
+	const value = massEach * g * height * triangleNumber;
+	return {
+		value,
+		rises,
+		triangleNumber,
+		worked: calc().step("\\text{brick } k \\text{ rises } (k-1)h", "they all start on the ground. The bottom one never moves; the second climbs one brick; the third climbs two").step(`W = mgh\\left(0 + 1 + 2 + \\ldots + ${count - 1}\\right)`, "add up what each brick cost. Nothing clever has happened yet").step(`0 + 1 + \\ldots + (n-1) = \\frac{n(n-1)}{2} = \\frac{${count} \\times ${count - 1}}{2} = ${texSigFigs(triangleNumber, sf)}`, "the triangle number. It also equals nC2, which is why the book prints a binomial coefficient, but there is no counting argument here").step(`W = ${texSigFigs(massEach, sf)} \\times ${texSigFigs(g, sf)} \\times ${texSigFigs(height, sf)} \\times ${texSigFigs(triangleNumber, sf)} = ${texSigFigs(value, sf)}\\ \\mathrm{J}`).step(`\\text{check: } \\bar{h} \\text{ rose from } \\frac{h}{2} \\text{ to } \\frac{nh}{2}`, "the same answer falls out of the centre of mass alone, which is the faster route once you trust it").done(value)
+	};
+}
+/**
+* Hauling a chain up a well, with a load on the end.
+*
+* Two contributions and they rise by different amounts, which is the entire question. The load on
+* the end travels the full depth. The chain's centre of mass starts halfway down and finishes at the
+* top, so it rises only HALF the depth. Treating the chain as though all of it climbed the full
+* depth doubles its share, and the resulting answer is wrong by an amount that depends on how heavy
+* the chain is relative to the load, which is why it can pass unnoticed.
+*/
+function chainLift(depth, chainMassPerMetre, loadMass, g = G_EARTH, sf = 4) {
+	const chainMass = chainMassPerMetre * depth;
+	const chainWork = chainMass * g * (depth / 2);
+	const loadWork = loadMass * g * depth;
+	const value = chainWork + loadWork;
+	return {
+		chainWork,
+		loadWork,
+		value,
+		chainMass,
+		worked: calc().step("W = W_{\\text{chain}} + W_{\\text{load}}", "two things are being raised and they do not rise by the same amount, so they are counted separately").step(`m_{\\text{chain}} = ${texSigFigs(chainMassPerMetre, sf)} \\times ${texSigFigs(depth, sf)} = ${texSigFigs(chainMass, sf)}\\ \\mathrm{kg}`).step(`W_{\\text{chain}} = m_{\\text{chain}}\\,g\\,\\frac{l}{2} = ${texSigFigs(chainMass, sf)} \\times ${texSigFigs(g, sf)} \\times ${texSigFigs(depth / 2, sf)} = ${texSigFigs(chainWork, sf)}\\ \\mathrm{J}`, "HALF the depth: the chain hangs from the top, so its centre of mass starts at the midpoint and ends at the rim").step(`W_{\\text{load}} = ${texSigFigs(loadMass, sf)} \\times ${texSigFigs(g, sf)} \\times ${texSigFigs(depth, sf)} = ${texSigFigs(loadWork, sf)}\\ \\mathrm{J}`, "the full depth: the load is a single lump on the end and every part of it makes the whole journey").step(`W = ${texSigFigs(value, sf)}\\ \\mathrm{J}`).done(value)
+	};
+}
+/**
+* Pumping every drop of liquid out over the rim of an upright container.
+*
+* The layer at height `y` has to rise `(H − y)`, so the work is `∫ ρgA(H − y) dy` over whatever is
+* actually in there. The integral is performed symbolically by the shared integrator, so the sweep
+* this returns can be animated as layers leaving one at a time while the running total fills, and
+* the number on the meter is the real antiderivative rather than a sum of rectangles.
+*
+* `fillFraction` is how full it is, measured from the BOTTOM. The mean lift comes out as
+* `H(1 − f/2)`, which is worth reading twice: a FULL tank has the lowest mean lift of all, `H/2`,
+* because most of its water is near the bottom where there is a lot of water and the top layers cost
+* almost nothing. A quarter-full tank lifts its water `7H/8` on average, because all of it is at the
+* bottom and all of it has nearly the whole height to travel. The emptier the tank, the harder each
+* kilogram is to get out.
+*/
+function columnDrain(height, crossSection, fillFraction = 1, density = 1e3, g = G_EARTH, sf = 4) {
+	if (fillFraction <= 0 || fillFraction > 1) throw new Error("The fill fraction is how full the container is, measured from the bottom, and lies between 0 and 1.");
+	const filled = height * fillFraction;
+	const mass = density * crossSection * filled;
+	const s = sweep({
+		element: "rho*g*A*(H - y)",
+		variable: "y",
+		from: "0",
+		to: "filled"
+	}, {
+		rho: density,
+		g,
+		A: crossSection,
+		H: height,
+		filled
+	});
+	const value = s.total;
+	const meanLift = mass === 0 ? 0 : value / (mass * g);
+	const naiveValue = mass * g * height;
+	return {
+		mass,
+		meanLift,
+		value,
+		naiveValue,
+		sweep: s,
+		worked: calc().step("dm = \\rho A\\,dy", "slice the liquid into thin horizontal layers. Each layer is its own little lifting problem").step("dW = dm\\,g(H - y) = \\rho g A (H - y)\\,dy", "the layer at height y still has (H - y) to climb before it clears the rim").step(`W = \\int_{0}^{${texSigFigs(filled, sf)}} \\rho g A (H - y)\\,dy = ${texSigFigs(value, sf)}\\ \\mathrm{J}`, "add up every layer. The lower layers dominate, because there is just as much of them and they travel further").step(`\\bar{h} = \\frac{W}{mg} = ${texSigFigs(meanLift, sf)}\\ \\mathrm{m} = H\\left(1 - \\frac{f}{2}\\right)`, "the mean lift, which is the height the centre of mass of the liquid rose").step(`\\text{using } H \\text{ for every drop would give } ${texSigFigs(naiveValue, sf)}\\ \\mathrm{J}`, `a factor of ${texSigFigs(naiveValue / (value || 1), 3)} too big. This is the standard wrong answer in this family`).done(value)
+	};
+}
+/**
+* The mean lift alone, for feeding into {@link pumpPower}.
+*
+* A well being pumped dry is the `fillFraction = 1` case, where the mean lift is half the depth. It
+* is its own named function because that is the number a power question needs and because writing
+* `depth / 2` inline in a pump calculation is how the reasoning gets lost.
+*/
+const meanLiftToRim = (height, fillFraction = 1) => height * (1 - fillFraction / 2);
+
+//#endregion
+export { centreOfMassLift, chainLift, columnDrain, meanLiftToRim, stackColumn, standBlockOnEnd, tiltRod };

package/dist/physics/energy/conservation.d.mts

@@ -0,0 +1,81 @@
+import { Worked } from "../../core/worked.mjs";
+
+//#region src/physics/energy/conservation.d.ts
+interface Station {
+  readonly label: string;
+  /** Height above the chosen reference level, metres. */
+  readonly height: number;
+  /** Speed at this station, metres per second. */
+  readonly speed: number;
+}
+interface Rung {
+  readonly label: string;
+  readonly kinetic: number;
+  readonly potential: number;
+  readonly total: number;
+  /** Mechanical energy lost since the PREVIOUS station. Zero at the first, and never negative. */
+  readonly lostSincePrevious: number;
+}
+interface Ladder {
+  readonly rungs: readonly Rung[];
+  readonly totalLost: number;
+  /** True when the total held to within tolerance across every station. */
+  readonly conserved: boolean;
+  readonly worked: Worked;
+}
+/**
+ * Track the two piles of energy across a journey.
+ *
+ * The tolerance is relative to the largest total, for the same reason it is in `isBalanced`: a
+ * shortfall of a millijoule is nothing in a roller coaster and is everything in a pendulum swinging
+ * in a lecture demonstration.
+ */
+declare function energyLadder(mass: number, stations: readonly Station[], g?: number, sf?: number): Ladder;
+/**
+ * The speed reached after falling through a height, from energy: `v = √(2gh)`.
+ *
+ * The mass cancels, which is the point and is the same fact that makes a feather and a hammer land
+ * together on the Moon. The path does not appear at all, which is the harder and more useful point:
+ * this is the speed at the bottom of a slide, a curved ramp, or a swing, not only of a vertical drop.
+ */
+declare function speedAfterDrop(height: number, g?: number, sf?: number): Worked;
+/** The height a body of known kinetic energy fell from: the drop run backwards. */
+declare function dropForKinetic(mass: number, kinetic: number, g?: number, sf?: number): Worked;
+/**
+ * Where on a fall the potential and kinetic energies stand in a given ratio.
+ *
+ * Their Example-19 asks where the potential energy is twice the kinetic during a 300 m fall, and it
+ * is a good question because the mass and `g` both cancel and the answer is a pure fraction of the
+ * height. `ratio` is potential-to-kinetic, so 2 means "potential is twice kinetic".
+ *
+ * Returns the height ABOVE THE GROUND, which is what such a question asks for, rather than the
+ * distance fallen, which is what the algebra naturally produces. Confusing the two is the trap.
+ */
+declare function heightWherePotentialIs(dropFrom: number, ratio: number, sf?: number): {
+  readonly heightAboveGround: number;
+  readonly distanceFallen: number;
+  readonly worked: Worked;
+};
+interface SwingResult {
+  /** How far the bob rose: `l(1 − cos θ)`. */
+  readonly rise: number;
+  /** Speed at the lowest point. */
+  readonly speed: number;
+  /** Horizontal distance of the bob from the vertical through the pivot, at the extreme. */
+  readonly offset: number;
+  readonly worked: Worked;
+}
+/**
+ * A pendulum released from an angle: how high the bob started, and how fast it passes the bottom.
+ *
+ * `h = l(1 − cos θ)` is the only real content, and it is geometry rather than physics. The bob hangs
+ * `l cos θ` below the pivot at the extreme and `l` below it at the bottom, so it fell the difference.
+ * Learners who memorise `l(1 − cos θ)` without that picture reliably write `l sin θ`, which is the
+ * sideways offset and is also returned here so the two can be seen side by side and never confused
+ * again.
+ */
+declare function pendulumSwing(length: number, releaseAngleDeg: number, g?: number, sf?: number): SwingResult;
+/** The angle a pendulum must be released from to pass the bottom at a stated speed. */
+declare function releaseAngleForSpeed(length: number, speed: number, g?: number, sf?: number): Worked;
+//#endregion
+export { Ladder, Rung, Station, SwingResult, dropForKinetic, energyLadder, heightWherePotentialIs, pendulumSwing, releaseAngleForSpeed, speedAfterDrop };

package/dist/physics/energy/conservation.mjs

@@ -0,0 +1,129 @@
+import { calc, texSigFigs } from "../../core/worked.mjs";
+import { toDegrees, toRadians } from "../vectors.mjs";
+import { G_EARTH } from "../kinematics/free-fall.mjs";
+
+//#region src/physics/energy/conservation.ts
+/**
+* Conservation of mechanical energy: the accountant's view of motion.
+*
+* Everything here could be done with SUVAT instead, and for a straight drop it would be no harder.
+* The reason to reach for energy is that energy DOES NOT CARE ABOUT THE PATH. A bead on a wire, a
+* pendulum bob, a ball down a curved slide: the speed at the bottom depends on the drop and on
+* nothing else, and no kinematic equation will tell you that because the acceleration is changing
+* direction the whole way down. That is the aha, and it is why a pendulum is the standard first
+* example rather than a dropped stone.
+*
+* THE ENERGY LADDER is the model this module returns. A journey is a list of stations; at each one
+* the energy is split between a kinetic pile and a potential pile, and if the total shrinks from one
+* station to the next, that shortfall went somewhere and can be named. Setting a problem out this
+* way turns "where did the energy go" from a rhetorical question into a column you can read.
+*
+* Pure: no React, no pixels.
+*/
+/**
+* Track the two piles of energy across a journey.
+*
+* The tolerance is relative to the largest total, for the same reason it is in `isBalanced`: a
+* shortfall of a millijoule is nothing in a roller coaster and is everything in a pendulum swinging
+* in a lecture demonstration.
+*/
+function energyLadder(mass, stations, g = G_EARTH, sf = 3) {
+	if (stations.length === 0) throw new Error("A ladder with no stations describes no journey.");
+	const rungs = [];
+	let previousTotal = null;
+	for (const s of stations) {
+		const kinetic = .5 * mass * s.speed * s.speed;
+		const potential = mass * g * s.height;
+		const total = kinetic + potential;
+		const lostSincePrevious = previousTotal === null ? 0 : Math.max(0, previousTotal - total);
+		rungs.push({
+			label: s.label,
+			kinetic,
+			potential,
+			total,
+			lostSincePrevious
+		});
+		previousTotal = total;
+	}
+	const largest = rungs.reduce((m, r) => Math.max(m, Math.abs(r.total)), 0);
+	const totalLost = rungs.reduce((sum, r) => sum + r.lostSincePrevious, 0);
+	const conserved = totalLost <= Math.max(largest, 1) * 1e-9;
+	const w = calc().step("E_k + E_p = \\text{constant}", "true only when nothing takes energy out. Any shortfall between two stations is the measure of what did");
+	for (const r of rungs) w.step(`\\text{${r.label}}: E_k = ${texSigFigs(r.kinetic, sf)},\\ E_p = ${texSigFigs(r.potential, sf)},\\ \\text{total} = ${texSigFigs(r.total, sf)}\\ \\mathrm{J}`, r.lostSincePrevious > 0 ? `${texSigFigs(r.lostSincePrevious, sf)} J went missing since the last station` : void 0);
+	w.step(conserved ? "\\text{total unchanged throughout}" : `\\text{lost} = ${texSigFigs(totalLost, sf)}\\ \\mathrm{J}`, conserved ? "mechanical energy was conserved, so the journey was smooth and nothing was pushed" : "this did not vanish. It became heat, sound, or deformation, and naming which is part of the answer");
+	return {
+		rungs,
+		totalLost,
+		conserved,
+		worked: w.done(totalLost)
+	};
+}
+/**
+* The speed reached after falling through a height, from energy: `v = √(2gh)`.
+*
+* The mass cancels, which is the point and is the same fact that makes a feather and a hammer land
+* together on the Moon. The path does not appear at all, which is the harder and more useful point:
+* this is the speed at the bottom of a slide, a curved ramp, or a swing, not only of a vertical drop.
+*/
+function speedAfterDrop(height, g = G_EARTH, sf = 3) {
+	if (height < 0) throw new Error("A negative drop is a rise, and a body does not gain speed rising.");
+	const value = Math.sqrt(2 * g * height);
+	return calc().step("mgh = \\tfrac{1}{2}mv^2", "all the potential energy given up becomes kinetic energy").step("v = \\sqrt{2gh}", "the mass cancels from both sides, so a heavy body and a light one arrive at the same speed").step(`v = \\sqrt{2 \\times ${texSigFigs(g, sf)} \\times ${texSigFigs(height, sf)}} = ${texSigFigs(value, sf)}\\ \\mathrm{m\\,s^{-1}}`, "and the shape of the path never entered the working, so this is the speed at the bottom of any smooth route down").done(value);
+}
+/** The height a body of known kinetic energy fell from: the drop run backwards. */
+function dropForKinetic(mass, kinetic, g = G_EARTH, sf = 3) {
+	const value = kinetic / (mass * g);
+	return calc().step("mgh = E_k \\Rightarrow h = \\frac{E_k}{mg}").step(`h = \\frac{${texSigFigs(kinetic, sf)}}{${texSigFigs(mass, sf)} \\times ${texSigFigs(g, sf)}} = ${texSigFigs(value, sf)}\\ \\mathrm{m}`).done(value);
+}
+/**
+* Where on a fall the potential and kinetic energies stand in a given ratio.
+*
+* Their Example-19 asks where the potential energy is twice the kinetic during a 300 m fall, and it
+* is a good question because the mass and `g` both cancel and the answer is a pure fraction of the
+* height. `ratio` is potential-to-kinetic, so 2 means "potential is twice kinetic".
+*
+* Returns the height ABOVE THE GROUND, which is what such a question asks for, rather than the
+* distance fallen, which is what the algebra naturally produces. Confusing the two is the trap.
+*/
+function heightWherePotentialIs(dropFrom, ratio, sf = 3) {
+	if (ratio <= 0) throw new Error("A ratio of potential to kinetic energy must be positive during a fall.");
+	const distanceFallen = dropFrom / (ratio + 1);
+	const heightAboveGround = dropFrom - distanceFallen;
+	return {
+		heightAboveGround,
+		distanceFallen,
+		worked: calc().step("E_k = mgx, \\quad E_p = mg(h - x)", "after falling x, the energy given up is mgx and what is left of the store is mg(h - x)").step(`\\frac{E_p}{E_k} = \\frac{h - x}{x} = ${texSigFigs(ratio, sf)}`, "the mass and g cancel, so the answer is a pure fraction of the height and holds for any body").step(`x = \\frac{h}{${texSigFigs(ratio, sf)} + 1} = \\frac{${texSigFigs(dropFrom, sf)}}{${texSigFigs(ratio + 1, sf)}} = ${texSigFigs(distanceFallen, sf)}\\ \\mathrm{m}`, "this is the distance FALLEN").step(`h - x = ${texSigFigs(heightAboveGround, sf)}\\ \\mathrm{m}`, "and this is the height above the ground, which is what the question asked for. Stopping one line early is the trap").done(heightAboveGround)
+	};
+}
+/**
+* A pendulum released from an angle: how high the bob started, and how fast it passes the bottom.
+*
+* `h = l(1 − cos θ)` is the only real content, and it is geometry rather than physics. The bob hangs
+* `l cos θ` below the pivot at the extreme and `l` below it at the bottom, so it fell the difference.
+* Learners who memorise `l(1 − cos θ)` without that picture reliably write `l sin θ`, which is the
+* sideways offset and is also returned here so the two can be seen side by side and never confused
+* again.
+*/
+function pendulumSwing(length, releaseAngleDeg, g = G_EARTH, sf = 4) {
+	const rad = toRadians(releaseAngleDeg);
+	const rise = length * (1 - Math.cos(rad));
+	const offset = length * Math.sin(rad);
+	const speed = Math.sqrt(2 * g * rise);
+	return {
+		rise,
+		speed,
+		offset,
+		worked: calc().step("h = l - l\\cos\\theta = l(1 - \\cos\\theta)", "at the extreme the bob hangs l cos theta below the pivot; at the bottom it hangs l below. It fell the difference").step(`h = ${texSigFigs(length, sf)}(1 - \\cos ${texSigFigs(releaseAngleDeg, sf)}^\\circ) = ${texSigFigs(rise, sf)}\\ \\mathrm{m}`).step(`l\\sin\\theta = ${texSigFigs(offset, sf)}\\ \\mathrm{m}`, "the SIDEWAYS offset, not the rise. Writing this into mgh is the standard slip").step("mgh = \\tfrac{1}{2}mv^2 \\Rightarrow v = \\sqrt{2gl(1 - \\cos\\theta)}", "the string tension does no work: it is always perpendicular to the motion, so it never appears").step(`v = ${texSigFigs(speed, sf)}\\ \\mathrm{m\\,s^{-1}}`, "at the lowest point of the swing").done(speed)
+	};
+}
+/** The angle a pendulum must be released from to pass the bottom at a stated speed. */
+function releaseAngleForSpeed(length, speed, g = G_EARTH, sf = 3) {
+	const rise = speed * speed / (2 * g);
+	const cos = 1 - rise / length;
+	if (cos < -1) throw new Error(`Reaching ${speed} m/s needs a drop of ${rise.toPrecision(3)} m, but a pendulum of length ${length} m can only ever drop ${(2 * length).toPrecision(3)} m, from straight up.`);
+	const value = toDegrees(Math.acos(cos));
+	return calc().step("h = \\frac{v^2}{2g}", "the drop the speed implies").step(`h = ${texSigFigs(rise, sf)}\\ \\mathrm{m}`).step(`\\cos\\theta = 1 - \\frac{h}{l} = 1 - \\frac{${texSigFigs(rise, sf)}}{${texSigFigs(length, sf)}} = ${texSigFigs(cos, sf)}`).step(`\\theta = ${texSigFigs(value, sf)}^\\circ`, "measured from the downward vertical").done(value);
+}
+
+//#endregion
+export { dropForKinetic, energyLadder, heightWherePotentialIs, pendulumSwing, releaseAngleForSpeed, speedAfterDrop };

package/dist/physics/energy/power.d.mts

@@ -0,0 +1,90 @@
+import { Worked } from "../../core/worked.mjs";
+
+//#region src/physics/energy/power.d.ts
+/** Mechanical (imperial) horsepower, 550 ft lb per second. What "h.p." means in a physics paper. */
+declare const HORSEPOWER = 745.699872;
+/** Metric horsepower (PS, cv), the one used in European car brochures. Not what exams mean. */
+declare const HORSEPOWER_METRIC = 735.49875;
+/** Watts to horsepower. */
+declare const toHorsepower: (watts: number, unit?: number) => number;
+/** `P = W/t`. */
+declare function power(work: number, time: number, sf?: number): Worked;
+/**
+ * `P = Fv`, the steady-speed form.
+ *
+ * Derived in the first step rather than quoted, because the derivation is the whole reason a learner
+ * can choose between the two forms instead of guessing.
+ */
+declare function powerFromForceSpeed(force: number, speed: number, sf?: number): Worked;
+/** The steady speed a stated power can sustain against a stated resisting force: `v = P/F`. */
+declare function speedFromPower(availablePower: number, resistance: number, sf?: number): Worked;
+interface EfficiencyResult {
+  /** As a fraction from 0 to 1. */
+  readonly fraction: number;
+  readonly percent: number;
+  /** Power (or energy) that did not do the wanted job. */
+  readonly wasted: number;
+  readonly worked: Worked;
+}
+/**
+ * Useful out over total in.
+ *
+ * The trap is not the arithmetic, it is which way up. "A motor is 90 per cent efficient and lifts
+ * water at 7.2 m" means the LIFTING is the 90 per cent and the electrical supply is the 100 per
+ * cent, so the useful output is `0.9 × input`, and dividing instead of multiplying gives an answer
+ * that is wrong by a factor of 1.23 and looks entirely reasonable.
+ */
+declare function efficiency(usefulOutput: number, totalInput: number, sf?: number): EfficiencyResult;
+/**
+ * Stages in series: the efficiencies MULTIPLY.
+ *
+ * An 80 per cent motor driving a 50 per cent crane is 40 per cent overall, not 65 and not 130. Each
+ * stage takes its cut of whatever reached it, which is why a long chain of quite good machines can
+ * still be dreadful end to end.
+ */
+declare function chainEfficiency(stages: readonly number[], sf?: number): EfficiencyResult;
+/** Useful output power from an input and an efficiency: the direction most questions need. */
+declare function usefulOutput(inputPower: number, efficiencyFraction: number, sf?: number): Worked;
+interface LiftingPower {
+  /** The force the machine must exert, newtons. */
+  readonly force: number;
+  /** Power at the load, before any efficiency is applied. */
+  readonly usefulPower: number;
+  /** Power the supply must deliver once the efficiency is taken into account. */
+  readonly inputPower: number;
+  readonly horsepower: number;
+  readonly worked: Worked;
+}
+/**
+ * A hoist or a lift cage raising a load at a steady speed, against a stated friction.
+ *
+ * Their Example-29, and the reason it is a good question is that it is `P = Fv` with a force that
+ * has to be ASSEMBLED first: the weight of the cage, the weight of the load, and the friction, all
+ * of which the motor must overcome at once. Getting the power right is easy; getting the force right
+ * is where the question lives.
+ */
+declare function hoistPower(cageMass: number, loadMass: number, speed: number, friction?: number, g?: number, efficiencyFraction?: number, sf?: number): LiftingPower;
+/**
+ * Pumping a mass of liquid through a mean lift, in a stated time.
+ *
+ * `meanLift` is deliberately a parameter and not computed from a depth, because THE MEAN LIFT IS THE
+ * WHOLE DIFFICULTY and it depends on the shape of what is being emptied. Pumping from a tank at a
+ * fixed level lifts every kilogram the same distance. Emptying a well lifts the top layer barely at
+ * all and the bottom layer the full depth, so the mean is the depth to the centre of mass of the
+ * water, which for a uniform column is half the depth. Getting that wrong is a factor of two, and it
+ * is the single most common error in this family of questions.
+ *
+ * `centreOfMassLift` and `columnDrain` in `centre-of-mass.ts` compute that mean for the standard
+ * shapes, and feed it here.
+ */
+declare function pumpPower(mass: number, meanLift: number, time: number, g?: number, efficiencyFraction?: number, sf?: number): LiftingPower;
+/**
+ * How much a machine of stated input power and efficiency can raise in a given time.
+ *
+ * Their Example-27 inverted into the form the question actually asks: kilograms per minute, given
+ * the motor rating. Worth having as its own function because the rearrangement puts `g` and `h` in
+ * the denominator, and a learner who rearranges under pressure tends to leave one of them upstairs.
+ */
+declare function massRaisedInTime(inputPower: number, efficiencyFraction: number, height: number, time: number, g?: number, sf?: number): Worked;
+//#endregion
+export { EfficiencyResult, HORSEPOWER, HORSEPOWER_METRIC, LiftingPower, chainEfficiency, efficiency, hoistPower, massRaisedInTime, power, powerFromForceSpeed, pumpPower, speedFromPower, toHorsepower, usefulOutput };

package/dist/physics/energy/power.mjs

@@ -0,0 +1,167 @@
+import { calc, texSigFigs } from "../../core/worked.mjs";
+import { G_EARTH } from "../kinematics/free-fall.mjs";
+
+//#region src/physics/energy/power.ts
+/**
+* Power: the rate, not the amount, and the confusion that costs the most marks in this chapter.
+*
+* WORK AND POWER ARE NOT THE SAME KIND OF THING and a surprising number of wrong answers come from
+* treating them as interchangeable. Carrying a load up four flights of stairs is the same WORK
+* whether you stroll or sprint; sprinting is more POWER. A question that gives a time is almost
+* always a power question, and a question that does not give a time cannot be one.
+*
+* THE TWO FORMS ARE THE SAME FORM.
+*
+*   `P = W/t` and `P = Fv` look like separate facts and are one line apart: `W = Fd`, so
+*   `P = Fd/t = Fv`. Knowing that, the choice between them stops being a memory problem and becomes
+*   a question of which quantity you were handed. Given a time, use the first; given a steady speed,
+*   use the second.
+*
+* `P = Fv` also carries the answer to "why does a car have a top speed". At constant speed the
+* engine's force exactly balances the resistance, and since `P = Fv` with `P` capped, the speed can
+* only rise until the resistance has eaten the whole power budget.
+*
+* ABOUT HORSEPOWER. It is not an SI unit and there are two of them, which is exactly the sort of
+* detail that turns a correct method into a wrong number. Both are defined here with their sizes,
+* and {@link HORSEPOWER} is the mechanical one at 745.7 W, because that is the one every exam board
+* in this market means when it prints "h.p.".
+*
+* Pure: no React, no pixels.
+*/
+/** Mechanical (imperial) horsepower, 550 ft lb per second. What "h.p." means in a physics paper. */
+const HORSEPOWER = 745.699872;
+/** Metric horsepower (PS, cv), the one used in European car brochures. Not what exams mean. */
+const HORSEPOWER_METRIC = 735.49875;
+/** Watts to horsepower. */
+const toHorsepower = (watts, unit = HORSEPOWER) => watts / unit;
+/** `P = W/t`. */
+function power(work, time, sf = 3) {
+	if (time <= 0) throw new Error("Power is work per unit time, and no time means no rate to report.");
+	const value = work / time;
+	return calc().step("P = \\frac{W}{t}", "power is a RATE. The same work done in half the time is twice the power").step(`P = \\frac{${texSigFigs(work, sf)}}{${texSigFigs(time, sf)}} = ${texSigFigs(value, sf)}\\ \\mathrm{W}`).step(`= ${texSigFigs(toHorsepower(value), sf)}\\ \\mathrm{h.p.}`, "one horsepower is 745.7 W. Metric horsepower is 735.5 W, and picking the wrong one is worth about one per cent").done(value);
+}
+/**
+* `P = Fv`, the steady-speed form.
+*
+* Derived in the first step rather than quoted, because the derivation is the whole reason a learner
+* can choose between the two forms instead of guessing.
+*/
+function powerFromForceSpeed(force, speed, sf = 3) {
+	const value = force * speed;
+	return calc().step("P = \\frac{W}{t} = \\frac{Fd}{t} = F\\frac{d}{t} = Fv", "not a second formula. It is P = W/t with W = Fd substituted and d/t recognised as the speed").step(`P = ${texSigFigs(force, sf)} \\times ${texSigFigs(speed, sf)} = ${texSigFigs(value, sf)}\\ \\mathrm{W}`).done(value);
+}
+/** The steady speed a stated power can sustain against a stated resisting force: `v = P/F`. */
+function speedFromPower(availablePower, resistance, sf = 3) {
+	if (resistance <= 0) throw new Error("With no resistance the speed is not limited by the power, so it has no steady value.");
+	const value = availablePower / resistance;
+	return calc().step("P = Fv \\Rightarrow v = \\frac{P}{F}", "at a steady speed the driving force exactly balances the resistance, so F is the resistance").step(`v = \\frac{${texSigFigs(availablePower, sf)}}{${texSigFigs(resistance, sf)}} = ${texSigFigs(value, sf)}\\ \\mathrm{m\\,s^{-1}}`, "this is the top speed: the resistance has absorbed the entire power budget, so nothing is left to accelerate with").done(value);
+}
+/**
+* Useful out over total in.
+*
+* The trap is not the arithmetic, it is which way up. "A motor is 90 per cent efficient and lifts
+* water at 7.2 m" means the LIFTING is the 90 per cent and the electrical supply is the 100 per
+* cent, so the useful output is `0.9 × input`, and dividing instead of multiplying gives an answer
+* that is wrong by a factor of 1.23 and looks entirely reasonable.
+*/
+function efficiency(usefulOutput, totalInput, sf = 3) {
+	if (totalInput <= 0) throw new Error("Efficiency compares output with input, and there was no input.");
+	if (usefulOutput > totalInput) throw new Error(`A useful output of ${usefulOutput} cannot exceed an input of ${totalInput}. An efficiency above 100 per cent means the two have been divided the wrong way round, or a loss has been counted as an output.`);
+	const fraction = usefulOutput / totalInput;
+	const wasted = totalInput - usefulOutput;
+	const worked = calc().step("\\eta = \\frac{\\text{useful output}}{\\text{total input}}", "always a fraction below 1. If you get more than 1, the division is upside down").step(`\\eta = \\frac{${texSigFigs(usefulOutput, sf)}}{${texSigFigs(totalInput, sf)}} = ${texSigFigs(fraction, sf)} = ${texSigFigs(fraction * 100, sf)}\\%`).step(`\\text{wasted} = ${texSigFigs(wasted, sf)}`, "mostly heat. It is not destroyed, it is just no longer doing the job you wanted").done(fraction);
+	return {
+		fraction,
+		percent: fraction * 100,
+		wasted,
+		worked
+	};
+}
+/**
+* Stages in series: the efficiencies MULTIPLY.
+*
+* An 80 per cent motor driving a 50 per cent crane is 40 per cent overall, not 65 and not 130. Each
+* stage takes its cut of whatever reached it, which is why a long chain of quite good machines can
+* still be dreadful end to end.
+*/
+function chainEfficiency(stages, sf = 3) {
+	if (stages.length === 0) throw new Error("A chain with no stages has nothing to be efficient at.");
+	const fraction = stages.reduce((product, s) => product * s, 1);
+	const worked = calc().step("\\eta_{\\text{total}} = \\eta_1 \\times \\eta_2 \\times \\ldots", "each stage takes its cut of what reached it, so the fractions multiply. They never add and never average").step(`\\eta = ${stages.map((s) => texSigFigs(s, sf)).join(" \\times ")} = ${texSigFigs(fraction, sf)} = ${texSigFigs(fraction * 100, sf)}\\%`).done(fraction);
+	return {
+		fraction,
+		percent: fraction * 100,
+		wasted: 1 - fraction,
+		worked
+	};
+}
+/** Useful output power from an input and an efficiency: the direction most questions need. */
+function usefulOutput(inputPower, efficiencyFraction, sf = 3) {
+	const value = inputPower * efficiencyFraction;
+	return calc().step("P_{\\text{out}} = \\eta P_{\\text{in}}", "the efficiency MULTIPLIES the input. Dividing gives more out than in, which is the giveaway").step(`P_{\\text{out}} = ${texSigFigs(efficiencyFraction, sf)} \\times ${texSigFigs(inputPower, sf)} = ${texSigFigs(value, sf)}\\ \\mathrm{W}`).done(value);
+}
+/**
+* A hoist or a lift cage raising a load at a steady speed, against a stated friction.
+*
+* Their Example-29, and the reason it is a good question is that it is `P = Fv` with a force that
+* has to be ASSEMBLED first: the weight of the cage, the weight of the load, and the friction, all
+* of which the motor must overcome at once. Getting the power right is easy; getting the force right
+* is where the question lives.
+*/
+function hoistPower(cageMass, loadMass, speed, friction = 0, g = G_EARTH, efficiencyFraction = 1, sf = 4) {
+	const force = (cageMass + loadMass) * g + friction;
+	const usefulPowerValue = force * speed;
+	const inputPower = usefulPowerValue / efficiencyFraction;
+	const worked = calc().step("F = (m_{\\text{cage}} + m_{\\text{load}})g + f", "the motor holds up everything it is carrying AND beats the friction. Assembling this force is the actual question").step(`F = (${texSigFigs(cageMass, sf)} + ${texSigFigs(loadMass, sf)}) \\times ${texSigFigs(g, sf)} + ${texSigFigs(friction, sf)} = ${texSigFigs(force, sf)}\\ \\mathrm{N}`).step(`P = Fv = ${texSigFigs(force, sf)} \\times ${texSigFigs(speed, sf)} = ${texSigFigs(usefulPowerValue, sf)}\\ \\mathrm{W}`, "steady speed, so there is no acceleration term and the force is exactly what is resisting");
+	if (efficiencyFraction !== 1) worked.step(`P_{\\text{in}} = \\frac{P}{\\eta} = ${texSigFigs(inputPower, sf)}\\ \\mathrm{W}`, "the supply must deliver more than the load receives, because some is lost on the way");
+	return {
+		force,
+		usefulPower: usefulPowerValue,
+		inputPower,
+		horsepower: toHorsepower(inputPower),
+		worked: worked.done(inputPower)
+	};
+}
+/**
+* Pumping a mass of liquid through a mean lift, in a stated time.
+*
+* `meanLift` is deliberately a parameter and not computed from a depth, because THE MEAN LIFT IS THE
+* WHOLE DIFFICULTY and it depends on the shape of what is being emptied. Pumping from a tank at a
+* fixed level lifts every kilogram the same distance. Emptying a well lifts the top layer barely at
+* all and the bottom layer the full depth, so the mean is the depth to the centre of mass of the
+* water, which for a uniform column is half the depth. Getting that wrong is a factor of two, and it
+* is the single most common error in this family of questions.
+*
+* `centreOfMassLift` and `columnDrain` in `centre-of-mass.ts` compute that mean for the standard
+* shapes, and feed it here.
+*/
+function pumpPower(mass, meanLift, time, g = G_EARTH, efficiencyFraction = 1, sf = 4) {
+	if (time <= 0) throw new Error("Power is a rate, so the pumping has to take some time.");
+	const force = mass * g;
+	const work = force * meanLift;
+	const usefulPowerValue = work / time;
+	const inputPower = usefulPowerValue / efficiencyFraction;
+	const worked = calc().step("W = mg\\bar{h}", "h-bar is the MEAN lift, the distance the centre of mass of the liquid rose. Not the depth, unless every drop rose the same amount").step(`W = ${texSigFigs(mass, sf)} \\times ${texSigFigs(g, sf)} \\times ${texSigFigs(meanLift, sf)} = ${texSigFigs(work, sf)}\\ \\mathrm{J}`).step(`P = \\frac{W}{t} = \\frac{${texSigFigs(work, sf)}}{${texSigFigs(time, sf)}} = ${texSigFigs(usefulPowerValue, sf)}\\ \\mathrm{W}`).step(`= ${texSigFigs(toHorsepower(inputPower), sf)}\\ \\mathrm{h.p.}`, "dividing by 745.7 W. Using the depth instead of the mean lift here would double the answer").done(inputPower);
+	return {
+		force,
+		usefulPower: usefulPowerValue,
+		inputPower,
+		horsepower: toHorsepower(inputPower),
+		worked
+	};
+}
+/**
+* How much a machine of stated input power and efficiency can raise in a given time.
+*
+* Their Example-27 inverted into the form the question actually asks: kilograms per minute, given
+* the motor rating. Worth having as its own function because the rearrangement puts `g` and `h` in
+* the denominator, and a learner who rearranges under pressure tends to leave one of them upstairs.
+*/
+function massRaisedInTime(inputPower, efficiencyFraction, height, time, g = G_EARTH, sf = 4) {
+	const useful = inputPower * efficiencyFraction;
+	const value = useful * time / (g * height);
+	return calc().step("P_{\\text{useful}} = \\eta P_{\\text{in}} = \\frac{mgh}{t}", "only the useful share of the supply ends up in the load. The rest is lost in the machine").step(`P_{\\text{useful}} = ${texSigFigs(efficiencyFraction, sf)} \\times ${texSigFigs(inputPower, sf)} = ${texSigFigs(useful, sf)}\\ \\mathrm{W}`).step("m = \\frac{\\eta P_{\\text{in}} t}{gh}", "both g and h belong in the denominator. Dropping either is the usual rearrangement slip").step(`m = \\frac{${texSigFigs(useful, sf)} \\times ${texSigFigs(time, sf)}}{${texSigFigs(g, sf)} \\times ${texSigFigs(height, sf)}} = ${texSigFigs(value, sf)}\\ \\mathrm{kg}`).done(value);
+}
+
+//#endregion
+export { HORSEPOWER, HORSEPOWER_METRIC, chainEfficiency, efficiency, hoistPower, massRaisedInTime, power, powerFromForceSpeed, pumpPower, speedFromPower, toHorsepower, usefulOutput };