@classytic/stage 0.2.0 → 0.4.0

package/dist/physics/momentum/impulse.d.mts

@@ -0,0 +1,89 @@
+import { Worked } from "../../core/worked.mjs";
+
+//#region src/physics/momentum/impulse.d.ts
+interface ImpulseResult {
+  /** The impulse, N s, which is the same thing as the momentum change in kg m/s. */
+  readonly impulse: number;
+  /** The average force over the contact, N. */
+  readonly averageForce: number;
+  readonly duration: number;
+  readonly worked: Worked;
+}
+/**
+ * The impulse that changes a mass's velocity from `u` to `v`, and the force that delivers it.
+ *
+ * Both velocities are SIGNED. A ball that arrives at 5 m/s and leaves at −3 m/s has changed its
+ * momentum by 8 m/s worth, not 2, and writing `v − u` as `3 − 5` is the single most common way to
+ * lose this mark.
+ */
+declare function impulseToChange(mass: number, u: number, v: number, duration: number, sf?: number): ImpulseResult;
+/**
+ * The force needed to deliver a fixed impulse over a chosen contact time.
+ *
+ * The airbag calculation, and the reason to have it as its own function is that the question it
+ * answers is the interesting one: not "what force" but "how much less force if the stop takes ten
+ * times longer". The answer is always exactly ten times less, because `J` did not move.
+ */
+declare const forceForContact: (impulse: number, duration: number) => number;
+/**
+ * A bounce off a wall, where only the component along the normal reverses.
+ *
+ * Angles are measured from the WALL, which is how these questions are drawn and stated. The
+ * component along the wall is untouched, so the whole impulse is perpendicular and its size is
+ * `2mu sin θ`. A learner who works with the full speed rather than the perpendicular component gets
+ * an answer that is too big by `1/sin θ`, and at the 90° case, where they usually check their work,
+ * the error vanishes.
+ */
+declare function bounceOffWall(mass: number, speed: number, angleToWallDeg: number, sf?: number): ImpulseResult & {
+  perpendicularSpeed: number;
+};
+interface VariableImpulse {
+  readonly impulse: number;
+  readonly averageForce: number;
+  readonly peakForce: number;
+  /** `peakForce / averageForce`. About 1.57 for a half-sine, and never 1 for a real impact. */
+  readonly peakRatio: number;
+  readonly method: 'symbolic' | 'numeric';
+  readonly worked: Worked;
+}
+/**
+ * `J = ∫F dt` for a force given as an expression in `t`.
+ *
+ * Symbolic when `math/calculus` can, quadrature when it cannot, in the same pattern and for the
+ * same reason as `integral-sweep`: an impact profile from a real data sheet has no closed form and
+ * a refusal would be useless.
+ *
+ * `peakForce` is reported because it, not the average, is what breaks things. A half-sine pulse
+ * peaks at `π/2` times its mean, so a safety margin computed from the average is out by 57%.
+ */
+declare function impulseOf(force: string, duration: number, values?: Readonly<Record<string, number>>, sf?: number): VariableImpulse;
+/**
+ * Rocket thrust, `F = v_e · (dm/dt)`.
+ *
+ * A rocket is the cleanest demonstration in the syllabus that momentum, not force, is the primitive
+ * idea: it throws mass backwards and the reaction pushes it forwards, and it works in a vacuum
+ * precisely because it does not push against anything external.
+ *
+ * Thrust does not depend on how fast the rocket is going, only on how fast and how quickly it
+ * throws mass away. Its ACCELERATION does change, sharply, because the mass being pushed keeps
+ * dropping, which is why a rocket accelerates hardest just before burnout.
+ */
+declare function rocketThrust(exhaustSpeed: number, burnRate: number, sf?: number): {
+  thrust: number;
+  worked: Worked;
+};
+/**
+ * A rocket's acceleration at an instant, against gravity.
+ *
+ * `a = (v_e · dm/dt) / m − g`, with `m` the mass RIGHT NOW. Taking off needs the thrust to beat the
+ * weight, and a rocket that cannot lift at ignition may be able to a minute later having burned a
+ * third of itself, which is a genuinely surprising thing to be able to show.
+ */
+declare function rocketAcceleration(exhaustSpeed: number, burnRate: number, currentMass: number, g?: number, sf?: number): {
+  acceleration: number;
+  thrust: number;
+  lifts: boolean;
+  worked: Worked;
+};
+//#endregion
+export { ImpulseResult, VariableImpulse, bounceOffWall, forceForContact, impulseOf, impulseToChange, rocketAcceleration, rocketThrust };

