space_units/

numeric_ext.rs

use crate::quantities::{
    Acceleration, Angle, Area, Capacitance, ElectricCharge, ElectricCurrent, Energy, Force,
    Frequency, Inductance, Length, MagneticFlux, MagneticFluxDensity, Mass, MassFlowRate, Power,
    Pressure, Resistance, SolidAngle, Temperature, Time, Velocity, Voltage, Volume,
};

/// Extension methods on numeric literals for constructing typed quantities.
///
/// This is the primary construction UX — it turns bare numbers into typed
/// quantities so code reads like English:
///
/// ```
/// use space_units::prelude::*;
///
/// let distance = 384_400.km();   // Length
/// let time     = 3.5.hours();    // Time
/// let angle    = 51.6.deg();     // Angle
/// ```
///
/// Implemented for `f64`, `f32`, `i32`, `i64`, `u32`, and `u64`.
/// Integer types convert to `f64` internally.
pub trait NumericExt {
    /// Create a [`Length`] in meters.
    fn m(self) -> Length;
    /// Create a [`Length`] in kilometers.
    fn km(self) -> Length;
    /// Create a [`Length`] in astronomical units.
    fn au(self) -> Length;
    /// Create a [`Length`] in feet.
    fn ft(self) -> Length;

    /// Create a [`Time`] in seconds.
    fn seconds(self) -> Time;
    /// Create a [`Time`] in minutes.
    fn minutes(self) -> Time;
    /// Create a [`Time`] in hours.
    fn hours(self) -> Time;
    /// Create a [`Time`] in days (86 400 s).
    fn days(self) -> Time;

    /// Create a [`Mass`] in kilograms.
    fn kg(self) -> Mass;
    /// Create a [`Mass`] in grams.
    fn g(self) -> Mass;
    /// Create a [`Mass`] in pounds (avoirdupois).
    fn lb(self) -> Mass;

    /// Create an [`Angle`] in radians.
    fn rad(self) -> Angle;
    /// Create an [`Angle`] in degrees.
    fn deg(self) -> Angle;
    /// Create an [`Angle`] in revolutions (1 rev = 2π rad).
    fn rev(self) -> Angle;

    /// Create a [`Velocity`] in meters per second.
    fn mps(self) -> Velocity;
    /// Create a [`Velocity`] in kilometers per second.
    fn kmps(self) -> Velocity;

    /// Create an [`Acceleration`] in meters per second squared.
    fn mps2(self) -> Acceleration;
    /// Create an [`Acceleration`] in standard gravities (1 g₀ = 9.80665 m/s²).
    fn g0(self) -> Acceleration;

    /// Create a [`Force`] in Newtons.
    fn n(self) -> Force;
    /// Create a [`Force`] in kilonewtons.
    fn kn(self) -> Force;
    /// Create a [`Force`] in pounds-force.
    fn lbf(self) -> Force;

    /// Create an [`Area`] in square meters.
    fn m2(self) -> Area;
    /// Create a [`Volume`] in cubic meters.
    fn m3(self) -> Volume;

    /// Create an [`Energy`] in Joules.
    fn j(self) -> Energy;
    /// Create a [`Power`] in Watts.
    fn w(self) -> Power;

    /// Create a [`Pressure`] in Pascals.
    fn pa(self) -> Pressure;
    /// Create a [`Pressure`] in bar (1 bar = 100 000 Pa).
    fn bar(self) -> Pressure;

    /// Create a [`Frequency`] in Hertz.
    fn hz(self) -> Frequency;
    /// Create a [`Frequency`] in kilohertz.
    fn khz(self) -> Frequency;
    /// Create a [`Frequency`] in megahertz.
    fn mhz(self) -> Frequency;
    /// Create a [`Frequency`] in gigahertz.
    fn ghz(self) -> Frequency;

    /// Create an [`ElectricCurrent`] in Amperes.
    fn amperes(self) -> ElectricCurrent;
    /// Create a [`Voltage`] in Volts.
    fn volts(self) -> Voltage;
    /// Create a [`Resistance`] in Ohms.
    fn ohms(self) -> Resistance;
    /// Create a [`MagneticFluxDensity`] in Tesla.
    fn tesla(self) -> MagneticFluxDensity;
    /// Create an [`ElectricCharge`] in Coulombs.
    fn coulombs(self) -> ElectricCharge;
    /// Create a [`Capacitance`] in Farads.
    fn farads(self) -> Capacitance;
    /// Create an [`Inductance`] in Henrys.
    fn henrys(self) -> Inductance;
    /// Create a [`MagneticFlux`] in Webers.
    fn webers(self) -> MagneticFlux;

