space_units/quantities/

mechanics.rs

use super::DisplayWithUnit;

// Length constants
const METERS_PER_FOOT: f64 = 0.3048;
const METERS_PER_NAUTICAL_MILE: f64 = 1852.0;
const METERS_PER_MILE: f64 = 1609.344;
const METERS_PER_AU: f64 = 149_597_870_700.0;
const METERS_PER_PARSEC: f64 = 3.085_677_581_491_367e16;
const METERS_PER_LIGHT_YEAR: f64 = 9.460_730_472_580_8e15;
const METERS_PER_EARTH_RADIUS: f64 = 6_371_000.0;
const METERS_PER_SOLAR_RADIUS: f64 = 6.957e8;

// Time constants
const SECONDS_PER_MINUTE: f64 = 60.0;
const SECONDS_PER_HOUR: f64 = 3_600.0;
const SECONDS_PER_DAY: f64 = 86_400.0;
const SECONDS_PER_JULIAN_YEAR: f64 = 365.25 * SECONDS_PER_DAY;

// Mass constants
pub(super) const KG_PER_POUND: f64 = 0.453_592_37;
const KG_PER_SLUG: f64 = 14.593_903;
const KG_PER_SOLAR_MASS: f64 = 1.988_92e30;
const KG_PER_EARTH_MASS: f64 = 5.972_2e24;

/// Standard gravity (m/s^2).
pub(super) const G0_MPS2: f64 = 9.806_65;

// Force constants
const NEWTONS_PER_LBF: f64 = 4.448_221_615_260_5;

// -------------------------
// Length
// -------------------------

/// A length / distance quantity, stored canonically in **meters** (m).
///
/// # Construction
/// ```
/// use space_units::prelude::*;
///
/// let a = Length::from_km(384_400.0);
/// let b = 384_400.0.km();        // NumericExt shorthand
/// ```
///
/// # Supported units
///
/// | Constructor         | Accessor          | Unit                  |
/// |---------------------|-------------------|-----------------------|
/// | `from_m`            | `in_m`            | meter (m)             |
/// | `from_km`           | `in_km`           | kilometer (km)        |
/// | `from_mm`           | `in_mm`           | millimeter (mm)       |
/// | `from_cm`           | `in_cm`           | centimeter (cm)       |
/// | `from_um`           | `in_um`           | micrometer (um)       |
/// | `from_nm`           | `in_nm`           | nanometer (nm)        |
/// | `from_au`           | `in_au`           | astronomical unit (AU)|
/// | `from_pc`           | `in_pc`           | parsec (pc)           |
/// | `from_ly`           | `in_ly`           | light-year (ly)       |
/// | `from_ft`           | `in_ft`           | foot (ft)             |
/// | `from_nmi`          | `in_nmi`          | nautical mile (nmi)   |
/// | `from_mi`           | `in_mi`           | statute mile (mi)     |
/// | `from_earth_radii`  | `in_earth_radii`  | Earth radius          |
/// | `from_solar_radii`  | `in_solar_radii`  | Solar radius          |
///
/// # Typed arithmetic
///
/// - [`Length`] / [`Time`] → [`Velocity`]
/// - [`Length`] / [`Velocity`] → [`Time`]
/// - [`Length`] × [`Length`] → [`Area`](crate::Area)
/// - [`Length`] × [`Velocity`] → [`SpecificAngularMomentum`](crate::SpecificAngularMomentum)
/// - [`Length`] × [`Force`] → [`Energy`](crate::Energy)
/// - [`Length`] × [`Area`](crate::Area) → [`Volume`](crate::Volume)
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Length(pub(crate) f64);

/// Display / conversion units for [`Length`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LengthUnit {
    /// Meter (m) -- SI base unit.
    Meter,
    /// Millimeter (mm).
    Millimeter,
    /// Centimeter (cm).
    Centimeter,
    /// Kilometer (km).
    Kilometer,
    /// Micrometer (um).
    Micrometer,
    /// Nanometer (nm).
    Nanometer,
    /// Astronomical unit (AU) -- ~149.6 Gm.
    AstronomicalUnit,
    /// Parsec (pc) -- ~3.086e16 m.
    Parsec,
    /// Light-year (ly) -- ~9.461e15 m.
    LightYear,
    /// International foot (ft) -- 0.3048 m.
    Foot,
    /// Nautical mile (nmi) -- 1852 m.
    NauticalMile,
    /// Statute mile (mi) -- 1609.344 m.
    Mile,
    /// Mean Earth radius -- 6 371 000 m.
    EarthRadius,
    /// Solar radius -- 6.957e8 m.
    SolarRadius,
}

