@classytic/stage 0.3.0 → 0.4.0

package/dist/optics/laws.mjs

@@ -0,0 +1,195 @@
+import { relation } from "../relation/index.mjs";
+
+//#region src/optics/laws.ts
+/**
+* The laws of optics, DECLARED once rather than written as functions.
+*
+* ## Why this file exists beside the others
+*
+* `refraction.ts`, `imaging.ts`, `prism.ts` and `wave-optics.ts` compute. They
+* take the quantities a question gives and return the one it asks for, in the
+* direction that question happened to run.
+*
+* This file declares the same physics as EQUATIONS, through
+* `@classytic/stage/relation`, and gets three things a function cannot give:
+*
+*   1. **Any direction.** `snellsLaw().solve({ n1, i, r })` returns n₂;
+*      `solve({ n1, i, n2 })` returns r. One declaration, not two functions,
+*      and no chance of the pair drifting apart.
+*   2. **The working.** `.steps({...})` returns the substitution line by line
+*      as LaTeX, so a lesson can SHOW the solution rather than assert the
+*      answer. Every number in it came from the caller, so a generated
+*      derivation cannot divide by a quantity the question never mentioned.
+*   3. **A units check at declaration.** A relation whose dimensions do not
+*      balance is refused here, before any lesson can be written against it.
+*
+* Solving an angle out of these became possible only once `math/rearrange`
+* learned to undo trigonometry. Before that, every law ending in an angle could
+* be solved for its indices and for nothing else.
+*
+* ## What is NOT here, and why
+*
+* Isolation peels operations off a variable that appears EXACTLY ONCE. The
+* prism's `n = sin((A + δm)/2) / sin(A/2)` has A twice, so it cannot be
+* declared usefully and lives in `prism.ts` as a numeric solve instead. That
+* boundary is stated rather than hidden, because a relation that silently
+* refused half its directions would be worse than no relation.
+*
+* ## Angles are in RADIANS here
+*
+* Unlike the computing modules, which take degrees because protractors do.
+* `relation` checks dimensions, and an angle has to be the dimensionless thing
+* a sine can accept. `DEG` is exported so a call site can convert in place and
+* stay readable.
+*/
+/** Multiply a value in degrees by this to get radians, for use in a `solve`. */
+const DEG = Math.PI / 180;
+/** Build once, on first use, matching the pattern in `chem/relations.ts`. */
+function lazy(build) {
+	let made;
+	return () => made ??= build();
+}
+/**
+* `n1 * sin(i) = n2 * sin(r)`, Snell's law.
+*
+* Solvable for either index and, since trigonometry inverts, for either angle.
+*
+* Asking for `r` past the critical angle THROWS, because no such angle exists:
+* the engine evaluates its own rearrangement, sees NaN and refuses rather than
+* handing back a number-shaped nothing. That is the right failure for a
+* declared equation, but it is not an explanation, so a lab that needs to SHOW
+* total internal reflection calls `refraction.ts` `refract()`, which names the
+* case and reports the critical angle alongside.
+*/
+const snellsLaw = lazy(() => relation("n1 * sin(i) = n2 * sin(r)", {
+	n1: "1",
+	i: "rad",
+	n2: "1",
+	r: "rad"
+}, "Snell's law"));
+/** `sin(c) = n2 / n1`, the critical angle for light leaving the denser medium. */
+const criticalAngleLaw = lazy(() => relation("sin(c) = n2 / n1", {
+	c: "rad",
+	n2: "1",
+	n1: "1"
+}, "the critical angle"));
+/** `n = c / v`, refractive index as the factor by which a medium slows light. */
+const indexFromSpeed = lazy(() => relation("n = c / v", {
+	n: "1",
+	c: "m/s",
+	v: "m/s"
+}, "refractive index from speed"));
+/** `n = d / a`, refractive index by the apparent-depth method. */
+const apparentDepthLaw = lazy(() => relation("n = d / a", {
+	n: "1",
+	d: "m",
+	a: "m"
+}, "refractive index from apparent depth"));
+/** `n = tan(p)`, Brewster's law for the polarising angle. */
+const brewstersLaw = lazy(() => relation("n = tan(p)", {
+	n: "1",
+	p: "rad"
+}, "Brewster's law"));
+/**
+* `1 / v - 1 / u = 1 / f`, the thin lens equation in the Cartesian convention.
+*
+* Each variable appears once, so it solves for any of the three. Note that `u`
+* must be given as the NEGATIVE number the convention requires, which is the
+* price of a declaration that is literally the textbook equation;
+* `imaging.ts` `thinLens()` is the one that takes a positive distance and
+* handles the sign.
+*/
+const thinLensEquation = lazy(() => relation("1 / v - 1 / u = 1 / f", {
+	v: "m",
+	u: "m",
+	f: "m"
+}, "the thin lens equation"));
+/** `1 / v + 1 / u = 1 / f`, the mirror equation with distances as positive lengths. */
+const mirrorEquation = lazy(() => relation("1 / v + 1 / u = 1 / f", {
+	v: "m",
+	u: "m",
+	f: "m"
+}, "the mirror equation"));
+/** `m = h2 / h1`, linear magnification as a height ratio. */
+const magnificationLaw = lazy(() => relation("m = h2 / h1", {
+	m: "1",
+	h2: "m",
+	h1: "m"
+}, "linear magnification"));
+/** `P = 1 / f`, lens power in dioptres from a focal length in metres. */
+const lensPowerLaw = lazy(() => relation("P = 1 / f", {
+	P: "1/m",
+	f: "m"
+}, "lens power"));
+/** `d = (n - 1) * A`, a thin prism's deviation. */
+const thinPrismLaw = lazy(() => relation("d = (n - 1) * A", {
+	d: "rad",
+	n: "1",
+	A: "rad"
+}, "thin prism deviation"));
+/** `w = lam * D / a`, the fringe spacing in Young's double-slit experiment. */
+const fringeSpacingLaw = lazy(() => relation("w = lam * D / a", {
+	w: "m",
+	lam: "m",
+	D: "m",
+	a: "m"
+}, "Young fringe spacing"));
+/**
+* `d * sin(t) = k * lam`, the diffraction grating equation.
+*
+* The order is `k` rather than the conventional `n`, because `n` is a
+* refractive index everywhere else in this file and one symbol meaning two
+* things across one module is how a wrong substitution gets written.
+*/
+const gratingLaw = lazy(() => relation("d * sin(t) = k * lam", {
+	d: "m",
+	t: "rad",
+	k: "1",
+	lam: "m"
+}, "the grating equation"));
+/** `I = I0 * cos(t)^2`, Malus's law for light through an analyser. */
+const malusLaw = lazy(() => relation("I = I0 * cos(t)^2", {
+	I: "W/m^2",
+	I0: "W/m^2",
+	t: "rad"
+}, "Malus's law"));
+/** `v = f * lam`, the wave equation, which underlies all of the above. */
+const waveEquation = lazy(() => relation("v = f * lam", {
+	v: "m/s",
+	f: "1/s",
+	lam: "m"
+}, "the wave equation"));
+/** `E = h * c / lam`, the energy of a photon of a given wavelength. */
+const photonEnergyLaw = lazy(() => relation("E = h * c / lam", {
+	E: "J",
+	h: "J*s",
+	c: "m/s",
+	lam: "m"
+}, "photon energy"));
+/**
+* Every declared optical law, for a gate that wants to walk them.
+*
+* Built on demand like the rest: touching this array declares all of them,
+* which is exactly what a test that checks they all parse and balance wants,
+* and exactly what a lesson importing one of them does not.
+*/
+const OPTICS_LAWS = () => [
+	snellsLaw(),
+	criticalAngleLaw(),
+	indexFromSpeed(),
+	apparentDepthLaw(),
+	brewstersLaw(),
+	thinLensEquation(),
+	mirrorEquation(),
+	magnificationLaw(),
+	lensPowerLaw(),
+	thinPrismLaw(),
+	fringeSpacingLaw(),
+	gratingLaw(),
+	malusLaw(),
+	waveEquation(),
+	photonEnergyLaw()
+];
+
+//#endregion
+export { DEG, OPTICS_LAWS, apparentDepthLaw, brewstersLaw, criticalAngleLaw, fringeSpacingLaw, gratingLaw, indexFromSpeed, lensPowerLaw, magnificationLaw, malusLaw, mirrorEquation, photonEnergyLaw, snellsLaw, thinLensEquation, thinPrismLaw, waveEquation };

