space_units/quantities/

angular.rs

use super::DisplayWithUnit;

// -------------------------
// Angle
// -------------------------

/// A plane angle, stored canonically in radians.
///
/// # Construction
///
/// ```
/// use space_units::Angle;
///
/// let a = Angle::from_deg(90.0);
/// let b = Angle::from_rad(std::f64::consts::FRAC_PI_2);
/// ```
///
/// With the `NumericExt` trait in scope:
///
/// ```
/// use space_units::{Angle, NumericExt as _};
///
/// let a = 90.0.deg();
/// let b = (std::f64::consts::FRAC_PI_2).rad();
/// ```
///
/// # Typed arithmetic
///
/// | Expression | Result |
/// |---|---|
/// | [`Angle`] / [`Time`](crate::Time) | [`AngularVelocity`] |
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Angle(pub(crate) f64);

/// Display and conversion units for [`Angle`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AngleUnit {
    /// Radians (rad) -- the canonical storage unit.
    Radian,
    /// Degrees (deg).
    Degree,
    /// Arc-minutes (arcmin), 1/60 of a degree.
    ArcMinute,
    /// Arc-seconds (arcsec), 1/3600 of a degree.
    ArcSecond,
    /// Milli-arc-seconds (mas), 1/1000 of an arc-second.
    MilliArcSecond,
    /// Full revolutions (rev), equal to 2*pi* radians.
    Revolution,
    /// Milliradians (mrad), 1/1000 of a radian.
    MilliRadian,
    /// Gradians (grad), 1/400 of a full turn.
    Grad,
    /// Hour angles, 1/24 of a full turn (used in astronomy).
    HourAngle,
}

impl AngleUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Radian => "rad",
            Self::Degree => "deg",
            Self::ArcMinute => "arcmin",
            Self::ArcSecond => "arcsec",
            Self::MilliArcSecond => "mas",
            Self::Revolution => "rev",
            Self::MilliRadian => "mrad",
            Self::Grad => "grad",
            Self::HourAngle => "hour_angle",
        }
    }

    const fn radians_per_unit(self) -> f64 {
        match self {
            Self::Radian => 1.0,
            Self::Degree => core::f64::consts::PI / 180.0,
            Self::ArcMinute => core::f64::consts::PI / 10_800.0,
            Self::ArcSecond => core::f64::consts::PI / 648_000.0,
            Self::MilliArcSecond => core::f64::consts::PI / 648_000_000.0,
            Self::Revolution => core::f64::consts::TAU,
            Self::MilliRadian => 1e-3,
            Self::Grad => core::f64::consts::PI / 200.0,
            Self::HourAngle => core::f64::consts::PI / 12.0,
        }
    }
}

impl Angle {
    /// Creates an angle from a value in radians.
    pub const fn from_rad(val: f64) -> Self {
        Self(val)
    }

    /// Creates an angle from a value in degrees.
    pub const fn from_deg(val: f64) -> Self {
        Self(val * (core::f64::consts::PI / 180.0))
    }

    /// Creates an angle from a value in full revolutions.
    pub const fn from_rev(val: f64) -> Self {
        Self(val * core::f64::consts::TAU)
    }

    /// Creates an angle from a value in arc-minutes.
    pub const fn from_arcmin(val: f64) -> Self {
        Self(val * (core::f64::consts::PI / 10_800.0))
    }

    /// Creates an angle from a value in arc-seconds.
    pub const fn from_arcsec(val: f64) -> Self {
        Self(val * (core::f64::consts::PI / 648_000.0))
    }

    /// Creates an angle from a value in milli-arc-seconds.
    pub const fn from_mas(val: f64) -> Self {
        Self(val * (core::f64::consts::PI / 648_000_000.0))
    }

