@classytic/stage 0.2.0 → 0.4.0

package/dist/thermo/processes.d.mts

@@ -0,0 +1,95 @@
+//#region src/thermo/processes.d.ts
+/**
+ * Quasi-static processes on an ideal gas, and the first law along each.
+ *
+ * THE MODEL. One ideal gas, pV = nRT, with a heat-capacity ratio γ = Cp/Cv. The
+ * first law ΔU = Q − W holds on every leg, with the sign convention that W is
+ * work done BY the gas and Q is heat added TO it:
+ *
+ *   isothermal  T const   pV = const      W = nRT·ln(V₂/V₁)   Q = W        ΔU = 0
+ *   adiabatic   Q = 0     pVᵞ = const     W = (p₁V₁−p₂V₂)/(γ−1) = −ΔU      ΔS = 0
+ *   isobaric    p const   V/T = const     W = pΔV             Q = nCpΔT
+ *   isochoric   V const   p/T = const     W = 0               Q = ΔU = nCvΔT
+ *   linear      a straight line on the p–V diagram; W is the trapezium area
+ *
+ * WHY `linear` IS HERE. The four named processes are the ones with closed
+ * forms, but the cycles students are actually given are drawn on a p–V diagram
+ * with straight legs that are none of them. Without it, the commonest exercise
+ * in the topic ("complete the Q, W, ΔU table for A→B→C→A") cannot be expressed
+ * at all, and every lab has to compute its own trapezium.
+ *
+ * THE METHOD. Closed forms wherever one exists, because they are exact and they
+ * are what the answer is checked against. `linear` integrates ∫p dV by the
+ * trapezium rule over the sampled path, which is EXACT for a straight line
+ * rather than merely convergent: the integrand is a first-degree polynomial in
+ * V and the trapezium rule is exact to first degree. Q then comes from the
+ * first law rather than from a separate formula, which is the only way to keep
+ * the three quantities consistent on a path that has no heat-capacity of its
+ * own.
+ *
+ * UNITS: SI. Pressure in pascals, volume in m³, temperature in kelvin, energy
+ * in joules, entropy in J/K.
+ */
+type ProcessKind = 'isothermal' | 'adiabatic' | 'isobaric' | 'isochoric' | 'linear';
+interface GasState {
+  /** Pressure, Pa. */
+  P: number;
+  /** Volume, m³. */
+  V: number;
+  /** Temperature, K. */
+  T: number;
+  /** Amount, mol. */
+  n: number;
+}
+interface ProcessResult {
+  kind: ProcessKind;
+  start: GasState;
+  end: GasState;
+  /** Sampled states from start to end, for drawing the p–V curve. */
+  path: GasState[];
+  /** Work done BY the gas, J ( = ∫p dV, the area under the p–V curve). */
+  W: number;
+  /** Heat added TO the gas, J. */
+  Q: number;
+  /** Change in internal energy, J ( = nCvΔT). */
+  dU: number;
+  /** Change in entropy, J/K. */
+  dS: number;
+}
+/**
+ * Run one quasi-static process from `start` to a target.
+ *
+ * Give exactly one target coordinate the process can reach: a target volume for
+ * an isothermal or adiabatic expansion, a target temperature for isobaric or
+ * isochoric heating. `linear` is the exception and needs a full end state,
+ * since a straight line on the p–V diagram is fixed by its two ends and by
+ * nothing less.
+ */
+declare function runProcess(start: GasState, kind: ProcessKind, target: {
+  V?: number;
+  P?: number;
+  T?: number;
+}, gamma?: number, samples?: number): ProcessResult;
+/**
+ * Work done by the gas along an arbitrary sampled path, J, by the trapezium
+ * rule over ∫p dV.
+ *
+ * For a path that came from somewhere other than `runProcess`: a measured
+ * indicator diagram, a path a student dragged out by hand, a cycle assembled
+ * from points. The sign follows the direction of travel, so a loop traversed
+ * clockwise gives positive net work and anticlockwise gives negative, which is
+ * the engine-versus-refrigerator distinction and not a convention to be fixed
+ * up afterwards.
+ */
+declare function workAlongPathJ(path: readonly GasState[]): number;
+/**
+ * The first law as a check rather than as a calculation: returns how far
+ * Q − W − ΔU is from zero, in joules.
+ *
+ * Exposed so a lab can SHOW conservation holding instead of asserting it in a
+ * test the student never sees. A number that is not zero here is a bug in the
+ * kernel, and it should be visible as one.
+ */
+declare function firstLawResidualJ(result: ProcessResult): number;
+//#endregion
+export { GasState, ProcessKind, ProcessResult, firstLawResidualJ, runProcess, workAlongPathJ };