package/dist/physics/momentum/impulse.mjs

@@ -0,0 +1,159 @@
+import { evaluate } from "../../math/ast.mjs";
+import { parse } from "../../math/parse.mjs";
+import { integrate } from "../../math/calculus.mjs";
+import { quadrature } from "../../math/analysis.mjs";
+import { calc, texSigFigs } from "../../core/worked.mjs";
+
+//#region src/physics/momentum/impulse.ts
+/**
+* Impulse: what a force does when you multiply it by how long it acts.
+*
+* `J = FΔt = Δp` is one of the few genuinely load-bearing identities at this level, and it is
+* usually presented as two unrelated facts. It is one: Newton's second law says `F = dp/dt`, so
+* integrating both sides over the time the force acts gives `∫F dt = Δp`. The left is the impulse
+* and the right is the change in momentum, and they are equal because that is what integrating an
+* equation does.
+*
+* WHY THIS MATTERS PRACTICALLY, and it is the point most worth teaching: for a given change in
+* momentum, the impulse is FIXED. A car stopping from 30 m/s has to lose all its momentum whether
+* it hits a wall or a crash barrier. Only `Δt` is negotiable, and since `F = J/Δt`, stretching the
+* time is the ONLY way to reduce the force. Airbags, crumple zones, bending your knees on landing,
+* a cricketer drawing the hands back with the ball: all the same sentence.
+*
+* A VARIABLE FORCE is handled by integrating it rather than by pretending it is constant. Real
+* impacts are not rectangles, and `F_max` is roughly twice the average for the half-sine pulse that
+* models a real collision, which is exactly the factor a safety calculation must not lose.
+*
+* Pure: no React, no pixels.
+*/
+/**
+* The impulse that changes a mass's velocity from `u` to `v`, and the force that delivers it.
+*
+* Both velocities are SIGNED. A ball that arrives at 5 m/s and leaves at −3 m/s has changed its
+* momentum by 8 m/s worth, not 2, and writing `v − u` as `3 − 5` is the single most common way to
+* lose this mark.
+*/
+function impulseToChange(mass, u, v, duration, sf = 3) {
+	if (duration <= 0) throw new Error("The contact has to last a positive time.");
+	const impulse = mass * (v - u);
+	const averageForce = impulse / duration;
+	return {
+		impulse,
+		averageForce,
+		duration,
+		worked: calc().step("J = \\Delta p = m(v - u)", "impulse IS the change in momentum, not merely equal to it").step(`J = ${texSigFigs(mass, sf)}(${texSigFigs(v, sf)} - ${texSigFigs(u, sf)}) = ${texSigFigs(impulse, sf)}\\ \\mathrm{N\\,s}`, v * u < 0 ? "the velocities have opposite signs, so the two speeds ADD: this is where the mark is usually lost" : void 0).step(`F = \\frac{J}{\\Delta t} = \\frac{${texSigFigs(impulse, sf)}}{${texSigFigs(duration, sf)}} = ${texSigFigs(averageForce, sf)}\\ \\mathrm{N}`, "the impulse was fixed by the momentum change; only the time is negotiable, and the force follows from it").done(impulse)
+	};
+}
+/**
+* The force needed to deliver a fixed impulse over a chosen contact time.
+*
+* The airbag calculation, and the reason to have it as its own function is that the question it
+* answers is the interesting one: not "what force" but "how much less force if the stop takes ten
+* times longer". The answer is always exactly ten times less, because `J` did not move.
+*/
+const forceForContact = (impulse, duration) => {
+	if (duration <= 0) throw new Error("The contact has to last a positive time.");
+	return impulse / duration;
+};
+/**
+* A bounce off a wall, where only the component along the normal reverses.
+*
+* Angles are measured from the WALL, which is how these questions are drawn and stated. The
+* component along the wall is untouched, so the whole impulse is perpendicular and its size is
+* `2mu sin θ`. A learner who works with the full speed rather than the perpendicular component gets
+* an answer that is too big by `1/sin θ`, and at the 90° case, where they usually check their work,
+* the error vanishes.
+*/
+function bounceOffWall(mass, speed, angleToWallDeg, sf = 3) {
+	const theta = angleToWallDeg * Math.PI / 180;
+	const perpendicularSpeed = speed * Math.sin(theta);
+	const impulse = 2 * mass * perpendicularSpeed;
+	return {
+		impulse,
+		averageForce: NaN,
+		duration: NaN,
+		perpendicularSpeed,
+		worked: calc().step("J = m(v_\\perp - u_\\perp) = 2mu\\sin\\theta", "only the component INTO the wall reverses; the component along it is untouched").step(`u_\\perp = ${texSigFigs(speed, sf)}\\sin ${texSigFigs(angleToWallDeg, sf)}^\\circ = ${texSigFigs(perpendicularSpeed, sf)}\\ \\mathrm{m\\,s^{-1}}`).step(`J = 2 \\times ${texSigFigs(mass, sf)} \\times ${texSigFigs(perpendicularSpeed, sf)} = ${texSigFigs(impulse, sf)}\\ \\mathrm{N\\,s}`, "directed along the normal, because that is the only direction anything changed in").done(impulse)
+	};
+}
+/**
+* `J = ∫F dt` for a force given as an expression in `t`.
+*
+* Symbolic when `math/calculus` can, quadrature when it cannot, in the same pattern and for the
+* same reason as `integral-sweep`: an impact profile from a real data sheet has no closed form and
+* a refusal would be useless.
+*
+* `peakForce` is reported because it, not the average, is what breaks things. A half-sine pulse
+* peaks at `π/2` times its mean, so a safety margin computed from the average is out by 57%.
+*/
+function impulseOf(force, duration, values = {}, sf = 3) {
+	if (duration <= 0) throw new Error("The contact has to last a positive time.");
+	const node = parse(force);
+	const at = (t) => evaluate(node, {
+		...values,
+		t
+	});
+	const antiderivative = integrate(node, "t");
+	const method = antiderivative ? "symbolic" : "numeric";
+	const impulse = antiderivative ? evaluate(antiderivative, {
+		...values,
+		t: duration
+	}) - evaluate(antiderivative, {
+		...values,
+		t: 0
+	}) : quadrature(at, 0, duration);
+	let peakForce = 0;
+	const STEPS = 2e3;
+	for (let i = 0; i <= STEPS; i++) peakForce = Math.max(peakForce, Math.abs(at(duration * i / STEPS)));
+	const averageForce = impulse / duration;
+	const worked = calc().step("J = \\int_0^{\\Delta t} F\\,dt", "a real impact is not a rectangle, so it is integrated rather than multiplied").step(`F(t) = ${force}`).step(`J = ${texSigFigs(impulse, sf)}\\ \\mathrm{N\\,s}`, method === "symbolic" ? "integrated exactly" : "no closed form, so integrated numerically").step(`\\bar{F} = ${texSigFigs(averageForce, sf)}\\ \\mathrm{N}, \\quad F_{\\max} = ${texSigFigs(peakForce, sf)}\\ \\mathrm{N}`, "the PEAK is what breaks things, and it is nothing like the average").done(impulse);
+	return {
+		impulse,
+		averageForce,
+		peakForce,
+		peakRatio: averageForce === 0 ? NaN : peakForce / averageForce,
+		method,
+		worked
+	};
+}
+/**
+* Rocket thrust, `F = v_e · (dm/dt)`.
+*
+* A rocket is the cleanest demonstration in the syllabus that momentum, not force, is the primitive
+* idea: it throws mass backwards and the reaction pushes it forwards, and it works in a vacuum
+* precisely because it does not push against anything external.
+*
+* Thrust does not depend on how fast the rocket is going, only on how fast and how quickly it
+* throws mass away. Its ACCELERATION does change, sharply, because the mass being pushed keeps
+* dropping, which is why a rocket accelerates hardest just before burnout.
+*/
+function rocketThrust(exhaustSpeed, burnRate, sf = 3) {
+	const thrust = exhaustSpeed * burnRate;
+	return {
+		thrust,
+		worked: calc().step("F = v_e \\frac{dm}{dt}", "the momentum given to the exhaust each second is the momentum the rocket gains each second").step(`F = ${texSigFigs(exhaustSpeed, sf)} \\times ${texSigFigs(burnRate, sf)} = ${texSigFigs(thrust, sf)}\\ \\mathrm{N}`, "independent of the rocket’s own speed, which is why it works in a vacuum").done(thrust)
+	};
+}
+/**
+* A rocket's acceleration at an instant, against gravity.
+*
+* `a = (v_e · dm/dt) / m − g`, with `m` the mass RIGHT NOW. Taking off needs the thrust to beat the
+* weight, and a rocket that cannot lift at ignition may be able to a minute later having burned a
+* third of itself, which is a genuinely surprising thing to be able to show.
+*/
+function rocketAcceleration(exhaustSpeed, burnRate, currentMass, g = 9.8, sf = 3) {
+	if (currentMass <= 0) throw new Error("A rocket has to have some mass left.");
+	const thrust = exhaustSpeed * burnRate;
+	const weight = currentMass * g;
+	const acceleration = thrust / currentMass - g;
+	const worked = calc().step("ma = F - mg", "thrust up, weight down, and the mass is whatever is left at this instant").step(`a = \\frac{${texSigFigs(thrust, sf)}}{${texSigFigs(currentMass, sf)}} - ${texSigFigs(g, sf)} = ${texSigFigs(acceleration, sf)}\\ \\mathrm{m\\,s^{-2}}`, thrust > weight ? "thrust beats the weight, so it climbs, and it climbs harder as it gets lighter" : "thrust is less than the weight, so it cannot lift yet").done(acceleration);
+	return {
+		acceleration,
+		thrust,
+		lifts: thrust > weight,
+		worked
+	};
+}
+
+//#endregion
+export { bounceOffWall, forceForContact, impulseOf, impulseToChange, rocketAcceleration, rocketThrust };

