space_units/quantities/

mod.rs

use core::fmt;

/// A display helper returned by `Quantity::display_as(Unit)`.
///
/// Respects all `fmt::Formatter` flags (precision, width, alignment, etc.):
/// ```
/// # use space_units::prelude::*;
/// let d = 384_400.km();
/// assert_eq!(format!("{:.2}", d.display_as(LengthUnit::Kilometer)), "384400.00 km");
/// ```
#[derive(Debug, Clone, Copy)]
pub struct DisplayWithUnit {
    pub(crate) value: f64,
    pub(crate) symbol: &'static str,
}

impl fmt::Display for DisplayWithUnit {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt(&self.value, f)?;
        write!(f, " {}", self.symbol)
    }
}

macro_rules! impl_common_ops {
    ($t:ty) => {
        impl core::ops::Add for $t {
            type Output = Self;
            fn add(self, rhs: Self) -> Self {
                Self(self.0 + rhs.0)
            }
        }

        impl core::ops::Sub for $t {
            type Output = Self;
            fn sub(self, rhs: Self) -> Self {
                Self(self.0 - rhs.0)
            }
        }

        impl core::ops::Neg for $t {
            type Output = Self;
            fn neg(self) -> Self {
                Self(-self.0)
            }
        }

        impl core::ops::Mul<f64> for $t {
            type Output = Self;
            fn mul(self, rhs: f64) -> Self {
                Self(self.0 * rhs)
            }
        }

        impl core::ops::Mul<$t> for f64 {
            type Output = $t;
            #[allow(clippy::suspicious_arithmetic_impl)]
            fn mul(self, rhs: $t) -> $t {
                // Reverse multiplication: scalar * quantity = quantity * scalar
                rhs * self
            }
        }

        impl core::ops::Div<f64> for $t {
            type Output = Self;
            fn div(self, rhs: f64) -> Self {
                Self(self.0 / rhs)
            }
        }

        impl core::ops::Div for $t {
            type Output = f64;
            fn div(self, rhs: Self) -> f64 {
                self.0 / rhs.0
            }
        }

        impl core::ops::AddAssign for $t {
            fn add_assign(&mut self, rhs: Self) {
                self.0 += rhs.0;
            }
        }

        impl core::ops::SubAssign for $t {
            fn sub_assign(&mut self, rhs: Self) {
                self.0 -= rhs.0;
            }
        }

        impl core::ops::MulAssign<f64> for $t {
            fn mul_assign(&mut self, rhs: f64) {
                self.0 *= rhs;
            }
        }

        impl core::ops::DivAssign<f64> for $t {
            fn div_assign(&mut self, rhs: f64) {
                self.0 /= rhs;
            }
        }

        impl core::iter::Sum for $t {
            fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
                Self(iter.map(|v| v.0).sum::<f64>())
            }
        }
    };
}

macro_rules! impl_quantity_display {
    ($t:ty, $symbol:expr) => {
        impl core::fmt::Display for $t {
            fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
                core::fmt::Display::fmt(&self.0, f)?;
                f.write_str(concat!(" ", $symbol))
            }
        }
    };
}

// Domain modules — macro must be defined before these declarations.
mod angular;
mod electromagnetic;
mod energy;
mod geometry;
mod mechanics;
mod orbital;
mod propulsion;
mod radiation;
mod thermal;
mod waves;

// Re-export everything so `use space_units::quantities::*` still works.
pub use angular::*;
pub use electromagnetic::*;
pub use energy::*;
pub use geometry::*;
pub use mechanics::*;
pub use orbital::*;
pub use propulsion::*;
pub use radiation::*;
pub use thermal::*;
pub use waves::*;

// =========================================================================
// Typed arithmetic graph
// =========================================================================

use core::ops::{Div, Mul};

// --- Mechanics ---

// Length / Time -> Velocity
impl Div<Time> for Length {
    type Output = Velocity;
    fn div(self, rhs: Time) -> Velocity {
        Velocity(self.0 / rhs.0)
    }
}

// Length / Velocity -> Time
impl Div<Velocity> for Length {
    type Output = Time;
    fn div(self, rhs: Velocity) -> Time {
        Time(self.0 / rhs.0)
    }
}

// Velocity * Time -> Length
impl Mul<Time> for Velocity {
    type Output = Length;
    fn mul(self, rhs: Time) -> Length {
        Length(self.0 * rhs.0)
    }
}