package/dist/thermo/processes.mjs

@@ -0,0 +1,154 @@
+import { R, gammaMonatomic, molarHeatCapacities } from "./gas.mjs";
+
+//#region src/thermo/processes.ts
+/**
+* Quasi-static processes on an ideal gas, and the first law along each.
+*
+* THE MODEL. One ideal gas, pV = nRT, with a heat-capacity ratio γ = Cp/Cv. The
+* first law ΔU = Q − W holds on every leg, with the sign convention that W is
+* work done BY the gas and Q is heat added TO it:
+*
+*   isothermal  T const   pV = const      W = nRT·ln(V₂/V₁)   Q = W        ΔU = 0
+*   adiabatic   Q = 0     pVᵞ = const     W = (p₁V₁−p₂V₂)/(γ−1) = −ΔU      ΔS = 0
+*   isobaric    p const   V/T = const     W = pΔV             Q = nCpΔT
+*   isochoric   V const   p/T = const     W = 0               Q = ΔU = nCvΔT
+*   linear      a straight line on the p–V diagram; W is the trapezium area
+*
+* WHY `linear` IS HERE. The four named processes are the ones with closed
+* forms, but the cycles students are actually given are drawn on a p–V diagram
+* with straight legs that are none of them. Without it, the commonest exercise
+* in the topic ("complete the Q, W, ΔU table for A→B→C→A") cannot be expressed
+* at all, and every lab has to compute its own trapezium.
+*
+* THE METHOD. Closed forms wherever one exists, because they are exact and they
+* are what the answer is checked against. `linear` integrates ∫p dV by the
+* trapezium rule over the sampled path, which is EXACT for a straight line
+* rather than merely convergent: the integrand is a first-degree polynomial in
+* V and the trapezium rule is exact to first degree. Q then comes from the
+* first law rather than from a separate formula, which is the only way to keep
+* the three quantities consistent on a path that has no heat-capacity of its
+* own.
+*
+* UNITS: SI. Pressure in pascals, volume in m³, temperature in kelvin, energy
+* in joules, entropy in J/K.
+*/
+/** State completed from any two of (p,V,T) via pV = nRT. */
+const fromPV = (P, V, n) => ({
+	P,
+	V,
+	n,
+	T: P * V / (n * R)
+});
+/**
+* Run one quasi-static process from `start` to a target.
+*
+* Give exactly one target coordinate the process can reach: a target volume for
+* an isothermal or adiabatic expansion, a target temperature for isobaric or
+* isochoric heating. `linear` is the exception and needs a full end state,
+* since a straight line on the p–V diagram is fixed by its two ends and by
+* nothing less.
+*/
+function runProcess(start, kind, target, gamma = gammaMonatomic, samples = 64) {
+	const { n } = start;
+	const { cv: Cv, cp: Cp } = molarHeatCapacities(gamma);
+	let end;
+	if (kind === "isothermal") {
+		const T = start.T;
+		const V2 = target.V ?? (target.P != null ? n * R * T / target.P : start.V);
+		end = fromPV(n * R * T / V2, V2, n);
+	} else if (kind === "adiabatic") {
+		const K = start.P * start.V ** gamma;
+		const V2 = target.V ?? (target.T != null ? start.V * (start.T / target.T) ** (1 / (gamma - 1)) : start.V);
+		end = fromPV(K / V2 ** gamma, V2, n);
+	} else if (kind === "isobaric") {
+		const P = start.P;
+		end = fromPV(P, target.V ?? (target.T != null ? n * R * target.T / P : start.V), n);
+	} else if (kind === "linear") {
+		if (target.P == null || target.V == null) throw new RangeError("A linear leg on the p–V diagram is fixed by its two ends, so it needs both a target pressure and a target volume.");
+		end = fromPV(target.P, target.V, n);
+	} else {
+		const V = start.V;
+		end = fromPV(target.P ?? (target.T != null ? n * R * target.T / V : start.P), V, n);
+	}
+	const path = [];
+	for (let i = 0; i <= samples; i++) {
+		const u = i / samples;
+		let s;
+		if (kind === "isochoric") s = fromPV(start.P + (end.P - start.P) * u, start.V, n);
+		else {
+			const V = start.V + (end.V - start.V) * u;
+			if (kind === "isothermal") s = fromPV(n * R * start.T / V, V, n);
+			else if (kind === "adiabatic") s = fromPV(start.P * start.V ** gamma / V ** gamma, V, n);
+			else if (kind === "linear") s = fromPV(start.P + (end.P - start.P) * u, V, n);
+			else s = fromPV(start.P, V, n);
+		}
+		path.push(s);
+	}
+	const dU = n * Cv * (end.T - start.T);
+	let W, Q, dS;
+	if (kind === "isothermal") {
+		W = n * R * start.T * Math.log(end.V / start.V);
+		Q = W;
+		dS = n * R * Math.log(end.V / start.V);
+	} else if (kind === "adiabatic") {
+		W = (start.P * start.V - end.P * end.V) / (gamma - 1);
+		Q = 0;
+		dS = 0;
+	} else if (kind === "isobaric") {
+		W = start.P * (end.V - start.V);
+		Q = n * Cp * (end.T - start.T);
+		dS = n * Cp * Math.log(end.T / start.T);
+	} else if (kind === "linear") {
+		W = .5 * (start.P + end.P) * (end.V - start.V);
+		Q = dU + W;
+		dS = n * Cv * Math.log(end.T / start.T) + n * R * Math.log(end.V / start.V);
+	} else {
+		W = 0;
+		Q = dU;
+		dS = n * Cv * Math.log(end.T / start.T);
+	}
+	return {
+		kind,
+		start,
+		end,
+		path,
+		W,
+		Q,
+		dU,
+		dS
+	};
+}
+/**
+* Work done by the gas along an arbitrary sampled path, J, by the trapezium
+* rule over ∫p dV.
+*
+* For a path that came from somewhere other than `runProcess`: a measured
+* indicator diagram, a path a student dragged out by hand, a cycle assembled
+* from points. The sign follows the direction of travel, so a loop traversed
+* clockwise gives positive net work and anticlockwise gives negative, which is
+* the engine-versus-refrigerator distinction and not a convention to be fixed
+* up afterwards.
+*/
+function workAlongPathJ(path) {
+	let total = 0;
+	for (let i = 1; i < path.length; i++) {
+		const a = path[i - 1];
+		const b = path[i];
+		total += .5 * (a.P + b.P) * (b.V - a.V);
+	}
+	return total;
+}
+/**
+* The first law as a check rather than as a calculation: returns how far
+* Q − W − ΔU is from zero, in joules.
+*
+* Exposed so a lab can SHOW conservation holding instead of asserting it in a
+* test the student never sees. A number that is not zero here is a bug in the
+* kernel, and it should be visible as one.
+*/
+function firstLawResidualJ(result) {
+	return result.Q - result.W - result.dU;
+}
+
+//#endregion
+export { firstLawResidualJ, runProcess, workAlongPathJ };