    /// Creates an angle from a value in milliradians.
    pub const fn from_mrad(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Creates an angle from a value in gradians.
    pub const fn from_grad(val: f64) -> Self {
        Self(val * (core::f64::consts::PI / 200.0))
    }

    /// Creates an angle from a value in hour angles.
    pub const fn from_hour_angle(val: f64) -> Self {
        Self(val * (core::f64::consts::PI / 12.0))
    }

    /// Returns the angle in radians.
    pub const fn in_rad(self) -> f64 {
        self.0
    }

    /// Returns the angle in degrees.
    pub const fn in_deg(self) -> f64 {
        self.0 / (core::f64::consts::PI / 180.0)
    }

    /// Returns the angle in full revolutions.
    pub const fn in_rev(self) -> f64 {
        self.0 / core::f64::consts::TAU
    }

    /// Returns the angle in arc-minutes.
    pub const fn in_arcmin(self) -> f64 {
        self.0 / (core::f64::consts::PI / 10_800.0)
    }

    /// Returns the angle in arc-seconds.
    pub const fn in_arcsec(self) -> f64 {
        self.0 / (core::f64::consts::PI / 648_000.0)
    }

    /// Returns the angle in milli-arc-seconds.
    pub const fn in_mas(self) -> f64 {
        self.0 / (core::f64::consts::PI / 648_000_000.0)
    }

    /// Returns the angle in milliradians.
    pub const fn in_mrad(self) -> f64 {
        self.0 / 1e-3
    }

    /// Returns the angle in gradians.
    pub const fn in_grad(self) -> f64 {
        self.0 / (core::f64::consts::PI / 200.0)
    }

    /// Returns the angle in hour angles.
    pub const fn in_hour_angle(self) -> f64 {
        self.0 / (core::f64::consts::PI / 12.0)
    }

    /// Returns the angle in the specified [`AngleUnit`].
    pub fn in_unit(self, unit: AngleUnit) -> f64 {
        self.0 / unit.radians_per_unit()
    }

    /// Returns a display wrapper that formats the angle in the specified unit.
    pub fn display_as(self, unit: AngleUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Normalize into the range `[0, 2π)`.
    pub fn normalize(self) -> Self {
        let tau = core::f64::consts::TAU;
        let mut v = self.0 % tau;
        if v < 0.0 {
            v += tau;
        }
        Self(v)
    }

    /// Returns the absolute value of the angle.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }

    /// Returns the sine of the angle.
    #[cfg(feature = "std")]
    pub fn sin(self) -> f64 {
        self.0.sin()
    }

    /// Returns the cosine of the angle.
    #[cfg(feature = "std")]
    pub fn cos(self) -> f64 {
        self.0.cos()
    }

    /// Returns the tangent of the angle.
    #[cfg(feature = "std")]
    pub fn tan(self) -> f64 {
        self.0.tan()
    }

    /// Returns the angle whose sine is `val` (inverse sine).
    #[cfg(feature = "std")]
    pub fn asin(val: f64) -> Self {
        Self(val.asin())
    }

    /// Returns the angle whose cosine is `val` (inverse cosine).
    #[cfg(feature = "std")]
    pub fn acos(val: f64) -> Self {
        Self(val.acos())
    }

    /// Returns the four-quadrant arc-tangent of `y / x`.
    #[cfg(feature = "std")]
    pub fn atan2(y: f64, x: f64) -> Self {
        Self(y.atan2(x))
    }
}

impl_quantity_display!(Angle, "rad");

impl_common_ops!(Angle);

// -------------------------
// Angular velocity
// -------------------------

/// An angular velocity (rate of rotation), stored canonically in rad/s.
///
/// # Construction
///
/// ```
/// use space_units::AngularVelocity;
///
/// let w = AngularVelocity::from_rpm(3600.0);
/// let w2 = AngularVelocity::from_radps(1.0);
/// ```
///
/// # Typed arithmetic
///
/// | Expression | Result |
/// |---|---|
/// | [`AngularVelocity`] * [`Time`](crate::Time) | [`Angle`] |
/// | [`AngularVelocity`] / [`Time`](crate::Time) | [`AngularAcceleration`] |
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct AngularVelocity(pub(crate) f64);

/// Display and conversion units for [`AngularVelocity`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AngularVelocityUnit {
    /// Radians per second (rad/s) -- the canonical storage unit.
    RadPerS,
    /// Degrees per second (deg/s).
    DegPerS,
    /// Revolutions per minute (rpm).
    Rpm,
    /// Revolutions per second (rev/s).
    RevPerS,
}

impl AngularVelocityUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::RadPerS => "rad/s",
            Self::DegPerS => "deg/s",
            Self::Rpm => "rpm",
            Self::RevPerS => "rev/s",
        }
    }

    const fn radps_per_unit(self) -> f64 {
        match self {
            Self::RadPerS => 1.0,
            Self::DegPerS => core::f64::consts::PI / 180.0,
            Self::Rpm => core::f64::consts::TAU / 60.0,
            Self::RevPerS => core::f64::consts::TAU,
        }
    }
}

