@classytic/stage 0.2.0 → 0.4.0

package/dist/waves/springs.d.mts

@@ -0,0 +1,103 @@
+import { Worked } from "../core/worked.mjs";
+
+//#region src/waves/springs.d.ts
+/**
+ * Hooke's law: the force a spring exerts at a given extension, newtons.
+ *
+ * SIGNED, and the sign is the point: stretch a spring in the positive
+ * direction and it pulls back in the negative one. Returning |kx| would lose
+ * exactly the fact that makes the motion periodic.
+ *
+ * Valid up to the limit of proportionality. Past that a real spring keeps
+ * stretching for less force and eventually does not come back, which is
+ * `@classytic/stage/physics`'s stress-strain territory rather than this one.
+ */
+declare const springForce: (stiffness: number, extension: number) => number;
+/** The extension a given force produces, metres: x = F/k. Takes the magnitude. */
+declare const springExtension: (stiffness: number, force: number) => number;
+/**
+ * The stiffness of a spring, from how far a hanging mass stretches it:
+ * k = mg/e.
+ *
+ * This is how k is actually MEASURED, and it is the first line of most spring
+ * questions: you are told a 200 g mass stretches the spring by 10 cm, and the
+ * 19.6 N/m you need is not given to you.
+ *
+ * `extension` is the extra length caused by hanging the mass, not the length of
+ * the spring.
+ */
+declare const stiffnessFromExtension: (mass: number, extension: number, gravity?: number) => number;
+/** How far a hanging mass stretches a spring, metres: e = mg/k. The inverse of the above. */
+declare const staticExtension: (mass: number, stiffness: number, gravity?: number) => number;
+/**
+ * The period of a hanging mass, from the extension it causes: T = 2π√(e/g).
+ *
+ * The MASS HAS CANCELLED, and that is worth stopping on. Substituting k = mg/e
+ * into T = 2π√(m/k) removes m entirely, so a spring stretched 10 cm by whatever
+ * is hanging on it has a period of 0.63 s whatever that thing weighs. Hang
+ * twice the mass: it stretches twice as far, and the period is the same.
+ *
+ * It is the same cancellation that makes a pendulum period massless, arrived at
+ * from the other direction, and it turns a two-step question into one line.
+ */
+declare const springPeriodFromExtension: (extension: number, gravity?: number) => number;
+/**
+ * Stiffness from the oscillation it produces: k = mω².
+ *
+ * The bridge back from `shm` to this module, and the reason a differential
+ * equation like `4·d²x/dt² + 100x = 0` can be read off directly: it is
+ * m·x'' + k·x = 0 with m = 4 and k = 100, so ω = √(k/m) = 5 rad/s. Nothing has
+ * to be solved.
+ */
+declare const stiffnessFromAngularFrequency: (mass: number, omega: number) => number;
+/**
+ * Springs end to end: 1/k = 1/k₁ + 1/k₂ + …
+ *
+ * The combination is SOFTER than either spring alone, which is the result that
+ * surprises people. Both springs carry the whole load, and both stretch, so the
+ * extensions add while the force does not: more give for the same pull.
+ *
+ * Note this is the resistor rule upside down, because stiffness is the
+ * spring's opposition to stretching, so it plays the part of conductance.
+ * Anyone who has met resistors first tends to import the wrong one of the two
+ * formulas, which is precisely why both are named here rather than left to be
+ * remembered.
+ */
+declare function stiffnessInSeries(...stiffnesses: number[]): number;
+/**
+ * Springs side by side: k = k₁ + k₂ + …
+ *
+ * STIFFER than either alone. They share the load and stretch together, so the
+ * forces add at a common extension. A car sits on four of these.
+ */
+declare function stiffnessInParallel(...stiffnesses: number[]): number;
+/**
+ * The stiffness of a PIECE of a spring, given what fraction of the original
+ * length it is: k' = k / fraction.
+ *
+ * Stiffness goes as 1/length. Half a spring is twice as stiff, a third of a
+ * spring three times as stiff. The reason is that every coil stretches by the
+ * same amount under a given load, so fewer coils give less total extension for
+ * the same force.
+ *
+ * The check that this is right and not backwards: the pieces put back in series
+ * must return the original spring, and `springs.test.ts` asserts exactly that.
+ */
+declare function cutSpringStiffness(stiffness: number, lengthFraction: number): number;
+/**
+ * Cut a spring into pieces in a given ratio, returning each piece's stiffness.
+ *
+ * `splitSpringStiffness(60, [1, 2])` cuts a 60 N/m spring in the ratio 1:2 and
+ * gives [180, 90]: the short piece is the stiff one. The ratio is taken as
+ * lengths, and needs no normalising.
+ */
+declare function splitSpringStiffness(stiffness: number, ratio: readonly number[]): number[];
+/**
+ * The stiffness question worked: measure the extension, get k, get the period.
+ *
+ * Both routes to the period are shown, because they must agree and a learner
+ * who has only ever seen T = 2π√(m/k) does not expect the mass to drop out.
+ */
+declare function stiffnessFromExtensionSteps(mass: number, extension: number, gravity?: number, sf?: number): Worked;
+//#endregion
+export { cutSpringStiffness, splitSpringStiffness, springExtension, springForce, springPeriodFromExtension, staticExtension, stiffnessFromAngularFrequency, stiffnessFromExtension, stiffnessFromExtensionSteps, stiffnessInParallel, stiffnessInSeries };

