eml-stdlib 0.4.0__py3-none-any.whl

eml_stdlib/__init__.py

@@ -0,0 +1,81 @@
+"""eml-stdlib -- EML standard-library prototype.
+
+This package ships *.eml source files (not Python modules). Use
+the helpers below to locate them so a Forge project can wire them
+into its `use stdlib::...` resolver.
+
+Example:
+
+    from eml_stdlib import path_to, list_modules, load_catalog
+
+    sigmoid = path_to('math/sigmoid.eml')   # absolute Path
+    math_dir = path_to('math')              # category directory
+    print(load_catalog()[0])                # introspection metadata
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+__version__ = "0.4.0"
+
+_PACKAGE_ROOT = Path(__file__).resolve().parent
+_CATALOG_PATH = _PACKAGE_ROOT / "catalog.json"
+
+
+def root() -> Path:
+    """Return the directory holding all category subfolders."""
+    return _PACKAGE_ROOT
+
+
+def path_to(relative: str) -> Path:
+    """Resolve a path inside the stdlib (file or directory).
+
+    Raises FileNotFoundError if the resolved path doesn't exist.
+    """
+    target = (_PACKAGE_ROOT / relative).resolve()
+    if not str(target).startswith(str(_PACKAGE_ROOT)):
+        raise ValueError(f"path escapes stdlib: {relative}")
+    if not target.exists():
+        raise FileNotFoundError(target)
+    return target
+
+
+def list_modules(category: str | None = None) -> list[Path]:
+    """Return paths to every .eml file in the stdlib (or one category).
+
+    `category` accepts both flat ("math") and nested ("gaming/noise")
+    paths. Nested subcategories under gaming/ are picked up via rglob
+    so `list_modules("gaming")` returns all 60 gaming kernels.
+    """
+    if category is None:
+        return sorted(_PACKAGE_ROOT.rglob("*.eml"))
+    cat_dir = _PACKAGE_ROOT / category
+    if not cat_dir.is_dir():
+        raise FileNotFoundError(cat_dir)
+    return sorted(cat_dir.rglob("*.eml"))
+
+
+def categories() -> list[str]:
+    """Return the names of every shipped category subdir."""
+    return sorted(
+        p.name for p in _PACKAGE_ROOT.iterdir()
+        if p.is_dir() and not p.name.startswith("_") and not p.name.startswith(".")
+    )
+
+
+def load_catalog() -> list[dict[str, Any]]:
+    """Return the parsed catalog (function-level introspection)."""
+    return json.loads(_CATALOG_PATH.read_text(encoding="utf-8"))
+
+
+__all__ = [
+    "__version__",
+    "root",
+    "path_to",
+    "list_modules",
+    "categories",
+    "load_catalog",
+]

eml_stdlib/ballistics/air_density.eml

@@ -0,0 +1,73 @@
+// air_density.eml -- atmospheric density model.
+//
+// Density falls off roughly exponentially with altitude:
+//
+//   ρ(alt) = ρ₀ * exp(-alt / scale_height)
+//
+// Plus temperature and humidity corrections (ideal gas + saturation
+// vapour pressure).
+//
+// Chain order 1 (one exp). Reference values: ρ₀ = 1.225 kg/m³ at
+// sea level, 15 °C, dry air; scale height ~8434 m.
+
+module air_density;
+
+const RHO_0_SEA_LEVEL: Real = 1.225        // kg/m³, dry air, 15°C
+const SCALE_HEIGHT:    Real = 8434.0       // m
+const T_REF_K:         Real = 288.15       // 15°C in kelvin
+const R_DRY_AIR:       Real = 287.058      // J / (kg K)
+const R_WATER:         Real = 461.495      // J / (kg K)
+
+// Pure-altitude isothermal model.
+@verify(lean, theorem = "air_density_decreases_with_altitude")
+fn density_isothermal(alt_m: Real) -> Real
+    where chain_order <= 1,
+          domain: alt_m >= 0.0
+    ensures (result > 0.0)
+    ensures (result <= RHO_0_SEA_LEVEL)
+{
+    RHO_0_SEA_LEVEL * exp(-alt_m / SCALE_HEIGHT)
+}
+
+// Temperature correction: ρ scales inversely with absolute T at
+// fixed pressure.
+@verify(lean, theorem = "air_density_inverse_temperature")
+fn density_with_temperature(alt_m: Real, t_kelvin: Real) -> Real
+    where chain_order <= 1,
+          domain: alt_m >= 0.0 && t_kelvin > 0.0
+    ensures (result > 0.0)
+{
+    let rho_iso: Real = RHO_0_SEA_LEVEL * exp(-alt_m / SCALE_HEIGHT);
+    rho_iso * T_REF_K / t_kelvin
+}
+
+// Humid-air density: dry-air density minus the water-vapour offset.
+// p_water is saturation vapour pressure (Pa) × relative humidity in [0,1].
+@verify(lean, theorem = "air_density_humid_lower_than_dry")
+fn density_humid(alt_m: Real, t_kelvin: Real,
+                 pressure_pa: Real, humidity_fraction: Real) -> Real
+    where chain_order <= 1,
+          domain: alt_m >= 0.0 && t_kelvin > 0.0 && pressure_pa > 0.0
+    requires (humidity_fraction >= 0.0)
+    requires (humidity_fraction <= 1.0)
+    ensures (result > 0.0)
+{
+    // Saturation vapour pressure (Magnus formula): in Pa, given T in °C.
+    let t_c: Real = t_kelvin - 273.15;
+    let p_sat: Real = 610.78 * exp(17.27 * t_c / (t_c + 237.3));
+    let p_water: Real = humidity_fraction * p_sat;
+    let p_dry: Real = pressure_pa - p_water;
+    p_dry / (R_DRY_AIR * t_kelvin) + p_water / (R_WATER * t_kelvin)
+}
+
+// Convert metres of altitude to a multiplier on sea-level density —
+// useful for the "thinner air = less drag" UI bar.
+@verify(lean, theorem = "density_ratio_in_unit_interval")
+fn density_ratio(alt_m: Real) -> Real
+    where chain_order <= 1,
+          domain: alt_m >= 0.0
+    ensures (result > 0.0)
+    ensures (result <= 1.0)
+{
+    exp(-alt_m / SCALE_HEIGHT)
+}

eml_stdlib/ballistics/ballistic_solver.eml

@@ -0,0 +1,102 @@
+// ballistic_solver.eml -- composes drag/gravity/wind/coriolis/spin
+// into a single trajectory prediction.
+//
+// This is the kernel the longshot calculator UI calls per shot.
+// Inputs:  shooter state (velocity, BC, twist), environmental state
+//          (rho, wind vector, latitude, heading), target state (range).
+// Outputs: drop (m), drift (m), eastward Coriolis component (m),
+//          spin drift (m), time of flight (s), impact velocity (m/s).
+//
+// Each output is reported separately so the post-shot analysis
+// screen can show how much each force contributed.
+//
+// Chain order 1 across the composition (Pejsa-style log + density
+// exp dominate the cost).
+
+module ballistic_solver;
+
+use stdlib::ballistics::drag;
+use stdlib::ballistics::gravity;
+use stdlib::ballistics::wind;
+use stdlib::ballistics::coriolis;
+use stdlib::ballistics::spin_drift;
+use stdlib::ballistics::time_of_flight;
+
+// Time of flight via the Pejsa form (single-step accurate).
+@verify(lean, theorem = "solver_tof_nonneg")
+fn solve_tof(range_m: Real, v_0: Real, k_retard: Real) -> Real
+    where chain_order <= 1,
+          domain: v_0 > 0.0 && k_retard > 0.0 && range_m >= 0.0
+    ensures (result >= 0.0)
+{
+    time_of_flight::tof_pejsa(range_m, v_0, k_retard)
+}
+
+// Gravity drop given the time of flight.
+@verify(lean, theorem = "solver_drop_nonneg")
+fn solve_drop(g: Real, tof: Real) -> Real
+    where chain_order <= 0,
+          domain: g >= 0.0 && tof >= 0.0
+    ensures (result >= 0.0)
+{
+    gravity::drop(g, tof)
+}
+
+// Crosswind drift.
+@verify(lean, theorem = "solver_wind_drift_signed")
+fn solve_wind_drift(v_wind_perp: Real, tof: Real) -> Real
+    where chain_order <= 0,
+          domain: tof >= 0.0
+{
+    wind::drift(v_wind_perp, tof)
+}
+
+// Coriolis horizontal component.
+@verify(lean, theorem = "solver_coriolis_signed")
+fn solve_coriolis_horiz(v_0: Real, latitude_rad: Real, tof: Real) -> Real
+    where chain_order <= 1,
+          domain: tof >= 0.0
+{
+    coriolis::horizontal_drift(v_0, latitude_rad, tof)
+}
+
+// Spin drift via Litz curve.
+@verify(lean, theorem = "solver_spin_drift_nonneg")
+fn solve_spin_drift(stability_factor: Real, tof: Real) -> Real
+    where chain_order <= 1,
+          domain: stability_factor > 0.0 && tof >= 0.0
+    ensures (result >= 0.0)
+{
+    spin_drift::drift_metres_litz(stability_factor, tof)
+}
+
+// Impact velocity at the target via Pejsa retardation.
+@verify(lean, theorem = "solver_impact_velocity_le_muzzle")
+fn solve_impact_velocity(v_0: Real, k_retard: Real, range_m: Real) -> Real
+    where chain_order <= 1,
+          domain: v_0 > 0.0 && k_retard > 0.0 && range_m >= 0.0
+    ensures (result >= 0.0)
+    ensures (result <= v_0)
+{
+    v_0 * exp(-range_m / k_retard)
+}
+
+// Total predicted hold-up in milliradians.
+@verify(lean, theorem = "solver_hold_up_mil_nonneg")
+fn solve_hold_up_mil(drop_m: Real, range_m: Real) -> Real
+    where chain_order <= 0,
+          domain: range_m > 0.0 && drop_m >= 0.0
+    ensures (result >= 0.0)
+{
+    drop_m / range_m * 1000.0
+}
+
+// Total predicted hold-off in milliradians (wind + coriolis + spin).
+@verify(lean, theorem = "solver_hold_off_mil_signed")
+fn solve_hold_off_mil(wind_drift_m: Real, coriolis_m: Real, spin_drift_m: Real,
+                       range_m: Real) -> Real
+    where chain_order <= 0,
+          domain: range_m > 0.0
+{
+    (wind_drift_m + coriolis_m + spin_drift_m) / range_m * 1000.0
+}

eml_stdlib/ballistics/coriolis.eml

@@ -0,0 +1,60 @@
+// coriolis.eml -- Coriolis deflection from Earth's rotation.
+//
+// At the latitudes long-range shooters operate, the Coriolis
+// acceleration is small but non-negligible for shots beyond 1000 m.
+// Two components:
+//
+//   horizontal: 2 * Ω * sin(lat) * v          (always rightward in
+//                                               the N hemisphere,
+//                                               leftward in S)
+//   vertical:   2 * Ω * cos(lat) * v * sin(heading)
+//                                              (Eötvös effect: more
+//                                               apparent drop east-
+//                                               firing, less west)
+//
+// where Ω is Earth's angular velocity and v is muzzle velocity.
+
+module coriolis;
+
+const OMEGA_EARTH: Real = 7.2921159e-5    // rad/s
+
+// Horizontal Coriolis acceleration (m/s²). Sign convention: positive
+// = rightward when facing the line-of-sight in the northern hemisphere.
+@verify(lean, theorem = "coriolis_horizontal_signed")
+fn horizontal_accel(v: Real, latitude_rad: Real) -> Real
+    where chain_order <= 1
+{
+    2.0 * OMEGA_EARTH * sin(latitude_rad) * v
+}
+
+// Vertical (Eötvös) Coriolis acceleration. heading_rad is azimuth
+// of the line of sight, measured east of true north.
+//   positive result = bullet rises (apparent drop reduces)
+//   negative result = bullet drops faster (apparent drop increases)
+@verify(lean, theorem = "coriolis_vertical_signed")
+fn vertical_accel(v: Real, latitude_rad: Real, heading_rad: Real) -> Real
+    where chain_order <= 1
+{
+    2.0 * OMEGA_EARTH * cos(latitude_rad) * v * sin(heading_rad)
+}
+
+// Total horizontal drift over the time of flight. Linearised:
+//   x = ½ * a * t²
+@verify(lean, theorem = "coriolis_drift_signed")
+fn horizontal_drift(v: Real, latitude_rad: Real, time_of_flight: Real) -> Real
+    where chain_order <= 1,
+          domain: time_of_flight >= 0.0
+{
+    0.5 * 2.0 * OMEGA_EARTH * sin(latitude_rad) * v * time_of_flight * time_of_flight
+}
+
+// Vertical drift contribution.
+@verify(lean, theorem = "coriolis_eotvos_signed")
+fn vertical_drift(v: Real, latitude_rad: Real, heading_rad: Real,
+                  time_of_flight: Real) -> Real
+    where chain_order <= 1,
+          domain: time_of_flight >= 0.0
+{
+    0.5 * 2.0 * OMEGA_EARTH * cos(latitude_rad) * v * sin(heading_rad)
+        * time_of_flight * time_of_flight
+}

eml_stdlib/ballistics/drag.eml

@@ -0,0 +1,44 @@
+// drag.eml -- quadratic aerodynamic drag.
+//
+//   F_drag = ½ * rho * v² * C_d * A
+//
+// where rho is air density [kg/m³], v is the airspeed magnitude
+// [m/s], C_d the drag coefficient (dimensionless), and A the
+// reference area [m²].
+//
+// Chain order 0 — pure polynomial in v. The exponential-tail
+// regimes (transonic + supersonic) are folded into C_d, kept as
+// a piecewise table outside this kernel.
+
+module drag;
+
+@verify(lean, theorem = "drag_force_nonneg")
+fn drag_force(rho: Real, v: Real, c_d: Real, area: Real) -> Real
+    where chain_order <= 0,
+          domain: rho >= 0.0 && c_d >= 0.0 && area >= 0.0
+    ensures (result >= 0.0)
+{
+    0.5 * rho * v * v * c_d * area
+}
+
+// Drag deceleration: a_drag = F_drag / m.
+@verify(lean, theorem = "drag_decel_nonneg")
+fn drag_deceleration(rho: Real, v: Real, c_d: Real, area: Real, mass: Real) -> Real
+    where chain_order <= 0,
+          domain: rho >= 0.0 && c_d >= 0.0 && area >= 0.0 && mass > 0.0
+    ensures (result >= 0.0)
+{
+    0.5 * rho * v * v * c_d * area / mass
+}
+
+// Ballistic coefficient form: BC = m / (C_d * A). BC encodes the
+// projectile's resistance to drag in a single number; ammunition
+// manufacturers publish BC instead of C_d/A separately.
+@verify(lean, theorem = "drag_decel_from_bc_nonneg")
+fn drag_decel_from_bc(rho: Real, v: Real, ballistic_coeff: Real) -> Real
+    where chain_order <= 0,
+          domain: rho >= 0.0 && ballistic_coeff > 0.0
+    ensures (result >= 0.0)
+{
+    0.5 * rho * v * v / ballistic_coeff
+}

eml_stdlib/ballistics/gravity.eml

@@ -0,0 +1,52 @@
+// gravity.eml -- ballistic drop from gravity, no drag coupling.
+//
+//   Δy = ½ * g * t²
+//
+// Chain order 0 (pure polynomial). g is positive downward by
+// convention, so the returned drop is a positive distance below
+// the line-of-sight. The full coupled-with-drag drop comes from
+// time_of_flight + this kernel: the ballistic_solver evaluates
+// `drop(g, time_of_flight(...))`.
+
+module gravity;
+
+const G_EARTH: Real = 9.80665   // standard gravity (m/s²)
+
+@verify(lean, theorem = "gravity_drop_monotone_increasing")
+fn drop(g: Real, t: Real) -> Real
+    where chain_order <= 0,
+          domain: g >= 0.0 && t >= 0.0
+    ensures (result >= 0.0)
+{
+    0.5 * g * t * t
+}
+
+@verify(lean, theorem = "gravity_drop_at_zero_is_zero")
+fn drop_at_zero(g: Real) -> Real
+    where chain_order <= 0,
+          domain: g >= 0.0
+    ensures (result == 0.0)
+{
+    0.5 * g * 0.0 * 0.0
+}
+
+// Earth-gravity convenience wrapper.
+fn drop_earth(t: Real) -> Real
+    where chain_order <= 0,
+          domain: t >= 0.0
+    ensures (result >= 0.0)
+{
+    0.5 * G_EARTH * t * t
+}
+
+// Required scope hold-up in *milliradians* given a drop distance
+// at a given range. Used by the ballistic-calculator UI.
+//   hold_up_mil = drop_meters / range_meters * 1000
+@verify(lean, theorem = "hold_up_mil_nonneg")
+fn hold_up_mil(drop_m: Real, range_m: Real) -> Real
+    where chain_order <= 0,
+          domain: drop_m >= 0.0 && range_m > 0.0
+    ensures (result >= 0.0)
+{
+    drop_m / range_m * 1000.0
+}

eml_stdlib/ballistics/muzzle_velocity.eml

@@ -0,0 +1,42 @@
+// muzzle_velocity.eml -- temperature compensation for muzzle velocity.
+//
+// Powder burn rate increases with temperature, raising muzzle
+// velocity. A common rule of thumb:
+//
+//   v_m(T) = v_m(T_ref) + α * (T - T_ref)
+//
+// where α ≈ 1 m/s per °C (roughly 1.5 fps/°F) for typical
+// smokeless powders. The exact slope depends on the powder.
+
+module muzzle_velocity;
+
+const T_REF_C: Real = 21.0     // 70°F reference, °C
+const ALPHA:   Real = 1.0      // m/s per °C, typical
+
+// Linear correction.
+@verify(lean, theorem = "muzzle_velocity_linear_in_temp")
+fn corrected_velocity(v_ref: Real, temp_c: Real, alpha: Real) -> Real
+    where chain_order <= 0,
+          domain: v_ref > 0.0
+{
+    v_ref + alpha * (temp_c - T_REF_C)
+}
+
+// Default-α convenience.
+@verify(lean, theorem = "muzzle_velocity_default_alpha")
+fn corrected_default(v_ref: Real, temp_c: Real) -> Real
+    where chain_order <= 0,
+          domain: v_ref > 0.0
+{
+    v_ref + ALPHA * (temp_c - T_REF_C)
+}
+
+// Powder-temperature sensitivity expressed as percentage change
+// per degree. Used by the calculator UI.
+@verify(lean, theorem = "powder_sensitivity_signed")
+fn percent_change(temp_c: Real, alpha: Real, v_ref: Real) -> Real
+    where chain_order <= 0,
+          domain: v_ref > 0.0
+{
+    alpha * (temp_c - T_REF_C) / v_ref * 100.0
+}

eml_stdlib/ballistics/spin_drift.eml

@@ -0,0 +1,60 @@
+// spin_drift.eml -- horizontal drift from gyroscopic Magnus effect.
+//
+// A spinning projectile precesses slightly off its line-of-flight,
+// causing a horizontal drift in the direction of the spin. For a
+// right-hand twist barrel (the U.S. standard) the drift is to the
+// right.
+//
+// Bryan Litz's curve-fit (Applied Ballistics):
+//
+//   SD_inches = 1.25 * (Sg + 1.2) * tof^1.83
+//
+// where Sg is the gyroscopic stability factor (dimensionless,
+// computed from the Miller stability formula) and tof is time of
+// flight in seconds.
+//
+// This module ships the Litz approximation plus a chain-order-0
+// linear surrogate for FPGA / shader use.
+
+module spin_drift;
+
+// Litz curve-fit. Returns drift in inches.
+@verify(lean, theorem = "spin_drift_litz_nonneg")
+fn drift_inches_litz(stability_factor: Real, time_of_flight: Real) -> Real
+    where chain_order <= 1,
+          domain: stability_factor > 0.0 && time_of_flight >= 0.0
+    ensures (result >= 0.0)
+{
+    1.25 * (stability_factor + 1.2) * pow(time_of_flight, 1.83)
+}
+
+// Same in metres, for the SI side of the calculator.
+@verify(lean, theorem = "spin_drift_litz_metres_nonneg")
+fn drift_metres_litz(stability_factor: Real, time_of_flight: Real) -> Real
+    where chain_order <= 1,
+          domain: stability_factor > 0.0 && time_of_flight >= 0.0
+    ensures (result >= 0.0)
+{
+    0.0254 * 1.25 * (stability_factor + 1.2) * pow(time_of_flight, 1.83)
+}
+
+// Linear surrogate for the budget pipeline:
+//   SD_m = k * tof
+// k tuned so the surrogate matches Litz at tof = 1.0 s.
+@verify(lean, theorem = "spin_drift_surrogate_nonneg")
+fn drift_metres_surrogate(stability_factor: Real, time_of_flight: Real) -> Real
+    where chain_order <= 0,
+          domain: stability_factor > 0.0 && time_of_flight >= 0.0
+    ensures (result >= 0.0)
+{
+    0.0254 * 1.25 * (stability_factor + 1.2) * time_of_flight
+}
+
+// Hold-off in milliradians.
+@verify(lean, theorem = "spin_drift_hold_off_signed")
+fn hold_off_mil(drift_m: Real, range_m: Real) -> Real
+    where chain_order <= 0,
+          domain: range_m > 0.0
+{
+    drift_m / range_m * 1000.0
+}

eml_stdlib/ballistics/time_of_flight.eml

@@ -0,0 +1,79 @@
+// time_of_flight.eml -- iterative time-of-flight under quadratic drag.
+//
+// In vacuum, t = R / v_0. Drag complicates this: the bullet
+// decelerates, so the average velocity is less than v_0 and the
+// true time-of-flight is longer.
+//
+// Two solutions ship here:
+//
+//   tof_vacuum            : R / v_0       (chain 0, baseline only)
+//   tof_constant_decel    : closed-form quadratic, treats drag
+//                            deceleration as constant (chain 0)
+//   tof_pejsa             : Pejsa retardation-coefficient form
+//                            (chain 1, log) — most accurate single-
+//                            step approximation ballistic calculators
+//                            use in the field.
+//
+// For the iterative-solver path, host code calls tof_step with the
+// current (range_remaining, v) state until convergence.
+
+module time_of_flight;
+
+@verify(lean, theorem = "tof_vacuum_nonneg")
+fn tof_vacuum(range_m: Real, v_0: Real) -> Real
+    where chain_order <= 0,
+          domain: v_0 > 0.0 && range_m >= 0.0
+    ensures (result >= 0.0)
+{
+    range_m / v_0
+}
+
+// Constant-deceleration model: v(t) = v_0 - a*t, range = ∫v dt.
+//   R = v_0 * t - ½ * a * t²
+//   t = (v_0 - sqrt(v_0² - 2*a*R)) / a
+@verify(lean, theorem = "tof_constant_decel_nonneg")
+fn tof_constant_decel(range_m: Real, v_0: Real, drag_decel: Real) -> Real
+    where chain_order <= 1,
+          domain: v_0 > 0.0 && range_m >= 0.0 && drag_decel >= 0.0
+    ensures (result >= 0.0)
+{
+    let disc: Real = v_0 * v_0 - 2.0 * drag_decel * range_m;
+    let safe_disc: Real = clamp(disc, 0.0, v_0 * v_0);
+    (v_0 - sqrt(safe_disc)) / clamp(drag_decel, 1.0e-6, 1.0e6)
+}
+
+// Pejsa form: t = R / V_avg, V_avg = (V_0 + V_R) / 2 with
+// V_R = V_0 * exp(-R / k), where k is the retardation coefficient
+// derived from the ballistic coefficient.
+@verify(lean, theorem = "tof_pejsa_nonneg")
+fn tof_pejsa(range_m: Real, v_0: Real, k_retard: Real) -> Real
+    where chain_order <= 1,
+          domain: v_0 > 0.0 && k_retard > 0.0 && range_m >= 0.0
+    ensures (result >= 0.0)
+{
+    let v_remaining: Real = v_0 * exp(-range_m / k_retard);
+    let v_avg: Real = 0.5 * (v_0 + v_remaining);
+    range_m / v_avg
+}
+
+// Single integration step for an iterative solver. dt is the time
+// step; returns the new (range_remaining, v) tuple-ish via two
+// helper functions.
+@verify(lean, theorem = "tof_step_range_decreases")
+fn step_range(range_remaining: Real, v: Real, dt: Real) -> Real
+    where chain_order <= 0,
+          domain: dt >= 0.0 && range_remaining >= 0.0 && v >= 0.0
+    ensures (result <= range_remaining)
+{
+    clamp(range_remaining - v * dt, 0.0, range_remaining)
+}
+
+@verify(lean, theorem = "tof_step_velocity_nonneg")
+fn step_velocity(v: Real, drag_decel: Real, dt: Real) -> Real
+    where chain_order <= 0,
+          domain: drag_decel >= 0.0 && dt >= 0.0
+    requires (v >= 0.0)
+    ensures (result >= 0.0)
+{
+    clamp(v - drag_decel * dt, 0.0, v)
+}

eml_stdlib/ballistics/wind.eml

@@ -0,0 +1,58 @@
+// wind.eml -- crosswind deflection.
+//
+//   drift = v_wind_perp * time_of_flight
+//
+// where v_wind_perp is the wind component perpendicular to the
+// line-of-sight in m/s, and time_of_flight in seconds.
+//
+// First-order approximation; ignores the bullet "lag" effect at
+// transonic speeds. For target distances <= 1500 m at typical
+// rifle velocities this is within 5% of the full integral.
+
+module wind;
+
+@verify(lean, theorem = "wind_drift_signed")
+fn drift(v_wind_perp: Real, time_of_flight: Real) -> Real
+    where chain_order <= 0,
+          domain: time_of_flight >= 0.0
+{
+    v_wind_perp * time_of_flight
+}
+
+// Headwind / tailwind component. Positive = headwind = adds to
+// drag = bullet arrives later. v_wind_along is the wind component
+// parallel to the LOS, sign convention as above.
+@verify(lean, theorem = "wind_extra_drag_signed")
+fn relative_airspeed(v_bullet: Real, v_wind_along: Real) -> Real
+    where chain_order <= 0
+{
+    v_bullet + v_wind_along
+}
+
+// Convert a wind speed + bearing to (perpendicular, along) components
+// relative to the shooter's heading. Heading and bearing both in
+// radians, measured from the shooter's forward direction.
+//   v_perp  =  v_wind * sin(bearing - heading)
+//   v_along = -v_wind * cos(bearing - heading)
+@verify(lean, theorem = "wind_components_pythagorean")
+fn perp_component(v_wind: Real, bearing: Real, heading: Real) -> Real
+    where chain_order <= 1
+{
+    v_wind * sin(bearing - heading)
+}
+
+@verify(lean, theorem = "wind_components_pythagorean")
+fn along_component(v_wind: Real, bearing: Real, heading: Real) -> Real
+    where chain_order <= 1
+{
+    -v_wind * cos(bearing - heading)
+}
+
+// Hold-off in milliradians for a crosswind drift at a given range.
+@verify(lean, theorem = "wind_hold_off_signed")
+fn hold_off_mil(drift_m: Real, range_m: Real) -> Real
+    where chain_order <= 0,
+          domain: range_m > 0.0
+{
+    drift_m / range_m * 1000.0
+}