package/dist/optics/prism.d.mts

@@ -0,0 +1,148 @@
+//#region src/optics/prism.d.ts
+/**
+ * Prisms: deviation, minimum deviation, and dispersion.
+ *
+ * THE MODEL. A ray crossing both faces of a prism of apex angle A obeys two
+ * geometric identities and Snell's law twice:
+ *
+ *     A = r₁ + r₂                 the refraction angles inside sum to the apex
+ *     δ = i₁ + i₂ − A             the deviation is what the ray lost overall
+ *
+ * Deviation falls, bottoms out, and rises again as the ray is tilted. At the
+ * bottom the path is SYMMETRIC (i₁ = i₂, r₁ = r₂ = A/2), and that symmetry
+ * gives the measurement every refractometer is built on:
+ *
+ *     n = sin((A + δ_min)/2) / sin(A/2)
+ *
+ * WHY THE MINIMUM EXISTS. δ is symmetric under swapping i₁ and i₂, because
+ * reversing a light path is always allowed. A smooth function symmetric about a
+ * point is stationary there, so the turning point is forced by reversibility
+ * rather than by any property of glass.
+ *
+ * WHERE ISOLATION RUNS OUT. Every relation above can be rearranged for any one
+ * of its variables except one: solving `n = sin((A+δm)/2)/sin(A/2)` for A is
+ * impossible by isolation, because A appears TWICE and the symbolic solver
+ * peels operations off a single occurrence. That is not a gap to paper over,
+ * it is the honest boundary of the method, so `prismAngleFromMinimumDeviation`
+ * brackets and bisects with the shared numeric root finder instead. It is the
+ * one function here that needs the maths engine rather than a formula.
+ *
+ * Angles in DEGREES throughout, matching `refraction.ts`.
+ */
+interface PrismPath {
+  /** Angle of incidence on the first face, degrees. */
+  incidenceDeg: number;
+  /** Refraction angle inside the first face, degrees. */
+  firstRefractionDeg: number;
+  /** Incidence angle on the second face from inside, degrees. */
+  secondRefractionDeg: number;
+  /** Emergence angle from the second face, degrees, or `null` if the ray never gets out. */
+  emergenceDeg: number | null;
+  /** Total deviation, degrees, or `null` when the ray is trapped. */
+  deviationDeg: number | null;
+  /**
+   * True when the ray hits the second face beyond the critical angle and
+   * reflects instead of emerging.
+   *
+   * Not an error: it is how a 45-45-90 prism turns light through a right angle
+   * in binoculars and periscopes, using total internal reflection rather than a
+   * silvered surface because it loses no light at all.
+   */
+  totalInternalReflection: boolean;
+}
+/**
+ * Trace a ray through a prism from one angle of incidence.
+ *
+ * Returns the whole path rather than only the deviation, because a lab drawing
+ * the ray needs all four angles and recomputing them from the deviation is
+ * neither possible nor sensible.
+ */
+declare function prismPath(apexDeg: number, incidenceDeg: number, n: number, outsideIndex?: number): PrismPath;
+/**
+ * The minimum deviation, degrees: δ_min = 2·asin(n·sin(A/2)) − A.
+ *
+ * From the symmetric path, so it needs no search. Throws when n·sin(A/2) > 1,
+ * which means the apex angle is too wide for any ray to get through this prism
+ * at all: see `maximumApexAngleDeg`.
+ */
+declare function minimumDeviationDeg(apexDeg: number, n: number): number;
+/** The incidence angle that produces minimum deviation: i = (A + δ_min)/2. */
+declare const minimumDeviationIncidenceDeg: (apexDeg: number, n: number) => number;
+/**
+ * Refractive index from the prism formula: n = sin((A + δm)/2) / sin(A/2).
+ *
+ * The standard spectrometer measurement, and the most accurate way of getting a
+ * refractive index in a school laboratory, because both angles are read off one
+ * divided circle.
+ */
+declare function indexFromMinimumDeviation(apexDeg: number, minimumDeviation: number): number;
+/**
+ * The apex angle that gives a stated minimum deviation for a known index.
+ *
+ * THE ONE THAT NEEDS THE NUMERIC SOLVER. A appears on both sides of
+ * n·sin(A/2) = sin((A + δm)/2), so it cannot be isolated; the shared
+ * bracket-and-bisect root finder from `math/analysis` does it instead. Kept as
+ * a real function rather than left to the caller because "what apex angle do I
+ * grind" is a genuine question and hand-solving it is a page of trigonometry.
+ */
+declare function prismAngleFromMinimumDeviation(minimumDeviation: number, n: number): number;
+/**
+ * The widest apex angle a prism of this index can transmit: A_max = 2·C.
+ *
+ * Past it, r₂ = A − r₁ exceeds the critical angle for every possible r₁, so the
+ * ray is always trapped at the second face however it enters. It is why prisms
+ * are 60 degrees rather than 90.
+ */
+declare const maximumApexAngleDeg: (n: number) => number;
+/**
+ * A thin prism's deviation: δ = (n − 1)·A.
+ *
+ * Valid for a few degrees of apex, where every sine may be replaced by its
+ * angle. Independent of the angle of incidence, which is exactly why thin
+ * prisms are the ones used in spectacles and in achromatic combinations: the
+ * deviation is a property of the prism rather than of how you hold it.
+ */
+declare function thinPrismDeviationDeg(apexDeg: number, n: number): number;
+interface Dispersion {
+  /** Deviation of the violet end, degrees. */
+  violetDeviationDeg: number;
+  /** Deviation of the red end, degrees. */
+  redDeviationDeg: number;
+  /** Deviation of the mean (yellow) ray, degrees. */
+  meanDeviationDeg: number;
+  /** Angular dispersion, the spread between the ends: θ = δ_v − δ_r. */
+  angularDispersionDeg: number;
+  /**
+   * Dispersive power ω = (n_v − n_r)/(n_mean − 1), a pure number.
+   *
+   * A property of the MATERIAL alone, with the apex angle cancelled out, which
+   * is what makes it the right thing to tabulate and the right thing to combine
+   * when cancelling dispersion between two glasses.
+   */
+  dispersivePower: number;
+}
+/**
+ * A thin prism's dispersion, given the index at each end of the spectrum.
+ *
+ * Violet is deviated more than red because glass has a higher index for shorter
+ * wavelengths, and that single fact is the rainbow, the chromatic aberration
+ * that ruined early telescopes, and the reason a spectrometer works.
+ *
+ * `meanIndex` defaults to the average of the two, which is what a question that
+ * gives only the extremes intends.
+ */
+declare function dispersion(apexDeg: number, violetIndex: number, redIndex: number, meanIndex?: number): Dispersion;
+/**
+ * The apex angle of a second prism that cancels the first's DISPERSION while
+ * leaving some deviation: an achromatic combination.
+ *
+ *     A₂ = −A₁ · (n_v1 − n_r1) / (n_v2 − n_r2)
+ *
+ * Returned as a positive angle, with the understanding that the second prism is
+ * inverted relative to the first. Achromatic doublets in lenses are the same
+ * idea: pair a crown and a flint so their dispersions subtract and their
+ * powers do not.
+ */
+declare function achromaticApexDeg(apexDeg: number, violet1: number, red1: number, violet2: number, red2: number): number;
+//#endregion
+export { Dispersion, PrismPath, achromaticApexDeg, dispersion, indexFromMinimumDeviation, maximumApexAngleDeg, minimumDeviationDeg, minimumDeviationIncidenceDeg, prismAngleFromMinimumDeviation, prismPath, thinPrismDeviationDeg };