impl LengthUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Meter => "m",
            Self::Millimeter => "mm",
            Self::Centimeter => "cm",
            Self::Kilometer => "km",
            Self::Micrometer => "um",
            Self::Nanometer => "nm",
            Self::AstronomicalUnit => "AU",
            Self::Parsec => "pc",
            Self::LightYear => "ly",
            Self::Foot => "ft",
            Self::NauticalMile => "nmi",
            Self::Mile => "mi",
            Self::EarthRadius => "R_earth",
            Self::SolarRadius => "R_sun",
        }
    }

    const fn meters_per_unit(self) -> f64 {
        match self {
            Self::Meter => 1.0,
            Self::Millimeter => 1e-3,
            Self::Centimeter => 1e-2,
            Self::Kilometer => 1_000.0,
            Self::Micrometer => 1e-6,
            Self::Nanometer => 1e-9,
            Self::AstronomicalUnit => METERS_PER_AU,
            Self::Parsec => METERS_PER_PARSEC,
            Self::LightYear => METERS_PER_LIGHT_YEAR,
            Self::Foot => METERS_PER_FOOT,
            Self::NauticalMile => METERS_PER_NAUTICAL_MILE,
            Self::Mile => METERS_PER_MILE,
            Self::EarthRadius => METERS_PER_EARTH_RADIUS,
            Self::SolarRadius => METERS_PER_SOLAR_RADIUS,
        }
    }
}

impl Length {
    /// Create from meters (canonical unit).
    pub const fn from_m(val: f64) -> Self {
        Self(val)
    }

    /// Create from kilometers. 1 km = 1 000 m.
    pub const fn from_km(val: f64) -> Self {
        Self(val * 1_000.0)
    }

