@classytic/stage 0.2.0 → 0.4.0

package/dist/optics/refraction.d.mts

@@ -0,0 +1,201 @@
+//#region src/optics/refraction.d.ts
+/**
+ * Refraction: light crossing a boundary, and everything that follows from it.
+ *
+ * THE MODEL. One law does the whole of this file:
+ *
+ *     n₁ sin θ₁ = n₂ sin θ₂          (Snell)
+ *
+ * with n = c/v, the factor by which a medium slows light down. Written that way
+ * rather than as a pair of "denser/rarer" rules, because the symmetry is the
+ * point: reverse the ray and the same equation describes it, which is why a
+ * critical angle exists at all and why it exists only going the other way.
+ *
+ * WHAT SNELL'S LAW RETURNS WHEN THERE IS NO ANSWER. Solving for θ₂ needs
+ * arcsin((n₁/n₂)·sin θ₁), and past the critical angle that argument exceeds 1.
+ * That is not a numerical accident to be clamped away: it is TOTAL INTERNAL
+ * REFLECTION, the physical statement that no refracted ray exists. So
+ * `refractAngleDeg` returns `null` rather than NaN or a clamped 90 degrees, and
+ * `refract` returns a result that says which case happened. A clamp here would
+ * draw a refracted ray grazing along the surface forever, which is a picture of
+ * something that does not happen.
+ *
+ * ANGLES ARE IN DEGREES at this boundary, because every syllabus, every
+ * protractor and every worked answer is, and a kernel that took radians would
+ * push a conversion into every single call site. Internally it converts once.
+ *
+ * SCOPE. Geometric optics: rays, not beams. No amplitude, so nothing here says
+ * how MUCH light reflects at a boundary (that is Fresnel, and it is not on
+ * either syllabus). Non-dispersive unless a caller passes a per-colour index;
+ * `prism.ts` is where dispersion is handled properly.
+ */
+/**
+ * Refractive indices at roughly 589 nm (the sodium D line), which is the
+ * wavelength every table is quoted at.
+ *
+ * Air is 1.000293 and is almost always taken as 1. Both are here: the exact
+ * value so a lesson about why we round it has something to point at, and the
+ * rounding left to the caller rather than baked in.
+ */
+declare const MEDIA: Record<string, number>;
+/** Speed of light in a medium, m/s: v = c/n. */
+declare function speedInMedium(n: number): number;
+/**
+ * Wavelength inside a medium, given the vacuum wavelength: λ = λ₀/n.
+ *
+ * The FREQUENCY does not change, and that is the whole reason refraction
+ * happens: the wave crests arrive at the boundary at a fixed rate, so if they
+ * travel more slowly on the far side they must be closer together, and a train
+ * of wavefronts meeting the boundary at an angle pivots. Colour is frequency,
+ * which is why light does not change colour on entering water.
+ */
+declare function wavelengthInMedium(vacuumWavelength: number, n: number): number;
+/**
+ * The refractive index of medium b relative to medium a: ₐn_b = n_b/n_a.
+ *
+ * The relative index is what Snell's law actually contains, which is why the
+ * chain ₐn_b × _bn_c × _cn_a = 1 holds: each factor is a ratio and the ratios
+ * telescope. That identity is a standard exam question and it is also the
+ * cheapest possible check that a table of indices is self-consistent.
+ */
+declare function relativeIndex(from: number, to: number): number;
+interface Refraction {
+  /** The angle of incidence given, degrees from the normal. */
+  incidenceDeg: number;
+  /** The refracted angle, degrees from the normal, or `null` under total internal reflection. */
+  refractionDeg: number | null;
+  /** True when no refracted ray exists and all the light reflects back. */
+  totalInternalReflection: boolean;
+  /**
+   * The critical angle for this pair, degrees, or `null` when there is none.
+   *
+   * Only exists going from denser to rarer. Reported even when the ray is below
+   * it, because "how much further could I tilt this before the ray vanishes" is
+   * the question the number answers.
+   */
+  criticalAngleDeg: number | null;
+  /** Index of the medium the light starts in. */
+  fromIndex: number;
+  /** Index of the medium it enters. */
+  toIndex: number;
+}
+/**
+ * Refract a ray across a boundary, reporting what happened rather than only the
+ * angle.
+ *
+ * Returns the critical angle alongside, so a caller drawing the boundary does
+ * not have to ask a second function to know how close it is to losing the ray.
+ */
+declare function refract(incidenceDeg: number, fromIndex: number, toIndex: number): Refraction;
+/** Just the refracted angle in degrees, or `null` under total internal reflection. */
+declare function refractAngleDeg(incidenceDeg: number, fromIndex: number, toIndex: number): number | null;
+/**
+ * The critical angle in degrees: sin C = n_rare/n_dense.
+ *
+ * Throws when the light is going the easy way, because there is no critical
+ * angle from rare to dense and returning one would invent a boundary that is
+ * not there. That refusal is the lesson: total internal reflection is a
+ * one-way phenomenon, which is why an optical fibre works and why it has to be
+ * made of a dense core in a less dense cladding rather than the other way
+ * round.
+ */
+declare function criticalAngleDeg(denseIndex: number, rareIndex?: number): number;
+/** One layer of a stack of transparent media, for the apparent-depth sum. */
+interface DepthLayer {
+  label?: string;
+  /** True thickness of this layer. */
+  thickness: number;
+  /** Refractive index of this layer. */
+  index: number;
+}
+interface ApparentDepth {
+  /** The total real depth, the sum of the layers. */
+  realDepth: number;
+  /** The depth the bottom appears to be at, viewed from directly above. */
+  apparentDepth: number;
+  /** How much closer the bottom looks: real minus apparent. */
+  apparentShift: number;
+  /** Each layer's contribution to the apparent depth. */
+  layers: {
+    label: string;
+    thickness: number;
+    index: number;
+    apparent: number;
+  }[];
+}
+/**
+ * How deep a stack of transparent layers appears, viewed from straight above.
+ *
+ * Each layer contributes its own thickness divided by its own index, and the
+ * apparent depths simply add:
+ *
+ *     d_apparent = Σ dᵢ / nᵢ
+ *
+ * That they add is worth pausing on, because the refractions do not: the ray
+ * bends at every boundary, and the bends do not sum to anything tidy. It is the
+ * near-normal limit that makes this exact, where every sine may be replaced by
+ * its angle, and this function is therefore only right for looking STRAIGHT
+ * DOWN. A fish watched from a shallow angle is not where this says it is.
+ *
+ * Handles one layer as easily as five, which is the usual case: a coin under
+ * water is `apparentDepth([{ thickness: 0.4, index: 1.333 }])`.
+ */
+declare function apparentDepth(layers: readonly DepthLayer[]): ApparentDepth;
+/**
+ * The refractive index measured by the apparent-depth method: n = real/apparent.
+ *
+ * The simplest quantitative optics experiment there is, and the inverse of the
+ * single-layer case above.
+ */
+declare function indexFromDepths(realDepth: number, apparentDepthValue: number): number;
+interface SlabPassage {
+  /** The refracted angle inside the slab, degrees. */
+  refractionDeg: number;
+  /** Sideways displacement of the emerging ray from the original line. */
+  lateralShift: number;
+  /** Path length travelled inside the slab. */
+  pathLength: number;
+  /** Time spent inside the slab, seconds, if the thickness is in metres. */
+  timeInside: number;
+}
+/**
+ * A ray through a parallel-sided slab: how far it is shifted, and how long it
+ * takes.
+ *
+ *     x = d · sin(i − r) / cos r
+ *
+ * The emerging ray is PARALLEL to the one that went in, never bent overall,
+ * because the second boundary undoes exactly what the first did. All a glass
+ * block does is move the ray sideways, which is why a window does not distort
+ * the view and why a thick one seen at a glancing angle does.
+ *
+ * `timeInside` uses the slowed speed c/n, so it is longer than the same path in
+ * air. Keep the thickness in metres for that to be in seconds.
+ */
+declare function throughSlab(thickness: number, incidenceDeg: number, slabIndex: number, outsideIndex?: number): SlabPassage;
+/**
+ * Brewster's angle, degrees: tan θ_p = n₂/n₁.
+ *
+ * The one angle of incidence at which the reflected light is completely plane
+ * polarised. At it, the reflected and refracted rays are exactly 90 degrees
+ * apart, which is the reason rather than a coincidence: the reflected ray is
+ * driven by the oscillation of charges in the second medium, and a dipole
+ * radiates nothing along its own axis.
+ *
+ * Polaroid sunglasses cut glare off water because that glare is reflected near
+ * this angle and is therefore polarised horizontally.
+ */
+declare function brewsterAngleDeg(toIndex: number, fromIndex?: number): number;
+/**
+ * The refractive index from the two angles a rod makes at a liquid surface:
+ *
+ *     n = tan θ / tan φ
+ *
+ * θ is the angle the rod makes with the surface, φ the angle the rod's IMAGE
+ * appears to make. This is the "a stick in water looks bent" measurement made
+ * quantitative, and it is a tangent rather than a sine because both angles are
+ * read off the surface rather than off the normal.
+ */
+declare function indexFromRodAngles(rodDeg: number, imageDeg: number): number;
+//#endregion
+export { ApparentDepth, DepthLayer, MEDIA, Refraction, SlabPassage, apparentDepth, brewsterAngleDeg, criticalAngleDeg, indexFromDepths, indexFromRodAngles, refract, refractAngleDeg, relativeIndex, speedInMedium, throughSlab, wavelengthInMedium };