package/dist/optics/prism.mjs

@@ -0,0 +1,197 @@
+import { roots } from "../math/analysis.mjs";
+import { criticalAngleDeg, refract } from "./refraction.mjs";
+
+//#region src/optics/prism.ts
+/**
+* Prisms: deviation, minimum deviation, and dispersion.
+*
+* THE MODEL. A ray crossing both faces of a prism of apex angle A obeys two
+* geometric identities and Snell's law twice:
+*
+*     A = r₁ + r₂                 the refraction angles inside sum to the apex
+*     δ = i₁ + i₂ − A             the deviation is what the ray lost overall
+*
+* Deviation falls, bottoms out, and rises again as the ray is tilted. At the
+* bottom the path is SYMMETRIC (i₁ = i₂, r₁ = r₂ = A/2), and that symmetry
+* gives the measurement every refractometer is built on:
+*
+*     n = sin((A + δ_min)/2) / sin(A/2)
+*
+* WHY THE MINIMUM EXISTS. δ is symmetric under swapping i₁ and i₂, because
+* reversing a light path is always allowed. A smooth function symmetric about a
+* point is stationary there, so the turning point is forced by reversibility
+* rather than by any property of glass.
+*
+* WHERE ISOLATION RUNS OUT. Every relation above can be rearranged for any one
+* of its variables except one: solving `n = sin((A+δm)/2)/sin(A/2)` for A is
+* impossible by isolation, because A appears TWICE and the symbolic solver
+* peels operations off a single occurrence. That is not a gap to paper over,
+* it is the honest boundary of the method, so `prismAngleFromMinimumDeviation`
+* brackets and bisects with the shared numeric root finder instead. It is the
+* one function here that needs the maths engine rather than a formula.
+*
+* Angles in DEGREES throughout, matching `refraction.ts`.
+*/
+const DEG = Math.PI / 180;
+const toRad = (d) => d * DEG;
+const toDeg = (r) => r / DEG;
+const apex = (value) => {
+	if (!Number.isFinite(value) || value <= 0 || value >= 180) throw new RangeError(`A prism's apex angle lies strictly between 0 and 180 degrees (got ${value}).`);
+	return value;
+};
+const index = (value, what = "A refractive index") => {
+	if (!Number.isFinite(value) || value < 1) throw new RangeError(`${what} must be at least 1 (got ${value}).`);
+	return value;
+};
+/**
+* Trace a ray through a prism from one angle of incidence.
+*
+* Returns the whole path rather than only the deviation, because a lab drawing
+* the ray needs all four angles and recomputing them from the deviation is
+* neither possible nor sensible.
+*/
+function prismPath(apexDeg, incidenceDeg, n, outsideIndex = 1) {
+	const A = apex(apexDeg);
+	const nPrism = index(n, "The prism's refractive index");
+	const r1 = refract(incidenceDeg, outsideIndex, nPrism).refractionDeg;
+	const r2 = A - r1;
+	if (r2 < 0 || r2 > 90) return {
+		incidenceDeg,
+		firstRefractionDeg: r1,
+		secondRefractionDeg: r2,
+		emergenceDeg: null,
+		deviationDeg: null,
+		totalInternalReflection: true
+	};
+	const second = refract(r2, nPrism, outsideIndex);
+	if (second.totalInternalReflection || second.refractionDeg === null) return {
+		incidenceDeg,
+		firstRefractionDeg: r1,
+		secondRefractionDeg: r2,
+		emergenceDeg: null,
+		deviationDeg: null,
+		totalInternalReflection: true
+	};
+	const i2 = second.refractionDeg;
+	return {
+		incidenceDeg,
+		firstRefractionDeg: r1,
+		secondRefractionDeg: r2,
+		emergenceDeg: i2,
+		deviationDeg: incidenceDeg + i2 - A,
+		totalInternalReflection: false
+	};
+}
+/**
+* The minimum deviation, degrees: δ_min = 2·asin(n·sin(A/2)) − A.
+*
+* From the symmetric path, so it needs no search. Throws when n·sin(A/2) > 1,
+* which means the apex angle is too wide for any ray to get through this prism
+* at all: see `maximumApexAngleDeg`.
+*/
+function minimumDeviationDeg(apexDeg, n) {
+	const A = apex(apexDeg);
+	const nPrism = index(n, "The prism's refractive index");
+	const s = nPrism * Math.sin(toRad(A / 2));
+	if (s > 1) throw new RangeError(`No ray can pass a prism of apex ${A} degrees with n = ${nPrism}: every ray is totally internally reflected at the second face. The limit is ${maximumApexAngleDeg(nPrism).toFixed(1)} degrees.`);
+	return 2 * toDeg(Math.asin(s)) - A;
+}
+/** The incidence angle that produces minimum deviation: i = (A + δ_min)/2. */
+const minimumDeviationIncidenceDeg = (apexDeg, n) => (apex(apexDeg) + minimumDeviationDeg(apexDeg, n)) / 2;
+/**
+* Refractive index from the prism formula: n = sin((A + δm)/2) / sin(A/2).
+*
+* The standard spectrometer measurement, and the most accurate way of getting a
+* refractive index in a school laboratory, because both angles are read off one
+* divided circle.
+*/
+function indexFromMinimumDeviation(apexDeg, minimumDeviation) {
+	const A = apex(apexDeg);
+	if (!Number.isFinite(minimumDeviation) || minimumDeviation < 0) throw new RangeError("A minimum deviation cannot be negative.");
+	return Math.sin(toRad((A + minimumDeviation) / 2)) / Math.sin(toRad(A / 2));
+}
+/**
+* The apex angle that gives a stated minimum deviation for a known index.
+*
+* THE ONE THAT NEEDS THE NUMERIC SOLVER. A appears on both sides of
+* n·sin(A/2) = sin((A + δm)/2), so it cannot be isolated; the shared
+* bracket-and-bisect root finder from `math/analysis` does it instead. Kept as
+* a real function rather than left to the caller because "what apex angle do I
+* grind" is a genuine question and hand-solving it is a page of trigonometry.
+*/
+function prismAngleFromMinimumDeviation(minimumDeviation, n) {
+	const dm = minimumDeviation;
+	const nPrism = index(n, "The prism's refractive index");
+	if (!Number.isFinite(dm) || dm <= 0) throw new RangeError("The minimum deviation must be positive.");
+	const residual = (A) => Math.sin(toRad((A + dm) / 2)) - nPrism * Math.sin(toRad(A / 2));
+	const found = roots(residual, .5, 179.5, {
+		steps: 720,
+		tol: 1e-12
+	});
+	if (found.length === 0) throw new RangeError(`No prism of index ${nPrism} has a minimum deviation of ${dm} degrees.`);
+	return found[0];
+}
+/**
+* The widest apex angle a prism of this index can transmit: A_max = 2·C.
+*
+* Past it, r₂ = A − r₁ exceeds the critical angle for every possible r₁, so the
+* ray is always trapped at the second face however it enters. It is why prisms
+* are 60 degrees rather than 90.
+*/
+const maximumApexAngleDeg = (n) => 2 * criticalAngleDeg(index(n));
+/**
+* A thin prism's deviation: δ = (n − 1)·A.
+*
+* Valid for a few degrees of apex, where every sine may be replaced by its
+* angle. Independent of the angle of incidence, which is exactly why thin
+* prisms are the ones used in spectacles and in achromatic combinations: the
+* deviation is a property of the prism rather than of how you hold it.
+*/
+function thinPrismDeviationDeg(apexDeg, n) {
+	return (index(n, "The prism's refractive index") - 1) * apex(apexDeg);
+}
+/**
+* A thin prism's dispersion, given the index at each end of the spectrum.
+*
+* Violet is deviated more than red because glass has a higher index for shorter
+* wavelengths, and that single fact is the rainbow, the chromatic aberration
+* that ruined early telescopes, and the reason a spectrometer works.
+*
+* `meanIndex` defaults to the average of the two, which is what a question that
+* gives only the extremes intends.
+*/
+function dispersion(apexDeg, violetIndex, redIndex, meanIndex = (violetIndex + redIndex) / 2) {
+	const A = apex(apexDeg);
+	const nv = index(violetIndex, "The violet refractive index");
+	const nr = index(redIndex, "The red refractive index");
+	const nm = index(meanIndex, "The mean refractive index");
+	if (nv < nr) throw new RangeError("Violet is refracted MORE than red in every ordinary transparent material, so the violet index cannot be the smaller one.");
+	const meanDeviationDeg = (nm - 1) * A;
+	if (nm === 1) throw new RangeError("A medium of index 1 deviates nothing, so it has no dispersive power.");
+	return {
+		violetDeviationDeg: (nv - 1) * A,
+		redDeviationDeg: (nr - 1) * A,
+		meanDeviationDeg,
+		angularDispersionDeg: (nv - nr) * A,
+		dispersivePower: (nv - nr) / (nm - 1)
+	};
+}
+/**
+* The apex angle of a second prism that cancels the first's DISPERSION while
+* leaving some deviation: an achromatic combination.
+*
+*     A₂ = −A₁ · (n_v1 − n_r1) / (n_v2 − n_r2)
+*
+* Returned as a positive angle, with the understanding that the second prism is
+* inverted relative to the first. Achromatic doublets in lenses are the same
+* idea: pair a crown and a flint so their dispersions subtract and their
+* powers do not.
+*/
+function achromaticApexDeg(apexDeg, violet1, red1, violet2, red2) {
+	const spread2 = index(violet2, "The second violet index") - index(red2, "The second red index");
+	if (spread2 === 0) throw new RangeError("The second prism has no dispersion, so it cannot cancel any.");
+	return apex(apexDeg) * (index(violet1, "The first violet index") - index(red1, "The first red index")) / spread2;
+}
+
+//#endregion
+export { achromaticApexDeg, dispersion, indexFromMinimumDeviation, maximumApexAngleDeg, minimumDeviationDeg, minimumDeviationIncidenceDeg, prismAngleFromMinimumDeviation, prismPath, thinPrismDeviationDeg };