    /// Create from millimeters. 1 mm = 0.001 m.
    pub const fn from_mm(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from centimeters. 1 cm = 0.01 m.
    pub const fn from_cm(val: f64) -> Self {
        Self(val * 1e-2)
    }

    /// Create from micrometers. 1 um = 1e-6 m.
    pub const fn from_um(val: f64) -> Self {
        Self(val * 1e-6)
    }

    /// Create from nanometers. 1 nm = 1e-9 m.
    pub const fn from_nm(val: f64) -> Self {
        Self(val * 1e-9)
    }

    /// Create from astronomical units. 1 AU = 149 597 870 700 m.
    pub const fn from_au(val: f64) -> Self {
        Self(val * METERS_PER_AU)
    }

    /// Create from parsecs. 1 pc = 3.086e16 m.
    pub const fn from_pc(val: f64) -> Self {
        Self(val * METERS_PER_PARSEC)
    }

    /// Create from light-years. 1 ly = 9.461e15 m.
    pub const fn from_ly(val: f64) -> Self {
        Self(val * METERS_PER_LIGHT_YEAR)
    }

    /// Create from feet. 1 ft = 0.3048 m.
    pub const fn from_ft(val: f64) -> Self {
        Self(val * METERS_PER_FOOT)
    }

    /// Create from nautical miles. 1 nmi = 1 852 m.
    pub const fn from_nmi(val: f64) -> Self {
        Self(val * METERS_PER_NAUTICAL_MILE)
    }

    /// Create from statute miles. 1 mi = 1 609.344 m.
    pub const fn from_mi(val: f64) -> Self {
        Self(val * METERS_PER_MILE)
    }

    /// Create from Earth radii. 1 `R_earth` = 6 371 000 m.
    pub const fn from_earth_radii(val: f64) -> Self {
        Self(val * METERS_PER_EARTH_RADIUS)
    }

    /// Create from Solar radii. 1 `R_sun` = 6.957e8 m.
    pub const fn from_solar_radii(val: f64) -> Self {
        Self(val * METERS_PER_SOLAR_RADIUS)
    }

    /// Get value in meters.
    pub const fn in_m(self) -> f64 {
        self.0
    }

    /// Get value in kilometers.
    pub const fn in_km(self) -> f64 {
        self.0 / 1_000.0
    }

    /// Get value in millimeters.
    pub const fn in_mm(self) -> f64 {
        self.0 / 1e-3
    }

    /// Get value in centimeters.
    pub const fn in_cm(self) -> f64 {
        self.0 / 1e-2
    }

    /// Get value in micrometers.
    pub const fn in_um(self) -> f64 {
        self.0 / 1e-6
    }

    /// Get value in nanometers.
    pub const fn in_nm(self) -> f64 {
        self.0 / 1e-9
    }

    /// Get value in astronomical units.
    pub const fn in_au(self) -> f64 {
        self.0 / METERS_PER_AU
    }

    /// Get value in parsecs.
    pub const fn in_pc(self) -> f64 {
        self.0 / METERS_PER_PARSEC
    }

    /// Get value in light-years.
    pub const fn in_ly(self) -> f64 {
        self.0 / METERS_PER_LIGHT_YEAR
    }

    /// Get value in feet.
    pub const fn in_ft(self) -> f64 {
        self.0 / METERS_PER_FOOT
    }

    /// Get value in nautical miles.
    pub const fn in_nmi(self) -> f64 {
        self.0 / METERS_PER_NAUTICAL_MILE
    }

    /// Get value in statute miles.
    pub const fn in_mi(self) -> f64 {
        self.0 / METERS_PER_MILE
    }

    /// Get value in Earth radii.
    pub const fn in_earth_radii(self) -> f64 {
        self.0 / METERS_PER_EARTH_RADIUS
    }

    /// Get value in Solar radii.
    pub const fn in_solar_radii(self) -> f64 {
        self.0 / METERS_PER_SOLAR_RADIUS
    }

    /// Get value in the specified [`LengthUnit`].
    pub fn in_unit(self, unit: LengthUnit) -> f64 {
        self.0 / unit.meters_per_unit()
    }

    /// Return a [`DisplayWithUnit`] for formatted printing in the given unit.
    pub fn display_as(self, unit: LengthUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Absolute value.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Length, "m");

impl_common_ops!(Length);

// -------------------------
// Time
// -------------------------

/// A time duration quantity, stored canonically in **seconds** (s).
///
/// # Construction
/// ```
/// use space_units::prelude::*;
///
/// let t = Time::from_hours(2.0);
/// let t2 = 2.0.hours();          // NumericExt shorthand
/// ```
///
/// # Supported units
///
/// | Constructor          | Accessor          | Unit              |
/// |----------------------|-------------------|-------------------|
/// | `from_s`             | `in_s`            | second (s)        |
/// | `from_ms`            | `in_ms`           | millisecond (ms)  |
/// | `from_us`            | `in_us`           | microsecond (us)  |
/// | `from_ns`            | `in_ns`           | nanosecond (ns)   |
/// | `from_min`           | `in_min`          | minute (min)      |
/// | `from_hours`         | `in_hours`        | hour (h)          |
/// | `from_days`          | `in_days`         | day (d)           |
/// | `from_julian_years`  | `in_julian_years` | Julian year       |
///
/// # Typed arithmetic
///
/// - [`Velocity`] × [`Time`] → [`Length`]
/// - [`Acceleration`] × [`Time`] → [`Velocity`]
/// - [`Force`] × [`Time`] → [`Impulse`]
/// - [`Angle`](crate::Angle) / [`Time`] → [`AngularVelocity`](crate::AngularVelocity)
/// - [`AngularVelocity`](crate::AngularVelocity) × [`Time`] → [`Angle`](crate::Angle)
/// - [`Mass`] / [`Time`] → [`MassFlowRate`](crate::MassFlowRate)
/// - [`Power`](crate::Power) × [`Time`] → [`Energy`](crate::Energy)
/// - [`Time::frequency()`](crate::Time::frequency) → [`Frequency`](crate::Frequency)
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Time(pub(crate) f64);

/// Display / conversion units for [`Time`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TimeUnit {
    /// Second (s) -- SI base unit.
    Second,
    /// Millisecond (ms).
    Millisecond,
    /// Microsecond (us).
    Microsecond,
    /// Nanosecond (ns).
    Nanosecond,
    /// Minute (min) -- 60 s.
    Minute,
    /// Hour (h) -- 3 600 s.
    Hour,
    /// Day (d) -- 86 400 s.
    Day,
    /// Julian year -- 365.25 days.
    JulianYear,
}

impl TimeUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Second => "s",
            Self::Millisecond => "ms",
            Self::Microsecond => "us",
            Self::Nanosecond => "ns",
            Self::Minute => "min",
            Self::Hour => "h",
            Self::Day => "d",
            Self::JulianYear => "julian_yr",
        }
    }

    const fn seconds_per_unit(self) -> f64 {
        match self {
            Self::Second => 1.0,
            Self::Millisecond => 1e-3,
            Self::Microsecond => 1e-6,
            Self::Nanosecond => 1e-9,
            Self::Minute => SECONDS_PER_MINUTE,
            Self::Hour => SECONDS_PER_HOUR,
            Self::Day => SECONDS_PER_DAY,
            Self::JulianYear => SECONDS_PER_JULIAN_YEAR,
        }
    }
}

impl Time {
    /// Create from seconds (canonical unit).
    pub const fn from_s(val: f64) -> Self {
        Self(val)
    }