package/dist/thermo/temperature.d.mts

@@ -0,0 +1,174 @@
+//#region src/thermo/temperature.d.ts
+/**
+ * Thermometry: temperature scales, and the thermometric property that any
+ * thermometer actually measures.
+ *
+ * THE MODEL. A thermometer never measures temperature. It measures some other
+ * quantity X that varies with it: the length of a mercury column, the pressure
+ * of a fixed volume of gas, the resistance of a platinum wire, the emf across a
+ * junction of two metals. Assume X is LINEAR in temperature, pin it at two
+ * reproducible fixed points, and the scale follows:
+ *
+ *     θ            X  −  X_ice
+ *   ───── = ─────────────────────        (θ in °C)
+ *    100      X_steam − X_ice
+ *
+ * Every scale in the table below is the same statement with a different pair of
+ * numbers at the fixed points, which is why the textbook chain
+ *
+ *     C/5 = (F−32)/9 = (K−273.15)/5 = (Rn−492)/9 = R/4
+ *
+ * holds: each term is the same fraction of the same interval.
+ *
+ * WHAT MAKES A SCALE. A scale is affine in thermodynamic temperature, so two
+ * numbers fix it: how many of its degrees span one kelvin, and what it reads at
+ * absolute zero. Ice and steam points are DERIVED from those here rather than
+ * stored beside them, because a stored pair can drift out of step with the
+ * conversion that is supposed to reproduce it.
+ *
+ * SCOPE. Linear thermometry only. A real platinum resistance thermometer is
+ * quadratic and a thermocouple is worse; both have their own functions below,
+ * and the difference between them and the linear assumption is the reason
+ * different thermometers disagree away from the fixed points.
+ *
+ * Units: temperatures carry their scale explicitly. Anything named `...K` is
+ * kelvin, `...C` is Celsius. The thermometric property X is unitless here
+ * because the ratio cancels it.
+ */
+type TemperatureScale = 'celsius' | 'fahrenheit' | 'kelvin' | 'rankine' | 'reaumur';
+interface ScaleDefinition {
+  name: string;
+  /** The degree symbol as written, e.g. '°C', 'K'. */
+  symbol: string;
+  /** How many of this scale's degrees span one kelvin. */
+  degreesPerKelvin: number;
+  /** What this scale reads at absolute zero. */
+  absoluteZeroReading: number;
+  /** True for a scale whose zero IS absolute zero, so ratios of readings mean something. */
+  absolute: boolean;
+}
+/**
+ * The five scales, each defined by its slope against kelvin and its reading at
+ * absolute zero.
+ *
+ * Réaumur and Rankine are here because they appear in the fixed-point tables
+ * students are asked to complete, not because anyone uses them.
+ */
+declare const TEMPERATURE_SCALES: Record<TemperatureScale, ScaleDefinition>;
+/** A reading on any scale, as thermodynamic temperature in kelvin. */
+declare function toKelvin(reading: number, scale: TemperatureScale): number;
+/** Thermodynamic temperature in kelvin, as a reading on any scale. */
+declare function fromKelvin(kelvin: number, scale: TemperatureScale): number;
+/**
+ * Convert a temperature READING between scales, offsets included.
+ *
+ * This is the one to use for "a fever of 102 °F is what in Celsius". It is the
+ * WRONG one for "a rise of 10 °F is what in Celsius" — see
+ * `convertTemperatureInterval`.
+ */
+declare function convertTemperature(value: number, from: TemperatureScale, to: TemperatureScale): number;
+/**
+ * Convert a temperature DIFFERENCE between scales: slope only, no offset.
+ *
+ * Split out from `convertTemperature` because running a difference through the
+ * offset is the most common temperature mistake there is, and it is silent: a
+ * 10 °C rise comes back as 50 °F instead of 18 °F, and 50 is a perfectly
+ * plausible-looking number. Separate functions make the caller say which they
+ * meant.
+ */
+declare function convertTemperatureInterval(delta: number, from: TemperatureScale, to: TemperatureScale): number;
+/** What a scale reads at the ice point, derived rather than tabulated. */
+declare const icePointOn: (scale: TemperatureScale) => number;
+/** What a scale reads at the steam point, derived rather than tabulated. */
+declare const steamPointOn: (scale: TemperatureScale) => number;
+/** The number of this scale's degrees between the ice and steam points. */
+declare const fundamentalInterval: (scale: TemperatureScale) => number;
+/**
+ * The reading at which two scales agree, or `null` when they never do.
+ *
+ * Answers "at what temperature do the Celsius and Fahrenheit thermometers show
+ * the same number" (−40) directly, instead of by setting up the equation by
+ * hand each time. Two scales with equal slope and different zeros are parallel
+ * and never meet, which is the `null`: Celsius and Kelvin never read alike.
+ */
+declare function scaleReadingsAgree(a: TemperatureScale, b: TemperatureScale): number | null;
+interface FixedPointCalibration {
+  /** The thermometric property read at the unknown temperature. */
+  x: number;
+  /** The same property read in melting ice. */
+  xIce: number;
+  /** The same property read in steam at standard pressure. */
+  xSteam: number;
+}
+/**
+ * Temperature from any thermometric property, by linear interpolation between
+ * the two fixed points.
+ *
+ * Deliberately unitless in X: the ratio cancels it, so the SAME function reads
+ * a mercury column in centimetres, a gas pressure in N/m², a resistance in ohms
+ * and a thermocouple emf in millivolts. That cancellation is the physics, and
+ * writing one function per instrument would hide it.
+ *
+ * Throws when the two fixed points coincide, because a property that does not
+ * change between ice and steam is not a thermometric property and the
+ * interpolation would be a division by zero dressed up as a temperature.
+ */
+declare function thermometricTemperatureC({
+  x,
+  xIce,
+  xSteam
+}: FixedPointCalibration): number;
+/** The inverse: what the property reads at a given Celsius temperature. */
+declare function thermometricValue(celsius: number, xIce: number, xSteam: number): number;
+/**
+ * Temperature from a thermometer calibrated at the triple point alone, in
+ * kelvin: T = 273.16 · X / X_triple.
+ *
+ * This is the constant-volume gas thermometer's defining relation, and it needs
+ * ONE fixed point rather than two because it uses a property that is
+ * proportional to thermodynamic temperature rather than merely linear in it.
+ * Pressure at fixed volume extrapolates to zero at absolute zero, so the origin
+ * is the second point and does not have to be measured.
+ *
+ * Throws on a non-positive `xTriple`, and on a negative `x`: a gas pressure
+ * below zero is not a cold reading, it is a broken instrument.
+ */
+declare function triplePointTemperatureK(x: number, xTriple: number): number;
+/**
+ * Resistance of a metal thermometer at θ °C, to second order:
+ *
+ *     R_θ = R_0 · (1 + a·θ + b·θ²)
+ *
+ * Pass `b = 0` for the linear model. The quadratic term is why a platinum
+ * thermometer and a mercury one, both correct at 0 °C and 100 °C, disagree at
+ * 50 °C: the curvature is real, and the linear scale is the chord across it.
+ */
+declare function resistanceAtC(r0: number, a: number, theta: number, b?: number): number;
+/**
+ * Thermocouple emf against the cold junction, in the standard quadratic form:
+ *
+ *     E = a·θ + b·θ²
+ *
+ * Kept as a named function rather than inlined because the two temperatures
+ * that fall out of it, below, are the whole reason a thermocouple has a usable
+ * range at all.
+ */
+declare function thermocoupleEmf(theta: number, a: number, b: number): number;
+/**
+ * The NEUTRAL temperature, where the emf peaks: θ_n = −a / 2b.
+ *
+ * Past it the emf falls again, so a single emf reading matches two
+ * temperatures and the thermocouple stops being a thermometer. That is the
+ * practical limit of the instrument, and it is a property of the metal pair
+ * rather than of the circuit.
+ */
+declare function thermocoupleNeutralTemperatureC(a: number, b: number): number;
+/**
+ * The INVERSION temperature, where the emf returns to zero: θ_i = −a / b.
+ *
+ * Exactly twice the neutral temperature when the cold junction is at 0 °C,
+ * which is the check a student is usually asked to make.
+ */
+declare function thermocoupleInversionTemperatureC(a: number, b: number): number;
+//#endregion
+export { FixedPointCalibration, ScaleDefinition, TEMPERATURE_SCALES, TemperatureScale, convertTemperature, convertTemperatureInterval, fromKelvin, fundamentalInterval, icePointOn, resistanceAtC, scaleReadingsAgree, steamPointOn, thermocoupleEmf, thermocoupleInversionTemperatureC, thermocoupleNeutralTemperatureC, thermometricTemperatureC, thermometricValue, toKelvin, triplePointTemperatureK };

