space_units/quantities/

electromagnetic.rs

use super::DisplayWithUnit;

// -------------------------
// Electric charge
// -------------------------

/// An electric charge quantity, stored internally in coulombs (C).
///
/// # Construction
/// ```
/// # use space_units::ElectricCharge;
/// let q = ElectricCharge::from_mah(2500.0);
/// ```
///
/// # Typed arithmetic
/// - [`ElectricCharge`] / [`Time`](crate::Time) → [`ElectricCurrent`]
/// - [`ElectricCharge`] / [`Voltage`] → [`Capacitance`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct ElectricCharge(pub(crate) f64);

/// Display/conversion units for [`ElectricCharge`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ElectricChargeUnit {
    /// Coulombs (C).
    Coulomb,
    /// Millicoulombs (mC).
    MilliCoulomb,
    /// Microcoulombs (uC).
    MicroCoulomb,
    /// Ampere-hours (Ah).
    AmpereHour,
    /// Milliampere-hours (mAh).
    MilliAmpereHour,
}

impl ElectricChargeUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Coulomb => "C",
            Self::MilliCoulomb => "mC",
            Self::MicroCoulomb => "uC",
            Self::AmpereHour => "Ah",
            Self::MilliAmpereHour => "mAh",
        }
    }

    const fn coulombs_per_unit(self) -> f64 {
        match self {
            Self::Coulomb => 1.0,
            Self::MilliCoulomb => 1e-3,
            Self::MicroCoulomb => 1e-6,
            Self::AmpereHour => 3_600.0,
            Self::MilliAmpereHour => 3.6,
        }
    }
}

impl ElectricCharge {
    /// Create from coulombs (canonical unit).
    pub const fn from_c(val: f64) -> Self {
        Self(val)
    }

    /// Create from millicoulombs. 1 mC = 1e-3 C.
    pub const fn from_mc(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from microcoulombs. 1 uC = 1e-6 C.
    pub const fn from_uc(val: f64) -> Self {
        Self(val * 1e-6)
    }

    /// Create from ampere-hours. 1 Ah = 3600 C.
    pub const fn from_ah(val: f64) -> Self {
        Self(val * 3_600.0)
    }

    /// Create from milliampere-hours. 1 mAh = 3.6 C.
    pub const fn from_mah(val: f64) -> Self {
        Self(val * 3.6)
    }

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

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

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

    /// Get value in ampere-hours.
    pub const fn in_ah(self) -> f64 {
        self.0 / 3_600.0
    }

    /// Get value in milliampere-hours.
    pub const fn in_mah(self) -> f64 {
        self.0 / 3.6
    }

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

    /// Return a display wrapper that formats this charge in the given unit.
    pub fn display_as(self, unit: ElectricChargeUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Return the absolute value of this charge.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(ElectricCharge, "C");

impl_common_ops!(ElectricCharge);

// -------------------------
// Electric current
// -------------------------

/// An electric current quantity, stored internally in amperes (A).
///
/// # Construction
/// ```
/// # use space_units::ElectricCurrent;
/// let i = ElectricCurrent::from_ma(500.0);
/// ```
///
/// # Typed arithmetic
/// - [`ElectricCurrent`] × [`Time`](crate::Time) → [`ElectricCharge`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct ElectricCurrent(pub(crate) f64);

/// Display/conversion units for [`ElectricCurrent`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ElectricCurrentUnit {
    /// Amperes (A).
    Ampere,
    /// Milliamperes (mA).
    MilliAmpere,
    /// Microamperes (uA).
    MicroAmpere,
    /// Kiloamperes (kA).
    KiloAmpere,
}

impl ElectricCurrentUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Ampere => "A",
            Self::MilliAmpere => "mA",
            Self::MicroAmpere => "uA",
            Self::KiloAmpere => "kA",
        }
    }

    const fn amperes_per_unit(self) -> f64 {
        match self {
            Self::Ampere => 1.0,
            Self::MilliAmpere => 1e-3,
            Self::MicroAmpere => 1e-6,
            Self::KiloAmpere => 1e3,
        }
    }
}

impl ElectricCurrent {
    /// Create from amperes (canonical unit).
    pub const fn from_a(val: f64) -> Self {
        Self(val)
    }