package/dist/physics/momentum/planar.d.mts

@@ -0,0 +1,60 @@
+import { Worked } from "../../core/worked.mjs";
+import { Complex } from "../../math/complex.mjs";
+import { Components, Polar } from "../vectors.mjs";
+
+//#region src/physics/momentum/planar.d.ts
+/** A body with a velocity in the plane. */
+interface PlanarBody {
+  readonly label: string;
+  readonly mass: number;
+  /** Speed, m/s. */
+  readonly speed: number;
+  /** Direction, degrees anticlockwise from the x axis. */
+  readonly angleDeg: number;
+}
+/** A body's momentum as components, kg m/s. */
+declare function momentumOf(body: PlanarBody): Components;
+/** Total momentum of any number of bodies. */
+declare function totalMomentum(bodies: readonly PlanarBody[]): Components;
+/**
+ * A momentum as a complex number, for the polar-arithmetic route.
+ *
+ * `p_x + i p_y`. Adding momenta is adding complex numbers, and the magnitude and argument of the
+ * sum are the size and direction of the resultant, which is why the calculator trick works.
+ */
+declare const momentumAsComplex: (body: PlanarBody) => Complex;
+interface PlanarSolution {
+  /** The missing velocity, as speed and direction. */
+  readonly velocity: Polar;
+  /** Its momentum components, for a diagram that draws the vector triangle. */
+  readonly momentum: Components;
+  readonly worked: Worked;
+}
+/**
+ * Find the one velocity that conservation requires, given every other one.
+ *
+ * This is the whole of oblique collisions: total momentum before, minus every known momentum after,
+ * is the momentum of the body you did not measure. Divide by its mass and you have its velocity.
+ *
+ * ```ts
+ * // 5 kg at 2 m/s along x strikes a stationary 3 kg; afterwards the 5 kg moves at 1 m/s, 30° off
+ * // the axis. Where does the 3 kg go?
+ * conserveMomentum(
+ *   [{ label: 'A before', mass: 5, speed: 2, angleDeg: 0 },
+ *    { label: 'B before', mass: 3, speed: 0, angleDeg: 0 }],
+ *   [{ label: 'A after',  mass: 5, speed: 1, angleDeg: 30 }],
+ *   3,
+ * ); // 2.07 m/s at −23.8°
+ * ```
+ */
+declare function conserveMomentum(before: readonly PlanarBody[], knownAfter: readonly PlanarBody[], unknownMass: number, sf?: number): PlanarSolution;
+/**
+ * Is momentum actually conserved across this collision?
+ *
+ * For checking a learner's answer, or a lab's own model. The tolerance is relative to the momentum
+ * present, because an absolute epsilon is meaningless when the same check has to serve a bullet and
+ * a goods train.
+ */
+declare function momentumIsConserved(before: readonly PlanarBody[], after: readonly PlanarBody[], tolerance?: number): boolean;
+//#endregion
+export { PlanarBody, PlanarSolution, conserveMomentum, momentumAsComplex, momentumIsConserved, momentumOf, totalMomentum };

