@classytic/stage 0.2.0 → 0.4.0

package/dist/optics/wave-optics.mjs

@@ -0,0 +1,259 @@
+import { pathFromPhase, phaseFromPath } from "../waves/wave.mjs";
+
+//#region src/optics/wave-optics.ts
+/**
+* Wave optics: interference, diffraction and polarisation.
+*
+* THE MODEL. Everything here follows from two statements. Waves superpose by
+* adding their displacements, and a path difference of one wavelength is a
+* phase difference of 2π:
+*
+*     φ = (2π/λ) · path difference
+*
+* Constructive where the path difference is a whole number of wavelengths,
+* destructive where it is a half-odd number. Young's slits, a single slit's
+* envelope and a grating are the same statement applied to two sources, to a
+* continuum of sources across one opening, and to many evenly spaced ones.
+*
+* THE SIGN THAT CATCHES EVERYONE. For a DOUBLE slit, `a sin θ = nλ` is a
+* BRIGHT fringe. For a SINGLE slit, `a sin θ = nλ` is a DARK one. Same-looking
+* equation, opposite meaning, because in the first `a` separates two sources
+* and in the second it spans one. The functions below are named for what they
+* return (`...Bright...`, `...Minimum...`) rather than for the equation, so the
+* two can never be confused at a call site.
+*
+* UNITS: SI. Wavelengths, slit separations and screen distances in METRES, so a
+* 589 nm line is `589e-9`. Angles come back in degrees to match the geometric
+* side of this package; positions come back in metres.
+*
+* SCOPE. Far-field (Fraunhofer) only. The small-angle fringe spacing assumes
+* the screen is far compared with the slit separation, which every laboratory
+* arrangement satisfies by a factor of thousands; `fringeAngleDeg` is exact and
+* does not assume it.
+*/
+const DEG = Math.PI / 180;
+const toDeg = (r) => r / DEG;
+const positive = (value, what) => {
+	if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${what} must be positive.`);
+	return value;
+};
+const order = (value, what = "An order") => {
+	if (!Number.isInteger(value)) throw new RangeError(`${what} must be a whole number (got ${value}).`);
+	return value;
+};
+/**
+* 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.
+*/
+function fringeSpacing(wavelength, screenDistance, slitSeparation) {
+	return positive(wavelength, "A wavelength") * positive(screenDistance, "The screen distance") / positive(slitSeparation, "The slit separation");
+}
+/** Wavelength from a measured fringe spacing, the inverse of `fringeSpacing`. */
+function wavelengthFromFringes(fringeWidth, screenDistance, slitSeparation) {
+	return positive(fringeWidth, "A fringe width") * positive(slitSeparation, "The slit separation") / positive(screenDistance, "The screen distance");
+}
+/**
+* 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.
+*/
+function brightFringePosition(n, wavelength, screenDistance, slitSeparation) {
+	return order(n, "A fringe order") * fringeSpacing(wavelength, screenDistance, slitSeparation);
+}
+/**
+* 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.
+*/
+function darkFringePosition(n, wavelength, screenDistance, slitSeparation) {
+	return (order(n, "A fringe order") + .5) * fringeSpacing(wavelength, screenDistance, slitSeparation);
+}
+/**
+* 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.
+*/
+function fringeAngleDeg(n, wavelength, slitSeparation) {
+	const s = order(n, "A fringe order") * positive(wavelength, "A wavelength") / positive(slitSeparation, "The slit separation");
+	return Math.abs(s) > 1 ? null : toDeg(Math.asin(s));
+}
+/**
+* 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.
+*/
+const twoSlitIntensity = (peakIntensity, phase) => peakIntensity * Math.cos(phase / 2) ** 2;
+/**
+* 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.
+*/
+function singleSlitEnvelope(thetaDeg, wavelength, slitWidth) {
+	const alpha = Math.PI * positive(slitWidth, "A slit width") * Math.sin(thetaDeg * DEG) / positive(wavelength, "A wavelength");
+	return alpha === 0 ? 1 : (Math.sin(alpha) / alpha) ** 2;
+}
+/**
+* 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.
+*/
+function doubleSlitPattern(thetaDeg, wavelength, slitSeparation, slitWidth, options = {}) {
+	const envelope = singleSlitEnvelope(thetaDeg, wavelength, slitWidth);
+	if (options.interfere === false) return envelope;
+	const beta = Math.PI * positive(slitSeparation, "A slit separation") * Math.sin(thetaDeg * DEG) / positive(wavelength, "A wavelength");
+	return envelope * Math.cos(beta) ** 2;
+}
+/**
+* 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.
+*/
+function singleSlitMinimumDeg(n, wavelength, slitWidth) {
+	const k = order(n, "A minimum order");
+	if (k === 0) throw new RangeError("There is no zeroth minimum: straight ahead is the central MAXIMUM.");
+	const s = k * positive(wavelength, "A wavelength") / positive(slitWidth, "The slit width");
+	return Math.abs(s) > 1 ? null : toDeg(Math.asin(s));
+}
+/**
+* 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.
+*/
+function centralMaximumHalfWidthDeg(wavelength, slitWidth) {
+	return singleSlitMinimumDeg(1, wavelength, slitWidth);
+}
+/**
+* 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.
+*/
+function centralMaximumWidth(wavelength, screenDistance, slitWidth) {
+	return 2 * positive(wavelength, "A wavelength") * positive(screenDistance, "The screen distance") / positive(slitWidth, "The slit width");
+}
+/** Slit spacing from a ruling density: d = 1/N, with N lines per metre. */
+const gratingSpacing = (linesPerMetre) => 1 / positive(linesPerMetre, "The ruling density");
+/**
+* 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.
+*/
+function gratingAngleDeg(n, wavelength, spacing) {
+	const s = order(n, "A grating order") * positive(wavelength, "A wavelength") / positive(spacing, "The grating spacing");
+	return Math.abs(s) > 1 ? null : toDeg(Math.asin(s));
+}
+/**
+* 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.
+*/
+function maximumGratingOrder(wavelength, spacing) {
+	const ratio = positive(spacing, "The grating spacing") / positive(wavelength, "A wavelength");
+	const floor = Math.floor(ratio);
+	return floor === ratio ? floor - 1 : floor;
+}
+/**
+* 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.
+*/
+function wavelengthFromGrating(n, angleDeg, spacing) {
+	const k = order(n, "A grating order");
+	if (k === 0) throw new RangeError("The zeroth order is undeviated for every wavelength, so it measures none of them.");
+	return positive(spacing, "The grating spacing") * Math.sin(angleDeg * DEG) / k;
+}
+/**
+* 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.
+*/
+function malusIntensity(incidentIntensity, analyserAngleDeg) {
+	if (!Number.isFinite(incidentIntensity) || incidentIntensity < 0) throw new RangeError("An intensity cannot be negative.");
+	return incidentIntensity * Math.cos(analyserAngleDeg * DEG) ** 2;
+}
+/**
+* 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.
+*/
+const unpolarisedThroughPolariser = (intensity) => {
+	if (!Number.isFinite(intensity) || intensity < 0) throw new RangeError("An intensity cannot be negative.");
+	return intensity / 2;
+};
+/**
+* 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².
+*/
+function pointSourceIntensity(power, distance) {
+	return positive(power, "A power") / (4 * Math.PI * positive(distance, "A distance") ** 2);
+}
+/**
+* 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.
+*/
+function rayleighResolutionRad(wavelength, aperture) {
+	return 1.22 * positive(wavelength, "A wavelength") / positive(aperture, "An aperture diameter");
+}
+
+//#endregion
+export { brightFringePosition, centralMaximumHalfWidthDeg, centralMaximumWidth, darkFringePosition, doubleSlitPattern, fringeAngleDeg, fringeSpacing, gratingAngleDeg, gratingSpacing, malusIntensity, maximumGratingOrder, pointSourceIntensity, rayleighResolutionRad, singleSlitEnvelope, singleSlitMinimumDeg, twoSlitIntensity, unpolarisedThroughPolariser, wavelengthFromFringes, wavelengthFromGrating };

package/dist/physics/ac/index.d.mts

@@ -0,0 +1,183 @@
+declare namespace ac_d_exports {
+  export { AcState, AcSupply, RectifiedInput, RectifiedPoint, RectifiedTrace, RectifierMode, WavePoint, acCurrentAt, acPeriodS, acRectifiedTrace, acState, acVoltageAt, acWaveTrace, formFactor, integrateSquareOverPeriod, meanAcPowerW, meanOverHalfCycle, meanRectifiedVoltage, meanSquareByIntegration, meanSquareFromPeak, peakFactor, rectify, rippleFrequencyHz, rmsFromPeak };
+}
+/**
+ * @classytic/stage/circuit/ac-waveform — Alternating currents (Cambridge International A Level Physics 9702, chapter 21).
+ *
+ * A sinusoidal supply v(t) = V0 sin(2 pi f t) drives a resistor R, so i(t) = v(t) / R. Three
+ * ideas live here, and only the middle one is hard:
+ *
+ *   period and peak   T = 1/f, and v and i share the same shape because R is constant
+ *   r.m.s.            V_rms = V0 / sqrt(2), DEFINED by equal heating, not by averaging v
+ *   rectification     one diode keeps half the wave, a bridge folds the whole wave up, and a
+ *                     capacitor across the load turns the ripple into a nearly steady line
+ *
+ * The r.m.s. part is the reason this file exists. The mean of v over a whole cycle is zero, so
+ * averaging the wave tells a learner nothing. What is NOT zero is the mean of v squared, because
+ * squaring makes every value positive. Power is v squared over R, so the mean of v squared is
+ * what sets the heating. Take the root of that mean and you have the steady d.c. voltage that
+ * would heat the same resistor at the same rate: root, of the mean, of the square.
+ *
+ * `meanSquareFromPeak` returns the exact answer V0^2 / 2. `meanSquareByIntegration` returns the
+ * SAME number by adding up v^2 across one period with Simpson's rule, reading nothing from the
+ * algebra. The lab draws the integrated value, so the horizontal line on the graph is a measured
+ * mean and not a formula redrawn as a line.
+ *
+ * Everything here is pure, deterministic and React-free, so it can be tested directly.
+ */
+interface AcSupply {
+  /** Peak (maximum) voltage V0, in volts. */
+  peakVoltageV: number;
+  /** Frequency f, in hertz. */
+  frequencyHz: number;
+  /** Load resistance R, in ohms. */
+  resistanceOhm: number;
+}
+/** One diode keeps the positive halves; a bridge of four folds the negative halves up. */
+type RectifierMode = 'half' | 'full';
+/** Period of the supply, T = 1 / f, in seconds. */
+declare function acPeriodS(frequencyHz: number): number;
+/** v(t) = V0 sin(2 pi f t), in volts. */
+declare function acVoltageAt(supply: AcSupply, t: number): number;
+/** i(t) = v(t) / R, in amperes. In phase with v, because a resistor has no phase shift. */
+declare function acCurrentAt(supply: AcSupply, t: number): number;
+/** The r.m.s. value of a SINUSOID from its peak: peak / sqrt(2). Works for volts and amps. */
+declare function rmsFromPeak(peak: number): number;
+/**
+ * Mean of a sine over HALF a cycle: 2 V0 / pi, about 0.637 of the peak.
+ *
+ * Not "the average value of an alternating current", which is zero over a whole
+ * cycle and is why the question always means the half-cycle average. Stating it
+ * as a half-cycle quantity keeps that from being something a student has to
+ * remember as an exception.
+ */
+declare function meanOverHalfCycle(peak: number): number;
+/**
+ * Form factor: r.m.s. divided by the half-cycle mean, about 1.11 for a sine.
+ *
+ * Its job is to say how PEAKY a waveform is. It depends only on the shape, not
+ * on the amplitude, which is the property worth showing: double the supply and
+ * it does not move.
+ */
+declare function formFactor(peak: number): number;
+/** Peak factor: peak divided by r.m.s., exactly root two for a sine. */
+declare function peakFactor(peak: number): number;
+/** The mean of v^2 over a whole cycle, from the algebra: V0^2 / 2. */
+declare function meanSquareFromPeak(peak: number): number;
+/**
+ * The integral of v^2 over ONE whole period, in V^2 s, by Simpson's rule.
+ *
+ * This is the honest route to the mean square: no identity for sin^2 is used anywhere. The exact
+ * answer is V0^2 T / 2, and Simpson's rule on a smooth periodic function reaches it to far more
+ * figures than the lab ever prints. `intervals` is rounded up to an even number, as Simpson's
+ * rule requires.
+ */
+declare function integrateSquareOverPeriod(peakVoltageV: number, frequencyHz: number, intervals?: number): number;
+/** The mean of v^2 over one period, measured by integration: (integral over T) / T. */
+declare function meanSquareByIntegration(peakVoltageV: number, frequencyHz: number, intervals?: number): number;
+/**
+ * Mean power delivered to R, in watts.
+ *
+ * P_mean = V_rms^2 / R = V0^2 / (2 R), which is exactly HALF the peak power. This single number
+ * is what r.m.s. is for: a steady d.c. supply of V_rms volts across the same R delivers it too.
+ */
+declare function meanAcPowerW(supply: AcSupply): number;
+interface AcState {
+  /** Period T = 1/f, s. */
+  periodS: number;
+  peakVoltageV: number;
+  /** I0 = V0 / R, A. */
+  peakCurrentA: number;
+  /** V_rms = V0 / sqrt(2), V. */
+  rmsVoltageV: number;
+  /** I_rms = I0 / sqrt(2) = V_rms / R, A. */
+  rmsCurrentA: number;
+  /** Mean of v^2 over a cycle, measured by integration, V^2. */
+  meanSquareVoltageV2: number;
+  /** Mean of v^2 from the algebra, V0^2 / 2, V^2. The two agree; the lab shows both. */
+  meanSquareExactV2: number;
+  /** Mean power into R, W. */
+  meanPowerW: number;
+  /** Peak power into R, V0^2 / R, W. Twice the mean. */
+  peakPowerW: number;
+}
+/** Everything the lab reads off one supply driving one resistor. */
+declare function acState(supply: AcSupply): AcState;
+interface WavePoint {
+  /** Time, s. */
+  t: number;
+  /** Supply voltage, V. */
+  v: number;
+  /** Current in R, A. */
+  i: number;
+}
+/** The supply sampled over whole cycles. Deterministic: the same input gives the same points. */
+declare function acWaveTrace(supply: AcSupply, cycles?: number, samplesPerCycle?: number): WavePoint[];
+/** What the diodes let through: half-wave keeps v when positive, full-wave folds it up. */
+declare function rectify(v: number, mode: RectifierMode): number;
+/**
+ * Mean of the rectified output over a whole cycle, with no smoothing capacitor.
+ *
+ * Half-wave gives V0 / pi (0.318 V0), because half the cycle is flat zero. Full-wave gives
+ * 2 V0 / pi (0.637 V0). Neither is V_rms: this is a mean HEIGHT, not a heating value.
+ */
+declare function meanRectifiedVoltage(peakVoltageV: number, mode: RectifierMode): number;
+/** The ripple repeats once per cycle after one diode, twice per cycle after a bridge. */
+declare function rippleFrequencyHz(frequencyHz: number, mode: RectifierMode): number;
+interface RectifiedPoint {
+  /** Time, s. */
+  t: number;
+  /** Supply voltage before the diodes, V. */
+  input: number;
+  /** Diode output with no capacitor, V. */
+  rectified: number;
+  /** Voltage across the load with the smoothing capacitor fitted, V. */
+  output: number;
+}
+interface RectifiedTrace {
+  points: RectifiedPoint[];
+  /** Largest output voltage in the last whole cycle, V. */
+  maxV: number;
+  /** Smallest output voltage in the last whole cycle, V. */
+  minV: number;
+  /** Peak-to-peak ripple in the last whole cycle, V. */
+  rippleV: number;
+  /** Mean output over the last whole cycle, V. */
+  meanV: number;
+  /** How often the output dips, Hz. */
+  rippleFrequencyHz: number;
+  /** Time constant R C, s. Compare it with the period: large R C means small ripple. */
+  timeConstantS: number;
+}
+interface RectifiedInput {
+  supply: AcSupply;
+  /** Smoothing capacitance across the load, farads. Zero means no capacitor. */
+  capacitanceF: number;
+  rectifier: RectifierMode;
+  cycles?: number;
+  samplesPerCycle?: number;
+}
+/**
+ * The load voltage after rectification, with an ideal peak-detector capacitor.
+ *
+ * The model is the one a textbook draws: while the rectified wave is above the capacitor
+ * voltage the diodes conduct and the capacitor follows the wave up; once the wave falls away
+ * the diodes stop conducting and the capacitor discharges through R, decaying by
+ * exp(-dt / RC) each step. So the output is
+ *
+ *   v_out(t) = max( rectified(t), v_out(t - dt) * exp(-dt / RC) )
+ *
+ * With no capacitor RC is zero, the decay factor is zero, and the output is the bare rectified
+ * wave. Charging is instantaneous here (ideal diodes, no series resistance), so the trace is in
+ * its steady state from the first peak onward, which is why the ripple and the mean are measured
+ * over the LAST whole cycle. Nothing random and nothing clock-based: same input, same trace.
+ */
+declare function acRectifiedTrace({
+  supply,
+  capacitanceF,
+  rectifier,
+  cycles,
+  samplesPerCycle
+}: RectifiedInput): RectifiedTrace;
+//#endregion
+export { AcState, AcSupply, RectifiedInput, RectifiedPoint, RectifiedTrace, RectifierMode, WavePoint, acCurrentAt, acPeriodS, acRectifiedTrace, acState, acVoltageAt, acWaveTrace, ac_d_exports, formFactor, integrateSquareOverPeriod, meanAcPowerW, meanOverHalfCycle, meanRectifiedVoltage, meanSquareByIntegration, meanSquareFromPeak, peakFactor, rectify, rippleFrequencyHz, rmsFromPeak };

package/dist/physics/ac/index.mjs

@@ -0,0 +1,203 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.mjs";
+
+//#region src/physics/ac.ts
+var ac_exports = /* @__PURE__ */ __exportAll({
+	acCurrentAt: () => acCurrentAt,
+	acPeriodS: () => acPeriodS,
+	acRectifiedTrace: () => acRectifiedTrace,
+	acState: () => acState,
+	acVoltageAt: () => acVoltageAt,
+	acWaveTrace: () => acWaveTrace,
+	formFactor: () => formFactor,
+	integrateSquareOverPeriod: () => integrateSquareOverPeriod,
+	meanAcPowerW: () => meanAcPowerW,
+	meanOverHalfCycle: () => meanOverHalfCycle,
+	meanRectifiedVoltage: () => meanRectifiedVoltage,
+	meanSquareByIntegration: () => meanSquareByIntegration,
+	meanSquareFromPeak: () => meanSquareFromPeak,
+	peakFactor: () => peakFactor,
+	rectify: () => rectify,
+	rippleFrequencyHz: () => rippleFrequencyHz,
+	rmsFromPeak: () => rmsFromPeak
+});
+/** Period of the supply, T = 1 / f, in seconds. */
+function acPeriodS(frequencyHz) {
+	return 1 / frequencyHz;
+}
+/** v(t) = V0 sin(2 pi f t), in volts. */
+function acVoltageAt(supply, t) {
+	return supply.peakVoltageV * Math.sin(2 * Math.PI * supply.frequencyHz * t);
+}
+/** i(t) = v(t) / R, in amperes. In phase with v, because a resistor has no phase shift. */
+function acCurrentAt(supply, t) {
+	return acVoltageAt(supply, t) / supply.resistanceOhm;
+}
+/** The r.m.s. value of a SINUSOID from its peak: peak / sqrt(2). Works for volts and amps. */
+function rmsFromPeak(peak) {
+	return peak / Math.SQRT2;
+}
+/**
+* Mean of a sine over HALF a cycle: 2 V0 / pi, about 0.637 of the peak.
+*
+* Not "the average value of an alternating current", which is zero over a whole
+* cycle and is why the question always means the half-cycle average. Stating it
+* as a half-cycle quantity keeps that from being something a student has to
+* remember as an exception.
+*/
+function meanOverHalfCycle(peak) {
+	return 2 * peak / Math.PI;
+}
+/**
+* Form factor: r.m.s. divided by the half-cycle mean, about 1.11 for a sine.
+*
+* Its job is to say how PEAKY a waveform is. It depends only on the shape, not
+* on the amplitude, which is the property worth showing: double the supply and
+* it does not move.
+*/
+function formFactor(peak) {
+	if (peak === 0) throw new RangeError("A waveform with no amplitude has no form factor.");
+	return rmsFromPeak(peak) / meanOverHalfCycle(peak);
+}
+/** Peak factor: peak divided by r.m.s., exactly root two for a sine. */
+function peakFactor(peak) {
+	if (peak === 0) throw new RangeError("A waveform with no amplitude has no peak factor.");
+	return peak / rmsFromPeak(peak);
+}
+/** The mean of v^2 over a whole cycle, from the algebra: V0^2 / 2. */
+function meanSquareFromPeak(peak) {
+	return peak * peak / 2;
+}
+/**
+* The integral of v^2 over ONE whole period, in V^2 s, by Simpson's rule.
+*
+* This is the honest route to the mean square: no identity for sin^2 is used anywhere. The exact
+* answer is V0^2 T / 2, and Simpson's rule on a smooth periodic function reaches it to far more
+* figures than the lab ever prints. `intervals` is rounded up to an even number, as Simpson's
+* rule requires.
+*/
+function integrateSquareOverPeriod(peakVoltageV, frequencyHz, intervals = 720) {
+	const n = Math.max(2, Math.ceil(intervals / 2) * 2);
+	const T = acPeriodS(frequencyHz);
+	const h = T / n;
+	const square = (t) => {
+		const v = peakVoltageV * Math.sin(2 * Math.PI * frequencyHz * t);
+		return v * v;
+	};
+	let sum = square(0) + square(T);
+	for (let k = 1; k < n; k++) sum += square(k * h) * (k % 2 === 1 ? 4 : 2);
+	return h / 3 * sum;
+}
+/** The mean of v^2 over one period, measured by integration: (integral over T) / T. */
+function meanSquareByIntegration(peakVoltageV, frequencyHz, intervals = 720) {
+	return integrateSquareOverPeriod(peakVoltageV, frequencyHz, intervals) / acPeriodS(frequencyHz);
+}
+/**
+* Mean power delivered to R, in watts.
+*
+* P_mean = V_rms^2 / R = V0^2 / (2 R), which is exactly HALF the peak power. This single number
+* is what r.m.s. is for: a steady d.c. supply of V_rms volts across the same R delivers it too.
+*/
+function meanAcPowerW(supply) {
+	return supply.peakVoltageV * supply.peakVoltageV / (2 * supply.resistanceOhm);
+}
+/** Everything the lab reads off one supply driving one resistor. */
+function acState(supply) {
+	const { peakVoltageV, frequencyHz, resistanceOhm } = supply;
+	const rmsVoltageV = rmsFromPeak(peakVoltageV);
+	return {
+		periodS: acPeriodS(frequencyHz),
+		peakVoltageV,
+		peakCurrentA: peakVoltageV / resistanceOhm,
+		rmsVoltageV,
+		rmsCurrentA: rmsVoltageV / resistanceOhm,
+		meanSquareVoltageV2: meanSquareByIntegration(peakVoltageV, frequencyHz),
+		meanSquareExactV2: meanSquareFromPeak(peakVoltageV),
+		meanPowerW: meanAcPowerW(supply),
+		peakPowerW: peakVoltageV * peakVoltageV / resistanceOhm
+	};
+}
+/** The supply sampled over whole cycles. Deterministic: the same input gives the same points. */
+function acWaveTrace(supply, cycles = 2, samplesPerCycle = 120) {
+	const n = Math.max(4, Math.round(samplesPerCycle));
+	const steps = Math.max(1, Math.round(cycles)) * n;
+	const dt = acPeriodS(supply.frequencyHz) / n;
+	const points = [];
+	for (let k = 0; k <= steps; k++) {
+		const t = k * dt;
+		const v = acVoltageAt(supply, t);
+		points.push({
+			t,
+			v,
+			i: v / supply.resistanceOhm
+		});
+	}
+	return points;
+}
+/** What the diodes let through: half-wave keeps v when positive, full-wave folds it up. */
+function rectify(v, mode) {
+	return mode === "half" ? Math.max(0, v) : Math.abs(v);
+}
+/**
+* Mean of the rectified output over a whole cycle, with no smoothing capacitor.
+*
+* Half-wave gives V0 / pi (0.318 V0), because half the cycle is flat zero. Full-wave gives
+* 2 V0 / pi (0.637 V0). Neither is V_rms: this is a mean HEIGHT, not a heating value.
+*/
+function meanRectifiedVoltage(peakVoltageV, mode) {
+	return mode === "half" ? peakVoltageV / Math.PI : 2 * peakVoltageV / Math.PI;
+}
+/** The ripple repeats once per cycle after one diode, twice per cycle after a bridge. */
+function rippleFrequencyHz(frequencyHz, mode) {
+	return mode === "half" ? frequencyHz : 2 * frequencyHz;
+}
+/**
+* The load voltage after rectification, with an ideal peak-detector capacitor.
+*
+* The model is the one a textbook draws: while the rectified wave is above the capacitor
+* voltage the diodes conduct and the capacitor follows the wave up; once the wave falls away
+* the diodes stop conducting and the capacitor discharges through R, decaying by
+* exp(-dt / RC) each step. So the output is
+*
+*   v_out(t) = max( rectified(t), v_out(t - dt) * exp(-dt / RC) )
+*
+* With no capacitor RC is zero, the decay factor is zero, and the output is the bare rectified
+* wave. Charging is instantaneous here (ideal diodes, no series resistance), so the trace is in
+* its steady state from the first peak onward, which is why the ripple and the mean are measured
+* over the LAST whole cycle. Nothing random and nothing clock-based: same input, same trace.
+*/
+function acRectifiedTrace({ supply, capacitanceF, rectifier, cycles = 2, samplesPerCycle = 180 }) {
+	const n = Math.max(8, Math.round(samplesPerCycle));
+	const steps = Math.max(1, Math.round(cycles)) * n;
+	const dt = acPeriodS(supply.frequencyHz) / n;
+	const timeConstantS = supply.resistanceOhm * capacitanceF;
+	const decay = timeConstantS > 0 ? Math.exp(-dt / timeConstantS) : 0;
+	const points = [];
+	let held = 0;
+	for (let k = 0; k <= steps; k++) {
+		const t = k * dt;
+		const input = acVoltageAt(supply, t);
+		const rectified = rectify(input, rectifier);
+		held = Math.max(rectified, held * decay);
+		points.push({
+			t,
+			input,
+			rectified,
+			output: held
+		});
+	}
+	const window = points.slice(steps - n, steps).map((p) => p.output);
+	const maxV = Math.max(...window);
+	const minV = Math.min(...window);
+	return {
+		points,
+		maxV,
+		minV,
+		rippleV: maxV - minV,
+		meanV: window.reduce((sum, v) => sum + v, 0) / window.length,
+		rippleFrequencyHz: rippleFrequencyHz(supply.frequencyHz, rectifier),
+		timeConstantS
+	};
+}
+
+//#endregion
+export { acCurrentAt, acPeriodS, acRectifiedTrace, acState, acVoltageAt, acWaveTrace, ac_exports, formFactor, integrateSquareOverPeriod, meanAcPowerW, meanOverHalfCycle, meanRectifiedVoltage, meanSquareByIntegration, meanSquareFromPeak, peakFactor, rectify, rippleFrequencyHz, rmsFromPeak };