package/dist/optics/refraction.mjs

@@ -0,0 +1,270 @@
+import { SPEED_OF_LIGHT } from "../core/constants.mjs";
+
+//#region src/optics/refraction.ts
+/**
+* Refraction: light crossing a boundary, and everything that follows from it.
+*
+* THE MODEL. One law does the whole of this file:
+*
+*     n₁ sin θ₁ = n₂ sin θ₂          (Snell)
+*
+* with n = c/v, the factor by which a medium slows light down. Written that way
+* rather than as a pair of "denser/rarer" rules, because the symmetry is the
+* point: reverse the ray and the same equation describes it, which is why a
+* critical angle exists at all and why it exists only going the other way.
+*
+* WHAT SNELL'S LAW RETURNS WHEN THERE IS NO ANSWER. Solving for θ₂ needs
+* arcsin((n₁/n₂)·sin θ₁), and past the critical angle that argument exceeds 1.
+* That is not a numerical accident to be clamped away: it is TOTAL INTERNAL
+* REFLECTION, the physical statement that no refracted ray exists. So
+* `refractAngleDeg` returns `null` rather than NaN or a clamped 90 degrees, and
+* `refract` returns a result that says which case happened. A clamp here would
+* draw a refracted ray grazing along the surface forever, which is a picture of
+* something that does not happen.
+*
+* ANGLES ARE IN DEGREES at this boundary, because every syllabus, every
+* protractor and every worked answer is, and a kernel that took radians would
+* push a conversion into every single call site. Internally it converts once.
+*
+* SCOPE. Geometric optics: rays, not beams. No amplitude, so nothing here says
+* how MUCH light reflects at a boundary (that is Fresnel, and it is not on
+* either syllabus). Non-dispersive unless a caller passes a per-colour index;
+* `prism.ts` is where dispersion is handled properly.
+*/
+const DEG = Math.PI / 180;
+const toRad = (deg) => deg * DEG;
+const toDeg = (rad) => rad / DEG;
+const finite = (value, what) => {
+	if (!Number.isFinite(value)) throw new RangeError(`${what} must be a finite number.`);
+	return value;
+};
+/**
+* Guard for a refractive index.
+*
+* Refuses anything below 1, because n = c/v and nothing carries light faster
+* than light does. A caller who has passed 0.9 has swapped two media or typed a
+* reciprocal, and both mistakes produce believable angles if allowed through.
+*/
+const index = (value, what = "A refractive index") => {
+	if (!Number.isFinite(value) || value < 1) throw new RangeError(`${what} must be at least 1 (got ${value}); n = c/v, and nothing outruns light in vacuum.`);
+	return value;
+};
+/** An angle measured from the NORMAL, in degrees, as every optics convention does. */
+const angle = (value, what = "An angle") => {
+	if (!Number.isFinite(value) || value < 0 || value > 90) throw new RangeError(`${what} is measured from the normal and lies in [0, 90] degrees (got ${value}).`);
+	return value;
+};
+/**
+* Refractive indices at roughly 589 nm (the sodium D line), which is the
+* wavelength every table is quoted at.
+*
+* Air is 1.000293 and is almost always taken as 1. Both are here: the exact
+* value so a lesson about why we round it has something to point at, and the
+* rounding left to the caller rather than baked in.
+*/
+const MEDIA = {
+	vacuum: 1,
+	air: 1.000293,
+	ice: 1.31,
+	water: 1.333,
+	ethanol: 1.361,
+	glycerol: 1.473,
+	perspex: 1.495,
+	crownGlass: 1.52,
+	glass: 1.5,
+	flintGlass: 1.62,
+	sapphire: 1.77,
+	diamond: 2.417
+};
+/** Speed of light in a medium, m/s: v = c/n. */
+function speedInMedium(n) {
+	return SPEED_OF_LIGHT / index(n);
+}
+/**
+* Wavelength inside a medium, given the vacuum wavelength: λ = λ₀/n.
+*
+* The FREQUENCY does not change, and that is the whole reason refraction
+* happens: the wave crests arrive at the boundary at a fixed rate, so if they
+* travel more slowly on the far side they must be closer together, and a train
+* of wavefronts meeting the boundary at an angle pivots. Colour is frequency,
+* which is why light does not change colour on entering water.
+*/
+function wavelengthInMedium(vacuumWavelength, n) {
+	return finite(vacuumWavelength, "A wavelength") / index(n);
+}
+/**
+* The refractive index of medium b relative to medium a: ₐn_b = n_b/n_a.
+*
+* The relative index is what Snell's law actually contains, which is why the
+* chain ₐn_b × _bn_c × _cn_a = 1 holds: each factor is a ratio and the ratios
+* telescope. That identity is a standard exam question and it is also the
+* cheapest possible check that a table of indices is self-consistent.
+*/
+function relativeIndex(from, to) {
+	return index(to, "The index of the second medium") / index(from, "The index of the first medium");
+}
+/**
+* Refract a ray across a boundary, reporting what happened rather than only the
+* angle.
+*
+* Returns the critical angle alongside, so a caller drawing the boundary does
+* not have to ask a second function to know how close it is to losing the ray.
+*/
+function refract(incidenceDeg, fromIndex, toIndex) {
+	const i = angle(incidenceDeg, "The angle of incidence");
+	const n1 = index(fromIndex, "The index of the first medium");
+	const n2 = index(toIndex, "The index of the second medium");
+	const critical = n1 > n2 ? toDeg(Math.asin(n2 / n1)) : null;
+	const sinR = n1 / n2 * Math.sin(toRad(i));
+	if (sinR > 1.000000000001) return {
+		incidenceDeg: i,
+		refractionDeg: null,
+		totalInternalReflection: true,
+		criticalAngleDeg: critical,
+		fromIndex: n1,
+		toIndex: n2
+	};
+	return {
+		incidenceDeg: i,
+		refractionDeg: toDeg(Math.asin(Math.min(1, sinR))),
+		totalInternalReflection: false,
+		criticalAngleDeg: critical,
+		fromIndex: n1,
+		toIndex: n2
+	};
+}
+/** Just the refracted angle in degrees, or `null` under total internal reflection. */
+function refractAngleDeg(incidenceDeg, fromIndex, toIndex) {
+	return refract(incidenceDeg, fromIndex, toIndex).refractionDeg;
+}
+/**
+* The critical angle in degrees: sin C = n_rare/n_dense.
+*
+* Throws when the light is going the easy way, because there is no critical
+* angle from rare to dense and returning one would invent a boundary that is
+* not there. That refusal is the lesson: total internal reflection is a
+* one-way phenomenon, which is why an optical fibre works and why it has to be
+* made of a dense core in a less dense cladding rather than the other way
+* round.
+*/
+function criticalAngleDeg(denseIndex, rareIndex = 1) {
+	const dense = index(denseIndex, "The index of the dense medium");
+	const rare = index(rareIndex, "The index of the rare medium");
+	if (dense <= rare) throw new RangeError(`No critical angle from n = ${dense} into n = ${rare}: total internal reflection only happens going from denser to rarer.`);
+	return toDeg(Math.asin(rare / dense));
+}
+/**
+* How deep a stack of transparent layers appears, viewed from straight above.
+*
+* Each layer contributes its own thickness divided by its own index, and the
+* apparent depths simply add:
+*
+*     d_apparent = Σ dᵢ / nᵢ
+*
+* That they add is worth pausing on, because the refractions do not: the ray
+* bends at every boundary, and the bends do not sum to anything tidy. It is the
+* near-normal limit that makes this exact, where every sine may be replaced by
+* its angle, and this function is therefore only right for looking STRAIGHT
+* DOWN. A fish watched from a shallow angle is not where this says it is.
+*
+* Handles one layer as easily as five, which is the usual case: a coin under
+* water is `apparentDepth([{ thickness: 0.4, index: 1.333 }])`.
+*/
+function apparentDepth(layers) {
+	if (layers.length === 0) throw new RangeError("There is nothing to look through.");
+	const resolved = layers.map((layer, i) => {
+		const thickness = finite(layer.thickness, "A layer thickness");
+		if (thickness < 0) throw new RangeError("A layer cannot have a negative thickness.");
+		const n = index(layer.index, `Layer ${i + 1}'s refractive index`);
+		return {
+			label: layer.label ?? `layer ${i + 1}`,
+			thickness,
+			index: n,
+			apparent: thickness / n
+		};
+	});
+	const realDepth = resolved.reduce((sum, l) => sum + l.thickness, 0);
+	const apparent = resolved.reduce((sum, l) => sum + l.apparent, 0);
+	return {
+		realDepth,
+		apparentDepth: apparent,
+		apparentShift: realDepth - apparent,
+		layers: resolved
+	};
+}
+/**
+* The refractive index measured by the apparent-depth method: n = real/apparent.
+*
+* The simplest quantitative optics experiment there is, and the inverse of the
+* single-layer case above.
+*/
+function indexFromDepths(realDepth, apparentDepthValue) {
+	const real = finite(realDepth, "The real depth");
+	const apparent = finite(apparentDepthValue, "The apparent depth");
+	if (apparent <= 0) throw new RangeError("The apparent depth must be positive.");
+	if (real < apparent) throw new RangeError("The bottom always looks CLOSER than it is, so the real depth cannot be the smaller of the two.");
+	return real / apparent;
+}
+/**
+* A ray through a parallel-sided slab: how far it is shifted, and how long it
+* takes.
+*
+*     x = d · sin(i − r) / cos r
+*
+* The emerging ray is PARALLEL to the one that went in, never bent overall,
+* because the second boundary undoes exactly what the first did. All a glass
+* block does is move the ray sideways, which is why a window does not distort
+* the view and why a thick one seen at a glancing angle does.
+*
+* `timeInside` uses the slowed speed c/n, so it is longer than the same path in
+* air. Keep the thickness in metres for that to be in seconds.
+*/
+function throughSlab(thickness, incidenceDeg, slabIndex, outsideIndex = 1) {
+	const d = finite(thickness, "The slab thickness");
+	if (d < 0) throw new RangeError("A slab cannot have a negative thickness.");
+	const i = angle(incidenceDeg, "The angle of incidence");
+	const result = refract(i, outsideIndex, slabIndex);
+	if (result.refractionDeg === null) throw new RangeError("No ray enters the slab, so it has no passage through it.");
+	const r = result.refractionDeg;
+	const pathLength = d / Math.cos(toRad(r));
+	return {
+		refractionDeg: r,
+		lateralShift: d * Math.sin(toRad(i - r)) / Math.cos(toRad(r)),
+		pathLength,
+		timeInside: pathLength / speedInMedium(slabIndex)
+	};
+}
+/**
+* Brewster's angle, degrees: tan θ_p = n₂/n₁.
+*
+* The one angle of incidence at which the reflected light is completely plane
+* polarised. At it, the reflected and refracted rays are exactly 90 degrees
+* apart, which is the reason rather than a coincidence: the reflected ray is
+* driven by the oscillation of charges in the second medium, and a dipole
+* radiates nothing along its own axis.
+*
+* Polaroid sunglasses cut glare off water because that glare is reflected near
+* this angle and is therefore polarised horizontally.
+*/
+function brewsterAngleDeg(toIndex, fromIndex = 1) {
+	return toDeg(Math.atan(index(toIndex, "The index of the second medium") / index(fromIndex, "The index of the first medium")));
+}
+/**
+* The refractive index from the two angles a rod makes at a liquid surface:
+*
+*     n = tan θ / tan φ
+*
+* θ is the angle the rod makes with the surface, φ the angle the rod's IMAGE
+* appears to make. This is the "a stick in water looks bent" measurement made
+* quantitative, and it is a tangent rather than a sine because both angles are
+* read off the surface rather than off the normal.
+*/
+function indexFromRodAngles(rodDeg, imageDeg) {
+	const theta = finite(rodDeg, "The rod angle");
+	const phi = finite(imageDeg, "The image angle");
+	if (theta <= 0 || theta >= 90 || phi <= 0 || phi >= 90) throw new RangeError("Both angles are measured from the liquid surface and lie strictly between 0 and 90 degrees.");
+	return Math.tan(toRad(theta)) / Math.tan(toRad(phi));
+}
+
+//#endregion
+export { MEDIA, apparentDepth, brewsterAngleDeg, criticalAngleDeg, indexFromDepths, indexFromRodAngles, refract, refractAngleDeg, relativeIndex, speedInMedium, throughSlab, wavelengthInMedium };