    /// Create from milliamperes. 1 mA = 1e-3 A.
    pub const fn from_ma(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from microamperes. 1 uA = 1e-6 A.
    pub const fn from_ua(val: f64) -> Self {
        Self(val * 1e-6)
    }

    /// Create from kiloamperes. 1 kA = 1e3 A.
    pub const fn from_ka(val: f64) -> Self {
        Self(val * 1e3)
    }

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

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

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

    /// Get value in kiloamperes.
    pub const fn in_ka(self) -> f64 {
        self.0 / 1e3
    }

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

    /// Return a display wrapper that formats this current in the given unit.
    pub fn display_as(self, unit: ElectricCurrentUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Return the absolute value of this current.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(ElectricCurrent, "A");

impl_common_ops!(ElectricCurrent);

// -------------------------
// Voltage
// -------------------------

/// A voltage (electric potential difference) quantity, stored internally in volts (V).
///
/// # Construction
/// ```
/// # use space_units::Voltage;
/// let v = Voltage::from_kv(3.3);
/// ```
///
/// # Typed arithmetic
/// - [`Voltage`] × [`ElectricCurrent`] → [`Power`](crate::Power)
/// - [`Voltage`] / [`ElectricCurrent`] → [`Resistance`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Voltage(pub(crate) f64);

/// Display/conversion units for [`Voltage`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum VoltageUnit {
    /// Volts (V).
    Volt,
    /// Millivolts (mV).
    MilliVolt,
    /// Kilovolts (kV).
    KiloVolt,
    /// Megavolts (MV).
    MegaVolt,
}

impl VoltageUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Volt => "V",
            Self::MilliVolt => "mV",
            Self::KiloVolt => "kV",
            Self::MegaVolt => "MV",
        }
    }

    const fn volts_per_unit(self) -> f64 {
        match self {
            Self::Volt => 1.0,
            Self::MilliVolt => 1e-3,
            Self::KiloVolt => 1e3,
            Self::MegaVolt => 1e6,
        }
    }
}

impl Voltage {
    /// Create from volts (canonical unit).
    pub const fn from_v(val: f64) -> Self {
        Self(val)
    }

    /// Create from millivolts. 1 mV = 1e-3 V.
    pub const fn from_mv(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from kilovolts. 1 kV = 1e3 V.
    pub const fn from_kv(val: f64) -> Self {
        Self(val * 1e3)
    }

    /// Create from megavolts. 1 MV = 1e6 V.
    pub const fn from_megav(val: f64) -> Self {
        Self(val * 1e6)
    }

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

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

    /// Get value in kilovolts.
    pub const fn in_kv(self) -> f64 {
        self.0 / 1e3
    }

    /// Get value in megavolts.
    pub const fn in_megav(self) -> f64 {
        self.0 / 1e6
    }

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

    /// Return a display wrapper that formats this voltage in the given unit.
    pub fn display_as(self, unit: VoltageUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Return the absolute value of this voltage.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Voltage, "V");

impl_common_ops!(Voltage);

// -------------------------
// Resistance
// -------------------------

/// An electrical resistance quantity, stored internally in ohms (Ohm).
///
/// # Construction
/// ```
/// # use space_units::Resistance;
/// let r = Resistance::from_kohm(4.7);
/// ```
///
/// # Typed arithmetic
/// - [`Resistance`] × [`ElectricCurrent`] → [`Voltage`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Resistance(pub(crate) f64);

/// Display/conversion units for [`Resistance`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ResistanceUnit {
    /// Ohms (Ohm).
    Ohm,
    /// Milliohms (mOhm).
    MilliOhm,
    /// Kilohms (kOhm).
    KiloOhm,
    /// Megaohms (`MOhm`).
    MegaOhm,
}

impl ResistanceUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Ohm => "Ohm",
            Self::MilliOhm => "mOhm",
            Self::KiloOhm => "kOhm",
            Self::MegaOhm => "MOhm",
        }
    }

    const fn ohms_per_unit(self) -> f64 {
        match self {
            Self::Ohm => 1.0,
            Self::MilliOhm => 1e-3,
            Self::KiloOhm => 1e3,
            Self::MegaOhm => 1e6,
        }
    }
}

impl Resistance {
    /// Create from ohms (canonical unit).
    pub const fn from_ohm(val: f64) -> Self {
        Self(val)
    }