package/dist/waves/springs.mjs

@@ -0,0 +1,176 @@
+import { calc, texSigFigs } from "../core/worked.mjs";
+import { G_EARTH } from "../physics/kinematics/free-fall.mjs";
+
+//#region src/waves/springs.ts
+/**
+* Real springs: stiffness, and where a number for it comes from.
+*
+* ## Why this is separate from `shm`
+*
+* `shm` takes ω as given and describes the motion. This module is about
+* everything that happens BEFORE that: a spring arrives as a coil with a
+* length, and a question gives you a hanging mass, or two springs bolted
+* together, or a spring that has been cut in half. Each of those is an
+* arithmetic step that produces the k which `shm` then uses.
+*
+* Keeping them apart matters because the mistakes live here. A learner who can
+* quote T = 2π√(m/k) still loses the mark by adding two stiffnesses that were
+* in series.
+*
+* ## The one relation everything else follows from
+*
+*     F = −kx
+*
+* The minus sign is the physics: the force points BACK towards the natural
+* length, which is what makes the motion oscillate rather than run away. Drop
+* it and you have described a spring that throws things.
+*
+* ## Stiffness is not a property of the material
+*
+* It is a property of the material AND the geometry. Half a spring is twice as
+* stiff, because each coil now carries the same force over half as much give.
+* That is `cutSpringStiffness`, and it is the step that makes the classic
+* "a spring is cut in the ratio 1:2" question tractable rather than magic.
+*
+* ## Units
+*
+* SI. Stiffness in newtons per metre, extension in metres, mass in kilograms,
+* force in newtons.
+*/
+const finite = (value, what) => {
+	if (!Number.isFinite(value)) throw new RangeError(`${what} must be a finite number.`);
+	return value;
+};
+const positive = (value, what) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${what} must be positive.`);
+	return value;
+};
+const everyPositive = (values, what) => {
+	if (values.length === 0) throw new RangeError(`${what} needs at least one spring.`);
+	for (const value of values) positive(value, what);
+	return values;
+};
+/**
+* Hooke's law: the force a spring exerts at a given extension, newtons.
+*
+* SIGNED, and the sign is the point: stretch a spring in the positive
+* direction and it pulls back in the negative one. Returning |kx| would lose
+* exactly the fact that makes the motion periodic.
+*
+* Valid up to the limit of proportionality. Past that a real spring keeps
+* stretching for less force and eventually does not come back, which is
+* `@classytic/stage/physics`'s stress-strain territory rather than this one.
+*/
+const springForce = (stiffness, extension) => -positive(stiffness, "A spring stiffness") * finite(extension, "An extension");
+/** The extension a given force produces, metres: x = F/k. Takes the magnitude. */
+const springExtension = (stiffness, force) => Math.abs(finite(force, "A force")) / positive(stiffness, "A spring stiffness");
+/**
+* The stiffness of a spring, from how far a hanging mass stretches it:
+* k = mg/e.
+*
+* This is how k is actually MEASURED, and it is the first line of most spring
+* questions: you are told a 200 g mass stretches the spring by 10 cm, and the
+* 19.6 N/m you need is not given to you.
+*
+* `extension` is the extra length caused by hanging the mass, not the length of
+* the spring.
+*/
+const stiffnessFromExtension = (mass, extension, gravity = G_EARTH) => positive(mass, "A mass") * positive(gravity, "A gravitational field strength") / positive(extension, "An extension");
+/** How far a hanging mass stretches a spring, metres: e = mg/k. The inverse of the above. */
+const staticExtension = (mass, stiffness, gravity = G_EARTH) => positive(mass, "A mass") * positive(gravity, "A gravitational field strength") / positive(stiffness, "A spring stiffness");
+/**
+* The period of a hanging mass, from the extension it causes: T = 2π√(e/g).
+*
+* The MASS HAS CANCELLED, and that is worth stopping on. Substituting k = mg/e
+* into T = 2π√(m/k) removes m entirely, so a spring stretched 10 cm by whatever
+* is hanging on it has a period of 0.63 s whatever that thing weighs. Hang
+* twice the mass: it stretches twice as far, and the period is the same.
+*
+* It is the same cancellation that makes a pendulum period massless, arrived at
+* from the other direction, and it turns a two-step question into one line.
+*/
+const springPeriodFromExtension = (extension, gravity = G_EARTH) => 2 * Math.PI * Math.sqrt(positive(extension, "An extension") / positive(gravity, "A gravitational field strength"));
+/**
+* Stiffness from the oscillation it produces: k = mω².
+*
+* The bridge back from `shm` to this module, and the reason a differential
+* equation like `4·d²x/dt² + 100x = 0` can be read off directly: it is
+* m·x'' + k·x = 0 with m = 4 and k = 100, so ω = √(k/m) = 5 rad/s. Nothing has
+* to be solved.
+*/
+const stiffnessFromAngularFrequency = (mass, omega) => positive(mass, "A mass") * positive(omega, "An angular frequency") ** 2;
+/**
+* Springs end to end: 1/k = 1/k₁ + 1/k₂ + …
+*
+* The combination is SOFTER than either spring alone, which is the result that
+* surprises people. Both springs carry the whole load, and both stretch, so the
+* extensions add while the force does not: more give for the same pull.
+*
+* Note this is the resistor rule upside down, because stiffness is the
+* spring's opposition to stretching, so it plays the part of conductance.
+* Anyone who has met resistors first tends to import the wrong one of the two
+* formulas, which is precisely why both are named here rather than left to be
+* remembered.
+*/
+function stiffnessInSeries(...stiffnesses) {
+	everyPositive(stiffnesses, "A spring stiffness");
+	return 1 / stiffnesses.reduce((sum, k) => sum + 1 / k, 0);
+}
+/**
+* Springs side by side: k = k₁ + k₂ + …
+*
+* STIFFER than either alone. They share the load and stretch together, so the
+* forces add at a common extension. A car sits on four of these.
+*/
+function stiffnessInParallel(...stiffnesses) {
+	everyPositive(stiffnesses, "A spring stiffness");
+	return stiffnesses.reduce((sum, k) => sum + k, 0);
+}
+/**
+* The stiffness of a PIECE of a spring, given what fraction of the original
+* length it is: k' = k / fraction.
+*
+* Stiffness goes as 1/length. Half a spring is twice as stiff, a third of a
+* spring three times as stiff. The reason is that every coil stretches by the
+* same amount under a given load, so fewer coils give less total extension for
+* the same force.
+*
+* The check that this is right and not backwards: the pieces put back in series
+* must return the original spring, and `springs.test.ts` asserts exactly that.
+*/
+function cutSpringStiffness(stiffness, lengthFraction) {
+	const k = positive(stiffness, "A spring stiffness");
+	const fraction = positive(lengthFraction, "A length fraction");
+	if (fraction > 1) throw new RangeError(`A piece cut from a spring cannot be ${fraction} of its length: a fraction is at most 1.`);
+	return k / fraction;
+}
+/**
+* Cut a spring into pieces in a given ratio, returning each piece's stiffness.
+*
+* `splitSpringStiffness(60, [1, 2])` cuts a 60 N/m spring in the ratio 1:2 and
+* gives [180, 90]: the short piece is the stiff one. The ratio is taken as
+* lengths, and needs no normalising.
+*/
+function splitSpringStiffness(stiffness, ratio) {
+	const k = positive(stiffness, "A spring stiffness");
+	everyPositive(ratio, "A ratio part");
+	const total = ratio.reduce((sum, part) => sum + part, 0);
+	return ratio.map((part) => cutSpringStiffness(k, part / total));
+}
+/**
+* The stiffness question worked: measure the extension, get k, get the period.
+*
+* Both routes to the period are shown, because they must agree and a learner
+* who has only ever seen T = 2π√(m/k) does not expect the mass to drop out.
+*/
+function stiffnessFromExtensionSteps(mass, extension, gravity = G_EARTH, sf = 3) {
+	const m = positive(mass, "A mass");
+	const e = positive(extension, "An extension");
+	const g = positive(gravity, "A gravitational field strength");
+	const k = stiffnessFromExtension(m, e, g);
+	const period = 2 * Math.PI * Math.sqrt(m / k);
+	return calc().step("kx = mg", "at rest the spring force balances the weight, so the extension measures k").step(`k = \\frac{mg}{e} = \\frac{${texSigFigs(m, sf)} \\times ${texSigFigs(g, sf)}}{${texSigFigs(e, sf)}} = ${texSigFigs(k, sf)}\\ \\mathrm{N\\,m^{-1}}`).step(`T = 2\\pi\\sqrt{\\frac{m}{k}} = ${texSigFigs(period, sf)}\\ \\mathrm{s}`, "the usual route, which needs the k we just found").step(`T = 2\\pi\\sqrt{\\frac{e}{g}} = ${texSigFigs(springPeriodFromExtension(e, g), sf)}\\ \\mathrm{s}`, "substituting k = mg/e cancels the mass entirely: the extension alone fixes the period").done(k);
+}
+
+//#endregion
+export { cutSpringStiffness, splitSpringStiffness, springExtension, springForce, springPeriodFromExtension, staticExtension, stiffnessFromAngularFrequency, stiffnessFromExtension, stiffnessFromExtensionSteps, stiffnessInParallel, stiffnessInSeries };

package/dist/waves/superposition.d.mts

@@ -0,0 +1,124 @@
+import { Wave } from "./wave.mjs";
+
+//#region src/waves/superposition.d.ts
+/** The sum of several waves at a point and time, by the principle of superposition. */
+declare function superpose(waves: readonly Wave[], x: number, t: number): number;
+/**
+ * Displacement of a standing wave: y = 2A·sin(kx)·cos(ωt).
+ *
+ * `amplitude` is that of EACH travelling wave, so the antinodes swing to twice
+ * it. That doubling is the part worth keeping explicit: a standing wave is
+ * built from two waves and its antinodes are louder than either.
+ */
+declare function standingWave(amplitude: number, wavelength: number, frequency: number, x: number, t: number): number;
+/**
+ * How a string or pipe can vibrate.
+ *
+ * `both-ends-fixed` is a string, and also a pipe closed at both ends.
+ * `both-ends-open` is an open pipe: antinodes at each end, same wavelengths as
+ * the string. `one-end-open` is a closed pipe, and it is the odd one out.
+ */
+type BoundaryKind = 'both-ends-fixed' | 'both-ends-open' | 'one-end-open';
+/**
+ * The wavelength of harmonic n, metres.
+ *
+ * A string fixed at both ends fits a whole number of HALF wavelengths, so
+ * λ = 2L/n. A pipe closed at one end has a node at the closed end and an
+ * antinode at the open one, so it fits an ODD number of QUARTER wavelengths:
+ * λ = 4L/n with n odd. That is why a closed pipe sounds an octave lower than an
+ * open one of the same length and why it is missing its even harmonics, which
+ * is most of what makes a clarinet sound like a clarinet.
+ */
+declare function harmonicWavelength(length: number, n: number, boundary?: BoundaryKind): number;
+/** The frequency of harmonic n, Hz, for a wave travelling at `speed`. */
+declare function harmonicFrequency(length: number, n: number, speed: number, boundary?: BoundaryKind): number;
+/** The harmonic numbers a boundary admits, in order, up to `count` of them. */
+declare function harmonicSeries(count: number, boundary?: BoundaryKind): number[];
+/**
+ * Node positions on [0, L] for harmonic n, metres.
+ *
+ * Nodes are where the displacement is always zero. A string fixed at both ends
+ * has one at each end, so harmonic n has n + 1 of them.
+ */
+declare function nodePositions(length: number, n: number, boundary?: BoundaryKind): number[];
+/** Antinode positions on [0, L] for harmonic n, metres: halfway between the nodes. */
+declare function antinodePositions(length: number, n: number, boundary?: BoundaryKind): number[];
+/** The distance between adjacent nodes, metres: half a wavelength, always. */
+declare const nodeSpacing: (wavelength: number) => number;
+/**
+ * The speed of a wave on a stretched string: v = √(T/μ).
+ *
+ * `tension` in newtons, `massPerLength` in kg/m. Tightening a string raises its
+ * pitch as the square ROOT of the tension, so an octave needs four times the
+ * tension, which is why instruments are strung with different gauges rather
+ * than tuned by tension alone.
+ */
+declare const stringWaveSpeed: (tension: number, massPerLength: number) => number;
+/**
+ * Beat frequency, Hz: |f₁ − f₂|.
+ *
+ * Heard as a throb rather than as two notes when the difference is small. A
+ * piano tuner listens for this going to zero, which is a far more sensitive
+ * test than comparing two pitches by ear.
+ */
+declare const beatFrequency: (f1: number, f2: number) => number;
+/**
+ * The envelope of a beat pattern at time t, as a fraction of the peak.
+ *
+ * Two equal tones add to 2A·cos(π·Δf·t)·cos(2π·f̄·t): a fast oscillation at the
+ * MEAN frequency inside a slow envelope at half the difference. The loudness
+ * peaks twice per envelope cycle, once at each extreme, which is why the beat
+ * you HEAR is at |f₁ − f₂| and not at half of it.
+ */
+declare function beatEnvelope(f1: number, f2: number, t: number): number;
+/** The displacement of two superposed tones of equal amplitude at time t. */
+declare function beatDisplacement(amplitude: number, f1: number, f2: number, t: number): number;
+interface TwoSourcePoint {
+  /** Distance from the first source, m. */
+  r1: number;
+  /** Distance from the second source, m. */
+  r2: number;
+  /** r1 − r2, m. */
+  pathDifference: number;
+  /** Combined displacement at this instant, for equal sources. */
+  displacement: number;
+  /** Standing envelope: 1 on a maximum line, 0 on a minimum line. */
+  envelope: number;
+}
+/**
+ * Two point sources, in phase, at a point in the plane.
+ *
+ * The ripple-tank calculation. `envelope` is the part that does not change with
+ * time and is therefore what makes the fixed pattern of bright and dark lines:
+ * |cos(k·Δr/2)|, one on the constructive lines and zero on the destructive
+ * ones. `displacement` is the instantaneous sum, which is what animates.
+ *
+ * Separating the two is the point. A lab that draws only the instantaneous sum
+ * shows a shimmer with no visible structure; the pattern is in the envelope.
+ */
+/**
+ * The standing ENVELOPE at a point, from the two path lengths: |cos(k·Δr/2)|.
+ *
+ * 1 on a constructive line, 0 on a destructive one, and it does not depend on
+ * time, which is why the pattern of bright and dark lines holds still.
+ *
+ * Takes the distances rather than the geometry, and returns a bare number
+ * rather than a record, because this is the function a canvas render loop calls
+ * once per pixel. `twoSourceField` is the readable version for everything else
+ * and is built from this one, so there is still a single formula.
+ */
+declare function twoSourceEnvelope(r1: number, r2: number, wavelength: number): number;
+/** The instantaneous sum at a point, from the two path lengths. The hot-path twin of the above. */
+declare function twoSourceDisplacement(r1: number, r2: number, wavelength: number, frequency: number, t: number, amplitude?: number): number;
+declare function twoSourceField(source1: {
+  x: number;
+  y: number;
+}, source2: {
+  x: number;
+  y: number;
+}, point: {
+  x: number;
+  y: number;
+}, wavelength: number, frequency: number, t: number, amplitude?: number): TwoSourcePoint;
+//#endregion
+export { BoundaryKind, TwoSourcePoint, antinodePositions, beatDisplacement, beatEnvelope, beatFrequency, harmonicFrequency, harmonicSeries, harmonicWavelength, nodePositions, nodeSpacing, standingWave, stringWaveSpeed, superpose, twoSourceDisplacement, twoSourceEnvelope, twoSourceField };

package/dist/waves/superposition.mjs

@@ -0,0 +1,196 @@
+import { angularFrequency, displacement, waveNumber } from "./wave.mjs";
+
+//#region src/waves/superposition.ts
+/**
+* Superposition: what happens where waves meet.
+*
+* ## One principle, three consequences
+*
+* The principle is that displacements ADD. Everything below is that statement
+* applied to a different pair of waves:
+*
+*   two sources, one medium   →  an interference pattern, fixed in space
+*   two waves, opposite ways  →  a STANDING wave, with nodes that never move
+*   two close frequencies     →  BEATS, a throb at |f₁ − f₂|
+*
+* No new physics enters at any step, which is worth saying because the three
+* are usually taught as three topics.
+*
+* ## The standing wave, and why it stands
+*
+*     y = 2A·sin(kx)·cos(ωt)
+*
+* The x and the t have come apart. That separation IS the difference between a
+* standing wave and a travelling one: the shape sin(kx) is fixed in space and
+* only its scale cos(ωt) changes, so the zeros stay put. In a travelling wave
+* the two are locked together inside one bracket and the zeros move along.
+*
+* A standing wave carries no net energy, because it is two equal waves carrying
+* energy in opposite directions.
+*
+* ## Units
+*
+* SI. Lengths in metres, frequencies in hertz, time in seconds.
+*/
+const finite = (value, what) => {
+	if (!Number.isFinite(value)) throw new RangeError(`${what} must be a finite number.`);
+	return value;
+};
+const positive = (value, what) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${what} must be positive.`);
+	return value;
+};
+const wholeNumber = (value, what) => {
+	if (!Number.isInteger(value) || value < 1) throw new RangeError(`${what} must be a whole number of at least 1.`);
+	return value;
+};
+/** The sum of several waves at a point and time, by the principle of superposition. */
+function superpose(waves, x, t) {
+	return waves.reduce((sum, wave) => sum + displacement(wave, x, t), 0);
+}
+/**
+* Displacement of a standing wave: y = 2A·sin(kx)·cos(ωt).
+*
+* `amplitude` is that of EACH travelling wave, so the antinodes swing to twice
+* it. That doubling is the part worth keeping explicit: a standing wave is
+* built from two waves and its antinodes are louder than either.
+*/
+function standingWave(amplitude, wavelength, frequency, x, t) {
+	return 2 * positive(amplitude, "An amplitude") * Math.sin(waveNumber(wavelength) * finite(x, "A position")) * Math.cos(angularFrequency(frequency) * finite(t, "A time"));
+}
+/**
+* The wavelength of harmonic n, metres.
+*
+* A string fixed at both ends fits a whole number of HALF wavelengths, so
+* λ = 2L/n. A pipe closed at one end has a node at the closed end and an
+* antinode at the open one, so it fits an ODD number of QUARTER wavelengths:
+* λ = 4L/n with n odd. That is why a closed pipe sounds an octave lower than an
+* open one of the same length and why it is missing its even harmonics, which
+* is most of what makes a clarinet sound like a clarinet.
+*/
+function harmonicWavelength(length, n, boundary = "both-ends-fixed") {
+	const L = positive(length, "A length");
+	const order = wholeNumber(n, "A harmonic number");
+	if (boundary === "one-end-open") {
+		if (order % 2 === 0) throw new RangeError(`A pipe closed at one end has no harmonic ${order}: only the odd harmonics fit, which is why it sounds hollow.`);
+		return 4 * L / order;
+	}
+	return 2 * L / order;
+}
+/** The frequency of harmonic n, Hz, for a wave travelling at `speed`. */
+function harmonicFrequency(length, n, speed, boundary = "both-ends-fixed") {
+	return positive(speed, "A wave speed") / harmonicWavelength(length, n, boundary);
+}
+/** The harmonic numbers a boundary admits, in order, up to `count` of them. */
+function harmonicSeries(count, boundary = "both-ends-fixed") {
+	const howMany = wholeNumber(count, "A count of harmonics");
+	const step = boundary === "one-end-open" ? 2 : 1;
+	return Array.from({ length: howMany }, (_, i) => 1 + i * step);
+}
+/**
+* Node positions on [0, L] for harmonic n, metres.
+*
+* Nodes are where the displacement is always zero. A string fixed at both ends
+* has one at each end, so harmonic n has n + 1 of them.
+*/
+function nodePositions(length, n, boundary = "both-ends-fixed") {
+	const L = positive(length, "A length");
+	const spacing = harmonicWavelength(L, n, boundary) / 2;
+	const start = boundary === "both-ends-open" ? spacing / 2 : 0;
+	const out = [];
+	for (let x = start; x <= L + 1e-9; x += spacing) out.push(Math.min(x, L));
+	return out;
+}
+/** Antinode positions on [0, L] for harmonic n, metres: halfway between the nodes. */
+function antinodePositions(length, n, boundary = "both-ends-fixed") {
+	const L = positive(length, "A length");
+	const spacing = harmonicWavelength(L, n, boundary) / 2;
+	const start = boundary === "both-ends-open" ? 0 : spacing / 2;
+	const out = [];
+	for (let x = start; x <= L + 1e-9; x += spacing) out.push(Math.min(x, L));
+	return out;
+}
+/** The distance between adjacent nodes, metres: half a wavelength, always. */
+const nodeSpacing = (wavelength) => positive(wavelength, "A wavelength") / 2;
+/**
+* The speed of a wave on a stretched string: v = √(T/μ).
+*
+* `tension` in newtons, `massPerLength` in kg/m. Tightening a string raises its
+* pitch as the square ROOT of the tension, so an octave needs four times the
+* tension, which is why instruments are strung with different gauges rather
+* than tuned by tension alone.
+*/
+const stringWaveSpeed = (tension, massPerLength) => Math.sqrt(positive(tension, "A tension") / positive(massPerLength, "A mass per unit length"));
+/**
+* Beat frequency, Hz: |f₁ − f₂|.
+*
+* Heard as a throb rather than as two notes when the difference is small. A
+* piano tuner listens for this going to zero, which is a far more sensitive
+* test than comparing two pitches by ear.
+*/
+const beatFrequency = (f1, f2) => Math.abs(positive(f1, "A frequency") - positive(f2, "A frequency"));
+/**
+* The envelope of a beat pattern at time t, as a fraction of the peak.
+*
+* Two equal tones add to 2A·cos(π·Δf·t)·cos(2π·f̄·t): a fast oscillation at the
+* MEAN frequency inside a slow envelope at half the difference. The loudness
+* peaks twice per envelope cycle, once at each extreme, which is why the beat
+* you HEAR is at |f₁ − f₂| and not at half of it.
+*/
+function beatEnvelope(f1, f2, t) {
+	const difference = positive(f1, "A frequency") - positive(f2, "A frequency");
+	return Math.abs(Math.cos(Math.PI * difference * finite(t, "A time")));
+}
+/** The displacement of two superposed tones of equal amplitude at time t. */
+function beatDisplacement(amplitude, f1, f2, t) {
+	const A = positive(amplitude, "An amplitude");
+	const time = finite(t, "A time");
+	return A * Math.sin(2 * Math.PI * positive(f1, "A frequency") * time) + A * Math.sin(2 * Math.PI * positive(f2, "A frequency") * time);
+}
+/**
+* Two point sources, in phase, at a point in the plane.
+*
+* The ripple-tank calculation. `envelope` is the part that does not change with
+* time and is therefore what makes the fixed pattern of bright and dark lines:
+* |cos(k·Δr/2)|, one on the constructive lines and zero on the destructive
+* ones. `displacement` is the instantaneous sum, which is what animates.
+*
+* Separating the two is the point. A lab that draws only the instantaneous sum
+* shows a shimmer with no visible structure; the pattern is in the envelope.
+*/
+/**
+* The standing ENVELOPE at a point, from the two path lengths: |cos(k·Δr/2)|.
+*
+* 1 on a constructive line, 0 on a destructive one, and it does not depend on
+* time, which is why the pattern of bright and dark lines holds still.
+*
+* Takes the distances rather than the geometry, and returns a bare number
+* rather than a record, because this is the function a canvas render loop calls
+* once per pixel. `twoSourceField` is the readable version for everything else
+* and is built from this one, so there is still a single formula.
+*/
+function twoSourceEnvelope(r1, r2, wavelength) {
+	return Math.abs(Math.cos(waveNumber(wavelength) * (r1 - r2) / 2));
+}
+/** The instantaneous sum at a point, from the two path lengths. The hot-path twin of the above. */
+function twoSourceDisplacement(r1, r2, wavelength, frequency, t, amplitude = 1) {
+	const k = waveNumber(wavelength);
+	const phase = angularFrequency(frequency) * t;
+	return amplitude * (Math.sin(k * r1 - phase) + Math.sin(k * r2 - phase));
+}
+function twoSourceField(source1, source2, point, wavelength, frequency, t, amplitude = 1) {
+	const A = positive(amplitude, "An amplitude");
+	const r1 = Math.hypot(point.x - source1.x, point.y - source1.y);
+	const r2 = Math.hypot(point.x - source2.x, point.y - source2.y);
+	const time = finite(t, "A time");
+	return {
+		r1,
+		r2,
+		pathDifference: r1 - r2,
+		displacement: twoSourceDisplacement(r1, r2, wavelength, frequency, time, A),
+		envelope: twoSourceEnvelope(r1, r2, wavelength)
+	};
+}
+
+//#endregion
+export { antinodePositions, beatDisplacement, beatEnvelope, beatFrequency, harmonicFrequency, harmonicSeries, harmonicWavelength, nodePositions, nodeSpacing, standingWave, stringWaveSpeed, superpose, twoSourceDisplacement, twoSourceEnvelope, twoSourceField };