    /// Create from milliseconds. 1 ms = 0.001 s.
    pub const fn from_ms(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from microseconds. 1 us = 1e-6 s.
    pub const fn from_us(val: f64) -> Self {
        Self(val * 1e-6)
    }

    /// Create from nanoseconds. 1 ns = 1e-9 s.
    pub const fn from_ns(val: f64) -> Self {
        Self(val * 1e-9)
    }

    /// Create from minutes. 1 min = 60 s.
    pub const fn from_min(val: f64) -> Self {
        Self(val * SECONDS_PER_MINUTE)
    }

    /// Create from hours. 1 h = 3 600 s.
    pub const fn from_hours(val: f64) -> Self {
        Self(val * SECONDS_PER_HOUR)
    }

    /// Create from days. 1 d = 86 400 s.
    pub const fn from_days(val: f64) -> Self {
        Self(val * SECONDS_PER_DAY)
    }

    /// Create from Julian years. 1 Julian year = 365.25 days.
    pub const fn from_julian_years(val: f64) -> Self {
        Self(val * SECONDS_PER_JULIAN_YEAR)
    }

    /// Get value in seconds.
    pub const fn in_s(self) -> f64 {
        self.0
    }

    /// Get value in seconds (alias for [`in_s`](Self::in_s)).
    pub const fn in_seconds(self) -> f64 {
        self.0
    }

    /// Get value in minutes.
    pub const fn in_min(self) -> f64 {
        self.0 / SECONDS_PER_MINUTE
    }

    /// Get value in hours.
    pub const fn in_hours(self) -> f64 {
        self.0 / SECONDS_PER_HOUR
    }

    /// Get value in days.
    pub const fn in_days(self) -> f64 {
        self.0 / SECONDS_PER_DAY
    }

    /// Get value in milliseconds.
    pub const fn in_ms(self) -> f64 {
        self.0 / 1e-3
    }

    /// Get value in microseconds.
    pub const fn in_us(self) -> f64 {
        self.0 / 1e-6
    }

    /// Get value in nanoseconds.
    pub const fn in_ns(self) -> f64 {
        self.0 / 1e-9
    }

    /// Get value in Julian years.
    pub const fn in_julian_years(self) -> f64 {
        self.0 / SECONDS_PER_JULIAN_YEAR
    }

    /// Get value in the specified [`TimeUnit`].
    pub fn in_unit(self, unit: TimeUnit) -> f64 {
        self.0 / unit.seconds_per_unit()
    }

    /// Return a [`DisplayWithUnit`] for formatted printing in the given unit.
    pub fn display_as(self, unit: TimeUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Absolute value.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Time, "s");

impl_common_ops!(Time);

// -------------------------
// Mass
// -------------------------

/// A mass quantity, stored canonically in **kilograms** (kg).
///
/// # Construction
/// ```
/// use space_units::prelude::*;
///
/// let m = Mass::from_kg(1000.0);
/// let m2 = 5.0.kg();             // NumericExt shorthand
/// ```
///
/// # Supported units
///
/// | Constructor           | Accessor            | Unit                  |
/// |-----------------------|---------------------|-----------------------|
/// | `from_kg`             | `in_kg`             | kilogram (kg)         |
/// | `from_g`              | `in_g`              | gram (g)              |
/// | `from_lb`             | `in_lb`             | pound (lb)            |
/// | `from_tonnes`         | `in_tonnes`         | metric tonne (t)      |
/// | `from_slug`           | `in_slug`           | slug                  |
/// | `from_solar_masses`   | `in_solar_masses`   | Solar mass (`M_sun`)    |
/// | `from_earth_masses`   | `in_earth_masses`   | Earth mass (`M_earth`)  |
///
/// # Typed arithmetic
///
/// - [`Mass`] × [`Acceleration`] → [`Force`]
/// - [`Mass`] × [`Velocity`] → [`Momentum`]
/// - [`Mass`] / [`Volume`](crate::Volume) → [`Density`](crate::Density)
/// - [`Mass`] / [`Time`] → [`MassFlowRate`](crate::MassFlowRate)
/// - [`Force`] / [`Mass`] → [`Acceleration`]
/// - [`Momentum`] / [`Mass`] → [`Velocity`]
/// - [`Energy`](crate::Energy) / [`Mass`] → [`SpecificEnergy`](crate::SpecificEnergy)
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Mass(pub(crate) f64);

/// Display / conversion units for [`Mass`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MassUnit {
    /// Kilogram (kg) -- SI base unit.
    Kilogram,
    /// Gram (g).
    Gram,
    /// Metric tonne (t) -- 1 000 kg.
    Tonne,
    /// Avoirdupois pound (lb) -- 0.453 592 37 kg.
    Pound,
    /// Slug -- ~14.594 kg.
    Slug,
    /// Solar mass (`M_sun`) -- ~1.989e30 kg.
    SolarMass,
    /// Earth mass (`M_earth`) -- ~5.972e24 kg.
    EarthMass,
}

impl MassUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Kilogram => "kg",
            Self::Gram => "g",
            Self::Tonne => "t",
            Self::Pound => "lb",
            Self::Slug => "slug",
            Self::SolarMass => "M_sun",
            Self::EarthMass => "M_earth",
        }
    }

    const fn kilograms_per_unit(self) -> f64 {
        match self {
            Self::Kilogram => 1.0,
            Self::Gram => 1e-3,
            Self::Tonne => 1e3,
            Self::Pound => KG_PER_POUND,
            Self::Slug => KG_PER_SLUG,
            Self::SolarMass => KG_PER_SOLAR_MASS,
            Self::EarthMass => KG_PER_EARTH_MASS,
        }
    }
}

impl Mass {
    /// Create from kilograms (canonical unit).
    pub const fn from_kg(val: f64) -> Self {
        Self(val)
    }