impl AngularVelocity {
    /// Creates an angular velocity from a value in radians per second.
    pub const fn from_radps(val: f64) -> Self {
        Self(val)
    }

    /// Creates an angular velocity from a value in degrees per second.
    pub const fn from_degps(val: f64) -> Self {
        Self(val * (core::f64::consts::PI / 180.0))
    }

    /// Creates an angular velocity from a value in revolutions per minute.
    pub const fn from_rpm(val: f64) -> Self {
        Self(val * (core::f64::consts::TAU / 60.0))
    }

    /// Creates an angular velocity from a value in revolutions per second.
    pub const fn from_revps(val: f64) -> Self {
        Self(val * core::f64::consts::TAU)
    }

    /// Returns the angular velocity in radians per second.
    pub const fn in_radps(self) -> f64 {
        self.0
    }

    /// Returns the angular velocity in degrees per second.
    pub const fn in_degps(self) -> f64 {
        self.0 / (core::f64::consts::PI / 180.0)
    }

    /// Returns the angular velocity in revolutions per minute.
    pub const fn in_rpm(self) -> f64 {
        self.0 / (core::f64::consts::TAU / 60.0)
    }

    /// Returns the angular velocity in revolutions per second.
    pub const fn in_revps(self) -> f64 {
        self.0 / core::f64::consts::TAU
    }

    /// Returns the angular velocity in the specified [`AngularVelocityUnit`].
    pub fn in_unit(self, unit: AngularVelocityUnit) -> f64 {
        self.0 / unit.radps_per_unit()
    }

    /// Returns a display wrapper that formats the angular velocity in the specified unit.
    pub fn display_as(self, unit: AngularVelocityUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Returns the absolute value of the angular velocity.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(AngularVelocity, "rad/s");

impl_common_ops!(AngularVelocity);

// -------------------------
// Angular acceleration
// -------------------------

/// An angular acceleration, stored canonically in rad/s².
///
/// # Construction
///
/// ```
/// use space_units::AngularAcceleration;
///
/// let alpha = AngularAcceleration::from_radps2(0.5);
/// let alpha2 = AngularAcceleration::from_degps2(30.0);
/// ```
///
/// # Typed arithmetic
///
/// | Expression | Result |
/// |---|---|
/// | [`MomentOfInertia`] * [`AngularAcceleration`] | [`Torque`] |
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct AngularAcceleration(pub(crate) f64);

/// Display and conversion units for [`AngularAcceleration`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AngularAccelerationUnit {
    /// Radians per second squared (rad/s²) -- the canonical storage unit.
    RadPerS2,
    /// Degrees per second squared (deg/s²).
    DegPerS2,
    /// Revolutions per second squared (rev/s²).
    RevPerS2,
}

impl AngularAccelerationUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::RadPerS2 => "rad/s^2",
            Self::DegPerS2 => "deg/s^2",
            Self::RevPerS2 => "rev/s^2",
        }
    }

    const fn radps2_per_unit(self) -> f64 {
        match self {
            Self::RadPerS2 => 1.0,
            Self::DegPerS2 => core::f64::consts::PI / 180.0,
            Self::RevPerS2 => core::f64::consts::TAU,
        }
    }
}