    /// Create a [`Temperature`] in Kelvin.
    fn kelvin(self) -> Temperature;

    /// Create a [`MassFlowRate`] in kilograms per second.
    fn kgps(self) -> MassFlowRate;

    /// Create a [`SolidAngle`] in steradians.
    fn sr(self) -> SolidAngle;
}

impl NumericExt for f64 {
    fn m(self) -> Length {
        Length::from_m(self)
    }

    fn km(self) -> Length {
        Length::from_km(self)
    }

    fn au(self) -> Length {
        Length::from_au(self)
    }

    fn ft(self) -> Length {
        Length::from_ft(self)
    }

    fn seconds(self) -> Time {
        Time::from_s(self)
    }

    fn minutes(self) -> Time {
        Time::from_min(self)
    }

    fn hours(self) -> Time {
        Time::from_hours(self)
    }

    fn days(self) -> Time {
        Time::from_days(self)
    }

    fn kg(self) -> Mass {
        Mass::from_kg(self)
    }

    fn g(self) -> Mass {
        Mass::from_g(self)
    }

    fn lb(self) -> Mass {
        Mass::from_lb(self)
    }

    fn rad(self) -> Angle {
        Angle::from_rad(self)
    }

    fn deg(self) -> Angle {
        Angle::from_deg(self)
    }

    fn rev(self) -> Angle {
        Angle::from_rev(self)
    }

    fn mps(self) -> Velocity {
        Velocity::from_mps(self)
    }

    fn kmps(self) -> Velocity {
        Velocity::from_kmps(self)
    }

    fn mps2(self) -> Acceleration {
        Acceleration::from_mps2(self)
    }

    fn g0(self) -> Acceleration {
        Acceleration::from_g(self)
    }

    fn n(self) -> Force {
        Force::from_n(self)
    }

    fn kn(self) -> Force {
        Force::from_kn(self)
    }

    fn lbf(self) -> Force {
        Force::from_lbf(self)
    }

    fn m2(self) -> Area {
        Area::from_m2(self)
    }

    fn m3(self) -> Volume {
        Volume::from_m3(self)
    }

    fn j(self) -> Energy {
        Energy::from_j(self)
    }

    fn w(self) -> Power {
        Power::from_w(self)
    }

    fn pa(self) -> Pressure {
        Pressure::from_pa(self)
    }

    fn bar(self) -> Pressure {
        Pressure::from_bar(self)
    }

    fn hz(self) -> Frequency {
        Frequency::from_hz(self)
    }

    fn khz(self) -> Frequency {
        Frequency::from_khz(self)
    }

    fn mhz(self) -> Frequency {
        Frequency::from_mhz(self)
    }

    fn ghz(self) -> Frequency {
        Frequency::from_ghz(self)
    }

    fn amperes(self) -> ElectricCurrent {
        ElectricCurrent::from_a(self)
    }

    fn volts(self) -> Voltage {
        Voltage::from_v(self)
    }

    fn ohms(self) -> Resistance {
        Resistance::from_ohm(self)
    }

    fn tesla(self) -> MagneticFluxDensity {
        MagneticFluxDensity::from_t(self)
    }

    fn coulombs(self) -> ElectricCharge {
        ElectricCharge::from_c(self)
    }

    fn farads(self) -> Capacitance {
        Capacitance::from_f(self)
    }

    fn henrys(self) -> Inductance {
        Inductance::from_h(self)
    }

    fn webers(self) -> MagneticFlux {
        MagneticFlux::from_wb(self)
    }

    fn kelvin(self) -> Temperature {
        Temperature::from_k(self)
    }

    fn kgps(self) -> MassFlowRate {
        MassFlowRate::from_kgps(self)
    }

    fn sr(self) -> SolidAngle {
        SolidAngle::from_sr(self)
    }
}