    /// Create from grams. 1 g = 0.001 kg.
    pub const fn from_g(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from pounds. 1 lb = 0.453 592 37 kg.
    pub const fn from_lb(val: f64) -> Self {
        Self(val * KG_PER_POUND)
    }

    /// Create from metric tonnes. 1 t = 1 000 kg.
    pub const fn from_tonnes(val: f64) -> Self {
        Self(val * 1e3)
    }

    /// Create from slugs. 1 slug = 14.593 903 kg.
    pub const fn from_slug(val: f64) -> Self {
        Self(val * KG_PER_SLUG)
    }

    /// Create from Solar masses. 1 `M_sun` = 1.989e30 kg.
    pub const fn from_solar_masses(val: f64) -> Self {
        Self(val * KG_PER_SOLAR_MASS)
    }

    /// Create from Earth masses. 1 `M_earth` = 5.972e24 kg.
    pub const fn from_earth_masses(val: f64) -> Self {
        Self(val * KG_PER_EARTH_MASS)
    }

    /// Get value in kilograms.
    pub const fn in_kg(self) -> f64 {
        self.0
    }

    /// Get value in grams.
    pub const fn in_g(self) -> f64 {
        self.0 / 1e-3
    }

    /// Get value in pounds.
    pub const fn in_lb(self) -> f64 {
        self.0 / KG_PER_POUND
    }

    /// Get value in metric tonnes.
    pub const fn in_tonnes(self) -> f64 {
        self.0 / 1e3
    }

    /// Get value in slugs.
    pub const fn in_slug(self) -> f64 {
        self.0 / KG_PER_SLUG
    }

    /// Get value in Solar masses.
    pub const fn in_solar_masses(self) -> f64 {
        self.0 / KG_PER_SOLAR_MASS
    }

    /// Get value in Earth masses.
    pub const fn in_earth_masses(self) -> f64 {
        self.0 / KG_PER_EARTH_MASS
    }

    /// Get value in the specified [`MassUnit`].
    pub fn in_unit(self, unit: MassUnit) -> f64 {
        self.0 / unit.kilograms_per_unit()
    }

    /// Return a [`DisplayWithUnit`] for formatted printing in the given unit.
    pub fn display_as(self, unit: MassUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Absolute value.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Mass, "kg");

impl_common_ops!(Mass);

// -------------------------
// Velocity
// -------------------------

/// A velocity quantity, stored canonically in **meters per second** (m/s).
///
/// # Construction
/// ```
/// use space_units::prelude::*;
///
/// let v = Velocity::from_kmps(7.8);
/// let v2 = 7.8.kmps();            // NumericExt shorthand
/// ```
///
/// # Supported units
///
/// | Constructor        | Accessor         | Unit                      |
/// |--------------------|------------------|---------------------------|
/// | `from_mps`         | `in_mps`         | meter/second (m/s)        |
/// | `from_kmps`        | `in_kmps`        | kilometer/second (km/s)   |
/// | `from_kmph`        | `in_kmph`        | kilometer/hour (km/h)     |
/// | `from_kn`          | `in_kn`          | knot (kn)                 |
/// | `from_au_per_day`  | `in_au_per_day`  | AU per day (AU/d)         |
/// | `from_ftps`        | `in_ftps`        | foot/second (ft/s)        |
///
/// # Typed arithmetic
///
/// - [`Velocity`] × [`Time`] → [`Length`]
/// - [`Velocity`] / [`Time`] → [`Acceleration`]
/// - [`Velocity`] × [`Mass`] → [`Momentum`]
/// - [`Velocity`] × [`Length`] → [`SpecificAngularMomentum`](crate::SpecificAngularMomentum)
/// - [`Velocity`] × [`Velocity`] → [`SpecificEnergy`](crate::SpecificEnergy)
/// - [`Velocity`] × [`MassFlowRate`](crate::MassFlowRate) → [`Force`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Velocity(pub(crate) f64);

/// Display / conversion units for [`Velocity`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VelocityUnit {
    /// Meter per second (m/s) -- SI derived.
    MeterPerSecond,
    /// Kilometer per second (km/s).
    KilometerPerSecond,
    /// Kilometer per hour (km/h).
    KilometerPerHour,
    /// Knot (kn) -- 0.514 444 m/s.
    Knot,
    /// Astronomical unit per day (AU/d).
    AuPerDay,
    /// Foot per second (ft/s).
    FootPerSecond,
}

impl VelocityUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::MeterPerSecond => "m/s",
            Self::KilometerPerSecond => "km/s",
            Self::KilometerPerHour => "km/h",
            Self::Knot => "kn",
            Self::AuPerDay => "AU/d",
            Self::FootPerSecond => "ft/s",
        }
    }

    const fn mps_per_unit(self) -> f64 {
        match self {
            Self::MeterPerSecond => 1.0,
            Self::KilometerPerSecond => 1_000.0,
            Self::KilometerPerHour => 1_000.0 / 3_600.0,
            Self::Knot => 0.514_444,
            Self::AuPerDay => METERS_PER_AU / SECONDS_PER_DAY,
            Self::FootPerSecond => METERS_PER_FOOT,
        }
    }
}