impl AngularAcceleration {
    /// Creates an angular acceleration from a value in radians per second squared.
    pub const fn from_radps2(val: f64) -> Self {
        Self(val)
    }

    /// Creates an angular acceleration from a value in degrees per second squared.
    pub const fn from_degps2(val: f64) -> Self {
        Self(val * (core::f64::consts::PI / 180.0))
    }

    /// Creates an angular acceleration from a value in revolutions per second squared.
    pub const fn from_revps2(val: f64) -> Self {
        Self(val * core::f64::consts::TAU)
    }

    /// Returns the angular acceleration in radians per second squared.
    pub const fn in_radps2(self) -> f64 {
        self.0
    }

    /// Returns the angular acceleration in degrees per second squared.
    pub const fn in_degps2(self) -> f64 {
        self.0 / (core::f64::consts::PI / 180.0)
    }

    /// Returns the angular acceleration in revolutions per second squared.
    pub const fn in_revps2(self) -> f64 {
        self.0 / core::f64::consts::TAU
    }

    /// Returns the angular acceleration in the specified [`AngularAccelerationUnit`].
    pub fn in_unit(self, unit: AngularAccelerationUnit) -> f64 {
        self.0 / unit.radps2_per_unit()
    }

    /// Returns a display wrapper that formats the angular acceleration in the specified unit.
    pub fn display_as(self, unit: AngularAccelerationUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Returns the absolute value of the angular acceleration.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(AngularAcceleration, "rad/s²");

impl_common_ops!(AngularAcceleration);

// -------------------------
// Torque
// -------------------------

/// A torque (moment of force), stored canonically in newton-metres (N*m).
///
/// # Construction
///
/// ```
/// use space_units::Torque;
///
/// let t = Torque::from_nm(50.0);
/// let t2 = Torque::from_lbf_ft(36.88);
/// ```
///
/// # Typed arithmetic
///
/// | Expression | Result |
/// |---|---|
/// | [`Torque`] / [`AngularAcceleration`] | [`MomentOfInertia`] |
/// | [`Torque`] * [`Time`](crate::Time) | [`AngularMomentum`] |
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Torque(pub(crate) f64);

/// Display and conversion units for [`Torque`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TorqueUnit {
    /// Newton-metres (N*m) -- the canonical storage unit.
    NewtonMeter,
    /// Kilonewton-metres (kN*m).
    KiloNewtonMeter,
    /// Pound-force feet (lbf*ft).
    PoundForceFoot,
}

impl TorqueUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::NewtonMeter => "N*m",
            Self::KiloNewtonMeter => "kN*m",
            Self::PoundForceFoot => "lbf*ft",
        }
    }
}

impl Torque {
    /// Creates a torque from a value in newton-metres.
    pub const fn from_nm(val: f64) -> Self {
        Self(val)
    }

    /// Creates a torque from a value in kilonewton-metres.
    pub const fn from_knm(val: f64) -> Self {
        Self(val * 1_000.0)
    }

    /// Creates a torque from a value in pound-force feet.
    pub const fn from_lbf_ft(val: f64) -> Self {
        Self(val * 1.355_817_948_331_4)
    }

    /// Returns the torque in newton-metres.
    pub const fn in_nm(self) -> f64 {
        self.0
    }

    /// Returns the torque in kilonewton-metres.
    pub const fn in_knm(self) -> f64 {
        self.0 / 1_000.0
    }

    /// Returns the torque in pound-force feet.
    pub const fn in_lbf_ft(self) -> f64 {
        self.0 / 1.355_817_948_331_4
    }