package/dist/physics/momentum/planar.mjs

@@ -0,0 +1,110 @@
+import { cx } from "../../math/complex.mjs";
+import { calc, texSigFigs } from "../../core/worked.mjs";
+import { compose, resolve } from "../vectors.mjs";
+
+//#region src/physics/momentum/planar.ts
+/**
+* Momentum in a plane: the same conservation law, resolved into two directions.
+*
+* There is no new physics here and that is the thing worth saying out loud. Momentum is a vector,
+* vectors add component by component, so conservation in two dimensions is conservation along x AND
+* conservation along y: two equations instead of one, from the same single law.
+*
+* That is the whole method for an oblique collision, and a textbook that presents it as a new
+* "type" with its own worked example has hidden the only idea in it.
+*
+* A NOTE ON THE CALCULATOR TRICK. Competitor material tells students to solve these in complex mode
+* on a calculator, because a 2D vector and a complex number are the same object and the calculator
+* will add them in polar form. That is a real and good insight buried in a keystroke sequence, and
+* `momentumAsComplex` exposes it properly: our complex kernel already does polar arithmetic, so the
+* method can be SHOWN rather than performed blind.
+*
+* Pure: no React, no pixels.
+*/
+/** A body's momentum as components, kg m/s. */
+function momentumOf(body) {
+	const v = resolve(body.speed, body.angleDeg);
+	return {
+		x: body.mass * v.x,
+		y: body.mass * v.y
+	};
+}
+/** Total momentum of any number of bodies. */
+function totalMomentum(bodies) {
+	let x = 0;
+	let y = 0;
+	for (const b of bodies) {
+		const p = momentumOf(b);
+		x += p.x;
+		y += p.y;
+	}
+	return {
+		x,
+		y
+	};
+}
+/**
+* A momentum as a complex number, for the polar-arithmetic route.
+*
+* `p_x + i p_y`. Adding momenta is adding complex numbers, and the magnitude and argument of the
+* sum are the size and direction of the resultant, which is why the calculator trick works.
+*/
+const momentumAsComplex = (body) => {
+	const p = momentumOf(body);
+	return cx(p.x, p.y);
+};
+/**
+* Find the one velocity that conservation requires, given every other one.
+*
+* This is the whole of oblique collisions: total momentum before, minus every known momentum after,
+* is the momentum of the body you did not measure. Divide by its mass and you have its velocity.
+*
+* ```ts
+* // 5 kg at 2 m/s along x strikes a stationary 3 kg; afterwards the 5 kg moves at 1 m/s, 30° off
+* // the axis. Where does the 3 kg go?
+* conserveMomentum(
+*   [{ label: 'A before', mass: 5, speed: 2, angleDeg: 0 },
+*    { label: 'B before', mass: 3, speed: 0, angleDeg: 0 }],
+*   [{ label: 'A after',  mass: 5, speed: 1, angleDeg: 30 }],
+*   3,
+* ); // 2.07 m/s at −23.8°
+* ```
+*/
+function conserveMomentum(before, knownAfter, unknownMass, sf = 3) {
+	if (unknownMass <= 0) throw new Error("The unknown body must have a positive mass.");
+	const total = totalMomentum(before);
+	const accounted = totalMomentum(knownAfter);
+	const momentum = {
+		x: total.x - accounted.x,
+		y: total.y - accounted.y
+	};
+	const velocity = compose(momentum.x / unknownMass, momentum.y / unknownMass);
+	const w = calc().step("\\sum p_x \\text{ before} = \\sum p_x \\text{ after}, \\quad \\sum p_y \\text{ before} = \\sum p_y \\text{ after}", "one law, resolved into two directions. That is the entire method for an oblique collision").step(`\\text{before: } (${texSigFigs(total.x, sf)},\\; ${texSigFigs(total.y, sf)})\\ \\mathrm{kg\\,m\\,s^{-1}}`, before.map((b) => b.label).join(" + "));
+	for (const b of knownAfter) {
+		const p = momentumOf(b);
+		w.step(`${b.label}: (${texSigFigs(p.x, sf)},\\; ${texSigFigs(p.y, sf)})\\ \\mathrm{kg\\,m\\,s^{-1}}`, `${texSigFigs(b.mass, sf)} kg at ${texSigFigs(b.speed, sf)} m/s, ${texSigFigs(b.angleDeg, sf)}°`);
+	}
+	w.step(`\\text{missing: } (${texSigFigs(momentum.x, sf)},\\; ${texSigFigs(momentum.y, sf)})\\ \\mathrm{kg\\,m\\,s^{-1}}`, "whatever is left over is the momentum of the body you did not measure");
+	w.step(`v = \\frac{|p|}{m} = ${texSigFigs(velocity.magnitude, sf)}\\ \\mathrm{m\\,s^{-1}} \\text{ at } ${texSigFigs(velocity.angleDeg, sf)}^\\circ`, velocity.angleDeg < 0 ? "below the axis, which the sign of p_y already told you" : void 0);
+	return {
+		velocity,
+		momentum,
+		worked: w.done(velocity.magnitude)
+	};
+}
+/**
+* Is momentum actually conserved across this collision?
+*
+* For checking a learner's answer, or a lab's own model. The tolerance is relative to the momentum
+* present, because an absolute epsilon is meaningless when the same check has to serve a bullet and
+* a goods train.
+*/
+function momentumIsConserved(before, after, tolerance = 1e-6) {
+	const a = totalMomentum(before);
+	const b = totalMomentum(after);
+	const scale = Math.max(Math.hypot(a.x, a.y), Math.hypot(b.x, b.y), 1);
+	return Math.hypot(a.x - b.x, a.y - b.y) <= scale * tolerance;
+}
+
+//#endregion
+export { conserveMomentum, momentumAsComplex, momentumIsConserved, momentumOf, totalMomentum };