impl Velocity {
    /// Create from meters per second (canonical unit).
    pub const fn from_mps(val: f64) -> Self {
        Self(val)
    }

    /// Create from kilometers per second. 1 km/s = 1 000 m/s.
    pub const fn from_kmps(val: f64) -> Self {
        Self(val * 1_000.0)
    }

    /// Create from kilometers per hour. 1 km/h = 1/3.6 m/s.
    pub const fn from_kmph(val: f64) -> Self {
        Self(val * (1_000.0 / 3_600.0))
    }

    /// Create from knots. 1 kn = 0.514 444 m/s.
    pub const fn from_kn(val: f64) -> Self {
        Self(val * 0.514_444)
    }

    /// Create from astronomical units per day. 1 AU/d = 1 731 456.8 m/s.
    pub const fn from_au_per_day(val: f64) -> Self {
        Self(val * (METERS_PER_AU / SECONDS_PER_DAY))
    }

    /// Create from feet per second. 1 ft/s = 0.3048 m/s.
    pub const fn from_ftps(val: f64) -> Self {
        Self(val * METERS_PER_FOOT)
    }

    /// Get value in meters per second.
    pub const fn in_mps(self) -> f64 {
        self.0
    }

    /// Get value in kilometers per second.
    pub const fn in_kmps(self) -> f64 {
        self.0 / 1_000.0
    }

    /// Get value in kilometers per hour.
    pub const fn in_kmph(self) -> f64 {
        self.0 / (1_000.0 / 3_600.0)
    }

    /// Get value in knots.
    pub const fn in_kn(self) -> f64 {
        self.0 / 0.514_444
    }

    /// Get value in astronomical units per day.
    pub const fn in_au_per_day(self) -> f64 {
        self.0 / (METERS_PER_AU / SECONDS_PER_DAY)
    }

    /// Get value in feet per second.
    pub const fn in_ftps(self) -> f64 {
        self.0 / METERS_PER_FOOT
    }

    /// Get value in the specified [`VelocityUnit`].
    pub fn in_unit(self, unit: VelocityUnit) -> f64 {
        self.0 / unit.mps_per_unit()
    }

    /// Return a [`DisplayWithUnit`] for formatted printing in the given unit.
    pub fn display_as(self, unit: VelocityUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Absolute value.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Velocity, "m/s");

impl_common_ops!(Velocity);

// -------------------------
// Acceleration
// -------------------------

/// An acceleration quantity, stored canonically in **meters per second squared** (m/s^2).
///
/// # Construction
/// ```
/// use space_units::prelude::*;
///
/// let a = Acceleration::from_g(1.0);
/// let a2 = 1.0.g0();               // NumericExt shorthand
/// ```
///
/// # Supported units
///
/// | Constructor    | Accessor     | Unit                        |
/// |----------------|--------------|-----------------------------|
/// | `from_mps2`   | `in_mps2`    | m/s^2                       |
/// | `from_g`      | `in_g`       | standard gravity (g0)       |
/// | `from_mgal`   | `in_mgal`    | milligal (mGal) -- 1e-5 m/s^2 |
/// | `from_ftps2`  | `in_ftps2`   | ft/s^2                      |
///
/// # Typed arithmetic
///
/// - [`Acceleration`] × [`Time`] → [`Velocity`]
/// - [`Acceleration`] × [`Mass`] → [`Force`]
/// - [`Force`] / [`Acceleration`] → [`Mass`]
/// - [`GravitationalParameter`](crate::GravitationalParameter) / [`Area`](crate::Area) → [`Acceleration`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Acceleration(pub(crate) f64);

/// Display / conversion units for [`Acceleration`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AccelerationUnit {
    /// Meter per second squared (m/s^2) -- SI derived.
    MeterPerSecondSquared,
    /// Standard gravity (g0) -- 9.806 65 m/s^2.
    StandardGravity,
    /// Milligal (mGal) -- 1e-5 m/s^2.
    Milligal,
    /// Foot per second squared (ft/s^2).
    FootPerSecondSquared,
}

impl AccelerationUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::MeterPerSecondSquared => "m/s^2",
            Self::StandardGravity => "g0",
            Self::Milligal => "mGal",
            Self::FootPerSecondSquared => "ft/s^2",
        }
    }

    const fn mps2_per_unit(self) -> f64 {
        match self {
            Self::MeterPerSecondSquared => 1.0,
            Self::StandardGravity => G0_MPS2,
            Self::Milligal => 1e-5,
            Self::FootPerSecondSquared => METERS_PER_FOOT,
        }
    }
}

impl Acceleration {
    /// Create from meters per second squared (canonical unit).
    pub const fn from_mps2(val: f64) -> Self {
        Self(val)
    }

    /// Create from standard gravities. 1 g0 = 9.806 65 m/s^2.
    pub const fn from_g(val: f64) -> Self {
        Self(val * G0_MPS2)
    }