package/dist/thermo/temperature.mjs

@@ -0,0 +1,236 @@
+import { WATER_TRIPLE_POINT_K, ZERO_CELSIUS_K } from "../core/constants.mjs";
+
+//#region src/thermo/temperature.ts
+/**
+* Thermometry: temperature scales, and the thermometric property that any
+* thermometer actually measures.
+*
+* THE MODEL. A thermometer never measures temperature. It measures some other
+* quantity X that varies with it: the length of a mercury column, the pressure
+* of a fixed volume of gas, the resistance of a platinum wire, the emf across a
+* junction of two metals. Assume X is LINEAR in temperature, pin it at two
+* reproducible fixed points, and the scale follows:
+*
+*     θ            X  −  X_ice
+*   ───── = ─────────────────────        (θ in °C)
+*    100      X_steam − X_ice
+*
+* Every scale in the table below is the same statement with a different pair of
+* numbers at the fixed points, which is why the textbook chain
+*
+*     C/5 = (F−32)/9 = (K−273.15)/5 = (Rn−492)/9 = R/4
+*
+* holds: each term is the same fraction of the same interval.
+*
+* WHAT MAKES A SCALE. A scale is affine in thermodynamic temperature, so two
+* numbers fix it: how many of its degrees span one kelvin, and what it reads at
+* absolute zero. Ice and steam points are DERIVED from those here rather than
+* stored beside them, because a stored pair can drift out of step with the
+* conversion that is supposed to reproduce it.
+*
+* SCOPE. Linear thermometry only. A real platinum resistance thermometer is
+* quadratic and a thermocouple is worse; both have their own functions below,
+* and the difference between them and the linear assumption is the reason
+* different thermometers disagree away from the fixed points.
+*
+* Units: temperatures carry their scale explicitly. Anything named `...K` is
+* kelvin, `...C` is Celsius. The thermometric property X is unitless here
+* because the ratio cancels it.
+*/
+/**
+* The five scales, each defined by its slope against kelvin and its reading at
+* absolute zero.
+*
+* Réaumur and Rankine are here because they appear in the fixed-point tables
+* students are asked to complete, not because anyone uses them.
+*/
+const TEMPERATURE_SCALES = {
+	celsius: {
+		name: "Celsius",
+		symbol: "°C",
+		degreesPerKelvin: 1,
+		absoluteZeroReading: -ZERO_CELSIUS_K,
+		absolute: false
+	},
+	fahrenheit: {
+		name: "Fahrenheit",
+		symbol: "°F",
+		degreesPerKelvin: 1.8,
+		absoluteZeroReading: -459.67,
+		absolute: false
+	},
+	kelvin: {
+		name: "kelvin",
+		symbol: "K",
+		degreesPerKelvin: 1,
+		absoluteZeroReading: 0,
+		absolute: true
+	},
+	rankine: {
+		name: "Rankine",
+		symbol: "°Rn",
+		degreesPerKelvin: 1.8,
+		absoluteZeroReading: 0,
+		absolute: true
+	},
+	reaumur: {
+		name: "Réaumur",
+		symbol: "°R",
+		degreesPerKelvin: .8,
+		absoluteZeroReading: -218.52,
+		absolute: false
+	}
+};
+const definitionFor = (scale) => {
+	const found = TEMPERATURE_SCALES[scale];
+	if (!found) throw new RangeError(`Unknown temperature scale "${String(scale)}".`);
+	return found;
+};
+const finite = (value, what) => {
+	if (!Number.isFinite(value)) throw new RangeError(`${what} must be a finite number.`);
+	return value;
+};
+/** A reading on any scale, as thermodynamic temperature in kelvin. */
+function toKelvin(reading, scale) {
+	const s = definitionFor(scale);
+	return (finite(reading, "A temperature reading") - s.absoluteZeroReading) / s.degreesPerKelvin;
+}
+/** Thermodynamic temperature in kelvin, as a reading on any scale. */
+function fromKelvin(kelvin, scale) {
+	const s = definitionFor(scale);
+	return finite(kelvin, "A temperature in kelvin") * s.degreesPerKelvin + s.absoluteZeroReading;
+}
+/**
+* Convert a temperature READING between scales, offsets included.
+*
+* This is the one to use for "a fever of 102 °F is what in Celsius". It is the
+* WRONG one for "a rise of 10 °F is what in Celsius" — see
+* `convertTemperatureInterval`.
+*/
+function convertTemperature(value, from, to) {
+	return fromKelvin(toKelvin(value, from), to);
+}
+/**
+* Convert a temperature DIFFERENCE between scales: slope only, no offset.
+*
+* Split out from `convertTemperature` because running a difference through the
+* offset is the most common temperature mistake there is, and it is silent: a
+* 10 °C rise comes back as 50 °F instead of 18 °F, and 50 is a perfectly
+* plausible-looking number. Separate functions make the caller say which they
+* meant.
+*/
+function convertTemperatureInterval(delta, from, to) {
+	return finite(delta, "A temperature interval") / definitionFor(from).degreesPerKelvin * definitionFor(to).degreesPerKelvin;
+}
+/** What a scale reads at the ice point, derived rather than tabulated. */
+const icePointOn = (scale) => fromKelvin(ZERO_CELSIUS_K, scale);
+/** What a scale reads at the steam point, derived rather than tabulated. */
+const steamPointOn = (scale) => fromKelvin(ZERO_CELSIUS_K + 100, scale);
+/** The number of this scale's degrees between the ice and steam points. */
+const fundamentalInterval = (scale) => steamPointOn(scale) - icePointOn(scale);
+/**
+* The reading at which two scales agree, or `null` when they never do.
+*
+* Answers "at what temperature do the Celsius and Fahrenheit thermometers show
+* the same number" (−40) directly, instead of by setting up the equation by
+* hand each time. Two scales with equal slope and different zeros are parallel
+* and never meet, which is the `null`: Celsius and Kelvin never read alike.
+*/
+function scaleReadingsAgree(a, b) {
+	const sa = definitionFor(a);
+	const sb = definitionFor(b);
+	const slopeGap = sa.degreesPerKelvin - sb.degreesPerKelvin;
+	if (slopeGap === 0) return null;
+	return fromKelvin((sb.absoluteZeroReading - sa.absoluteZeroReading) / slopeGap, a);
+}
+/**
+* Temperature from any thermometric property, by linear interpolation between
+* the two fixed points.
+*
+* Deliberately unitless in X: the ratio cancels it, so the SAME function reads
+* a mercury column in centimetres, a gas pressure in N/m², a resistance in ohms
+* and a thermocouple emf in millivolts. That cancellation is the physics, and
+* writing one function per instrument would hide it.
+*
+* Throws when the two fixed points coincide, because a property that does not
+* change between ice and steam is not a thermometric property and the
+* interpolation would be a division by zero dressed up as a temperature.
+*/
+function thermometricTemperatureC({ x, xIce, xSteam }) {
+	const span = finite(xSteam, "The steam-point value") - finite(xIce, "The ice-point value");
+	if (span === 0) throw new RangeError("The ice-point and steam-point readings are equal, so this property does not vary with temperature.");
+	return (finite(x, "The measured value") - xIce) / span * 100;
+}
+/** The inverse: what the property reads at a given Celsius temperature. */
+function thermometricValue(celsius, xIce, xSteam) {
+	return xIce + finite(celsius, "A temperature") / 100 * (xSteam - xIce);
+}
+/**
+* Temperature from a thermometer calibrated at the triple point alone, in
+* kelvin: T = 273.16 · X / X_triple.
+*
+* This is the constant-volume gas thermometer's defining relation, and it needs
+* ONE fixed point rather than two because it uses a property that is
+* proportional to thermodynamic temperature rather than merely linear in it.
+* Pressure at fixed volume extrapolates to zero at absolute zero, so the origin
+* is the second point and does not have to be measured.
+*
+* Throws on a non-positive `xTriple`, and on a negative `x`: a gas pressure
+* below zero is not a cold reading, it is a broken instrument.
+*/
+function triplePointTemperatureK(x, xTriple) {
+	if (finite(xTriple, "The triple-point value") <= 0) throw new RangeError("The triple-point reading must be positive.");
+	if (finite(x, "The measured value") < 0) throw new RangeError("A property proportional to absolute temperature cannot be negative.");
+	return WATER_TRIPLE_POINT_K * x / xTriple;
+}
+/**
+* Resistance of a metal thermometer at θ °C, to second order:
+*
+*     R_θ = R_0 · (1 + a·θ + b·θ²)
+*
+* Pass `b = 0` for the linear model. The quadratic term is why a platinum
+* thermometer and a mercury one, both correct at 0 °C and 100 °C, disagree at
+* 50 °C: the curvature is real, and the linear scale is the chord across it.
+*/
+function resistanceAtC(r0, a, theta, b = 0) {
+	if (finite(r0, "The ice-point resistance") <= 0) throw new RangeError("The ice-point resistance must be positive.");
+	return r0 * (1 + a * finite(theta, "A temperature") + b * theta * theta);
+}
+/**
+* Thermocouple emf against the cold junction, in the standard quadratic form:
+*
+*     E = a·θ + b·θ²
+*
+* Kept as a named function rather than inlined because the two temperatures
+* that fall out of it, below, are the whole reason a thermocouple has a usable
+* range at all.
+*/
+function thermocoupleEmf(theta, a, b) {
+	const t = finite(theta, "A temperature");
+	return a * t + finite(b, "The quadratic coefficient") * t * t;
+}
+/**
+* The NEUTRAL temperature, where the emf peaks: θ_n = −a / 2b.
+*
+* Past it the emf falls again, so a single emf reading matches two
+* temperatures and the thermocouple stops being a thermometer. That is the
+* practical limit of the instrument, and it is a property of the metal pair
+* rather than of the circuit.
+*/
+function thermocoupleNeutralTemperatureC(a, b) {
+	if (finite(b, "The quadratic coefficient") === 0) throw new RangeError("With no quadratic term the emf never turns, so there is no neutral temperature.");
+	return -a / (2 * b);
+}
+/**
+* The INVERSION temperature, where the emf returns to zero: θ_i = −a / b.
+*
+* Exactly twice the neutral temperature when the cold junction is at 0 °C,
+* which is the check a student is usually asked to make.
+*/
+function thermocoupleInversionTemperatureC(a, b) {
+	if (finite(b, "The quadratic coefficient") === 0) throw new RangeError("With no quadratic term the emf never returns to zero.");
+	return -a / b;
+}
+
+//#endregion
+export { TEMPERATURE_SCALES, convertTemperature, convertTemperatureInterval, fromKelvin, fundamentalInterval, icePointOn, resistanceAtC, scaleReadingsAgree, steamPointOn, thermocoupleEmf, thermocoupleInversionTemperatureC, thermocoupleNeutralTemperatureC, thermometricTemperatureC, thermometricValue, toKelvin, triplePointTemperatureK };