@classytic/stage 0.3.0 → 0.4.0

package/dist/thermo/cycles.mjs

@@ -0,0 +1,256 @@
+import { R, gammaMonatomic, molarHeatCapacities } from "./gas.mjs";
+import { runProcess } from "./processes.mjs";
+
+//#region src/thermo/cycles.ts
+/**
+* Cycles, engines, refrigerators, and the second law.
+*
+* THE MODEL. A cycle is a list of processes that returns the gas to where it
+* started. Because internal energy and entropy are STATE functions, going all
+* the way round must leave both unchanged, and so the net work equals the net
+* heat:
+*
+*   ΣΔU = 0    ⟹    W_net = Q_in − Q_out
+*   efficiency η = W_net / Q_in = 1 − Q_out/Q_in
+*
+* For a reversible cycle between two reservoirs that becomes Carnot's result,
+* η = 1 − T_c/T_h, which is the second law with a number attached: the only way
+* to reach η = 1 is a cold reservoir at absolute zero.
+*
+* THE GENERAL CASE FIRST. `cycleSummary` takes any list of legs and works out
+* the totals, the direction, and the efficiency or coefficient of performance.
+* The named cycles below are compositions of `runProcess` that feed it. The
+* closed forms are kept as CHECKS on the general machinery rather than as the
+* way answers are produced, which is the same discipline the field integrals
+* follow: a formula that is only ever compared against is a formula that cannot
+* quietly become the source of truth.
+*
+* DIRECTION IS NOT A SETTING. Whether a cycle is an engine or a refrigerator is
+* read off the sign of the net work, not passed in. Traverse the same four legs
+* the other way round and the same code reports a refrigerator, because that is
+* what it has become.
+*
+* UNITS: SI throughout, as `processes.ts`.
+*/
+const positive = (value, what) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${what} must be positive.`);
+	return value;
+};
+/**
+* Reservoir temperatures, with the ordering checked.
+*
+* A "hot" reservoir colder than the "cold" one is not a sign error to be
+* absorbed silently: it produces an efficiency above 1, which looks like a
+* result rather than like a mistake.
+*/
+const reservoirs = (hotK, coldK) => {
+	positive(hotK, "The hot reservoir temperature");
+	positive(coldK, "The cold reservoir temperature");
+	if (coldK > hotK) throw new RangeError(`The cold reservoir (${coldK} K) is hotter than the hot one (${hotK} K), so these are the wrong way round.`);
+	return [hotK, coldK];
+};
+/**
+* Totals, direction and figures of merit for any list of legs.
+*
+* Works on a cycle assembled from `runProcess`, on one built by hand, and on
+* one that does not close, which is why the closure error is reported rather
+* than enforced: a lab that lets a student build a cycle leg by leg needs to
+* show them it has not closed yet, not refuse to draw it.
+*/
+function cycleSummary(legs) {
+	if (legs.length === 0) throw new RangeError("A cycle needs at least one leg.");
+	const WnetJ = legs.reduce((sum, l) => sum + l.W, 0);
+	const QinJ = legs.reduce((sum, l) => sum + Math.max(0, l.Q), 0);
+	const QoutJ = legs.reduce((sum, l) => sum - Math.min(0, l.Q), 0);
+	const first = legs[0].start;
+	const last = legs[legs.length - 1].end;
+	const closureError = Math.abs(last.V - first.V) / Math.abs(first.V) + Math.abs(last.P - first.P) / Math.abs(first.P);
+	const scale = Math.max(QinJ, QoutJ, 1e-30);
+	const direction = WnetJ > 1e-9 * scale ? "engine" : WnetJ < -1e-9 * scale ? "refrigerator" : "neutral";
+	return {
+		legs: [...legs],
+		WnetJ,
+		QinJ,
+		QoutJ,
+		direction,
+		efficiency: direction === "engine" && QinJ > 0 ? WnetJ / QinJ : null,
+		coefficientOfPerformance: direction === "refrigerator" ? QinJ / Math.abs(WnetJ) : null,
+		heatPumpCOP: direction === "refrigerator" ? QoutJ / Math.abs(WnetJ) : null,
+		internalEnergyResidualJ: legs.reduce((sum, l) => sum + l.dU, 0),
+		entropyResidualJ: legs.reduce((sum, l) => sum + l.dS, 0),
+		closureError
+	};
+}
+/**
+* Carnot efficiency, 1 − T_c/T_h.
+*
+* The ceiling on every heat engine working between these two temperatures,
+* whatever its working substance and however it is built. That universality is
+* the content of the second law, and it is why this depends on nothing but the
+* two temperatures.
+*/
+function carnotEfficiency(hotK, coldK) {
+	const [Th, Tc] = reservoirs(hotK, coldK);
+	return 1 - Tc / Th;
+}
+/** Efficiency from the heats alone, 1 − Q_out/Q_in: the measurable version. */
+function efficiencyFromHeat(QinJ, QoutJ) {
+	const qin = positive(QinJ, "The heat absorbed");
+	const qout = positive(QoutJ, "The heat rejected");
+	if (qout > qin) throw new RangeError("More heat rejected than absorbed, so this engine is producing negative work.");
+	return 1 - qout / qin;
+}
+/**
+* Coefficient of performance of a refrigerator, T_c/(T_h − T_c).
+*
+* Not called an efficiency, and greater than 1 in any working fridge, because
+* what you get out (heat removed from the cold space) is not the same kind of
+* thing as what you put in (work). A COP of 5 moves five joules of heat per
+* joule of electricity, and nothing is being created.
+*/
+function refrigeratorCOP(hotK, coldK) {
+	const [Th, Tc] = reservoirs(hotK, coldK);
+	if (Th === Tc) throw new RangeError("With no temperature difference the coefficient of performance is unbounded.");
+	return Tc / (Th - Tc);
+}
+/**
+* Coefficient of performance of a heat pump, T_h/(T_h − T_c).
+*
+* Exactly one more than the refrigerator's, because the heat delivered to the
+* warm end is the heat taken from the cold end PLUS the work. That is why a
+* heat pump beats a resistive heater: the electricity arrives as heat either
+* way, and the pump also brings the outside in.
+*/
+function heatPumpCOP(hotK, coldK) {
+	return refrigeratorCOP(hotK, coldK) + 1;
+}
+/**
+* Otto (petrol engine) efficiency, 1 − r^(1−γ), for a compression ratio r.
+*
+* Says compression ratio is the only thing that matters, which is true of the
+* ideal cycle and is why the real limit is knock rather than thermodynamics.
+*/
+function ottoEfficiency(compressionRatio, gamma = 7 / 5) {
+	const r = positive(compressionRatio, "The compression ratio");
+	if (r <= 1) throw new RangeError("A compression ratio must exceed 1.");
+	return 1 - r ** (1 - gamma);
+}
+/**
+* Diesel efficiency for a compression ratio r and cut-off ratio rc:
+*
+*   η = 1 − (1/r^(γ−1)) · (rc^γ − 1) / (γ(rc − 1))
+*
+* Always below an Otto cycle at the SAME compression ratio, which surprises
+* people; the diesel wins in practice because it can use a compression ratio
+* the petrol engine cannot.
+*/
+function dieselEfficiency(compressionRatio, cutoffRatio, gamma = 7 / 5) {
+	const r = positive(compressionRatio, "The compression ratio");
+	const rc = positive(cutoffRatio, "The cut-off ratio");
+	if (r <= 1) throw new RangeError("A compression ratio must exceed 1.");
+	if (rc <= 1) throw new RangeError("A cut-off ratio must exceed 1.");
+	return 1 - 1 / r ** (gamma - 1) * ((rc ** gamma - 1) / (gamma * (rc - 1)));
+}
+/**
+* A Carnot cycle starting at `(V1, Th)`: isothermal expansion V1→V2 at Th, then
+* adiabatic expansion to Tc, isothermal compression at Tc, and adiabatic
+* compression back to the start. V3 and V4 are fixed by the closure condition.
+*/
+function carnotCycle(n, Th, Tc, V1, V2, gamma = gammaMonatomic) {
+	reservoirs(Th, Tc);
+	const ratio = (Th / Tc) ** (1 / (gamma - 1));
+	const V3 = V2 * ratio;
+	const V4 = V1 * ratio;
+	const legHot = runProcess({
+		P: n * R * Th / V1,
+		V: V1,
+		n,
+		T: Th
+	}, "isothermal", { V: V2 }, gamma);
+	const legExp = runProcess(legHot.end, "adiabatic", { V: V3 }, gamma);
+	const legCold = runProcess(legExp.end, "isothermal", { V: V4 }, gamma);
+	const legComp = runProcess(legCold.end, "adiabatic", { V: V1 }, gamma);
+	const Qh = legHot.Q;
+	const Qc = -legCold.Q;
+	return {
+		legs: [
+			legHot,
+			legExp,
+			legCold,
+			legComp
+		],
+		Th,
+		Tc,
+		Qh,
+		Qc,
+		Wnet: Qh - Qc,
+		efficiency: 1 - Tc / Th
+	};
+}
+/**
+* An Otto cycle: adiabatic compression, isochoric heating (the spark),
+* adiabatic expansion (the power stroke), isochoric cooling (the exhaust).
+*
+* `compressionRatio` is V_max/V_min, and `peakTemperatureK` is how hot the
+* burning mixture gets, which is what sets the heat input.
+*/
+function ottoCycle(n, intakeK, peakTemperatureK, Vmax, compressionRatio, gamma = 7 / 5) {
+	const r = positive(compressionRatio, "The compression ratio");
+	if (r <= 1) throw new RangeError("A compression ratio must exceed 1.");
+	const Vmin = Vmax / r;
+	const compress = runProcess({
+		P: n * R * intakeK / Vmax,
+		V: Vmax,
+		n,
+		T: intakeK
+	}, "adiabatic", { V: Vmin }, gamma);
+	const spark = runProcess(compress.end, "isochoric", { T: peakTemperatureK }, gamma);
+	const power = runProcess(spark.end, "adiabatic", { V: Vmax }, gamma);
+	return [
+		compress,
+		spark,
+		power,
+		runProcess(power.end, "isochoric", { T: intakeK }, gamma)
+	];
+}
+/**
+* A Stirling cycle: isothermal expansion at Th, isochoric cooling, isothermal
+* compression at Tc, isochoric heating.
+*
+* Reaches Carnot efficiency only with a perfect regenerator, because the heat
+* dumped on the cooling leg is exactly the heat needed on the heating leg. With
+* no regenerator, `cycleSummary` counts that heat as fresh input and the
+* efficiency drops sharply, which is the honest answer and the reason the
+* regenerator was the invention.
+*/
+function stirlingCycle(n, Th, Tc, Vmin, Vmax, gamma = gammaMonatomic) {
+	reservoirs(Th, Tc);
+	const expand = runProcess({
+		P: n * R * Th / Vmin,
+		V: Vmin,
+		n,
+		T: Th
+	}, "isothermal", { V: Vmax }, gamma);
+	const cool = runProcess(expand.end, "isochoric", { T: Tc }, gamma);
+	const compress = runProcess(cool.end, "isothermal", { V: Vmin }, gamma);
+	return [
+		expand,
+		cool,
+		compress,
+		runProcess(compress.end, "isochoric", { T: Th }, gamma)
+	];
+}
+/**
+* The internal energy an ideal gas holds at a state, J, for reading a cycle's
+* corners off a p–V diagram.
+*
+* Exists so a lab can label the corners of a cycle with U as well as p, V and
+* T, which is what makes "ΔU round the loop is zero" visible rather than
+* asserted.
+*/
+function stateInternalEnergyJ(state, gamma = gammaMonatomic) {
+	return state.n * molarHeatCapacities(gamma).cv * state.T;
+}
+
+//#endregion
+export { carnotCycle, carnotEfficiency, cycleSummary, dieselEfficiency, efficiencyFromHeat, heatPumpCOP, ottoCycle, ottoEfficiency, refrigeratorCOP, stateInternalEnergyJ, stirlingCycle };

package/dist/thermo/entropy.d.mts

@@ -0,0 +1,87 @@
+import { MixtureBody } from "./calorimetry.mjs";
+
+//#region src/thermo/entropy.d.ts
+/**
+ * Entropy change on warming or cooling a body, J/K: ΔS = m·c·ln(T₂/T₁).
+ *
+ * The logarithm is the whole difference from q = m·c·ΔT, and it is there
+ * because each joule is divided by the temperature it arrives at, which is
+ * rising as it goes. A body warmed through 10 K near absolute zero gains far
+ * more entropy than the same body warmed through 10 K on a hot day.
+ */
+declare function entropyChangeWarmingJPerK(massKg: number, specificHeat: number, fromK: number, toK: number): number;
+/** Entropy change on a phase change at constant temperature, J/K: ΔS = m·L/T. */
+declare function entropyChangePhaseJPerK(massKg: number, latentHeat: number, atK: number): number;
+/**
+ * Entropy change of a reservoir that gains heat Q at temperature T, J/K.
+ *
+ * `heatJ` is signed: a reservoir that GIVES heat up loses entropy. A reservoir
+ * is by definition large enough that its temperature does not move, which is
+ * what makes this a division rather than a logarithm.
+ */
+declare function entropyChangeReservoirJPerK(heatJ: number, atK: number): number;
+/**
+ * Entropy change of an ideal gas expanding isothermally, J/K: ΔS = nR·ln(V₂/V₁).
+ *
+ * The same number whether the expansion was reversible and did work, or was a
+ * free expansion into a vacuum and did none. Entropy does not care how it got
+ * there; only the surroundings' share differs.
+ */
+declare function entropyChangeIsothermalGasJPerK(moles: number, fromV: number, toV: number): number;
+interface EntropyBalance {
+  /** Entropy lost by whatever gave the heat up, J/K (negative). */
+  sourceJPerK: number;
+  /** Entropy gained by whatever received it, J/K (positive). */
+  sinkJPerK: number;
+  /** The sum, J/K. Positive for a spontaneous transfer. */
+  totalJPerK: number;
+  /**
+   * True when the total is positive, so the transfer can happen on its own.
+   *
+   * The second law reduced to a boolean, and it is worth the field: the whole
+   * content of Clausius's statement is that this is false for heat running
+   * uphill, and a lab can now let a student drag the temperatures around and
+   * watch it flip.
+   */
+  spontaneous: boolean;
+}
+/**
+ * The entropy books for a quantity of heat moving between two reservoirs.
+ *
+ * Both halves and the sum, because the sum is the point: the hot body loses
+ * Q/T_h and the cold body gains Q/T_c, and since T_c is the smaller divisor the
+ * gain always beats the loss. Heat flowing the other way makes the total
+ * negative, which is the second law stated as an arithmetic fact rather than as
+ * a prohibition.
+ */
+declare function heatTransferEntropy(heatJ: number, fromK: number, toK: number): EntropyBalance;
+interface MixtureEntropyResult {
+  /** The equilibrium temperature the mixture reaches, °C. */
+  finalTemperatureC: number;
+  /** Each body's entropy change, J/K. */
+  bodies: {
+    label: string;
+    entropyChangeJPerK: number;
+  }[];
+  /** The total, J/K. Positive for any real mixing. */
+  totalJPerK: number;
+}
+/**
+ * The entropy generated by letting bodies at different temperatures reach
+ * equilibrium.
+ *
+ * Built on `mixtureEquilibrium`, so the final temperature is the real one
+ * including any partial melting, and each body's contribution is integrated
+ * along a reversible path to it. The total is always positive when the bodies
+ * started at different temperatures, and zero only when they were already in
+ * equilibrium, which is the cleanest numerical demonstration of the second law
+ * available at this level: nothing was wasted, no engine was involved, and
+ * entropy went up anyway.
+ *
+ * SCOPE: the per-body integral uses the specific heat of the phase each body
+ * ENDS in, so a body that changes phase on the way gets an approximate answer.
+ * Phase changes carry their own m·L/T term, which this does not yet split out.
+ */
+declare function mixtureEntropyChange(bodies: readonly MixtureBody[]): MixtureEntropyResult;
+//#endregion
+export { EntropyBalance, MixtureEntropyResult, entropyChangeIsothermalGasJPerK, entropyChangePhaseJPerK, entropyChangeReservoirJPerK, entropyChangeWarmingJPerK, heatTransferEntropy, mixtureEntropyChange };

package/dist/thermo/entropy.mjs

@@ -0,0 +1,140 @@
+import { ZERO_CELSIUS_K } from "../core/constants.mjs";
+import { mixtureEquilibrium } from "./calorimetry.mjs";
+import { R } from "./gas.mjs";
+
+//#region src/thermo/entropy.ts
+/**
+* Entropy, and the second law as an inequality you can evaluate.
+*
+* THE MODEL. Entropy change along a REVERSIBLE path is
+*
+*   ΔS = ∫ dQ / T
+*
+* and because S is a state function, that integral can be taken along any
+* reversible path between the same two states even when the real process was
+* nothing like it. That is the move that makes irreversible changes
+* computable: a free expansion does no work and transfers no heat, so ∫dQ/T
+* along what actually happened is zero, yet the entropy rises, and the way to
+* get the right answer is to integrate along a reversible isothermal expansion
+* between the same endpoints instead.
+*
+* The three cases that cover the syllabus:
+*
+*   warming a body         ΔS = m·c·ln(T₂/T₁)       (T varies, so it integrates)
+*   changing phase         ΔS = m·L / T             (T fixed, so it does not)
+*   a reservoir            ΔS = Q / T               (too big to change temperature)
+*
+* WHAT IS WORTH SHOWING. Every function here returns a signed number, and the
+* interesting results are the TOTALS: heat flowing from hot to cold gives a
+* positive total, the reverse gives a negative one, and the second law is
+* exactly the observation that only the first is ever seen. That is a
+* calculation a student can do, not a slogan, which is why the paired functions
+* below report both halves and the sum rather than just the answer.
+*
+* UNITS: SI. Entropy in J/K, temperatures in KELVIN throughout, since these are
+* all ratios or divisions and an offset scale would be meaningless.
+*/
+const positive = (value, what) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${what} must be positive.`);
+	return value;
+};
+const kelvin = (value, what = "Temperature") => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${what} must be a positive number of kelvin (got ${value}).`);
+	return value;
+};
+/**
+* Entropy change on warming or cooling a body, J/K: ΔS = m·c·ln(T₂/T₁).
+*
+* The logarithm is the whole difference from q = m·c·ΔT, and it is there
+* because each joule is divided by the temperature it arrives at, which is
+* rising as it goes. A body warmed through 10 K near absolute zero gains far
+* more entropy than the same body warmed through 10 K on a hot day.
+*/
+function entropyChangeWarmingJPerK(massKg, specificHeat, fromK, toK) {
+	return positive(massKg, "Mass") * positive(specificHeat, "Specific heat capacity") * Math.log(kelvin(toK, "The final temperature") / kelvin(fromK, "The initial temperature"));
+}
+/** Entropy change on a phase change at constant temperature, J/K: ΔS = m·L/T. */
+function entropyChangePhaseJPerK(massKg, latentHeat, atK) {
+	return positive(massKg, "Mass") * positive(latentHeat, "Latent heat") / kelvin(atK, "The transition temperature");
+}
+/**
+* Entropy change of a reservoir that gains heat Q at temperature T, J/K.
+*
+* `heatJ` is signed: a reservoir that GIVES heat up loses entropy. A reservoir
+* is by definition large enough that its temperature does not move, which is
+* what makes this a division rather than a logarithm.
+*/
+function entropyChangeReservoirJPerK(heatJ, atK) {
+	if (!Number.isFinite(heatJ)) throw new RangeError("Heat must be a finite number.");
+	return heatJ / kelvin(atK, "The reservoir temperature");
+}
+/**
+* Entropy change of an ideal gas expanding isothermally, J/K: ΔS = nR·ln(V₂/V₁).
+*
+* The same number whether the expansion was reversible and did work, or was a
+* free expansion into a vacuum and did none. Entropy does not care how it got
+* there; only the surroundings' share differs.
+*/
+function entropyChangeIsothermalGasJPerK(moles, fromV, toV) {
+	return positive(moles, "Amount") * R * Math.log(positive(toV, "The final volume") / positive(fromV, "The initial volume"));
+}
+/**
+* The entropy books for a quantity of heat moving between two reservoirs.
+*
+* Both halves and the sum, because the sum is the point: the hot body loses
+* Q/T_h and the cold body gains Q/T_c, and since T_c is the smaller divisor the
+* gain always beats the loss. Heat flowing the other way makes the total
+* negative, which is the second law stated as an arithmetic fact rather than as
+* a prohibition.
+*/
+function heatTransferEntropy(heatJ, fromK, toK) {
+	const Q = positive(heatJ, "The heat transferred");
+	const sourceJPerK = -Q / kelvin(fromK, "The source temperature");
+	const sinkJPerK = Q / kelvin(toK, "The destination temperature");
+	const totalJPerK = sourceJPerK + sinkJPerK;
+	return {
+		sourceJPerK,
+		sinkJPerK,
+		totalJPerK,
+		spontaneous: totalJPerK > 0
+	};
+}
+/**
+* The entropy generated by letting bodies at different temperatures reach
+* equilibrium.
+*
+* Built on `mixtureEquilibrium`, so the final temperature is the real one
+* including any partial melting, and each body's contribution is integrated
+* along a reversible path to it. The total is always positive when the bodies
+* started at different temperatures, and zero only when they were already in
+* equilibrium, which is the cleanest numerical demonstration of the second law
+* available at this level: nothing was wasted, no engine was involved, and
+* entropy went up anyway.
+*
+* SCOPE: the per-body integral uses the specific heat of the phase each body
+* ENDS in, so a body that changes phase on the way gets an approximate answer.
+* Phase changes carry their own m·L/T term, which this does not yet split out.
+*/
+function mixtureEntropyChange(bodies) {
+	const equilibrium = mixtureEquilibrium(bodies);
+	const finalK = equilibrium.finalTemperatureC + ZERO_CELSIUS_K;
+	const perBody = bodies.map((b, i) => {
+		const result = equilibrium.bodies[i];
+		const startK = b.temperatureC + ZERO_CELSIUS_K;
+		const phase = result.endPhase;
+		const c = phase === "solid" ? b.material.cSolid : phase === "liquid" ? b.material.cLiquid : b.material.cGas;
+		const entropyChangeJPerK = startK === finalK ? 0 : entropyChangeWarmingJPerK(b.massKg, c, startK, finalK);
+		return {
+			label: b.label,
+			entropyChangeJPerK
+		};
+	});
+	return {
+		finalTemperatureC: equilibrium.finalTemperatureC,
+		bodies: perBody,
+		totalJPerK: perBody.reduce((sum, b) => sum + b.entropyChangeJPerK, 0)
+	};
+}
+
+//#endregion
+export { entropyChangeIsothermalGasJPerK, entropyChangePhaseJPerK, entropyChangeReservoirJPerK, entropyChangeWarmingJPerK, heatTransferEntropy, mixtureEntropyChange };

package/dist/thermo/expansion.d.mts

@@ -0,0 +1,130 @@
+//#region src/thermo/expansion.d.ts
+/**
+ * Thermal expansion: how much bigger things get when they are warmed, and what
+ * happens when they are not allowed to.
+ *
+ * THE MODEL. To first order every dimension grows in proportion to its own
+ * length and to the temperature rise:
+ *
+ *   length   ΔL = L₀·α·Δθ
+ *   area     ΔA = A₀·β·Δθ      with β ≈ 2α
+ *   volume   ΔV = V₀·γ·Δθ      with γ ≈ 3α
+ *
+ * WHY β = 2α AND γ = 3α ARE NOT SEPARATE MEASUREMENTS. A square of side L has
+ * area L², and (1+αΔθ)² = 1 + 2αΔθ + (αΔθ)², so the area coefficient is twice
+ * the linear one plus a term in α² that is about 10⁻⁸ for a metal over a 100 K
+ * rise. The functions below use the EXACT powers rather than the doubled and
+ * tripled approximations, and `areaCoefficient` / `volumeCoefficient` return
+ * the textbook 2α and 3α, so a lab can show the two agreeing and then show
+ * where they part company.
+ *
+ * THE THING STUDENTS GET WRONG. A hole in a plate gets BIGGER, not smaller.
+ * Every function here takes a dimension and scales it, with no notion of
+ * "solid" or "hole", precisely because the material does not have one: the
+ * plate expands as if the hole were filled with more plate.
+ *
+ * UNITS: SI. Lengths in m, areas in m², volumes in m³, coefficients per kelvin,
+ * temperature changes in K (identical to changes in °C).
+ */
+/**
+ * Linear expansivity α, per kelvin, for materials that appear in the standard
+ * questions.
+ *
+ * Invar is in the table because it is the control: an alloy chosen to have
+ * almost no expansion, which is what makes the others' numbers mean something.
+ * The glass pair matters for the same reason, since the whole point of Pyrex is
+ * that a third of the expansion is a third of the thermal shock.
+ */
+declare const LINEAR_EXPANSIVITY: Record<string, number>;
+/** Length after a temperature change: L = L₀(1 + αΔθ). */
+declare function expandedLengthM(length0: number, alpha: number, deltaT: number): number;
+/** The change in length itself, m: ΔL = L₀·α·Δθ. */
+declare function lengthChangeM(length0: number, alpha: number, deltaT: number): number;
+/**
+ * Area after a temperature change, using the exact square rather than 2α.
+ *
+ * A = A₀(1 + αΔθ)², which is where β = 2α comes from and where it stops being
+ * quite right.
+ */
+declare function expandedAreaM2(area0: number, alpha: number, deltaT: number): number;
+/** Volume after a temperature change, using the exact cube rather than 3α. */
+declare function expandedVolumeM3(volume0: number, alpha: number, deltaT: number): number;
+/** The area expansivity β = 2α, as the textbook approximation. */
+declare const areaCoefficient: (alpha: number) => number;
+/** The volume expansivity γ = 3α, as the textbook approximation. */
+declare const volumeCoefficient: (alpha: number) => number;
+/**
+ * Density after a temperature change, kg/m³: ρ = ρ₀/(1 + γΔθ).
+ *
+ * The mass does not change and the volume does, so the density falls. This is
+ * the engine behind convection: warmed fluid is less dense, so it rises, and
+ * the buoyancy that drives every convection current is this division.
+ */
+declare function densityAfterExpansionKgM3(density0: number, volumeExpansivity: number, deltaT: number): number;
+/**
+ * The real expansivity of a liquid from the apparent one:
+ *
+ *   γ_real = γ_apparent + γ_container
+ *
+ * Measuring a liquid's expansion means watching it rise in a vessel that is
+ * also expanding, so what you see is the DIFFERENCE. Forgetting the container's
+ * share is the standard error in this experiment, and it is systematic rather
+ * than random, so no amount of repetition finds it.
+ */
+declare function realExpansivity(apparent: number, containerVolumeExpansivity: number): number;
+/**
+ * Thermal stress in a bar held rigidly while its temperature changes, Pa:
+ *
+ *   σ = E·α·Δθ
+ *
+ * Note what is NOT in it: the length. A rail a kilometre long and a bolt a
+ * centimetre long, both clamped, reach the same stress for the same temperature
+ * rise, because the strain that would have been αΔθ is the same fraction
+ * either way. That is why expansion gaps are about the same size whatever the
+ * span, and why a long bridge needs more of them rather than bigger ones.
+ */
+declare function thermalStressPa(youngsModulus: number, alpha: number, deltaT: number): number;
+interface BimetallicBend {
+  /** Radius of curvature the strip bends to, m. Infinite when it stays straight. */
+  radiusM: number;
+  /** Angle subtended by the strip, radians. */
+  angleRad: number;
+  /** Sideways deflection of the free end of a clamped strip, m. */
+  deflectionM: number;
+}
+/**
+ * A bimetallic strip's bend, for two bonded strips of EQUAL thickness and
+ * equal Young's modulus:
+ *
+ *   1/ρ = 3·(α₂ − α₁)·Δθ / (2·t)
+ *
+ * with t the TOTAL thickness of the pair. The strip bends because the two
+ * metals want different lengths and are not allowed to have them, so it curves
+ * with the faster-expanding metal on the OUTSIDE of the curve.
+ *
+ * The sign follows through: a negative Δθ bends it the other way, which is what
+ * makes the strip a switch rather than merely a warning light.
+ *
+ * SCOPE: the equal-thickness, equal-modulus case of Timoshenko's result, which
+ * is how these strips are actually made and what every textbook quotes. A pair
+ * with different moduli bends less than this predicts.
+ */
+declare function bimetallicBend(totalThicknessM: number, alphaHigh: number, alphaLow: number, deltaT: number, lengthM: number): BimetallicBend;
+/**
+ * The density of liquid water, kg/m³, between 0 °C and 100 °C.
+ *
+ * Water is the exception this whole file otherwise assumes away: its density
+ * PEAKS near 4 °C, so between 0 and 4 it contracts on warming and its expansion
+ * coefficient is negative. That anomaly is why ice floats, why a lake freezes
+ * from the top down, and why fish survive winter, so it is worth having as real
+ * data rather than as a note saying water is unusual.
+ *
+ * Uses the Thiesen-Scheel-Diesselhorst form, which fits measurement to about
+ * one part in 10⁵ across the range. A polynomial, not a physical model: it
+ * knows the shape of the curve and nothing about why.
+ */
+declare function waterDensityKgM3(celsius: number): number;
+/** The temperature at which water is densest, °C: the anomaly's turning point. */
+declare const WATER_DENSITY_PEAK_C = 3.9863;
+//#endregion
+export { BimetallicBend, LINEAR_EXPANSIVITY, WATER_DENSITY_PEAK_C, areaCoefficient, bimetallicBend, densityAfterExpansionKgM3, expandedAreaM2, expandedLengthM, expandedVolumeM3, lengthChangeM, realExpansivity, thermalStressPa, volumeCoefficient, waterDensityKgM3 };