Trait uom::Conversion

pub trait Conversion<V> {
    type T: ConversionFactor<V>;
    fn coefficient() -> Self::T { ... }
    fn constant(op: ConstantOp) -> Self::T { ... }
    fn into_conversion(&self) -> Self::T
    where
        Self: Sized,
    { ... }
}

Trait to identify units which have a conversion factor.

Generic Parameters

• V: Underlying storage type trait is implemented for.

Associated Types

type T: ConversionFactor<V>

Conversion factor type specific to the underlying storage type.

Loading content...

Provided methods

fn coefficient() -> Self::T

Coefficient portion of conversion factor for converting the given unit to the base unit for the quantity: (value * coefficient()) + constant(). Implementation should return the multiplicative identity (Self::T::one()) if no coefficient exists.

fn constant(op: ConstantOp) -> Self::T

Constant portion of conversion factor for converting the given unit to the base unit for the quantity: (value * coefficient()) + constant(). Implementation should return the additive identity (Self::T::zero()) if no constant exists. See ConstantOp documentation for details about parameter use to ensure the method optimizes correctly.

fn into_conversion(&self) -> Self::T where
    Self: Sized, 

Instance conversion factor.

Default implementation returns the coefficient: Self::coefficient().

Loading content...

Implementations on Foreign Types

impl Conversion<f32> for f32

type T = f32

fn constant(op: ConstantOp) -> Self::T

fn into_conversion(&self) -> Self::T

impl Conversion<f64> for f64

type T = f64

fn constant(op: ConstantOp) -> Self::T

fn into_conversion(&self) -> Self::T

Loading content...

Implementors