    /// Returns a display wrapper that formats the torque in the specified unit.
    pub const fn display_as(self, unit: TorqueUnit) -> DisplayWithUnit {
        match unit {
            TorqueUnit::NewtonMeter => DisplayWithUnit {
                value: self.0,
                symbol: unit.symbol(),
            },
            TorqueUnit::KiloNewtonMeter => DisplayWithUnit {
                value: self.in_knm(),
                symbol: unit.symbol(),
            },
            TorqueUnit::PoundForceFoot => DisplayWithUnit {
                value: self.in_lbf_ft(),
                symbol: unit.symbol(),
            },
        }
    }

    /// Returns the absolute value of the torque.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Torque, "N·m");

impl_common_ops!(Torque);

// -------------------------
// Angular momentum
// -------------------------

/// An angular momentum, stored canonically in newton-metre-seconds (N*m*s).
///
/// # Construction
///
/// ```
/// use space_units::AngularMomentum;
///
/// let l = AngularMomentum::from_n_m_s(42.0);
/// ```
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct AngularMomentum(pub(crate) f64);

/// Display and conversion units for [`AngularMomentum`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum AngularMomentumUnit {
    /// Newton-metre-seconds (N*m*s) -- the canonical storage unit.
    NewtonMeterSecond,
}

impl AngularMomentumUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::NewtonMeterSecond => "N*m*s",
        }
    }
}

impl AngularMomentum {
    /// Creates an angular momentum from a value in newton-metre-seconds.
    pub const fn from_n_m_s(val: f64) -> Self {
        Self(val)
    }

    /// Returns the angular momentum in newton-metre-seconds.
    pub const fn in_n_m_s(self) -> f64 {
        self.0
    }

    /// Returns a display wrapper that formats the angular momentum in the specified unit.
    pub const fn display_as(self, unit: AngularMomentumUnit) -> DisplayWithUnit {
        match unit {
            AngularMomentumUnit::NewtonMeterSecond => DisplayWithUnit {
                value: self.0,
                symbol: unit.symbol(),
            },
        }
    }

    /// Returns the absolute value of the angular momentum.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(AngularMomentum, "N·m·s");

impl_common_ops!(AngularMomentum);

// -------------------------
// Moment of inertia
// -------------------------

/// A moment of inertia (rotational inertia), stored canonically in kg*m².
///
/// # Construction
///
/// ```
/// use space_units::MomentOfInertia;
///
/// let i = MomentOfInertia::from_kgm2(12.5);
/// let i2 = MomentOfInertia::from_slug_ft2(9.2);
/// ```
///
/// # Typed arithmetic
///
/// | Expression | Result |
/// |---|---|
/// | [`MomentOfInertia`] * [`AngularAcceleration`] | [`Torque`] |
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct MomentOfInertia(pub(crate) f64);

/// Display and conversion units for [`MomentOfInertia`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MomentOfInertiaUnit {
    /// Kilogram-metres squared (kg*m²) -- the canonical storage unit.
    KgM2,
    /// Gram-centimetres squared (g*cm²).
    GramCentimeter2,
    /// Slug-feet squared (slug*ft²).
    SlugFoot2,
}

impl MomentOfInertiaUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::KgM2 => "kg*m^2",
            Self::GramCentimeter2 => "g*cm^2",
            Self::SlugFoot2 => "slug*ft^2",
        }
    }
}

impl MomentOfInertia {
    /// Creates a moment of inertia from a value in kilogram-metres squared.
    pub const fn from_kgm2(val: f64) -> Self {
        Self(val)
    }

    /// Creates a moment of inertia from a value in gram-centimetres squared.
    pub const fn from_gcm2(val: f64) -> Self {
        Self(val * 1e-7)
    }

    /// Creates a moment of inertia from a value in slug-feet squared.
    pub const fn from_slug_ft2(val: f64) -> Self {
        Self(val * 1.355_817_948_331_4)
    }

    /// Returns the moment of inertia in kilogram-metres squared.
    pub const fn in_kgm2(self) -> f64 {
        self.0
    }