    /// Create from milligals. 1 mGal = 1e-5 m/s^2.
    pub const fn from_mgal(val: f64) -> Self {
        Self(val * 1e-5)
    }

    /// Create from feet per second squared. 1 ft/s^2 = 0.3048 m/s^2.
    pub const fn from_ftps2(val: f64) -> Self {
        Self(val * METERS_PER_FOOT)
    }

    /// Get value in meters per second squared.
    pub const fn in_mps2(self) -> f64 {
        self.0
    }

    /// Get value in standard gravities.
    pub const fn in_g(self) -> f64 {
        self.0 / G0_MPS2
    }

    /// Get value in milligals.
    pub const fn in_mgal(self) -> f64 {
        self.0 / 1e-5
    }

    /// Get value in feet per second squared.
    pub const fn in_ftps2(self) -> f64 {
        self.0 / METERS_PER_FOOT
    }

    /// Get value in the specified [`AccelerationUnit`].
    pub fn in_unit(self, unit: AccelerationUnit) -> f64 {
        self.0 / unit.mps2_per_unit()
    }

    /// Return a [`DisplayWithUnit`] for formatted printing in the given unit.
    pub fn display_as(self, unit: AccelerationUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Absolute value.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Acceleration, "m/s^2");

impl_common_ops!(Acceleration);

// -------------------------
// Force
// -------------------------

/// A force quantity, stored canonically in **Newtons** (N).
///
/// # Construction
/// ```
/// use space_units::prelude::*;
///
/// let f = Force::from_kn(50.0);
/// let f2 = 50.0.kn();            // NumericExt shorthand
/// ```
///
/// # Supported units
///
/// | Constructor  | Accessor  | Unit               |
/// |--------------|-----------|--------------------|
/// | `from_n`     | `in_n`    | Newton (N)         |
/// | `from_kn`    | `in_kn`   | kilonewton (kN)    |
/// | `from_mn`    | `in_mn`   | meganewton (MN)    |
/// | `from_lbf`   | `in_lbf`  | pound-force (lbf)  |
/// | `from_dyn`   | `in_dyn`  | dyne (dyn)         |
///
/// # Typed arithmetic
///
/// - [`Force`] × [`Length`] → [`Energy`](crate::Energy)
/// - [`Force`] × [`Time`] → [`Impulse`]
/// - [`Force`] / [`Mass`] → [`Acceleration`]
/// - [`Force`] / [`Acceleration`] → [`Mass`]
/// - [`Force`] / [`Area`](crate::Area) → [`Pressure`](crate::Pressure)
/// - [`Force`] / [`MassFlowRate`](crate::MassFlowRate) → [`Velocity`]
/// - [`Force`] / [`Velocity`] → [`MassFlowRate`](crate::MassFlowRate)
/// - [`Energy`](crate::Energy) / [`Length`] → [`Force`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Force(pub(crate) f64);

/// Display / conversion units for [`Force`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ForceUnit {
    /// Newton (N) -- SI derived unit.
    Newton,
    /// Kilonewton (kN) -- 1 000 N.
    KiloNewton,
    /// Meganewton (MN) -- 1 000 000 N.
    MegaNewton,
    /// Pound-force (lbf) -- 4.448 222 N.
    PoundForce,
    /// Dyne (dyn) -- 1e-5 N.
    Dyne,
}

impl ForceUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Newton => "N",
            Self::KiloNewton => "kN",
            Self::MegaNewton => "MN",
            Self::PoundForce => "lbf",
            Self::Dyne => "dyn",
        }
    }

    const fn newtons_per_unit(self) -> f64 {
        match self {
            Self::Newton => 1.0,
            Self::KiloNewton => 1_000.0,
            Self::MegaNewton => 1_000_000.0,
            Self::PoundForce => NEWTONS_PER_LBF,
            Self::Dyne => 1e-5,
        }
    }
}

impl Force {
    /// Create from Newtons (canonical unit).
    pub const fn from_n(val: f64) -> Self {
        Self(val)
    }

    /// Create from kilonewtons. 1 kN = 1 000 N.
    pub const fn from_kn(val: f64) -> Self {
        Self(val * 1_000.0)
    }

    /// Create from meganewtons. 1 MN = 1 000 000 N.
    pub const fn from_mn(val: f64) -> Self {
        Self(val * 1_000_000.0)
    }

    /// Create from pound-force. 1 lbf = 4.448 222 N.
    pub const fn from_lbf(val: f64) -> Self {
        Self(val * NEWTONS_PER_LBF)
    }

    /// Create from dynes. 1 dyn = 1e-5 N.
    pub const fn from_dyn(val: f64) -> Self {
        Self(val * 1e-5)
    }

    /// Get value in Newtons.
    pub const fn in_n(self) -> f64 {
        self.0
    }

    /// Get value in kilonewtons.
    pub const fn in_kn(self) -> f64 {
        self.0 / 1_000.0
    }