    /// Create from milliohms. 1 mOhm = 1e-3 Ohm.
    pub const fn from_mohm(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from kilohms. 1 kOhm = 1e3 Ohm.
    pub const fn from_kohm(val: f64) -> Self {
        Self(val * 1e3)
    }

    /// Create from megaohms. 1 `MOhm` = 1e6 Ohm.
    pub const fn from_megaohm(val: f64) -> Self {
        Self(val * 1e6)
    }

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

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

    /// Get value in kilohms.
    pub const fn in_kohm(self) -> f64 {
        self.0 / 1e3
    }

    /// Get value in megaohms.
    pub const fn in_megaohm(self) -> f64 {
        self.0 / 1e6
    }

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

    /// Return a display wrapper that formats this resistance in the given unit.
    pub fn display_as(self, unit: ResistanceUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Return the absolute value of this resistance.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Resistance, "Ω");

impl_common_ops!(Resistance);

// -------------------------
// Magnetic flux density
// -------------------------

/// A magnetic flux density quantity, stored internally in tesla (T).
///
/// # Construction
/// ```
/// # use space_units::MagneticFluxDensity;
/// let b = MagneticFluxDensity::from_gauss(0.5);
/// ```
///
/// # Typed arithmetic
/// - [`MagneticFluxDensity`] × [`Area`](crate::Area) → [`MagneticFlux`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct MagneticFluxDensity(pub(crate) f64);

/// Display/conversion units for [`MagneticFluxDensity`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MagneticFluxDensityUnit {
    /// Tesla (T).
    Tesla,
    /// Millitesla (mT).
    MilliTesla,
    /// Microtesla (uT).
    MicroTesla,
    /// Nanotesla (nT).
    NanoTesla,
    /// Gauss (G). 1 G = 1e-4 T.
    Gauss,
}

impl MagneticFluxDensityUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Tesla => "T",
            Self::MilliTesla => "mT",
            Self::MicroTesla => "uT",
            Self::NanoTesla => "nT",
            Self::Gauss => "G",
        }
    }

    const fn tesla_per_unit(self) -> f64 {
        match self {
            Self::Tesla => 1.0,
            Self::MilliTesla => 1e-3,
            Self::MicroTesla => 1e-6,
            Self::NanoTesla => 1e-9,
            Self::Gauss => 1e-4,
        }
    }
}

impl MagneticFluxDensity {
    /// Create from tesla (canonical unit).
    pub const fn from_t(val: f64) -> Self {
        Self(val)
    }

    /// Create from millitesla. 1 mT = 1e-3 T.
    pub const fn from_mt(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from microtesla. 1 uT = 1e-6 T.
    pub const fn from_ut(val: f64) -> Self {
        Self(val * 1e-6)
    }

    /// Create from nanotesla. 1 nT = 1e-9 T.
    pub const fn from_nt(val: f64) -> Self {
        Self(val * 1e-9)
    }

    /// Create from gauss. 1 G = 1e-4 T.
    pub const fn from_gauss(val: f64) -> Self {
        Self(val * 1e-4)
    }

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

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

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

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

    /// Get value in gauss.
    pub const fn in_gauss(self) -> f64 {
        self.0 / 1e-4
    }

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

    /// Return a display wrapper that formats this flux density in the given unit.
    pub fn display_as(self, unit: MagneticFluxDensityUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Return the absolute value of this magnetic flux density.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(MagneticFluxDensity, "T");

impl_common_ops!(MagneticFluxDensity);

// -------------------------
// Magnetic flux
// -------------------------

/// A magnetic flux quantity, stored internally in webers (Wb).
///
/// # Construction
/// ```
/// # use space_units::MagneticFlux;
/// let phi = MagneticFlux::from_mwb(12.0);
/// ```
///
/// # Typed arithmetic
/// - [`MagneticFlux`] / [`Area`](crate::Area) → [`MagneticFluxDensity`]
/// - [`MagneticFlux`] / [`ElectricCurrent`] → [`Inductance`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct MagneticFlux(pub(crate) f64);

/// Display/conversion units for [`MagneticFlux`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MagneticFluxUnit {
    /// Webers (Wb).
    Weber,
    /// Milliwebers (mWb).
    MilliWeber,
    /// Microwebers (uWb).
    MicroWeber,
}

impl MagneticFluxUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Weber => "Wb",
            Self::MilliWeber => "mWb",
            Self::MicroWeber => "uWb",
        }
    }

    const fn webers_per_unit(self) -> f64 {
        match self {
            Self::Weber => 1.0,
            Self::MilliWeber => 1e-3,
            Self::MicroWeber => 1e-6,
        }
    }
}

impl MagneticFlux {
    /// Create from webers (canonical unit).
    pub const fn from_wb(val: f64) -> Self {
        Self(val)
    }