package/dist/optics/wave-optics.d.mts

@@ -0,0 +1,171 @@
+import { pathFromPhase, phaseFromPath } from "../waves/wave.mjs";
+
+//#region src/optics/wave-optics.d.ts
+/**
+ * Fringe spacing in Young's experiment: w = λD/a.
+ *
+ * The workhorse, and the reason the experiment is the classic measurement of a
+ * wavelength: every quantity on the right is measurable with a ruler, and the
+ * left is a few tenths of a millimetre magnified into something you can count.
+ *
+ * The slit separation `a` is in the DENOMINATOR, which is the counter-intuitive
+ * part: pushing the slits closer together spreads the fringes apart.
+ */
+declare function fringeSpacing(wavelength: number, screenDistance: number, slitSeparation: number): number;
+/** Wavelength from a measured fringe spacing, the inverse of `fringeSpacing`. */
+declare function wavelengthFromFringes(fringeWidth: number, screenDistance: number, slitSeparation: number): number;
+/**
+ * Distance from the centre of the pattern to the nth BRIGHT fringe, metres.
+ *
+ * `n = 0` is the central maximum, which sits at zero path difference and is
+ * therefore in the same place for every wavelength. That is why the centre of a
+ * white-light interference pattern is white and everything either side is
+ * coloured.
+ */
+declare function brightFringePosition(n: number, wavelength: number, screenDistance: number, slitSeparation: number): number;
+/**
+ * Distance to the nth DARK fringe, metres, with `n = 0` the first one out from
+ * the centre.
+ *
+ * Half a fringe width further out than the bright one of the same index, which
+ * is the (n + ½) in the textbook formula written where it cannot be misread as
+ * (2n+1)/2 applied to the wrong thing.
+ */
+declare function darkFringePosition(n: number, wavelength: number, screenDistance: number, slitSeparation: number): number;
+/**
+ * The exact angle to the nth bright fringe, degrees, from a sin θ = nλ.
+ *
+ * No small-angle assumption, so it stays right where `fringeSpacing` starts to
+ * drift. Returns `null` when the order does not exist, which happens once
+ * nλ exceeds the slit separation.
+ */
+declare function fringeAngleDeg(n: number, wavelength: number, slitSeparation: number): number | null;
+/**
+ * Relative intensity of a two-slit pattern at a phase difference φ:
+ * I = I₀·cos²(φ/2).
+ *
+ * Note the pattern's peaks are FOUR times one slit's intensity, not twice, and
+ * the average is twice. Energy is conserved by redistribution, not by creation:
+ * the light missing from the dark fringes is exactly the excess in the bright
+ * ones.
+ */
+declare const twoSlitIntensity: (peakIntensity: number, phase: number) => number;
+/**
+ * The single-slit ENVELOPE at an angle, normalised to 1 straight ahead:
+ *
+ *     I/I₀ = (sin α / α)²   with   α = πa·sinθ/λ
+ *
+ * The shape every diffraction pattern sits inside. `α = 0` is 0/0 and the limit
+ * is 1, handled explicitly rather than left to produce NaN on the axis, which
+ * is the one point every plot draws.
+ *
+ * Note the contrast with the two-slit fringe term: the same algebra
+ * `a sinθ = nλ` gives a MINIMUM here and a MAXIMUM there. Confusing the two is
+ * the commonest error in the topic.
+ */
+declare function singleSlitEnvelope(thetaDeg: number, wavelength: number, slitWidth: number): number;
+/**
+ * The full two-slit pattern at an angle, normalised to 1 straight ahead:
+ * the envelope times the fringes.
+ *
+ * Two independent effects multiplied, and that product is the insight the
+ * pattern exists to deliver. The slit WIDTH sets the broad envelope, which
+ * decides how bright each fringe is; the slit SEPARATION sets the fine fringes
+ * inside it. Students routinely attribute both to one number, and a lab that
+ * draws only the fringe term cannot show them otherwise.
+ *
+ * `interfere: false` drops the fringe term and leaves the envelope, which is
+ * what covering one slit looks like, and what a which-path measurement does to
+ * the quantum version.
+ */
+declare function doubleSlitPattern(thetaDeg: number, wavelength: number, slitSeparation: number, slitWidth: number, options?: {
+  readonly interfere?: boolean;
+}): number;
+/**
+ * Angle to the nth diffraction MINIMUM of a single slit, degrees: a sin θ = nλ.
+ *
+ * `n` starts at 1; there is no n = 0 minimum, because straight ahead every
+ * contribution across the slit arrives in phase and that is the central
+ * maximum. Returns `null` when the order does not exist.
+ */
+declare function singleSlitMinimumDeg(n: number, wavelength: number, slitWidth: number): number | null;
+/**
+ * Angular half-width of the central diffraction maximum, degrees.
+ *
+ * The central bright band is TWICE this wide, and twice as wide as every other
+ * band, which is the single most recognisable feature of a diffraction pattern.
+ */
+declare function centralMaximumHalfWidthDeg(wavelength: number, slitWidth: number): number | null;
+/**
+ * Width of the central maximum on a screen, metres, in the small-angle limit:
+ * 2λD/a.
+ *
+ * Narrowing the slit WIDENS the patch. Push it to a slit comparable with the
+ * wavelength and the light spreads through most of a hemisphere, which is the
+ * observation that rules out light being a stream of particles travelling in
+ * straight lines.
+ */
+declare function centralMaximumWidth(wavelength: number, screenDistance: number, slitWidth: number): number;
+/** Slit spacing from a ruling density: d = 1/N, with N lines per metre. */
+declare const gratingSpacing: (linesPerMetre: number) => number;
+/**
+ * Angle of the nth order from a grating, degrees: d sin θ = nλ.
+ *
+ * Returns `null` when that order does not exist, rather than NaN, because
+ * "which orders can I see" is the question and a missing order is an answer to
+ * it.
+ */
+declare function gratingAngleDeg(n: number, wavelength: number, spacing: number): number | null;
+/**
+ * The highest order a grating can show: floor(d/λ).
+ *
+ * Because sin θ cannot exceed 1. A subtlety worth the comment: the order at
+ * exactly d/λ would sit at 90 degrees, grazing along the grating and carrying
+ * no light, so when d/λ is a whole number the highest OBSERVABLE order is one
+ * less. That edge is handled rather than rounded past.
+ */
+declare function maximumGratingOrder(wavelength: number, spacing: number): number;
+/**
+ * Wavelength from a grating measurement: λ = d sin θ / n.
+ *
+ * The grating's advantage over two slits is that many slits make each maximum
+ * very sharp, so the angle can be read precisely, which is why spectrometers
+ * use gratings rather than double slits.
+ */
+declare function wavelengthFromGrating(n: number, angleDeg: number, spacing: number): number;
+/**
+ * Malus's law: I = I₀·cos²θ, with θ between the analyser and the polarisation.
+ *
+ * Crossed polarisers pass nothing, and a third one inserted between them at 45
+ * degrees lets light through again, which is impossible to explain if
+ * polarisers are filters that merely remove things. They do not filter, they
+ * PROJECT, and cos² is the projection.
+ */
+declare function malusIntensity(incidentIntensity: number, analyserAngleDeg: number): number;
+/**
+ * Intensity after unpolarised light passes one ideal polariser: exactly half.
+ *
+ * Half rather than cos² of anything, because unpolarised light carries every
+ * orientation equally and the average of cos² over all angles is a half. The
+ * first polariser is the one that loses half; the second loses by Malus.
+ */
+declare const unpolarisedThroughPolariser: (intensity: number) => number;
+/**
+ * Intensity at a distance from a point source: I = P/(4πr²).
+ *
+ * The inverse square is geometry, not a property of light: the same power
+ * spread over a sphere whose area grows as r².
+ */
+declare function pointSourceIntensity(power: number, distance: number): number;
+/**
+ * The Rayleigh criterion, radians: θ = 1.22·λ/D.
+ *
+ * Two point sources are just resolved when the first's diffraction maximum
+ * falls on the other's first minimum. The 1.22 is the first zero of a Bessel
+ * function, and it is there because the aperture is a CIRCLE; a slit gives
+ * exactly 1. This is the hard limit on every telescope and microscope, and the
+ * reason bigger mirrors see finer detail quite apart from gathering more light.
+ */
+declare function rayleighResolutionRad(wavelength: number, aperture: number): number;
+//#endregion
+export { brightFringePosition, centralMaximumHalfWidthDeg, centralMaximumWidth, darkFringePosition, doubleSlitPattern, fringeAngleDeg, fringeSpacing, gratingAngleDeg, gratingSpacing, malusIntensity, maximumGratingOrder, pointSourceIntensity, rayleighResolutionRad, singleSlitEnvelope, singleSlitMinimumDeg, twoSlitIntensity, unpolarisedThroughPolariser, wavelengthFromFringes, wavelengthFromGrating };