impl Conversion<f32> for attometer_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centimeter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decameter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decimeter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exameter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtometer_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for galileo

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigameter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectometer_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for inch_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilometer_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megameter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for meter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micrometer_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimeter_per_minute_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimeter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanometer_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petameter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picometer_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terameter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctometer_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottameter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptometer_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettameter_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attomole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centimole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decamole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decimole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for examole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtomole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigamole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectomole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilomole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megamole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micromole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanomole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petamole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picomole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teramole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctomole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottamole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptomole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettamole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for degree

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gon

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::angle::mil

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::angle::minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for radian

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for revolution

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::angle::second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for degree_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for radian_per_second_squared

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for degree_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for radian_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for degree_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for radian_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for revolution_per_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for revolution_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for revolution_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for acre

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for are

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for barn

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for circular_mil

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectare

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_attometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_decameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_exameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_femtometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_foot

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_gigameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_hectometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_inch

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_kilometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_megameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_micrometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_mile

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_nanometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_petameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_picometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_terameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_yard

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_yoctometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_yottameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_zeptometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_zettameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attojoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_pound

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_pound

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_it_per_gram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_per_gram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centijoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decajoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decijoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exajoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtojoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigajoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectojoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_attogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_exagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_femtogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_gigagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_gram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_megagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_microgram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_milligram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_nanogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_petagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_picogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_teragram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_yottagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_zeptogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_zettagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilojoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megajoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microjoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millijoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanojoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petajoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picojoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terajoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctojoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottajoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptojoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettajoule_per_kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for abfarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attofarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centifarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decafarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decifarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exafarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for farad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtofarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigafarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectofarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilofarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megafarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microfarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millifarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanofarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petafarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picofarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for statfarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terafarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctofarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottafarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptofarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettafarad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for atto_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attokatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centi_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centikatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deca_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decakatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deci_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decikatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exa_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exakatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femto_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtokatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for giga_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigakatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hecto_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectokatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for katal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilo_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilokatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mega_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megakatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micro_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microkatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milli_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millikatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nano_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanokatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for peta_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petakatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pico_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picokatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for tera_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terakatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yocto_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctokatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yotta_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottakatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zepto_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptokatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zetta_enzyme_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettakatal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for atto_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attokatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centi_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centikatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deca_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decakatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deci_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decikatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for enzyme_unit_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for enzyme_unit_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for enzyme_unit_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for enzyme_unit_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exa_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exakatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femto_enzyme_unit_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femto_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femto_enzyme_unit_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femto_enzyme_unit_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femto_enzyme_unit_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtokatal_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtokatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtokatal_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtokatal_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtokatal_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for giga_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigakatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hecto_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectokatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for katal_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for katal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for katal_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for katal_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for katal_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilo_enzyme_unit_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilo_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilo_enzyme_unit_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilo_enzyme_unit_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilo_enzyme_unit_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilokatal_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilokatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilokatal_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilokatal_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilokatal_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mega_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megakatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micro_enzyme_unit_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micro_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micro_enzyme_unit_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micro_enzyme_unit_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micro_enzyme_unit_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microkatal_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microkatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microkatal_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microkatal_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microkatal_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milli_enzyme_unit_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milli_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milli_enzyme_unit_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milli_enzyme_unit_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milli_enzyme_unit_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millikatal_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millikatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millikatal_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millikatal_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millikatal_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nano_enzyme_unit_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nano_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nano_enzyme_unit_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nano_enzyme_unit_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nano_enzyme_unit_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanokatal_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanokatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanokatal_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanokatal_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanokatal_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for peta_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petakatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pico_enzyme_unit_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pico_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pico_enzyme_unit_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pico_enzyme_unit_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pico_enzyme_unit_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picokatal_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picokatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picokatal_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picokatal_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picokatal_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for tera_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terakatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yocto_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctokatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yotta_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottakatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zepto_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptokatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zetta_enzyme_unit_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettakatal_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for degree_per_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for degree_per_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for radian_per_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for radian_per_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for abcoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ampere_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attocoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centicoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for coulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decaampere_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decacoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decicoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exacoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for faraday

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtocoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for franklin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigaampere_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigacoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectoampere_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectocoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kiloampere_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilocoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megaampere_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megacoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microampere_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microcoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliampere_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millicoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanocoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petaampere_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petacoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picocoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for statcoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teraampere_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teracoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctocoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottacoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptocoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettacoulomb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for abampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attoampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centiampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decaampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deciampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exaampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtoampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigaampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gilbert

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectoampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kiloampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megaampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanoampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petaampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picoampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for statampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teraampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctoampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottaampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptoampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettaampere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for abvolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attovolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centivolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decavolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decivolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exavolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtovolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigavolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectovolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilovolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megavolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microvolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millivolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanovolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petavolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picovolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for statvolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teravolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for volt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctovolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottavolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptovolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettavolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for abmho

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for absiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attosiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centisiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decasiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decisiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exasiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtosiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigasiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectosiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilosiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megasiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mho

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microsiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millisiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanosiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petasiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picosiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for siemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for statmho

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for statsiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terasiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctosiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottasiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptosiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettasiemens

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for abohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attoohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centiohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decaohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deciohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exaohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtoohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigaohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectoohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kiloohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megaohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanoohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petaohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picoohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for statohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teraohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctoohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottaohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptoohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettaohm

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attojoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_39

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_59

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_60

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_15

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_20

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_it

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_it_nutrition

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_nutrition

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centijoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decaelectronvolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decajoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decawatt_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decijoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for electronvolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for erg

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exajoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtojoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_pound

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_poundal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigaelectronvolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigajoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigawatt_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectoelectronvolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectojoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectowatt_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilocalorie

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilocalorie_it

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kiloelectronvolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilojoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilowatt_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megaelectronvolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megajoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megawatt_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microjoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microwatt_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millijoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliwatt_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanojoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petaelectronvolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petajoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petawatt_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picojoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for quad

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teraelectronvolt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terajoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terawatt_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for therm_ec

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for therm_us

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_tnt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctojoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottajoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptojoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettajoule

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attonewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centinewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decanewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decinewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for dyne

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exanewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtonewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for giganewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectonewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_force

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilonewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kip

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for meganewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micronewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millinewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanonewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ounce_force

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petanewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for piconewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_force

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for poundal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teranewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_force

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctonewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottanewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptonewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettanewton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attohertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centihertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cycle_per_day

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cycle_per_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cycle_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cycle_per_shake

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cycle_per_year

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decahertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decihertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exahertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtohertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigahertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectohertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilohertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megahertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microhertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millihertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanohertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petahertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picohertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terahertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctohertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottahertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptohertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettahertz

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attogram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attojoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centigram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centijoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decagram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decajoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decigram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decijoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exagram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exajoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtogram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtojoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigagram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigajoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectogram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectojoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilojoule_per_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilojoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megagram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megajoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microgram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microjoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milligram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millijoule_per_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millijoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanogram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanojoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petagram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petajoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picogram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picojoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teragram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terajoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctogram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctojoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottagram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottajoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptogram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptojoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettagram_square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettajoule_per_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attowatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centiwatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decawatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deciwatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exawatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtowatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigawatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectowatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilowatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megawatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microwatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliwatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanowatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petawatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picowatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terawatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctowatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottawatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptowatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettawatt_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attogram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attowatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_hour_square_foot_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_hour_square_inch_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_minute_square_foot_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_minute_square_inch_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_second_square_foot_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_second_square_inch_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_hour_square_foot_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_hour_square_inch_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_minute_square_foot_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_minute_square_inch_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_second_square_foot_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_second_square_inch_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centigram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centiwatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decagram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decawatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decigram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deciwatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exagram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exawatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtogram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtowatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigagram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigawatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectogram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectowatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_second_square_meter_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_second_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_per_second_cubed_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilowatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megagram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megawatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microgram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microwatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milligram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliwatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanogram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanowatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petagram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petawatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picogram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picowatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teragram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terawatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_per_square_centimeter_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_per_square_kilometer_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_per_square_meter_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_per_square_millimeter_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctogram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctowatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottagram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottawatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptogram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptowatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettagram_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettawatt_per_square_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for abhenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attohenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centihenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decahenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decihenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exahenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtohenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigahenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectohenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for henry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilohenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megahenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microhenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millihenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanohenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petahenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picohenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for stathenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terahenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctohenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottahenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptohenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettahenry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for bit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for byte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for crumb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deciban

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exabit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exabyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exbibit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exbibyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gibibit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gibibyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigabit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigabyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hartley

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kibibit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kibibyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilobit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilobyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mebibit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mebibyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megabit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megabyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for natural_unit_of_information

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nibble

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for octet

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pebibit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pebibyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petabit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petabyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for shannon

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for tebibit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for tebibyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terabit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terabyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for trit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yobibit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yobibyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottabit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottabyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zebibit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zebibyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettabit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettabyte

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for bit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for byte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exabit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exabyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exbibit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exbibyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gibibit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gibibyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigabit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigabyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kibibit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kibibyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilobit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilobyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mebibit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mebibyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megabit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megabyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for octet_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pebibit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pebibyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petabit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petabyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for tebibit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for tebibyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terabit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terabyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yobibit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yobibyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottabit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottabyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zebibit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zebibyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettabit_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettabyte_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attometer_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centimeter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decameter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decimeter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exameter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtometer_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigameter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectometer_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for inch_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilometer_per_minute_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilometer_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megameter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for meter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micrometer_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimeter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanometer_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petameter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picometer_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terameter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctometer_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottameter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptometer_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettameter_per_second_cubed

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for angstrom

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for astronomical_unit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for chain

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for fathom

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for fermi

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_survey

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for inch

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for light_year

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microinch

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micrometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micron

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::length::mil

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mile

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mile_survey

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nautical_mile

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for parsec

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pica_computer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pica_printers

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for point_computer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for point_printers

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for rod

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yard

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attocandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_foot

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_gigameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_inch

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_kilometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_megameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_micrometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_nanometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_picometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela_per_square_terameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centicandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decacandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decicandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exacandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtocandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for footlambert

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigacandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectocandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilocandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for lambert

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megacandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microcandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millicandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanocandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petacandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picocandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for stilb

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teracandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctocandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottacandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptocandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettacandela_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attocandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for candela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centicandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decacandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decicandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exacandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtocandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigacandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectocandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilocandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megacandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microcandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millicandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanocandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petacandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picocandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teracandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctocandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottacandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptocandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettacandela

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attoweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centiweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decaweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deciweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exaweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtoweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigaweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectoweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kiloweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for maxwell

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megaweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanoweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petaweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picoweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teraweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for weber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctoweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottaweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptoweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettaweber

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attotesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centitesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decatesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decitesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exatesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtotesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gamma

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gauss

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigatesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectotesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilotesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megatesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microtesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millitesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanotesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petatesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picotesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teratesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for tesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctotesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottatesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptotesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettatesla

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for carat

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centigram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decigram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for grain

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hundredweight_long

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hundredweight_short

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microgram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milligram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ounce

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ounce_troy

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pennyweight

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_troy

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for slug

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teragram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_assay

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_long

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_short

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptogram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettagram

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::attogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::centigram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::decagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::decigram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::exagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtogram_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::femtogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtogram_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtogram_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtogram_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::gigagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::gram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::hectogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::kilogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::megagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microgram_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::microgram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microgram_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microgram_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microgram_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milligram_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::milligram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milligram_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milligram_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milligram_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanogram_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::nanogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanogram_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanogram_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanogram_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::petagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picogram_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::picogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picogram_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picogram_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picogram_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::teragram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::yoctogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::yottagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::zeptogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_concentration::zettagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::attogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for carat_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::centigram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::decagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::decigram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::exagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::femtogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::gigagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for grain_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for grain_per_gallon

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_per_cubic_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::gram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::hectogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hundredweight_long_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hundredweight_short_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::kilogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::megagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::microgram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::milligram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::nanogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ounce_per_cubic_inch

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ounce_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ounce_per_gallon

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ounce_per_gallon_imperial

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ounce_troy_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pennyweight_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::petagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::picogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_per_cubic_foot

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_per_cubic_inch

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_per_cubic_yard

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_per_gallon

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_per_gallon_imperial

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_troy_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for slug_per_cubic_foot

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for slug_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::teragram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_assay_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_long_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_long_per_cubic_yard

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_short_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_short_per_cubic_yard

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::yoctogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::yottagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::zeptogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::mass_density::zettagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attogram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for carat_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centigram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decagram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decigram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exagram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtogram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigagram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for grain_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_per_day

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_per_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectogram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hundredweight_long_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hundredweight_short_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_per_day

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_per_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megagram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microgram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milligram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanogram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ounce_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ounce_troy_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pennyweight_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petagram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picogram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_per_day

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_per_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_troy_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for slug_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teragram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_assay_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_long_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_short_per_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_short_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctogram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottagram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptogram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettagram_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attomole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centimole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decamole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decimole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for examole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtomole_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtomole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtomole_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtomole_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtomole_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigamole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectomole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilomole_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilomole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilomole_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilomole_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilomole_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megamole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micromole_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micromole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micromole_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micromole_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micromole_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimole_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimole_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimole_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimole_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mole_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mole_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mole_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mole_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanomole_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanomole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanomole_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanomole_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanomole_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petamole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picomole_per_cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picomole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picomole_per_deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picomole_per_liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picomole_per_milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teramole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctomole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottamole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptomole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettamole_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attojoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_39_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_59_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_60_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_15_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_20_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_it_nutrition_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_it_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_nutrition_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for calorie_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centijoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decajoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decawatt_hour_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decijoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for electronvolt_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for erg_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exajoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtojoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_pound_force_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_poundal_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigajoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigawatt_hour_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectojoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectowatt_hour_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilocalorie_it_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilocalorie_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_square_meter_per_second_squared_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilojoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilowatt_hour_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megajoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megawatt_hour_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microjoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microwatt_hour_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millijoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliwatt_hour_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanojoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petajoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petawatt_hour_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picojoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for quad_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terajoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terawatt_hour_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for therm_ec_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for therm_us_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_tnt_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_hour_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_second_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctojoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottajoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptojoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettajoule_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attogram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centigram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decagram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decigram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exagram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtogram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigagram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectogram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megagram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microgram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milligram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanogram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petagram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picogram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teragram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctogram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottagram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptogram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettagram_per_mole

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attogram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centigram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decagram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decigram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exagram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtogram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigagram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectogram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_attometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_centimeter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_decameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_decimeter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_exameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_femtometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_gigameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_hectometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_kilometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_megameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_meter_per_day

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_meter_per_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_meter_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_micrometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_millimeter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_nanometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_petameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_picometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_terameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_yoctometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_yottameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_zeptometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_zettameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megagram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microgram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milligram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanogram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petagram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picogram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_foot_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_inch_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for slug_foot_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for slug_inch_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teragram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ton_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctogram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottagram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptogram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettagram_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attowatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centiwatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decawatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deciwatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for erg_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exawatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtowatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_pound_per_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_pound_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_pound_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigawatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectowatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for horsepower

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for horsepower_boiler

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for horsepower_electric

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for horsepower_imperial

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for horsepower_metric

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hydraulic_horsepower

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilowatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megawatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microwatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliwatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanowatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petawatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picowatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terawatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctowatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottawatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptowatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettawatt

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for atmosphere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for atmosphere_technical

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attopascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for bar

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centimeter_of_mercury

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centimeter_of_mercury_0

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centimeter_of_water

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centimeter_of_water_4

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centipascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decapascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decipascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for dyne_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exapascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtopascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_of_mercury

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_of_water

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_of_water_39_2

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigapascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_force_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectopascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for inch_of_mercury

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for inch_of_mercury_32

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for inch_of_mercury_60

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for inch_of_water

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for inch_of_water_39_2

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for inch_of_water_60

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_force_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_force_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_force_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilopascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kip_per_square_inch

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megapascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micropascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millibar

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimeter_of_mercury

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimeter_of_water

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millipascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millitorr

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanopascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petapascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picopascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_force_per_square_foot

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_force_per_square_inch

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for poundal_per_square_foot

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for psi

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terapascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for torr

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctopascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottapascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptopascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettapascal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attojoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centijoule_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centijoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centijoule_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decajoule_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decajoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decajoule_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decijoule_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decijoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decijoule_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exajoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtojoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigajoule_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigajoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigajoule_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectojoule_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectojoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectojoule_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilojoule_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilojoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilojoule_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megajoule_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megajoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megajoule_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microjoule_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microjoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microjoule_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millijoule_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millijoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millijoule_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanojoule_per_square_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanojoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanojoule_per_square_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petajoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picojoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terajoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctojoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottajoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptojoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettajoule_per_square_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for basis_point

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for part_per_billion

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for part_per_hundred

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for part_per_million

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for part_per_quadrillion

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for part_per_ten_thousand

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for part_per_thousand

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for part_per_trillion

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for per_mille

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for percent

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ratio

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for spat

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_degree

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for steradian

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attojoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_ounce_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_pound_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_it_per_ton_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_ounce_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_pound_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for btu_per_ton_degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centijoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decajoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decijoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exajoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtojoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigajoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectojoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_gram_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_kilogram_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for joule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilojoule_per_gram_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilojoule_per_kilogram_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilojoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megajoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microjoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millijoule_per_gram_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millijoule_per_kilogram_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millijoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanojoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petajoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picojoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_centimeter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_kilometer_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_meter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_micrometer_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for square_millimeter_per_second_squared_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terajoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctojoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottajoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptojoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettajoule_per_kilogram_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::attokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::centikelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::decakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::decikelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::degree_rankine

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::exakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::femtokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::gigakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::hectokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::kilokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::megakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::microkelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::millikelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::nanokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::petakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::picokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::terakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::yoctokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::yottakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::zeptokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::temperature_interval::zettakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attogram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attowatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centigram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centiwatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decagram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decawatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decigram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deciwatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exagram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exawatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtogram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtowatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigagram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigawatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectogram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectowatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_meter_per_second_cubed_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilowatt_per_meter_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilowatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megagram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megawatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microgram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microwatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milligram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliwatt_per_meter_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliwatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanogram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanowatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petagram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petawatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picogram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picowatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teragram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terawatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_per_meter_degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for watt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctogram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctowatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottagram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottawatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptogram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptowatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettagram_meter_per_second_cubed_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettawatt_per_meter_kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::attokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::centikelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::decakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::decikelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::degree_celsius

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::degree_fahrenheit

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::degree_rankine

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::exakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::femtokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::gigakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::hectokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::kelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::kilokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::megakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::microkelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::millikelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::nanokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::petakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::picokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::terakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::yoctokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::yottakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::zeptokelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::thermodynamic_temperature::zettakelvin

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attosecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centisecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for day

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for day_sidereal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decasecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decisecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exasecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtosecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigasecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectosecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hour_sidereal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilosecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megasecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microsecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millisecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::time::minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanosecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petasecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picosecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for uom::si::time::second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for second_sidereal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for shake

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terasecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for year

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for year_sidereal

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for year_tropical

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctosecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottasecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptosecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettasecond

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attonewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centinewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decanewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decinewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for dyne_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for dyne_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exanewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtonewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for giganewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectonewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilogram_force_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilonewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for meganewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micronewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millinewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanonewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_attometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_decameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_exameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_femtometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_gigameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_hectometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_kilometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_megameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_micrometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_nanometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_petameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_picometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_terameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_yoctometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_yottameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_zeptometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for newton_zettameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for ounce_force_inch

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petanewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for piconewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_force_foot

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pound_force_inch

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teranewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctonewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottanewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptonewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettanewton_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centimeter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decimeter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_per_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for foot_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for inch_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilometer_per_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kilometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for knot

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for micrometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mile_per_hour

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mile_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for mile_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimeter_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for millimeter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for terameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for acre_foot

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attoliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for barrel

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for bushel

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centiliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cord

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_attometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_centimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_decameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_decimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_exameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_femtometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_foot

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_gigameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_hectometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_inch

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_kilometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_megameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_meter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_micrometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_mile

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_millimeter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_nanometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_petameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_picometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_terameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_yard

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_yoctometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_yottameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_zeptometer

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_zettameter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cup

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decaliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deciliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exaliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtoliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for fluid_ounce

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for fluid_ounce_imperial

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gallon

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gallon_imperial

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigaliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gill

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gill_imperial

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectoliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kiloliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for liter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megaliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanoliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for peck

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petaliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picoliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pint_dry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pint_liquid

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for quart_dry

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for quart_liquid

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for register_ton

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for stere

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for tablespoon

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teaspoon

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teraliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctoliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottaliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptoliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettaliter

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for acre_foot_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for attoliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for barrel_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for bushel_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for centiliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cord_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_attometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_centimeter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_decameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_decimeter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_exameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_femtometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_foot_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_foot_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_gigameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_hectometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_inch_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_inch_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_kilometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_megameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_meter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_micrometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_mile_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_millimeter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_nanometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_petameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_picometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_terameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_yard_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_yard_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_yoctometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_yottameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_zeptometer_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cubic_zettameter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for cup_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for decaliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for deciliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for exaliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for femtoliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for fluid_ounce_imperial_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for fluid_ounce_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gallon_imperial_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gallon_per_day

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gallon_per_minute

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gallon_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gigaliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gill_imperial_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for gill_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for hectoliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for kiloliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for liter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for megaliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for microliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for milliliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for nanoliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for peck_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for petaliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for picoliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pint_dry_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for pint_liquid_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for quart_dry_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for quart_liquid_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for register_ton_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for stere_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for tablespoon_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teaspoon_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for teraliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yoctoliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for yottaliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zeptoliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f32> for zettaliter_per_second