    /// Returns the moment of inertia in gram-centimetres squared.
    pub const fn in_gcm2(self) -> f64 {
        self.0 / 1e-7
    }

    /// Returns the moment of inertia in slug-feet squared.
    pub const fn in_slug_ft2(self) -> f64 {
        self.0 / 1.355_817_948_331_4
    }

    /// Returns a display wrapper that formats the moment of inertia in the specified unit.
    pub const fn display_as(self, unit: MomentOfInertiaUnit) -> DisplayWithUnit {
        match unit {
            MomentOfInertiaUnit::KgM2 => DisplayWithUnit {
                value: self.0,
                symbol: unit.symbol(),
            },
            MomentOfInertiaUnit::GramCentimeter2 => DisplayWithUnit {
                value: self.in_gcm2(),
                symbol: unit.symbol(),
            },
            MomentOfInertiaUnit::SlugFoot2 => DisplayWithUnit {
                value: self.in_slug_ft2(),
                symbol: unit.symbol(),
            },
        }
    }

    /// Returns the absolute value of the moment of inertia.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(MomentOfInertia, "kg·m²");

impl_common_ops!(MomentOfInertia);

// -------------------------
// Solid angle
// -------------------------

/// A solid angle (two-dimensional angular span), stored canonically in steradians (sr).
///
/// # Construction
///
/// ```
/// use space_units::SolidAngle;
///
/// let omega = SolidAngle::from_sr(2.0);
/// let omega2 = SolidAngle::from_deg2(100.0);
/// let full_sphere = SolidAngle::from_spat(1.0);
/// ```
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct SolidAngle(pub(crate) f64);

/// Display and conversion units for [`SolidAngle`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SolidAngleUnit {
    /// Steradians (sr) -- the canonical storage unit.
    Steradian,
    /// Square degrees (deg²).
    SquareDegree,
    /// Spats (the full sphere, 4*pi* sr).
    Spat,
}

impl SolidAngleUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Steradian => "sr",
            Self::SquareDegree => "deg^2",
            Self::Spat => "spat",
        }
    }

    const fn sr_per_unit(self) -> f64 {
        match self {
            Self::Steradian => 1.0,
            // (PI/180)^2
            Self::SquareDegree => (core::f64::consts::PI / 180.0) * (core::f64::consts::PI / 180.0),
            Self::Spat => 4.0 * core::f64::consts::PI,
        }
    }
}

impl SolidAngle {
    /// Creates a solid angle from a value in steradians.
    pub const fn from_sr(val: f64) -> Self {
        Self(val)
    }

    /// Creates a solid angle from a value in square degrees.
    pub const fn from_deg2(val: f64) -> Self {
        Self(val * (core::f64::consts::PI / 180.0) * (core::f64::consts::PI / 180.0))
    }

    /// Creates a solid angle from a value in spats (full spheres).
    pub const fn from_spat(val: f64) -> Self {
        Self(val * 4.0 * core::f64::consts::PI)
    }

    /// Returns the solid angle in steradians.
    pub const fn in_sr(self) -> f64 {
        self.0
    }

    /// Returns the solid angle in square degrees.
    pub const fn in_deg2(self) -> f64 {
        self.0 / ((core::f64::consts::PI / 180.0) * (core::f64::consts::PI / 180.0))
    }

    /// Returns the solid angle in spats (full spheres).
    pub const fn in_spat(self) -> f64 {
        self.0 / (4.0 * core::f64::consts::PI)
    }

    /// Returns the solid angle in the specified [`SolidAngleUnit`].
    pub fn in_unit(self, unit: SolidAngleUnit) -> f64 {
        self.0 / unit.sr_per_unit()
    }

    /// Returns a display wrapper that formats the solid angle in the specified unit.
    pub fn display_as(self, unit: SolidAngleUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Returns the absolute value of the solid angle.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(SolidAngle, "sr");

impl_common_ops!(SolidAngle);