package/dist/physics/projectile.d.mts

@@ -0,0 +1,107 @@
+import { Worked } from "../core/worked.mjs";
+import { Components, toDegrees, toRadians } from "./vectors.mjs";
+import { Root } from "./kinematics/roots.mjs";
+import { G_EARTH } from "./kinematics/free-fall.mjs";
+
+//#region src/physics/projectile.d.ts
+interface Launch {
+  /** Launch speed, m/s. */
+  readonly speed: number;
+  /** Launch angle above the horizontal, degrees. Negative aims below the horizontal. */
+  readonly angleDeg: number;
+  /**
+   * Launch point above the landing level, m. Zero is the level-ground case every textbook does
+   * first; a positive value is the cliff, the roof, the gun barrel 1.9 m off the ground.
+   */
+  readonly height?: number;
+  /** Gravitational acceleration, m/s². Positive; the sign is applied here. */
+  readonly g?: number;
+}
+interface Flight {
+  /** Horizontal and vertical launch velocity components. */
+  readonly launchVelocity: Components;
+  /** Time from launch until it returns to the landing level, s. */
+  readonly timeOfFlight: number;
+  /** Horizontal distance covered in that time, m. */
+  readonly range: number;
+  /** Time to the top of the arc, s. */
+  readonly timeToPeak: number;
+  /** Rise above the LAUNCH point, m. Zero when the launch aims downwards. */
+  readonly peakRise: number;
+  /** Height of the top of the arc above the LANDING level, m. */
+  readonly maxHeight: number;
+  /** Speed at the moment it lands, m/s. */
+  readonly impactSpeed: number;
+  /** Direction of travel at landing, degrees BELOW the horizontal. */
+  readonly impactAngleDeg: number;
+}
+/** The launch speed split into its horizontal and vertical parts. */
+declare const launchVelocity: (launch: Launch) => Components;
+/**
+ * Everything about one flight.
+ *
+ * The time of flight goes through the kinematics solver rather than through a closed form, because
+ * with a launch height it IS a quadratic with a root to reject, and routing it through the same
+ * code path as the level-ground case means the level-ground case cannot quietly be a different
+ * piece of physics.
+ */
+declare function flight(launch: Launch): Flight;
+/** Where the projectile is at time `t`, measured from the launch point. */
+declare function positionAt(launch: Launch, t: number): Components;
+/** How fast and which way it is going at time `t`. Horizontal never changes; that is the point. */
+declare function velocityAt(launch: Launch, t: number): Components;
+/** The arc, sampled for drawing. Always includes the landing point exactly. */
+declare function arc(launch: Launch, samples?: number): readonly Components[];
+/**
+ * Every moment the projectile is at a given height above the LAUNCH point.
+ *
+ * Usually two, and that is the interesting part: on the way up and on the way down. A lab that
+ * draws both, and a lesson that says why there are two, turns a confusing quadratic into the
+ * obvious fact that the arc is symmetric.
+ */
+declare function timeAtHeight(launch: Launch, heightAboveLaunch: number): readonly Root[];
+/**
+ * The launch angles that put a projectile a given distance away on level ground.
+ *
+ * There are normally TWO, one low and flat and one high and lobbed, and they are complementary
+ * (they add to 90°). That pair is the most under-taught fact in the topic: a mortar and a rifle
+ * hitting the same target is the same equation twice. Returns null when the target is out of
+ * range at that speed, which is the honest answer and the one a game needs.
+ */
+declare function anglesForRange(range: number, speed: number, g?: number): {
+  low: number;
+  high: number;
+} | null;
+/**
+ * The smallest launch speed that can reach a distance on level ground, and the angle that does it.
+ *
+ * `R = v² sin 2θ / g` is largest for a given speed when `sin 2θ = 1`, so the cheapest shot is
+ * always at 45° and needs `v = √(Rg)`. Worth having as its own function because "what is the
+ * minimum speed" is a standard exam question and because the answer explains why 45° is the angle
+ * everybody remembers.
+ */
+declare function minimumSpeedForRange(range: number, g?: number): {
+  speed: number;
+  angleDeg: number;
+};
+/**
+ * The launch angle at which the range equals the maximum height.
+ *
+ * `R = H` gives `tan θ = 4`, independent of speed and of gravity, which is a genuinely surprising
+ * result and a good lab question: the learner predicts whether firing harder changes the angle,
+ * and it does not.
+ */
+declare const angleWhereRangeEqualsHeight: () => number;
+/**
+ * The worked solution for a flight, as a lesson would set it out.
+ *
+ * Structured as resolve, then vertical, then horizontal, in that order and labelled as such,
+ * because that ordering IS the method. A derivation that jumps to `R = u² sin 2θ / g` gives a
+ * student a formula to memorise; this one gives them something they can redo when the question has
+ * a cliff in it and the memorised formula does not apply.
+ */
+declare function flightSteps(launch: Launch, sf?: number): Worked;
+/** The working for the peak: why the highest point is where the vertical velocity is zero. */
+declare function peakSteps(launch: Launch, sf?: number): Worked;
+//#endregion
+export { Flight, Launch, angleWhereRangeEqualsHeight, anglesForRange, arc, flight, flightSteps, launchVelocity, minimumSpeedForRange, peakSteps, positionAt, timeAtHeight, velocityAt };