type T = f32

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attometer_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centimeter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decameter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decimeter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exameter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtometer_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for galileo

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigameter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectometer_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for inch_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilometer_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megameter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for meter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micrometer_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimeter_per_minute_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimeter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanometer_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petameter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picometer_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terameter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctometer_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottameter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptometer_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettameter_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attomole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centimole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decamole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decimole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for examole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtomole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigamole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectomole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilomole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megamole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micromole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanomole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petamole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picomole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teramole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctomole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottamole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptomole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettamole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for degree

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gon

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::angle::mil

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::angle::minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for radian

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for revolution

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::angle::second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for degree_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for radian_per_second_squared

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for degree_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for radian_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for degree_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for radian_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for revolution_per_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for revolution_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for revolution_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for acre

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for are

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for barn

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for circular_mil

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectare

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_attometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_decameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_exameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_femtometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_foot

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_gigameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_hectometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_inch

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_kilometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_megameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_micrometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_mile

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_nanometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_petameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_picometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_terameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_yard

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_yoctometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_yottameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_zeptometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_zettameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attojoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_pound

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_pound

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_it_per_gram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_per_gram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centijoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decajoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decijoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exajoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtojoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigajoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectojoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_attogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_exagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_femtogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_gigagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_gram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_megagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_microgram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_milligram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_nanogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_petagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_picogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_teragram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_yottagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_zeptogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_zettagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilojoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megajoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microjoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millijoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanojoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petajoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picojoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terajoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctojoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottajoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptojoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettajoule_per_kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for abfarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attofarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centifarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decafarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decifarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exafarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for farad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtofarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigafarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectofarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilofarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megafarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microfarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millifarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanofarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petafarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picofarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for statfarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terafarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctofarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottafarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptofarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettafarad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for atto_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attokatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centi_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centikatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deca_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decakatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deci_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decikatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exa_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exakatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femto_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtokatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for giga_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigakatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hecto_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectokatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for katal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilo_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilokatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mega_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megakatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micro_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microkatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milli_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millikatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nano_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanokatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for peta_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petakatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pico_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picokatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for tera_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terakatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yocto_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctokatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yotta_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottakatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zepto_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptokatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zetta_enzyme_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettakatal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for atto_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attokatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centi_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centikatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deca_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decakatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deci_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decikatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for enzyme_unit_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for enzyme_unit_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for enzyme_unit_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for enzyme_unit_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exa_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exakatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femto_enzyme_unit_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femto_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femto_enzyme_unit_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femto_enzyme_unit_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femto_enzyme_unit_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtokatal_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtokatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtokatal_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtokatal_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtokatal_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for giga_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigakatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hecto_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectokatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for katal_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for katal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for katal_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for katal_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for katal_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilo_enzyme_unit_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilo_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilo_enzyme_unit_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilo_enzyme_unit_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilo_enzyme_unit_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilokatal_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilokatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilokatal_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilokatal_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilokatal_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mega_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megakatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micro_enzyme_unit_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micro_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micro_enzyme_unit_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micro_enzyme_unit_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micro_enzyme_unit_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microkatal_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microkatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microkatal_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microkatal_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microkatal_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milli_enzyme_unit_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milli_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milli_enzyme_unit_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milli_enzyme_unit_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milli_enzyme_unit_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millikatal_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millikatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millikatal_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millikatal_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millikatal_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nano_enzyme_unit_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nano_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nano_enzyme_unit_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nano_enzyme_unit_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nano_enzyme_unit_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanokatal_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanokatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanokatal_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanokatal_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanokatal_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for peta_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petakatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pico_enzyme_unit_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pico_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pico_enzyme_unit_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pico_enzyme_unit_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pico_enzyme_unit_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picokatal_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picokatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picokatal_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picokatal_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picokatal_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for tera_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terakatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yocto_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctokatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yotta_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottakatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zepto_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptokatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zetta_enzyme_unit_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettakatal_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for degree_per_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for degree_per_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for radian_per_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for radian_per_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for abcoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ampere_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attocoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centicoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for coulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decaampere_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decacoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decicoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exacoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for faraday

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtocoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for franklin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigaampere_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigacoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectoampere_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectocoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kiloampere_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilocoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megaampere_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megacoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microampere_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microcoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliampere_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millicoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanocoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petaampere_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petacoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picocoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for statcoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teraampere_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teracoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctocoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottacoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptocoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettacoulomb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for abampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attoampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centiampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decaampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deciampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exaampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtoampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigaampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gilbert

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectoampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kiloampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megaampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanoampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petaampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picoampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for statampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teraampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctoampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottaampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptoampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettaampere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for abvolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attovolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centivolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decavolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decivolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exavolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtovolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigavolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectovolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilovolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megavolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microvolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millivolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanovolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petavolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picovolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for statvolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teravolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for volt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctovolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottavolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptovolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettavolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for abmho

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for absiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attosiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centisiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decasiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decisiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exasiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtosiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigasiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectosiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilosiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megasiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mho

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microsiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millisiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanosiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petasiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picosiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for siemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for statmho

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for statsiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terasiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctosiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottasiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptosiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettasiemens

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for abohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attoohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centiohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decaohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deciohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exaohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtoohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigaohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectoohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kiloohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megaohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanoohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petaohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picoohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for statohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teraohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctoohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottaohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptoohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettaohm

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attojoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_39

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_59

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_60

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_15

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_20

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_it

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_it_nutrition

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_nutrition

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centijoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decaelectronvolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decajoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decawatt_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decijoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for electronvolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for erg

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exajoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtojoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_pound

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_poundal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigaelectronvolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigajoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigawatt_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectoelectronvolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectojoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectowatt_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilocalorie

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilocalorie_it

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kiloelectronvolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilojoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilowatt_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megaelectronvolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megajoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megawatt_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microjoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microwatt_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millijoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliwatt_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanojoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petaelectronvolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petajoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petawatt_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picojoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for quad

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teraelectronvolt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terajoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terawatt_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for therm_ec

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for therm_us

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_tnt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctojoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottajoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptojoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettajoule

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attonewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centinewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decanewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decinewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for dyne

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exanewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtonewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for giganewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectonewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_force

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilonewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kip

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for meganewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micronewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millinewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanonewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ounce_force

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petanewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for piconewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_force

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for poundal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teranewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_force

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctonewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottanewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptonewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettanewton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attohertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centihertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cycle_per_day

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cycle_per_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cycle_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cycle_per_shake

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cycle_per_year

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decahertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decihertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exahertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtohertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigahertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectohertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilohertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megahertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microhertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millihertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanohertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petahertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picohertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terahertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctohertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottahertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptohertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettahertz

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attogram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attojoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centigram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centijoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decagram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decajoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decigram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decijoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exagram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exajoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtogram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtojoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigagram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigajoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectogram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectojoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilojoule_per_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilojoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megagram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megajoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microgram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microjoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milligram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millijoule_per_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millijoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanogram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanojoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petagram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petajoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picogram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picojoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teragram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terajoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctogram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctojoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottagram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottajoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptogram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptojoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettagram_square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettajoule_per_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attowatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centiwatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decawatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deciwatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exawatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtowatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigawatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectowatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilowatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megawatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microwatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliwatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanowatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petawatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picowatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terawatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctowatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottawatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptowatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettawatt_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attogram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attowatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_hour_square_foot_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_hour_square_inch_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_minute_square_foot_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_minute_square_inch_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_second_square_foot_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_second_square_inch_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_hour_square_foot_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_hour_square_inch_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_minute_square_foot_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_minute_square_inch_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_second_square_foot_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_second_square_inch_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centigram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centiwatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decagram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decawatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decigram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deciwatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exagram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exawatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtogram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtowatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigagram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigawatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectogram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectowatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_second_square_meter_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_second_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_per_second_cubed_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilowatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megagram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megawatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microgram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microwatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milligram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliwatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanogram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanowatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petagram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petawatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picogram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picowatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teragram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terawatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_per_square_centimeter_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_per_square_kilometer_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_per_square_meter_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_per_square_millimeter_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctogram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctowatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottagram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottawatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptogram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptowatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettagram_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettawatt_per_square_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for abhenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attohenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centihenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decahenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decihenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exahenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtohenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigahenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectohenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for henry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilohenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megahenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microhenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millihenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanohenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petahenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picohenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for stathenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terahenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctohenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottahenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptohenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettahenry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for bit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for byte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for crumb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deciban

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exabit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exabyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exbibit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exbibyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gibibit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gibibyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigabit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigabyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hartley

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kibibit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kibibyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilobit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilobyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mebibit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mebibyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megabit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megabyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for natural_unit_of_information

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nibble

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for octet

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pebibit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pebibyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petabit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petabyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for shannon

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for tebibit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for tebibyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terabit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terabyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for trit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yobibit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yobibyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottabit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottabyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zebibit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zebibyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettabit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettabyte

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for bit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for byte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exabit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exabyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exbibit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exbibyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gibibit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gibibyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigabit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigabyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kibibit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kibibyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilobit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilobyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mebibit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mebibyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megabit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megabyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for octet_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pebibit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pebibyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petabit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petabyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for tebibit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for tebibyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terabit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terabyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yobibit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yobibyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottabit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottabyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zebibit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zebibyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettabit_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettabyte_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attometer_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centimeter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decameter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decimeter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exameter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtometer_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigameter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectometer_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for inch_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilometer_per_minute_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilometer_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megameter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for meter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micrometer_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimeter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanometer_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petameter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picometer_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terameter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctometer_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottameter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptometer_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettameter_per_second_cubed

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for angstrom

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for astronomical_unit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for chain

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for fathom

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for fermi

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_survey

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for inch

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for light_year

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microinch

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micrometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micron

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::length::mil

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mile

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mile_survey

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nautical_mile

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for parsec

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pica_computer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pica_printers

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for point_computer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for point_printers

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for rod

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yard

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attocandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_foot

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_gigameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_inch

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_kilometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_megameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_micrometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_nanometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_picometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela_per_square_terameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centicandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decacandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decicandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exacandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtocandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for footlambert

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigacandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectocandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilocandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for lambert

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megacandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microcandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millicandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanocandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petacandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picocandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for stilb

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teracandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctocandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottacandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptocandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettacandela_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attocandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for candela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centicandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decacandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decicandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exacandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtocandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigacandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectocandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilocandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megacandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microcandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millicandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanocandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petacandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picocandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teracandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctocandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottacandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptocandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettacandela

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attoweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centiweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decaweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deciweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exaweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtoweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigaweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectoweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kiloweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for maxwell

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megaweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanoweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petaweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picoweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teraweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for weber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctoweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottaweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptoweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettaweber

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attotesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centitesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decatesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decitesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exatesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtotesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gamma

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gauss

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigatesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectotesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilotesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megatesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microtesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millitesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanotesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petatesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picotesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teratesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for tesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctotesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottatesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptotesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettatesla

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for carat

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centigram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decigram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for grain

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hundredweight_long

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hundredweight_short

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microgram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milligram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ounce

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ounce_troy

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pennyweight

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_troy

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for slug

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teragram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_assay

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_long

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_short

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptogram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettagram

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::attogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::centigram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::decagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::decigram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::exagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtogram_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::femtogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtogram_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtogram_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtogram_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::gigagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::gram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::hectogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::kilogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::megagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microgram_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::microgram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microgram_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microgram_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microgram_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milligram_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::milligram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milligram_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milligram_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milligram_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanogram_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::nanogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanogram_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanogram_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanogram_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::petagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picogram_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::picogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picogram_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picogram_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picogram_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::teragram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::yoctogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::yottagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::zeptogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_concentration::zettagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::attogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for carat_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::centigram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::decagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::decigram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::exagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::femtogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::gigagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for grain_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for grain_per_gallon

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_per_cubic_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::gram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::hectogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hundredweight_long_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hundredweight_short_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::kilogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::megagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::microgram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::milligram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::nanogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ounce_per_cubic_inch

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ounce_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ounce_per_gallon

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ounce_per_gallon_imperial

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ounce_troy_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pennyweight_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::petagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::picogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_per_cubic_foot

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_per_cubic_inch

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_per_cubic_yard

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_per_gallon

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_per_gallon_imperial

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_troy_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for slug_per_cubic_foot

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for slug_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::teragram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_assay_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_long_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_long_per_cubic_yard

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_short_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_short_per_cubic_yard

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::yoctogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::yottagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::zeptogram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::mass_density::zettagram_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attogram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for carat_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centigram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decagram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decigram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exagram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtogram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigagram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for grain_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_per_day

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_per_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectogram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hundredweight_long_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hundredweight_short_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_per_day

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_per_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megagram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microgram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milligram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanogram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ounce_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ounce_troy_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pennyweight_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petagram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picogram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_per_day

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_per_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_troy_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for slug_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teragram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_assay_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_long_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_short_per_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_short_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctogram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottagram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptogram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettagram_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attomole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centimole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decamole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decimole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for examole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtomole_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtomole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtomole_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtomole_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtomole_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigamole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectomole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilomole_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilomole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilomole_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilomole_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilomole_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megamole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micromole_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micromole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micromole_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micromole_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micromole_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimole_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimole_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimole_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimole_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mole_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mole_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mole_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mole_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanomole_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanomole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanomole_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanomole_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanomole_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petamole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picomole_per_cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picomole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picomole_per_deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picomole_per_liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picomole_per_milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teramole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctomole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottamole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptomole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettamole_per_cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attojoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_39_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_59_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_60_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_15_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_20_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_it_nutrition_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_it_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_nutrition_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for calorie_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centijoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decajoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decawatt_hour_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decijoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for electronvolt_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for erg_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exajoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtojoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_pound_force_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_poundal_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigajoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigawatt_hour_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectojoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectowatt_hour_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilocalorie_it_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilocalorie_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_square_meter_per_second_squared_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilojoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilowatt_hour_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megajoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megawatt_hour_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microjoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microwatt_hour_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millijoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliwatt_hour_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanojoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petajoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petawatt_hour_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picojoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for quad_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terajoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terawatt_hour_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for therm_ec_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for therm_us_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_tnt_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_hour_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_second_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctojoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottajoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptojoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettajoule_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attogram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centigram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decagram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decigram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exagram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtogram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigagram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectogram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megagram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microgram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milligram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanogram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petagram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picogram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teragram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctogram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottagram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptogram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettagram_per_mole

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attogram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centigram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decagram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decigram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exagram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtogram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigagram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectogram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_attometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_centimeter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_decameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_decimeter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_exameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_femtometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_gigameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_hectometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_kilometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_megameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_meter_per_day

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_meter_per_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_meter_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_micrometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_millimeter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_nanometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_petameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_picometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_terameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_yoctometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_yottameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_zeptometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_zettameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megagram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microgram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milligram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanogram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petagram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picogram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_foot_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_inch_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for slug_foot_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for slug_inch_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teragram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ton_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctogram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottagram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptogram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettagram_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attowatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centiwatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decawatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deciwatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for erg_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exawatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtowatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_pound_per_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_pound_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_pound_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigawatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectowatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for horsepower

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for horsepower_boiler

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for horsepower_electric

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for horsepower_imperial

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for horsepower_metric

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hydraulic_horsepower

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilowatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megawatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microwatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliwatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanowatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petawatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picowatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terawatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctowatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottawatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptowatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettawatt

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for atmosphere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for atmosphere_technical

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attopascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for bar

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centimeter_of_mercury

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centimeter_of_mercury_0

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centimeter_of_water

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centimeter_of_water_4

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centipascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decapascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decipascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for dyne_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exapascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtopascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_of_mercury

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_of_water

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_of_water_39_2

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigapascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_force_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectopascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for inch_of_mercury

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for inch_of_mercury_32

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for inch_of_mercury_60

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for inch_of_water

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for inch_of_water_39_2

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for inch_of_water_60

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_force_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_force_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_force_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilopascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kip_per_square_inch

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megapascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micropascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millibar

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimeter_of_mercury

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimeter_of_water

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millipascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millitorr

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanopascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petapascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picopascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_force_per_square_foot

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_force_per_square_inch

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for poundal_per_square_foot

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for psi

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terapascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for torr

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctopascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottapascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptopascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettapascal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attojoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centijoule_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centijoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centijoule_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decajoule_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decajoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decajoule_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decijoule_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decijoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decijoule_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exajoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtojoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigajoule_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigajoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigajoule_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectojoule_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectojoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectojoule_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilojoule_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilojoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilojoule_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megajoule_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megajoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megajoule_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microjoule_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microjoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microjoule_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millijoule_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millijoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millijoule_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanojoule_per_square_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanojoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanojoule_per_square_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petajoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picojoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terajoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctojoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottajoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptojoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettajoule_per_square_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for basis_point

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for part_per_billion

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for part_per_hundred

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for part_per_million

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for part_per_quadrillion

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for part_per_ten_thousand

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for part_per_thousand

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for part_per_trillion

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for per_mille

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for percent

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ratio

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for spat

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_degree

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for steradian

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attojoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_ounce_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_pound_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_it_per_ton_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_ounce_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_pound_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for btu_per_ton_degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centijoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decajoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decijoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exajoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtojoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigajoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectojoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_gram_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_kilogram_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for joule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilojoule_per_gram_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilojoule_per_kilogram_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilojoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megajoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microjoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millijoule_per_gram_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millijoule_per_kilogram_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millijoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanojoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petajoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picojoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_centimeter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_kilometer_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_meter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_micrometer_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for square_millimeter_per_second_squared_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terajoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctojoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottajoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptojoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettajoule_per_kilogram_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::attokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::centikelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::decakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::decikelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::degree_rankine

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::exakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::femtokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::gigakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::hectokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::kilokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::megakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::microkelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::millikelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::nanokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::petakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::picokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::terakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::yoctokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::yottakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::zeptokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::temperature_interval::zettakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attogram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attowatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centigram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centiwatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decagram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decawatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decigram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deciwatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exagram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exawatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtogram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtowatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigagram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigawatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectogram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectowatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_meter_per_second_cubed_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilowatt_per_meter_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilowatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megagram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megawatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microgram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microwatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milligram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliwatt_per_meter_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliwatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanogram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanowatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petagram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petawatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picogram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picowatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teragram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terawatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_per_meter_degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for watt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctogram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctowatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottagram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottawatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptogram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptowatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettagram_meter_per_second_cubed_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettawatt_per_meter_kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::attokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::centikelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::decakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::decikelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::degree_celsius

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::degree_fahrenheit

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::degree_rankine

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::exakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::femtokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::gigakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::hectokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::kelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::kilokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::megakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::microkelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::millikelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::nanokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::petakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::picokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::terakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::yoctokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::yottakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::zeptokelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::thermodynamic_temperature::zettakelvin

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attosecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centisecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for day

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for day_sidereal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decasecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decisecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exasecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtosecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigasecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectosecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hour_sidereal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilosecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megasecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microsecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millisecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::time::minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanosecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petasecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picosecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for uom::si::time::second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for second_sidereal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for shake

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terasecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for year

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for year_sidereal

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for year_tropical

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctosecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottasecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptosecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettasecond

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attonewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centinewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decanewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decinewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for dyne_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for dyne_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exanewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtonewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for giganewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectonewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilogram_force_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilonewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for meganewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micronewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millinewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanonewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_attometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_decameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_exameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_femtometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_gigameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_hectometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_kilometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_megameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_micrometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_nanometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_petameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_picometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_terameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_yoctometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_yottameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_zeptometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for newton_zettameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for ounce_force_inch

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petanewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for piconewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_force_foot

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pound_force_inch

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teranewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctonewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottanewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptonewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettanewton_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centimeter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decimeter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_per_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for foot_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for inch_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilometer_per_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kilometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for knot

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for micrometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mile_per_hour

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mile_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for mile_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimeter_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for millimeter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for terameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for acre_foot

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attoliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for barrel

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for bushel

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centiliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cord

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_attometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_centimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_decameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_decimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_exameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_femtometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_foot

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_gigameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_hectometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_inch

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_kilometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_megameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_meter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_micrometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_mile

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_millimeter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_nanometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_petameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_picometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_terameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_yard

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_yoctometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_yottameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_zeptometer

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_zettameter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cup

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decaliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deciliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exaliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtoliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for fluid_ounce

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for fluid_ounce_imperial

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gallon

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gallon_imperial

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigaliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gill

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gill_imperial

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectoliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kiloliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for liter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megaliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanoliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for peck

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petaliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picoliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pint_dry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pint_liquid

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for quart_dry

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for quart_liquid

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for register_ton

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for stere

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for tablespoon

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teaspoon

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teraliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctoliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottaliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptoliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettaliter

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for acre_foot_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for attoliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for barrel_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for bushel_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for centiliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cord_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_attometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_centimeter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_decameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_decimeter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_exameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_femtometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_foot_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_foot_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_gigameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_hectometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_inch_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_inch_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_kilometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_megameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_meter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_micrometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_mile_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_millimeter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_nanometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_petameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_picometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_terameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_yard_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_yard_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_yoctometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_yottameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_zeptometer_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cubic_zettameter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for cup_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for decaliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for deciliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for exaliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for femtoliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for fluid_ounce_imperial_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for fluid_ounce_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gallon_imperial_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gallon_per_day

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gallon_per_minute

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gallon_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gigaliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gill_imperial_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for gill_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for hectoliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for kiloliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for liter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for megaliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for microliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for milliliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for nanoliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for peck_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for petaliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for picoliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pint_dry_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for pint_liquid_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for quart_dry_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for quart_liquid_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for register_ton_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for stere_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for tablespoon_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teaspoon_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for teraliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yoctoliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for yottaliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zeptoliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

impl Conversion<f64> for zettaliter_per_second

type T = f64

fn coefficient() -> Self::T

fn constant(op: ConstantOp) -> Self::T

Loading content...