impl Mul<Velocity> for Time {
    type Output = Length;
    fn mul(self, rhs: Velocity) -> Length {
        Length(self.0 * rhs.0)
    }
}

// Acceleration * Time -> Velocity
impl Mul<Time> for Acceleration {
    type Output = Velocity;
    fn mul(self, rhs: Time) -> Velocity {
        Velocity(self.0 * rhs.0)
    }
}

impl Mul<Acceleration> for Time {
    type Output = Velocity;
    fn mul(self, rhs: Acceleration) -> Velocity {
        Velocity(self.0 * rhs.0)
    }
}

// Velocity / Time -> Acceleration
impl Div<Time> for Velocity {
    type Output = Acceleration;
    fn div(self, rhs: Time) -> Acceleration {
        Acceleration(self.0 / rhs.0)
    }
}

// Mass * Acceleration -> Force
impl Mul<Acceleration> for Mass {
    type Output = Force;
    fn mul(self, rhs: Acceleration) -> Force {
        Force(self.0 * rhs.0)
    }
}

impl Mul<Mass> for Acceleration {
    type Output = Force;
    fn mul(self, rhs: Mass) -> Force {
        Force(self.0 * rhs.0)
    }
}

// Force / Mass -> Acceleration
impl Div<Mass> for Force {
    type Output = Acceleration;
    fn div(self, rhs: Mass) -> Acceleration {
        Acceleration(self.0 / rhs.0)
    }
}

// Force / Acceleration -> Mass
impl Div<Acceleration> for Force {
    type Output = Mass;
    fn div(self, rhs: Acceleration) -> Mass {
        Mass(self.0 / rhs.0)
    }
}

// Force * Time -> Impulse
impl Mul<Time> for Force {
    type Output = Impulse;
    fn mul(self, rhs: Time) -> Impulse {
        Impulse(self.0 * rhs.0)
    }
}

impl Mul<Force> for Time {
    type Output = Impulse;
    fn mul(self, rhs: Force) -> Impulse {
        Impulse(self.0 * rhs.0)
    }
}

// Mass * Velocity -> Momentum
impl Mul<Velocity> for Mass {
    type Output = Momentum;
    fn mul(self, rhs: Velocity) -> Momentum {
        Momentum(self.0 * rhs.0)
    }
}

impl Mul<Mass> for Velocity {
    type Output = Momentum;
    fn mul(self, rhs: Mass) -> Momentum {
        Momentum(self.0 * rhs.0)
    }
}

// Impulse / Mass -> Velocity
impl Div<Mass> for Impulse {
    type Output = Velocity;
    fn div(self, rhs: Mass) -> Velocity {
        Velocity(self.0 / rhs.0)
    }
}

// Momentum / Mass -> Velocity
impl Div<Mass> for Momentum {
    type Output = Velocity;
    fn div(self, rhs: Mass) -> Velocity {
        Velocity(self.0 / rhs.0)
    }
}

// Momentum / Velocity -> Mass
impl Div<Velocity> for Momentum {
    type Output = Mass;
    fn div(self, rhs: Velocity) -> Mass {
        Mass(self.0 / rhs.0)
    }
}

// --- Geometry ---

impl Mul<Self> for Length {
    type Output = Area;
    fn mul(self, rhs: Self) -> Area {
        Area(self.0 * rhs.0)
    }
}

impl Div<Length> for Area {
    type Output = Length;
    fn div(self, rhs: Length) -> Length {
        Length(self.0 / rhs.0)
    }
}

impl Mul<Length> for Area {
    type Output = Volume;
    fn mul(self, rhs: Length) -> Volume {
        Volume(self.0 * rhs.0)
    }
}

impl Mul<Area> for Length {
    type Output = Volume;
    fn mul(self, rhs: Area) -> Volume {
        Volume(self.0 * rhs.0)
    }
}

impl Div<Length> for Volume {
    type Output = Area;
    fn div(self, rhs: Length) -> Area {
        Area(self.0 / rhs.0)
    }
}

impl Div<Area> for Volume {
    type Output = Length;
    fn div(self, rhs: Area) -> Length {
        Length(self.0 / rhs.0)
    }
}

// --- Density and pressure ---