    /// Get value in meganewtons.
    pub const fn in_mn(self) -> f64 {
        self.0 / 1_000_000.0
    }

    /// Get value in pound-force.
    pub const fn in_lbf(self) -> f64 {
        self.0 / NEWTONS_PER_LBF
    }

    /// Get value in dynes.
    pub const fn in_dyn(self) -> f64 {
        self.0 / 1e-5
    }

    /// Get value in the specified [`ForceUnit`].
    pub fn in_unit(self, unit: ForceUnit) -> f64 {
        self.0 / unit.newtons_per_unit()
    }

    /// Return a [`DisplayWithUnit`] for formatted printing in the given unit.
    pub fn display_as(self, unit: ForceUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Absolute value.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Force, "N");

impl_common_ops!(Force);

// -------------------------
// Impulse
// -------------------------

/// An impulse quantity, stored canonically in **Newton-seconds** (N*s).
///
/// # Construction
/// ```
/// use space_units::prelude::*;
///
/// let j = Impulse::from_n_s(5000.0);
/// let j2 = Impulse::from_kn_s(5.0);
/// ```
///
/// # Supported units
///
/// | Constructor   | Accessor   | Unit                  |
/// |---------------|------------|-----------------------|
/// | `from_n_s`    | `in_n_s`   | Newton-second (N*s)   |
/// | `from_kn_s`   | `in_kn_s`  | kN*s                  |
/// | `from_lbf_s`  | `in_lbf_s` | pound-force-second    |
///
/// # Typed arithmetic
///
/// - [`Force`] × [`Time`] → [`Impulse`]
/// - [`Impulse`] / [`Mass`] → [`Velocity`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Impulse(pub(crate) f64);

/// Display / conversion units for [`Impulse`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ImpulseUnit {
    /// Newton-second (N*s) -- SI derived.
    NewtonSecond,
    /// Kilonewton-second (kN*s).
    KiloNewtonSecond,
    /// Pound-force-second (lbf*s).
    PoundForceSecond,
}

impl ImpulseUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::NewtonSecond => "N*s",
            Self::KiloNewtonSecond => "kN*s",
            Self::PoundForceSecond => "lbf*s",
        }
    }

    const fn newton_seconds_per_unit(self) -> f64 {
        match self {
            Self::NewtonSecond => 1.0,
            Self::KiloNewtonSecond => 1_000.0,
            Self::PoundForceSecond => NEWTONS_PER_LBF,
        }
    }
}

impl Impulse {
    /// Create from Newton-seconds (canonical unit).
    pub const fn from_n_s(val: f64) -> Self {
        Self(val)
    }

    /// Create from kilonewton-seconds. 1 kN*s = 1 000 N*s.
    pub const fn from_kn_s(val: f64) -> Self {
        Self(val * 1_000.0)
    }

    /// Create from pound-force-seconds. 1 lbf*s = 4.448 222 N*s.
    pub const fn from_lbf_s(val: f64) -> Self {
        Self(val * NEWTONS_PER_LBF)
    }

    /// Get value in Newton-seconds.
    pub const fn in_n_s(self) -> f64 {
        self.0
    }

    /// Get value in kilonewton-seconds.
    pub const fn in_kn_s(self) -> f64 {
        self.0 / 1_000.0
    }

    /// Get value in pound-force-seconds.
    pub const fn in_lbf_s(self) -> f64 {
        self.0 / NEWTONS_PER_LBF
    }

    /// Get value in the specified [`ImpulseUnit`].
    pub fn in_unit(self, unit: ImpulseUnit) -> f64 {
        self.0 / unit.newton_seconds_per_unit()
    }

    /// Return a [`DisplayWithUnit`] for formatted printing in the given unit.
    pub fn display_as(self, unit: ImpulseUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Absolute value.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Impulse, "N\u{00b7}s");

impl_common_ops!(Impulse);

// -------------------------
// Momentum
// -------------------------

/// A momentum quantity, stored canonically in **kg*m/s**.
///
/// # Construction
/// ```
/// use space_units::prelude::*;
///
/// let p = Momentum::from_kg_mps(1000.0);
/// ```
///
/// # Supported units
///
/// | Constructor      | Accessor      | Unit          |
/// |------------------|---------------|---------------|
/// | `from_kg_mps`    | `in_kg_mps`   | kg*m/s        |
///
/// # Typed arithmetic
///
/// - [`Mass`] × [`Velocity`] → [`Momentum`]
/// - [`Momentum`] / [`Mass`] → [`Velocity`]
/// - [`Momentum`] / [`Velocity`] → [`Mass`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Momentum(pub(crate) f64);

impl Momentum {
    /// Create from kg*m/s (canonical and only unit).
    pub const fn from_kg_mps(val: f64) -> Self {
        Self(val)
    }

    /// Get value in kg*m/s.
    pub const fn in_kg_mps(self) -> f64 {
        self.0
    }

    /// Absolute value.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Momentum, "kg\u{00b7}m/s");

impl_common_ops!(Momentum);