// Blanket macro for all non-f64 numeric types. Delegates every method to the
// canonical f64 impl via `self as f64`. The `#[allow]` covers:
//   - cast_lossless  : f32/i32/u32 → f64 (lossless but clippy prefers From)
//   - cast_precision_loss : i64/u64 → f64 (intentionally lossy — documented on NumericExt)
macro_rules! impl_numeric_ext_for {
    ($t:ty) => {
        #[allow(clippy::cast_lossless, clippy::cast_precision_loss)]
        impl NumericExt for $t {
            fn m(self) -> Length {
                <f64 as NumericExt>::m(self as f64)
            }

            fn km(self) -> Length {
                <f64 as NumericExt>::km(self as f64)
            }

            fn au(self) -> Length {
                <f64 as NumericExt>::au(self as f64)
            }

            fn ft(self) -> Length {
                <f64 as NumericExt>::ft(self as f64)
            }

            fn seconds(self) -> Time {
                <f64 as NumericExt>::seconds(self as f64)
            }

            fn minutes(self) -> Time {
                <f64 as NumericExt>::minutes(self as f64)
            }

            fn hours(self) -> Time {
                <f64 as NumericExt>::hours(self as f64)
            }

            fn days(self) -> Time {
                <f64 as NumericExt>::days(self as f64)
            }

            fn kg(self) -> Mass {
                <f64 as NumericExt>::kg(self as f64)
            }

            fn g(self) -> Mass {
                <f64 as NumericExt>::g(self as f64)
            }

            fn lb(self) -> Mass {
                <f64 as NumericExt>::lb(self as f64)
            }

            fn rad(self) -> Angle {
                <f64 as NumericExt>::rad(self as f64)
            }

            fn deg(self) -> Angle {
                <f64 as NumericExt>::deg(self as f64)
            }

            fn rev(self) -> Angle {
                <f64 as NumericExt>::rev(self as f64)
            }

            fn mps(self) -> Velocity {
                <f64 as NumericExt>::mps(self as f64)
            }

            fn kmps(self) -> Velocity {
                <f64 as NumericExt>::kmps(self as f64)
            }

            fn mps2(self) -> Acceleration {
                <f64 as NumericExt>::mps2(self as f64)
            }

            fn g0(self) -> Acceleration {
                <f64 as NumericExt>::g0(self as f64)
            }

            fn n(self) -> Force {
                <f64 as NumericExt>::n(self as f64)
            }

            fn kn(self) -> Force {
                <f64 as NumericExt>::kn(self as f64)
            }

            fn lbf(self) -> Force {
                <f64 as NumericExt>::lbf(self as f64)
            }

            fn m2(self) -> Area {
                <f64 as NumericExt>::m2(self as f64)
            }

            fn m3(self) -> Volume {
                <f64 as NumericExt>::m3(self as f64)
            }

            fn j(self) -> Energy {
                <f64 as NumericExt>::j(self as f64)
            }

            fn w(self) -> Power {
                <f64 as NumericExt>::w(self as f64)
            }

            fn pa(self) -> Pressure {
                <f64 as NumericExt>::pa(self as f64)
            }

            fn bar(self) -> Pressure {
                <f64 as NumericExt>::bar(self as f64)
            }

            fn hz(self) -> Frequency {
                <f64 as NumericExt>::hz(self as f64)
            }

            fn khz(self) -> Frequency {
                <f64 as NumericExt>::khz(self as f64)
            }

            fn mhz(self) -> Frequency {
                <f64 as NumericExt>::mhz(self as f64)
            }

            fn ghz(self) -> Frequency {
                <f64 as NumericExt>::ghz(self as f64)
            }

            fn amperes(self) -> ElectricCurrent {
                <f64 as NumericExt>::amperes(self as f64)
            }

            fn volts(self) -> Voltage {
                <f64 as NumericExt>::volts(self as f64)
            }

            fn ohms(self) -> Resistance {
                <f64 as NumericExt>::ohms(self as f64)
            }

            fn tesla(self) -> MagneticFluxDensity {
                <f64 as NumericExt>::tesla(self as f64)
            }

            fn coulombs(self) -> ElectricCharge {
                <f64 as NumericExt>::coulombs(self as f64)
            }

            fn farads(self) -> Capacitance {
                <f64 as NumericExt>::farads(self as f64)
            }

            fn henrys(self) -> Inductance {
                <f64 as NumericExt>::henrys(self as f64)
            }

            fn webers(self) -> MagneticFlux {
                <f64 as NumericExt>::webers(self as f64)
            }

            fn kelvin(self) -> Temperature {
                <f64 as NumericExt>::kelvin(self as f64)
            }

            fn kgps(self) -> MassFlowRate {
                <f64 as NumericExt>::kgps(self as f64)
            }

            fn sr(self) -> SolidAngle {
                <f64 as NumericExt>::sr(self as f64)
            }
        }
    };
}

impl_numeric_ext_for!(f32);
impl_numeric_ext_for!(i32);
impl_numeric_ext_for!(i64);
impl_numeric_ext_for!(u32);
impl_numeric_ext_for!(u64);