impl Div<Volume> for Mass {
    type Output = Density;
    fn div(self, rhs: Volume) -> Density {
        Density(self.0 / rhs.0)
    }
}

impl Mul<Volume> for Density {
    type Output = Mass;
    fn mul(self, rhs: Volume) -> Mass {
        Mass(self.0 * rhs.0)
    }
}

impl Mul<Density> for Volume {
    type Output = Mass;
    fn mul(self, rhs: Density) -> Mass {
        Mass(self.0 * rhs.0)
    }
}

impl Div<Area> for Force {
    type Output = Pressure;
    fn div(self, rhs: Area) -> Pressure {
        Pressure(self.0 / rhs.0)
    }
}

impl Mul<Area> for Pressure {
    type Output = Force;
    fn mul(self, rhs: Area) -> Force {
        Force(self.0 * rhs.0)
    }
}

impl Mul<Pressure> for Area {
    type Output = Force;
    fn mul(self, rhs: Pressure) -> Force {
        Force(self.0 * rhs.0)
    }
}

// --- Energy and power ---

impl Mul<Length> for Force {
    type Output = Energy;
    fn mul(self, rhs: Length) -> Energy {
        Energy(self.0 * rhs.0)
    }
}

impl Mul<Force> for Length {
    type Output = Energy;
    fn mul(self, rhs: Force) -> Energy {
        Energy(self.0 * rhs.0)
    }
}

impl Div<Time> for Energy {
    type Output = Power;
    fn div(self, rhs: Time) -> Power {
        Power(self.0 / rhs.0)
    }
}

impl Mul<Time> for Power {
    type Output = Energy;
    fn mul(self, rhs: Time) -> Energy {
        Energy(self.0 * rhs.0)
    }
}

impl Div<Length> for Energy {
    type Output = Force;
    fn div(self, rhs: Length) -> Force {
        Force(self.0 / rhs.0)
    }
}

impl Div<Mass> for Energy {
    type Output = SpecificEnergy;
    fn div(self, rhs: Mass) -> SpecificEnergy {
        SpecificEnergy(self.0 / rhs.0)
    }
}

// --- Orbital mechanics ---

impl Div<Length> for GravitationalParameter {
    type Output = SpecificEnergy;
    fn div(self, rhs: Length) -> SpecificEnergy {
        SpecificEnergy(self.0 / rhs.0)
    }
}

impl Div<Area> for GravitationalParameter {
    type Output = Acceleration;
    fn div(self, rhs: Area) -> Acceleration {
        Acceleration(self.0 / rhs.0)
    }
}

impl Mul<Self> for Velocity {
    type Output = SpecificEnergy;
    fn mul(self, rhs: Self) -> SpecificEnergy {
        SpecificEnergy(self.0 * rhs.0)
    }
}

impl Mul<Velocity> for Length {
    type Output = SpecificAngularMomentum;
    fn mul(self, rhs: Velocity) -> SpecificAngularMomentum {
        SpecificAngularMomentum(self.0 * rhs.0)
    }
}

impl Mul<Length> for Velocity {
    type Output = SpecificAngularMomentum;
    fn mul(self, rhs: Length) -> SpecificAngularMomentum {
        SpecificAngularMomentum(self.0 * rhs.0)
    }
}

impl Div<Time> for Area {
    type Output = SpecificAngularMomentum;
    fn div(self, rhs: Time) -> SpecificAngularMomentum {
        SpecificAngularMomentum(self.0 / rhs.0)
    }
}

// --- Angular motion ---

impl Div<Time> for Angle {
    type Output = AngularVelocity;
    fn div(self, rhs: Time) -> AngularVelocity {
        AngularVelocity(self.0 / rhs.0)
    }
}

impl Mul<Time> for AngularVelocity {
    type Output = Angle;
    fn mul(self, rhs: Time) -> Angle {
        Angle(self.0 * rhs.0)
    }
}

impl Mul<AngularVelocity> for Time {
    type Output = Angle;
    fn mul(self, rhs: AngularVelocity) -> Angle {
        Angle(self.0 * rhs.0)
    }
}

impl Div<Time> for AngularVelocity {
    type Output = AngularAcceleration;
    fn div(self, rhs: Time) -> AngularAcceleration {
        AngularAcceleration(self.0 / rhs.0)
    }
}

