@classytic/stage 0.2.0 → 0.4.0

package/dist/optics/imaging.d.mts

@@ -0,0 +1,218 @@
+//#region src/optics/imaging.d.ts
+/**
+ * Image formation: lenses, mirrors, and refraction at a curved surface.
+ *
+ * ## The sign convention, decided once and stated loudly
+ *
+ * This kernel uses the CARTESIAN convention throughout:
+ *
+ *   - Light travels left to right, in the +x direction.
+ *   - Every distance is measured FROM the optical centre (or pole), and is
+ *     positive when measured in the direction light travels.
+ *   - So a real object sitting to the left has a NEGATIVE u. A real image
+ *     formed to the right has a positive v.
+ *   - A centre of curvature to the right gives a positive R.
+ *
+ * That is not the convention the Bengali and Indian textbooks print. They use
+ * REAL-IS-POSITIVE, where a real object has a positive u and the lens equation
+ * reads 1/v + 1/u = 1/f. Both describe the same physics and the translation is
+ * exactly u → −u, which `fromRealPositive` does.
+ *
+ * Cartesian is the one implemented because it is the only convention in which
+ * the refracting formulas hold at once, with no per-formula sign patch:
+ *
+ *     thin lens          1/v − 1/u = 1/f
+ *     curved surface     n₂/v − n₁/u = (n₂−n₁)/R
+ *     lens maker         1/f = (n_l/n_m − 1)(1/R₁ − 1/R₂)
+ *
+ * ## Mirrors, and why they need no separate equation here
+ *
+ * A mirror sends light BACK, so its image forms on the object's own side. In
+ * strict Cartesian that makes a concave mirror's focal length negative, which
+ * is correct and which nobody writes: every table, this kernel's own callers
+ * included, says a concave mirror is the converging one. So `focalLength > 0`
+ * means CONVERGING for both elements here.
+ *
+ * With that fixed, and with the object distance supplied as a positive length,
+ * the two textbook equations turn out to be the same arithmetic:
+ *
+ *     lens    1/v = 1/f + 1/u,  u = −d   →   1/v = 1/f − 1/d
+ *     mirror  1/v = 1/f − 1/d            →   1/v = 1/f − 1/d
+ *
+ * So there is one equation in this file, not two. That is worth stating because
+ * the obvious implementation is a branch on element type, and a branch whose
+ * arms agree is worse than no branch: it reads as though the cases differ.
+ *
+ * The sign still has to be got right on the way IN, and getting it wrong is
+ * silent: passing a Cartesian (negative) object distance to the mirror puts the
+ * image of an object 30 cm from an f = 10 cm concave mirror at 7.5 cm instead
+ * of 15 cm, and 7.5 is a perfectly plausible-looking number. Hence the positive
+ * distance at every entry point, and `tests/optics/imaging` pinning both
+ * elements against worked answers.
+ *
+ * What the shared equation genuinely cannot say is WHERE a positive v sits: the
+ * far side for a lens, the object's own side for a mirror. Both are "the
+ * outgoing side", so `real` is right for both, and the rest is the caller's to
+ * draw.
+ *
+ * ## The convenience that is NOT a convention change
+ *
+ * Every entry point below takes `objectDistance` as a POSITIVE distance to a
+ * real object, because that is what a person measures with a ruler and what
+ * every question states. It is negated on the way in, once, in one place.
+ * `imageDistance` comes back signed in the Cartesian sense, and the result
+ * carries `real` and `upright` flags so a caller never has to remember what the
+ * sign meant.
+ *
+ * Units: whatever the caller uses, consistently. Distances in and distances
+ * out. The only exception is `lensPower`, which is dioptres and therefore
+ * demands metres, and says so.
+ */
+/** Translate a textbook real-is-positive object distance into the Cartesian one. */
+declare const fromRealPositive: (u: number) => number;
+interface Image {
+  /**
+   * Image distance from the optical centre, signed.
+   *
+   * Positive is on the outgoing side: behind a lens, in front of a mirror.
+   * `Infinity` when the object sits at the focal point and the rays leave
+   * parallel, which is a real answer and not an error.
+   */
+  imageDistance: number;
+  /** Object distance as a positive length, as supplied. */
+  objectDistance: number;
+  /** Focal length, signed: positive converging, negative diverging. */
+  focalLength: number;
+  /** Linear magnification, signed. Negative means inverted. */
+  magnification: number;
+  /** True when light actually converges there and a screen would catch it. */
+  real: boolean;
+  /** True when the image is the same way up as the object. */
+  upright: boolean;
+  /** True when the image is bigger than the object. */
+  enlarged: boolean;
+  /** Image height, when an object height was given. */
+  imageHeight?: number;
+}
+/**
+ * Image in a thin lens: 1/v − 1/u = 1/f.
+ *
+ * `focalLength` is positive for a converging (convex) lens and negative for a
+ * diverging (concave) one. A converging lens is the only element here that can
+ * make a real image, and only when the object is beyond the focal point; inside
+ * it, the same lens is a magnifying glass and the image is virtual, upright and
+ * enlarged. Both cases fall out of the one equation rather than needing a
+ * branch, which is why there is no branch.
+ */
+declare function thinLens(focalLength: number, objectDistance: number, objectHeight?: number): Image;
+/**
+ * Image in a spherical mirror: 1/v + 1/u = 1/f, with f = R/2.
+ *
+ * `focalLength` is positive for a concave (converging) mirror, negative for a
+ * convex one. A convex mirror always gives a virtual, upright, diminished image
+ * whatever the object distance, which is why it is the one on a car and at a
+ * blind corner: it cannot help but show a wide view the right way up.
+ */
+declare function sphericalMirror(focalLength: number, objectDistance: number, objectHeight?: number): Image;
+/** Focal length of a mirror from its radius of curvature: f = R/2. */
+declare const mirrorFocalLength: (radiusOfCurvature: number) => number;
+/**
+ * Refraction at a single spherical surface:
+ *
+ *     n₂/v − n₁/u = (n₂ − n₁)/R
+ *
+ * The primitive a lens is built from, and the one that answers questions about
+ * a fish in a bowl or a bubble in a glass sphere, where there is only one
+ * surface to cross. `radius` is Cartesian: positive when the centre of
+ * curvature lies on the outgoing side.
+ *
+ * A flat surface is R = Infinity, which reduces this to n₂/v = n₁/u and
+ * recovers the apparent-depth result. That limit is why `Infinity` is accepted
+ * rather than rejected as a non-finite radius.
+ */
+declare function sphericalSurface(fromIndex: number, toIndex: number, radius: number, objectDistance: number): {
+  imageDistance: number;
+  magnification: number;
+  real: boolean;
+};
+/**
+ * The lens maker's equation, including the surrounding medium:
+ *
+ *     1/f = (n_lens/n_medium − 1) · (1/R₁ − 1/R₂)
+ *
+ * The medium is not decoration. A glass lens in water has a much longer focal
+ * length because what bends light is the RATIO of the indices, not the glass
+ * alone, and a lens made of something with the same index as its surroundings
+ * does nothing at all. Push it further and the sign flips: a converging air
+ * bubble in water is a diverging lens, which this returns without special
+ * handling because the ratio simply drops below 1.
+ *
+ * Radii are Cartesian. For a biconvex lens R₁ > 0 and R₂ < 0. A flat face is
+ * `Infinity`.
+ */
+declare function lensMakerFocalLength(lensIndex: number, r1: number, r2: number, mediumIndex?: number): number;
+/**
+ * Lens power in dioptres: P = 1/f with f IN METRES.
+ *
+ * The unit is the reason opticians use it: powers of lenses in contact simply
+ * add, so a prescription is a sum rather than a reciprocal of a sum of
+ * reciprocals.
+ */
+declare function lensPower(focalLengthM: number): number;
+/** Focal length in metres from a power in dioptres. */
+declare const focalLengthFromPower: (dioptres: number) => number;
+/**
+ * Two thin lenses in contact: 1/f = 1/f₁ + 1/f₂, or equivalently P = P₁ + P₂.
+ *
+ * The special case of the separated formula below with d = 0, written out
+ * because it is the one that appears in every prescription and every achromatic
+ * doublet.
+ */
+declare function lensesInContact(...focalLengths: readonly number[]): number;
+/**
+ * Two thin lenses a distance d apart:
+ *
+ *     1/f = 1/f₁ + 1/f₂ − d/(f₁f₂)
+ *
+ * The separation term is what makes a telescope a telescope rather than a thick
+ * lens. Note it can cancel the other two exactly, at d = f₁ + f₂, which is the
+ * telescope's normal adjustment: the combination then has infinite focal length
+ * and magnifies without focusing, and this throws rather than returning a
+ * division by zero dressed as a number.
+ */
+declare function lensesSeparated(f1: number, f2: number, separation: number): number;
+interface DisplacementMethod {
+  /** The focal length the measurement gives. */
+  focalLength: number;
+  /** The two object distances at which a sharp image appears. */
+  objectDistances: [number, number];
+  /** The magnification at each of those positions. */
+  magnifications: [number, number];
+}
+/**
+ * Focal length by the displacement (Bessel) method:
+ *
+ *     f = (L² − x²) / 4L
+ *
+ * With the object and screen a fixed distance L apart, there are TWO lens
+ * positions giving a sharp image, x apart, and measuring x is far more accurate
+ * than locating either one alone. The reason there are two is that the lens
+ * equation is symmetric in u and v: swap them and it still holds, so the
+ * conjugate positions come in pairs.
+ *
+ * Requires L > 4f, which is the same statement as x being real. A screen closer
+ * than four focal lengths catches no sharp image at all, and this reports that
+ * rather than returning a complex-looking number.
+ */
+declare function displacementMethod(screenDistance: number, positionGap: number): DisplacementMethod;
+/**
+ * The minimum separation between a real object and the real image a converging
+ * lens makes of it: L = 4f.
+ *
+ * Below it there is no solution at all, which is the fact behind the
+ * displacement method's requirement and behind the familiar experience that a
+ * projector cannot be moved arbitrarily close to its screen.
+ */
+declare const minimumObjectImageSeparation: (focalLength: number) => number;
+//#endregion
+export { DisplacementMethod, Image, displacementMethod, focalLengthFromPower, fromRealPositive, lensMakerFocalLength, lensPower, lensesInContact, lensesSeparated, minimumObjectImageSeparation, mirrorFocalLength, sphericalMirror, sphericalSurface, thinLens };