    /// Create from milliwebers. 1 mWb = 1e-3 Wb.
    pub const fn from_mwb(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from microwebers. 1 uWb = 1e-6 Wb.
    pub const fn from_uwb(val: f64) -> Self {
        Self(val * 1e-6)
    }

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

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

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

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

    /// Return a display wrapper that formats this flux in the given unit.
    pub fn display_as(self, unit: MagneticFluxUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Return the absolute value of this magnetic flux.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(MagneticFlux, "Wb");

impl_common_ops!(MagneticFlux);

// -------------------------
// Capacitance
// -------------------------

/// A capacitance quantity, stored internally in farads (F).
///
/// # Construction
/// ```
/// # use space_units::Capacitance;
/// let c = Capacitance::from_uf(100.0);
/// ```
///
/// # Typed arithmetic
/// - [`Capacitance`] × [`Voltage`] → [`ElectricCharge`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Capacitance(pub(crate) f64);

/// Display/conversion units for [`Capacitance`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum CapacitanceUnit {
    /// Farads (F).
    Farad,
    /// Millifarads (mF).
    MilliFarad,
    /// Microfarads (uF).
    MicroFarad,
    /// Nanofarads (nF).
    NanoFarad,
    /// Picofarads (pF).
    PicoFarad,
}

impl CapacitanceUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Farad => "F",
            Self::MilliFarad => "mF",
            Self::MicroFarad => "uF",
            Self::NanoFarad => "nF",
            Self::PicoFarad => "pF",
        }
    }

    const fn farads_per_unit(self) -> f64 {
        match self {
            Self::Farad => 1.0,
            Self::MilliFarad => 1e-3,
            Self::MicroFarad => 1e-6,
            Self::NanoFarad => 1e-9,
            Self::PicoFarad => 1e-12,
        }
    }
}

impl Capacitance {
    /// Create from farads (canonical unit).
    pub const fn from_f(val: f64) -> Self {
        Self(val)
    }

    /// Create from millifarads. 1 mF = 1e-3 F.
    pub const fn from_mf(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from microfarads. 1 uF = 1e-6 F.
    pub const fn from_uf(val: f64) -> Self {
        Self(val * 1e-6)
    }

    /// Create from nanofarads. 1 nF = 1e-9 F.
    pub const fn from_nf(val: f64) -> Self {
        Self(val * 1e-9)
    }

    /// Create from picofarads. 1 pF = 1e-12 F.
    pub const fn from_pf(val: f64) -> Self {
        Self(val * 1e-12)
    }

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

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

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

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

    /// Get value in picofarads.
    pub const fn in_pf(self) -> f64 {
        self.0 / 1e-12
    }

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

    /// Return a display wrapper that formats this capacitance in the given unit.
    pub fn display_as(self, unit: CapacitanceUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Return the absolute value of this capacitance.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Capacitance, "F");

impl_common_ops!(Capacitance);

// -------------------------
// Inductance
// -------------------------

/// An inductance quantity, stored internally in henrys (H).
///
/// # Construction
/// ```
/// # use space_units::Inductance;
/// let l = Inductance::from_mh(10.0);
/// ```
///
/// # Typed arithmetic
/// - [`Inductance`] × [`ElectricCurrent`] → [`MagneticFlux`]
#[must_use]
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd, Default)]
pub struct Inductance(pub(crate) f64);

/// Display/conversion units for [`Inductance`].
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum InductanceUnit {
    /// Henrys (H).
    Henry,
    /// Millihenrys (mH).
    MilliHenry,
    /// Microhenrys (uH).
    MicroHenry,
    /// Nanohenrys (nH).
    NanoHenry,
}

impl InductanceUnit {
    const fn symbol(self) -> &'static str {
        match self {
            Self::Henry => "H",
            Self::MilliHenry => "mH",
            Self::MicroHenry => "uH",
            Self::NanoHenry => "nH",
        }
    }

    const fn henrys_per_unit(self) -> f64 {
        match self {
            Self::Henry => 1.0,
            Self::MilliHenry => 1e-3,
            Self::MicroHenry => 1e-6,
            Self::NanoHenry => 1e-9,
        }
    }
}

impl Inductance {
    /// Create from henrys (canonical unit).
    pub const fn from_h(val: f64) -> Self {
        Self(val)
    }

    /// Create from millihenrys. 1 mH = 1e-3 H.
    pub const fn from_mh(val: f64) -> Self {
        Self(val * 1e-3)
    }

    /// Create from microhenrys. 1 uH = 1e-6 H.
    pub const fn from_uh(val: f64) -> Self {
        Self(val * 1e-6)
    }

    /// Create from nanohenrys. 1 nH = 1e-9 H.
    pub const fn from_nh(val: f64) -> Self {
        Self(val * 1e-9)
    }

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

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

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

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

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

    /// Return a display wrapper that formats this inductance in the given unit.
    pub fn display_as(self, unit: InductanceUnit) -> DisplayWithUnit {
        DisplayWithUnit {
            value: self.in_unit(unit),
            symbol: unit.symbol(),
        }
    }

    /// Return the absolute value of this inductance.
    pub fn abs(self) -> Self {
        Self(self.0.abs())
    }
}

impl_quantity_display!(Inductance, "H");

impl_common_ops!(Inductance);