impl Mul<AngularAcceleration> for MomentOfInertia {
    type Output = Torque;
    fn mul(self, rhs: AngularAcceleration) -> Torque {
        Torque(self.0 * rhs.0)
    }
}

impl Mul<MomentOfInertia> for AngularAcceleration {
    type Output = Torque;
    fn mul(self, rhs: MomentOfInertia) -> Torque {
        Torque(self.0 * rhs.0)
    }
}

impl Div<AngularAcceleration> for Torque {
    type Output = MomentOfInertia;
    fn div(self, rhs: AngularAcceleration) -> MomentOfInertia {
        MomentOfInertia(self.0 / rhs.0)
    }
}

impl Mul<Time> for Torque {
    type Output = AngularMomentum;
    fn mul(self, rhs: Time) -> AngularMomentum {
        AngularMomentum(self.0 * rhs.0)
    }
}

impl Div<Time> for AngularMomentum {
    type Output = Torque;
    fn div(self, rhs: Time) -> Torque {
        Torque(self.0 / rhs.0)
    }
}

// --- Propulsion ---

// Mass / Time -> MassFlowRate
impl Div<Time> for Mass {
    type Output = MassFlowRate;
    fn div(self, rhs: Time) -> MassFlowRate {
        MassFlowRate(self.0 / rhs.0)
    }
}

// MassFlowRate * Time -> Mass
impl Mul<Time> for MassFlowRate {
    type Output = Mass;
    fn mul(self, rhs: Time) -> Mass {
        Mass(self.0 * rhs.0)
    }
}

impl Mul<MassFlowRate> for Time {
    type Output = Mass;
    fn mul(self, rhs: MassFlowRate) -> Mass {
        Mass(self.0 * rhs.0)
    }
}

// MassFlowRate * Velocity -> Force (thrust: F = ṁVe)
impl Mul<Velocity> for MassFlowRate {
    type Output = Force;
    fn mul(self, rhs: Velocity) -> Force {
        Force(self.0 * rhs.0)
    }
}

impl Mul<MassFlowRate> for Velocity {
    type Output = Force;
    fn mul(self, rhs: MassFlowRate) -> Force {
        Force(self.0 * rhs.0)
    }
}

// Force / MassFlowRate -> Velocity
impl Div<MassFlowRate> for Force {
    type Output = Velocity;
    fn div(self, rhs: MassFlowRate) -> Velocity {
        Velocity(self.0 / rhs.0)
    }
}

// Force / Velocity -> MassFlowRate
impl Div<Velocity> for Force {
    type Output = MassFlowRate;
    fn div(self, rhs: Velocity) -> MassFlowRate {
        MassFlowRate(self.0 / rhs.0)
    }
}

// --- Electromagnetic ---

// ElectricCharge / Time -> ElectricCurrent
impl Div<Time> for ElectricCharge {
    type Output = ElectricCurrent;
    fn div(self, rhs: Time) -> ElectricCurrent {
        ElectricCurrent(self.0 / rhs.0)
    }
}

// ElectricCurrent * Time -> ElectricCharge
impl Mul<Time> for ElectricCurrent {
    type Output = ElectricCharge;
    fn mul(self, rhs: Time) -> ElectricCharge {
        ElectricCharge(self.0 * rhs.0)
    }
}

impl Mul<ElectricCurrent> for Time {
    type Output = ElectricCharge;
    fn mul(self, rhs: ElectricCurrent) -> ElectricCharge {
        ElectricCharge(self.0 * rhs.0)
    }
}

// Power / ElectricCurrent -> Voltage
impl Div<ElectricCurrent> for Power {
    type Output = Voltage;
    fn div(self, rhs: ElectricCurrent) -> Voltage {
        Voltage(self.0 / rhs.0)
    }
}

// Voltage * ElectricCurrent -> Power
impl Mul<ElectricCurrent> for Voltage {
    type Output = Power;
    fn mul(self, rhs: ElectricCurrent) -> Power {
        Power(self.0 * rhs.0)
    }
}

impl Mul<Voltage> for ElectricCurrent {
    type Output = Power;
    fn mul(self, rhs: Voltage) -> Power {
        Power(self.0 * rhs.0)
    }
}

// Energy / ElectricCharge -> Voltage
impl Div<ElectricCharge> for Energy {
    type Output = Voltage;
    fn div(self, rhs: ElectricCharge) -> Voltage {
        Voltage(self.0 / rhs.0)
    }
}