package/dist/optics/imaging.mjs

@@ -0,0 +1,276 @@
+//#region src/optics/imaging.ts
+/**
+* Image formation: lenses, mirrors, and refraction at a curved surface.
+*
+* ## The sign convention, decided once and stated loudly
+*
+* This kernel uses the CARTESIAN convention throughout:
+*
+*   - Light travels left to right, in the +x direction.
+*   - Every distance is measured FROM the optical centre (or pole), and is
+*     positive when measured in the direction light travels.
+*   - So a real object sitting to the left has a NEGATIVE u. A real image
+*     formed to the right has a positive v.
+*   - A centre of curvature to the right gives a positive R.
+*
+* That is not the convention the Bengali and Indian textbooks print. They use
+* REAL-IS-POSITIVE, where a real object has a positive u and the lens equation
+* reads 1/v + 1/u = 1/f. Both describe the same physics and the translation is
+* exactly u → −u, which `fromRealPositive` does.
+*
+* Cartesian is the one implemented because it is the only convention in which
+* the refracting formulas hold at once, with no per-formula sign patch:
+*
+*     thin lens          1/v − 1/u = 1/f
+*     curved surface     n₂/v − n₁/u = (n₂−n₁)/R
+*     lens maker         1/f = (n_l/n_m − 1)(1/R₁ − 1/R₂)
+*
+* ## Mirrors, and why they need no separate equation here
+*
+* A mirror sends light BACK, so its image forms on the object's own side. In
+* strict Cartesian that makes a concave mirror's focal length negative, which
+* is correct and which nobody writes: every table, this kernel's own callers
+* included, says a concave mirror is the converging one. So `focalLength > 0`
+* means CONVERGING for both elements here.
+*
+* With that fixed, and with the object distance supplied as a positive length,
+* the two textbook equations turn out to be the same arithmetic:
+*
+*     lens    1/v = 1/f + 1/u,  u = −d   →   1/v = 1/f − 1/d
+*     mirror  1/v = 1/f − 1/d            →   1/v = 1/f − 1/d
+*
+* So there is one equation in this file, not two. That is worth stating because
+* the obvious implementation is a branch on element type, and a branch whose
+* arms agree is worse than no branch: it reads as though the cases differ.
+*
+* The sign still has to be got right on the way IN, and getting it wrong is
+* silent: passing a Cartesian (negative) object distance to the mirror puts the
+* image of an object 30 cm from an f = 10 cm concave mirror at 7.5 cm instead
+* of 15 cm, and 7.5 is a perfectly plausible-looking number. Hence the positive
+* distance at every entry point, and `tests/optics/imaging` pinning both
+* elements against worked answers.
+*
+* What the shared equation genuinely cannot say is WHERE a positive v sits: the
+* far side for a lens, the object's own side for a mirror. Both are "the
+* outgoing side", so `real` is right for both, and the rest is the caller's to
+* draw.
+*
+* ## The convenience that is NOT a convention change
+*
+* Every entry point below takes `objectDistance` as a POSITIVE distance to a
+* real object, because that is what a person measures with a ruler and what
+* every question states. It is negated on the way in, once, in one place.
+* `imageDistance` comes back signed in the Cartesian sense, and the result
+* carries `real` and `upright` flags so a caller never has to remember what the
+* sign meant.
+*
+* Units: whatever the caller uses, consistently. Distances in and distances
+* out. The only exception is `lensPower`, which is dioptres and therefore
+* demands metres, and says so.
+*/
+const finite = (value, what) => {
+	if (!Number.isFinite(value)) throw new RangeError(`${what} must be a finite number.`);
+	return value;
+};
+const positive = (value, what) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${what} must be positive.`);
+	return value;
+};
+/** Translate a textbook real-is-positive object distance into the Cartesian one. */
+const fromRealPositive = (u) => -finite(u, "An object distance");
+/**
+* The one place the imaging equation is solved, shared by both elements.
+*
+* See the comment inside: once the object distance is supplied as a positive
+* length, the lens and mirror equations are the SAME arithmetic, and the two
+* wrappers differ only in what they document and in where a caller draws the
+* result.
+*/
+function formImage(focalLength, objectDistance, objectHeight) {
+	const f = finite(focalLength, "A focal length");
+	const distance = positive(objectDistance, "An object distance");
+	if (f === 0) throw new RangeError("A focal length of zero is not an optical element.");
+	const invV = 1 / f - 1 / distance;
+	const v = invV === 0 ? Number.POSITIVE_INFINITY : 1 / invV;
+	const magnification = -v / distance;
+	const real = v > 0;
+	return {
+		imageDistance: v,
+		objectDistance: distance,
+		focalLength: f,
+		magnification,
+		real: Number.isFinite(v) ? real : false,
+		upright: magnification > 0,
+		enlarged: Math.abs(magnification) > 1,
+		...objectHeight === void 0 ? {} : { imageHeight: magnification * objectHeight }
+	};
+}
+/**
+* Image in a thin lens: 1/v − 1/u = 1/f.
+*
+* `focalLength` is positive for a converging (convex) lens and negative for a
+* diverging (concave) one. A converging lens is the only element here that can
+* make a real image, and only when the object is beyond the focal point; inside
+* it, the same lens is a magnifying glass and the image is virtual, upright and
+* enlarged. Both cases fall out of the one equation rather than needing a
+* branch, which is why there is no branch.
+*/
+function thinLens(focalLength, objectDistance, objectHeight) {
+	return formImage(focalLength, objectDistance, objectHeight);
+}
+/**
+* Image in a spherical mirror: 1/v + 1/u = 1/f, with f = R/2.
+*
+* `focalLength` is positive for a concave (converging) mirror, negative for a
+* convex one. A convex mirror always gives a virtual, upright, diminished image
+* whatever the object distance, which is why it is the one on a car and at a
+* blind corner: it cannot help but show a wide view the right way up.
+*/
+function sphericalMirror(focalLength, objectDistance, objectHeight) {
+	return formImage(focalLength, objectDistance, objectHeight);
+}
+/** Focal length of a mirror from its radius of curvature: f = R/2. */
+const mirrorFocalLength = (radiusOfCurvature) => finite(radiusOfCurvature, "A radius of curvature") / 2;
+/**
+* Refraction at a single spherical surface:
+*
+*     n₂/v − n₁/u = (n₂ − n₁)/R
+*
+* The primitive a lens is built from, and the one that answers questions about
+* a fish in a bowl or a bubble in a glass sphere, where there is only one
+* surface to cross. `radius` is Cartesian: positive when the centre of
+* curvature lies on the outgoing side.
+*
+* A flat surface is R = Infinity, which reduces this to n₂/v = n₁/u and
+* recovers the apparent-depth result. That limit is why `Infinity` is accepted
+* rather than rejected as a non-finite radius.
+*/
+function sphericalSurface(fromIndex, toIndex, radius, objectDistance) {
+	const n1 = positive(fromIndex, "The first refractive index");
+	const n2 = positive(toIndex, "The second refractive index");
+	const u = -positive(objectDistance, "An object distance");
+	if (Number.isNaN(radius)) throw new RangeError("A radius of curvature must be a number or Infinity.");
+	const invV = ((radius === Infinity || radius === -Infinity ? 0 : (n2 - n1) / radius) + n1 / u) / n2;
+	const v = invV === 0 ? Number.POSITIVE_INFINITY : 1 / invV;
+	return {
+		imageDistance: v,
+		magnification: n1 * v / (n2 * u),
+		real: v > 0
+	};
+}
+/**
+* The lens maker's equation, including the surrounding medium:
+*
+*     1/f = (n_lens/n_medium − 1) · (1/R₁ − 1/R₂)
+*
+* The medium is not decoration. A glass lens in water has a much longer focal
+* length because what bends light is the RATIO of the indices, not the glass
+* alone, and a lens made of something with the same index as its surroundings
+* does nothing at all. Push it further and the sign flips: a converging air
+* bubble in water is a diverging lens, which this returns without special
+* handling because the ratio simply drops below 1.
+*
+* Radii are Cartesian. For a biconvex lens R₁ > 0 and R₂ < 0. A flat face is
+* `Infinity`.
+*/
+function lensMakerFocalLength(lensIndex, r1, r2, mediumIndex = 1) {
+	const nl = positive(lensIndex, "The lens refractive index");
+	const nm = positive(mediumIndex, "The medium refractive index");
+	const curvature = (r) => r === Infinity || r === -Infinity ? 0 : 1 / finite(r, "A radius of curvature");
+	const power = (nl / nm - 1) * (curvature(r1) - curvature(r2));
+	if (power === 0) throw new RangeError("This lens has no focusing power: either its faces have matching curvature, or it has the same refractive index as the medium around it.");
+	return 1 / power;
+}
+/**
+* Lens power in dioptres: P = 1/f with f IN METRES.
+*
+* The unit is the reason opticians use it: powers of lenses in contact simply
+* add, so a prescription is a sum rather than a reciprocal of a sum of
+* reciprocals.
+*/
+function lensPower(focalLengthM) {
+	const f = finite(focalLengthM, "A focal length");
+	if (f === 0) throw new RangeError("A focal length of zero has infinite power.");
+	return 1 / f;
+}
+/** Focal length in metres from a power in dioptres. */
+const focalLengthFromPower = (dioptres) => {
+	if (finite(dioptres, "A power") === 0) throw new RangeError("A lens of zero power has no focal length.");
+	return 1 / dioptres;
+};
+/**
+* Two thin lenses in contact: 1/f = 1/f₁ + 1/f₂, or equivalently P = P₁ + P₂.
+*
+* The special case of the separated formula below with d = 0, written out
+* because it is the one that appears in every prescription and every achromatic
+* doublet.
+*/
+function lensesInContact(...focalLengths) {
+	if (focalLengths.length === 0) throw new RangeError("No lenses to combine.");
+	const power = focalLengths.reduce((sum, f) => {
+		if (finite(f, "A focal length") === 0) throw new RangeError("A focal length of zero is not a lens.");
+		return sum + 1 / f;
+	}, 0);
+	if (power === 0) throw new RangeError("These lenses cancel exactly, so the combination has no focal length.");
+	return 1 / power;
+}
+/**
+* Two thin lenses a distance d apart:
+*
+*     1/f = 1/f₁ + 1/f₂ − d/(f₁f₂)
+*
+* The separation term is what makes a telescope a telescope rather than a thick
+* lens. Note it can cancel the other two exactly, at d = f₁ + f₂, which is the
+* telescope's normal adjustment: the combination then has infinite focal length
+* and magnifies without focusing, and this throws rather than returning a
+* division by zero dressed as a number.
+*/
+function lensesSeparated(f1, f2, separation) {
+	const a = finite(f1, "The first focal length");
+	const b = finite(f2, "The second focal length");
+	const d = finite(separation, "The separation");
+	if (a === 0 || b === 0) throw new RangeError("A focal length of zero is not a lens.");
+	const power = 1 / a + 1 / b - d / (a * b);
+	if (power === 0) throw new RangeError("These lenses are separated by exactly f1 + f2, so the pair has no net power: parallel light in, parallel light out. That is a telescope, not a lens.");
+	return 1 / power;
+}
+/**
+* Focal length by the displacement (Bessel) method:
+*
+*     f = (L² − x²) / 4L
+*
+* With the object and screen a fixed distance L apart, there are TWO lens
+* positions giving a sharp image, x apart, and measuring x is far more accurate
+* than locating either one alone. The reason there are two is that the lens
+* equation is symmetric in u and v: swap them and it still holds, so the
+* conjugate positions come in pairs.
+*
+* Requires L > 4f, which is the same statement as x being real. A screen closer
+* than four focal lengths catches no sharp image at all, and this reports that
+* rather than returning a complex-looking number.
+*/
+function displacementMethod(screenDistance, positionGap) {
+	const L = positive(screenDistance, "The object-to-screen distance");
+	const x = finite(positionGap, "The gap between lens positions");
+	if (Math.abs(x) >= L) throw new RangeError("The two lens positions cannot be further apart than the object and screen are.");
+	const focalLength = (L * L - x * x) / (4 * L);
+	const u1 = (L - Math.abs(x)) / 2;
+	const u2 = (L + Math.abs(x)) / 2;
+	return {
+		focalLength,
+		objectDistances: [u1, u2],
+		magnifications: [(L - u1) / u1, (L - u2) / u2]
+	};
+}
+/**
+* The minimum separation between a real object and the real image a converging
+* lens makes of it: L = 4f.
+*
+* Below it there is no solution at all, which is the fact behind the
+* displacement method's requirement and behind the familiar experience that a
+* projector cannot be moved arbitrarily close to its screen.
+*/
+const minimumObjectImageSeparation = (focalLength) => 4 * positive(focalLength, "A focal length");
+
+//#endregion
+export { displacementMethod, focalLengthFromPower, fromRealPositive, lensMakerFocalLength, lensPower, lensesInContact, lensesSeparated, minimumObjectImageSeparation, mirrorFocalLength, sphericalMirror, sphericalSurface, thinLens };

package/dist/optics/index.d.mts

@@ -0,0 +1,7 @@
+import { ApparentDepth, DepthLayer, MEDIA, Refraction, SlabPassage, apparentDepth, brewsterAngleDeg, criticalAngleDeg, indexFromDepths, indexFromRodAngles, refract, refractAngleDeg, relativeIndex, speedInMedium, throughSlab, wavelengthInMedium } from "./refraction.mjs";
+import { DisplacementMethod, Image, displacementMethod, focalLengthFromPower, fromRealPositive, lensMakerFocalLength, lensPower, lensesInContact, lensesSeparated, minimumObjectImageSeparation, mirrorFocalLength, sphericalMirror, sphericalSurface, thinLens } from "./imaging.mjs";
+import { Dispersion, PrismPath, achromaticApexDeg, dispersion, indexFromMinimumDeviation, maximumApexAngleDeg, minimumDeviationDeg, minimumDeviationIncidenceDeg, prismAngleFromMinimumDeviation, prismPath, thinPrismDeviationDeg } from "./prism.mjs";
+import { pathFromPhase, phaseFromPath } from "../waves/wave.mjs";
+import { brightFringePosition, centralMaximumHalfWidthDeg, centralMaximumWidth, darkFringePosition, doubleSlitPattern, fringeAngleDeg, fringeSpacing, gratingAngleDeg, gratingSpacing, malusIntensity, maximumGratingOrder, pointSourceIntensity, rayleighResolutionRad, singleSlitEnvelope, singleSlitMinimumDeg, twoSlitIntensity, unpolarisedThroughPolariser, wavelengthFromFringes, wavelengthFromGrating } from "./wave-optics.mjs";
+import { DEG, OPTICS_LAWS, apparentDepthLaw, brewstersLaw, criticalAngleLaw, fringeSpacingLaw, gratingLaw, indexFromSpeed, lensPowerLaw, magnificationLaw, malusLaw, mirrorEquation, photonEnergyLaw, snellsLaw, thinLensEquation, thinPrismLaw, waveEquation } from "./laws.mjs";
+export { ApparentDepth, DEG, DepthLayer, Dispersion, DisplacementMethod, Image, MEDIA, OPTICS_LAWS, PrismPath, Refraction, SlabPassage, achromaticApexDeg, apparentDepth, apparentDepthLaw, brewsterAngleDeg, brewstersLaw, brightFringePosition, centralMaximumHalfWidthDeg, centralMaximumWidth, criticalAngleDeg, criticalAngleLaw, darkFringePosition, dispersion, displacementMethod, doubleSlitPattern, focalLengthFromPower, fringeAngleDeg, fringeSpacing, fringeSpacingLaw, fromRealPositive, gratingAngleDeg, gratingLaw, gratingSpacing, indexFromDepths, indexFromMinimumDeviation, indexFromRodAngles, indexFromSpeed, lensMakerFocalLength, lensPower, lensPowerLaw, lensesInContact, lensesSeparated, magnificationLaw, malusIntensity, malusLaw, maximumApexAngleDeg, maximumGratingOrder, minimumDeviationDeg, minimumDeviationIncidenceDeg, minimumObjectImageSeparation, mirrorEquation, mirrorFocalLength, pathFromPhase as pathDifference, phaseFromPath as phaseDifference, photonEnergyLaw, pointSourceIntensity, prismAngleFromMinimumDeviation, prismPath, rayleighResolutionRad, refract, refractAngleDeg, relativeIndex, singleSlitEnvelope, singleSlitMinimumDeg, snellsLaw, speedInMedium, sphericalMirror, sphericalSurface, thinLens, thinLensEquation, thinPrismDeviationDeg, thinPrismLaw, throughSlab, twoSlitIntensity, unpolarisedThroughPolariser, waveEquation, wavelengthFromFringes, wavelengthFromGrating, wavelengthInMedium };

package/dist/optics/index.mjs

@@ -0,0 +1,8 @@
+import { MEDIA, apparentDepth, brewsterAngleDeg, criticalAngleDeg, indexFromDepths, indexFromRodAngles, refract, refractAngleDeg, relativeIndex, speedInMedium, throughSlab, wavelengthInMedium } from "./refraction.mjs";
+import { displacementMethod, focalLengthFromPower, fromRealPositive, lensMakerFocalLength, lensPower, lensesInContact, lensesSeparated, minimumObjectImageSeparation, mirrorFocalLength, sphericalMirror, sphericalSurface, thinLens } from "./imaging.mjs";
+import { achromaticApexDeg, dispersion, indexFromMinimumDeviation, maximumApexAngleDeg, minimumDeviationDeg, minimumDeviationIncidenceDeg, prismAngleFromMinimumDeviation, prismPath, thinPrismDeviationDeg } from "./prism.mjs";
+import { pathFromPhase, phaseFromPath } from "../waves/wave.mjs";
+import { brightFringePosition, centralMaximumHalfWidthDeg, centralMaximumWidth, darkFringePosition, doubleSlitPattern, fringeAngleDeg, fringeSpacing, gratingAngleDeg, gratingSpacing, malusIntensity, maximumGratingOrder, pointSourceIntensity, rayleighResolutionRad, singleSlitEnvelope, singleSlitMinimumDeg, twoSlitIntensity, unpolarisedThroughPolariser, wavelengthFromFringes, wavelengthFromGrating } from "./wave-optics.mjs";
+import { DEG, OPTICS_LAWS, apparentDepthLaw, brewstersLaw, criticalAngleLaw, fringeSpacingLaw, gratingLaw, indexFromSpeed, lensPowerLaw, magnificationLaw, malusLaw, mirrorEquation, photonEnergyLaw, snellsLaw, thinLensEquation, thinPrismLaw, waveEquation } from "./laws.mjs";
+
+export { DEG, MEDIA, OPTICS_LAWS, achromaticApexDeg, apparentDepth, apparentDepthLaw, brewsterAngleDeg, brewstersLaw, brightFringePosition, centralMaximumHalfWidthDeg, centralMaximumWidth, criticalAngleDeg, criticalAngleLaw, darkFringePosition, dispersion, displacementMethod, doubleSlitPattern, focalLengthFromPower, fringeAngleDeg, fringeSpacing, fringeSpacingLaw, fromRealPositive, gratingAngleDeg, gratingLaw, gratingSpacing, indexFromDepths, indexFromMinimumDeviation, indexFromRodAngles, indexFromSpeed, lensMakerFocalLength, lensPower, lensPowerLaw, lensesInContact, lensesSeparated, magnificationLaw, malusIntensity, malusLaw, maximumApexAngleDeg, maximumGratingOrder, minimumDeviationDeg, minimumDeviationIncidenceDeg, minimumObjectImageSeparation, mirrorEquation, mirrorFocalLength, pathFromPhase as pathDifference, phaseFromPath as phaseDifference, photonEnergyLaw, pointSourceIntensity, prismAngleFromMinimumDeviation, prismPath, rayleighResolutionRad, refract, refractAngleDeg, relativeIndex, singleSlitEnvelope, singleSlitMinimumDeg, snellsLaw, speedInMedium, sphericalMirror, sphericalSurface, thinLens, thinLensEquation, thinPrismDeviationDeg, thinPrismLaw, throughSlab, twoSlitIntensity, unpolarisedThroughPolariser, waveEquation, wavelengthFromFringes, wavelengthFromGrating, wavelengthInMedium };

package/dist/optics/laws.d.mts

@@ -0,0 +1,70 @@
+import { Relation } from "../relation/index.mjs";
+
+//#region src/optics/laws.d.ts
+/** Multiply a value in degrees by this to get radians, for use in a `solve`. */
+declare const DEG: number;
+/**
+ * `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.
+ */
+declare const snellsLaw: () => Relation;
+/** `sin(c) = n2 / n1`, the critical angle for light leaving the denser medium. */
+declare const criticalAngleLaw: () => Relation;
+/** `n = c / v`, refractive index as the factor by which a medium slows light. */
+declare const indexFromSpeed: () => Relation;
+/** `n = d / a`, refractive index by the apparent-depth method. */
+declare const apparentDepthLaw: () => Relation;
+/** `n = tan(p)`, Brewster's law for the polarising angle. */
+declare const brewstersLaw: () => Relation;
+/**
+ * `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.
+ */
+declare const thinLensEquation: () => Relation;
+/** `1 / v + 1 / u = 1 / f`, the mirror equation with distances as positive lengths. */
+declare const mirrorEquation: () => Relation;
+/** `m = h2 / h1`, linear magnification as a height ratio. */
+declare const magnificationLaw: () => Relation;
+/** `P = 1 / f`, lens power in dioptres from a focal length in metres. */
+declare const lensPowerLaw: () => Relation;
+/** `d = (n - 1) * A`, a thin prism's deviation. */
+declare const thinPrismLaw: () => Relation;
+/** `w = lam * D / a`, the fringe spacing in Young's double-slit experiment. */
+declare const fringeSpacingLaw: () => Relation;
+/**
+ * `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.
+ */
+declare const gratingLaw: () => Relation;
+/** `I = I0 * cos(t)^2`, Malus's law for light through an analyser. */
+declare const malusLaw: () => Relation;
+/** `v = f * lam`, the wave equation, which underlies all of the above. */
+declare const waveEquation: () => Relation;
+/** `E = h * c / lam`, the energy of a photon of a given wavelength. */
+declare const photonEnergyLaw: () => Relation;
+/**
+ * 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.
+ */
+declare const OPTICS_LAWS: () => Relation[];
+//#endregion
+export { DEG, OPTICS_LAWS, apparentDepthLaw, brewstersLaw, criticalAngleLaw, fringeSpacingLaw, gratingLaw, indexFromSpeed, lensPowerLaw, magnificationLaw, malusLaw, mirrorEquation, photonEnergyLaw, snellsLaw, thinLensEquation, thinPrismLaw, waveEquation };