// Voltage * ElectricCharge -> Energy
impl Mul<ElectricCharge> for Voltage {
    type Output = Energy;
    fn mul(self, rhs: ElectricCharge) -> Energy {
        Energy(self.0 * rhs.0)
    }
}

impl Mul<Voltage> for ElectricCharge {
    type Output = Energy;
    fn mul(self, rhs: Voltage) -> Energy {
        Energy(self.0 * rhs.0)
    }
}

// Voltage / ElectricCurrent -> Resistance
impl Div<ElectricCurrent> for Voltage {
    type Output = Resistance;
    fn div(self, rhs: ElectricCurrent) -> Resistance {
        Resistance(self.0 / rhs.0)
    }
}

// ElectricCurrent * Resistance -> Voltage
impl Mul<Resistance> for ElectricCurrent {
    type Output = Voltage;
    fn mul(self, rhs: Resistance) -> Voltage {
        Voltage(self.0 * rhs.0)
    }
}

impl Mul<ElectricCurrent> for Resistance {
    type Output = Voltage;
    fn mul(self, rhs: ElectricCurrent) -> Voltage {
        Voltage(self.0 * rhs.0)
    }
}

// ElectricCharge / Voltage -> Capacitance
impl Div<Voltage> for ElectricCharge {
    type Output = Capacitance;
    fn div(self, rhs: Voltage) -> Capacitance {
        Capacitance(self.0 / rhs.0)
    }
}

// Capacitance * Voltage -> ElectricCharge
impl Mul<Voltage> for Capacitance {
    type Output = ElectricCharge;
    fn mul(self, rhs: Voltage) -> ElectricCharge {
        ElectricCharge(self.0 * rhs.0)
    }
}

impl Mul<Capacitance> for Voltage {
    type Output = ElectricCharge;
    fn mul(self, rhs: Capacitance) -> ElectricCharge {
        ElectricCharge(self.0 * rhs.0)
    }
}

// MagneticFluxDensity * Area -> MagneticFlux
impl Mul<Area> for MagneticFluxDensity {
    type Output = MagneticFlux;
    fn mul(self, rhs: Area) -> MagneticFlux {
        MagneticFlux(self.0 * rhs.0)
    }
}

impl Mul<MagneticFluxDensity> for Area {
    type Output = MagneticFlux;
    fn mul(self, rhs: MagneticFluxDensity) -> MagneticFlux {
        MagneticFlux(self.0 * rhs.0)
    }
}

// MagneticFlux / Area -> MagneticFluxDensity
impl Div<Area> for MagneticFlux {
    type Output = MagneticFluxDensity;
    fn div(self, rhs: Area) -> MagneticFluxDensity {
        MagneticFluxDensity(self.0 / rhs.0)
    }
}

// MagneticFlux / ElectricCurrent -> Inductance
impl Div<ElectricCurrent> for MagneticFlux {
    type Output = Inductance;
    fn div(self, rhs: ElectricCurrent) -> Inductance {
        Inductance(self.0 / rhs.0)
    }
}

// Inductance * ElectricCurrent -> MagneticFlux
impl Mul<ElectricCurrent> for Inductance {
    type Output = MagneticFlux;
    fn mul(self, rhs: ElectricCurrent) -> MagneticFlux {
        MagneticFlux(self.0 * rhs.0)
    }
}

impl Mul<Inductance> for ElectricCurrent {
    type Output = MagneticFlux;
    fn mul(self, rhs: Inductance) -> MagneticFlux {
        MagneticFlux(self.0 * rhs.0)
    }
}

// --- Thermal ---

// Power / Area -> HeatFlux
impl Div<Area> for Power {
    type Output = HeatFlux;
    fn div(self, rhs: Area) -> HeatFlux {
        HeatFlux(self.0 / rhs.0)
    }
}

// HeatFlux * Area -> Power
impl Mul<Area> for HeatFlux {
    type Output = Power;
    fn mul(self, rhs: Area) -> Power {
        Power(self.0 * rhs.0)
    }
}

impl Mul<HeatFlux> for Area {
    type Output = Power;
    fn mul(self, rhs: HeatFlux) -> Power {
        Power(self.0 * rhs.0)
    }
}