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...

Implementors

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 zettameter_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 petameter_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 gigameter_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 kilometer_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 decameter_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 decimeter_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 millimeter_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 nanometer_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 femtometer_per_second_squared

type T = f32

fn coefficient() -> Self::T

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

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 zeptometer_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 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 inch_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 yottamole

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 examole

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 teramole

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 megamole

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 hectomole

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 mole

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 centimole

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 micromole

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 picomole

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 attomole

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 yoctomole

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 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 uom::si::angle::second

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_squared

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_cubed

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 degree_per_second

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 revolution_per_minute

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 square_yottameter

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 square_exameter

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_terameter

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_megameter

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_hectometer

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_meter

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_centimeter

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_micrometer

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_picometer

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_attometer

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_yoctometer

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_foot

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_mile

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 yottajoule_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 exajoule_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 terajoule_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 megajoule_per_kilogram

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 hectojoule_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 joule_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 centijoule_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 microjoule_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 picojoule_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 attojoule_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 yoctojoule_per_kilogram

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_attogram

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_picogram

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_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_gram

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_gigagram

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_petagram

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_zettagram

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 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 yottafarad

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 exafarad

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 terafarad

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 megafarad

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 hectofarad

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 farad

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 centifarad

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 microfarad

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 picofarad

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 attofarad

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 yoctofarad

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 statfarad

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 zettacoulomb

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 petacoulomb

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 gigacoulomb

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 kilocoulomb

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 decacoulomb

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 decicoulomb

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 millicoulomb

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 nanocoulomb

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 femtocoulomb

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 zeptocoulomb

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 petaampere_hour

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 gigaampere_hour

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 kiloampere_hour

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 decaampere_hour

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 milliampere_hour

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 abcoulomb

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 franklin

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 yottaampere

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 exaampere

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 teraampere

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 megaampere

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 hectoampere

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 ampere

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 centiampere

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 microampere

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 picoampere

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 attoampere

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 yoctoampere

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 gilbert

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 yottavolt

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 exavolt

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 teravolt

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 megavolt

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 hectovolt

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 volt

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 centivolt

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 microvolt

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 picovolt

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 attovolt

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 yoctovolt

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 statvolt

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 zettasiemens

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 petasiemens

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 gigasiemens

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 kilosiemens

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 decasiemens

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 mho

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 centisiemens

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 microsiemens

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 picosiemens

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 attosiemens

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 yoctosiemens

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 statsiemens

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 yottaohm

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 exaohm

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 teraohm

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 megaohm

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 hectoohm

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 ohm

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 centiohm

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 microohm

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 picoohm

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 attoohm

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 yoctoohm

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 statohm

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 zettajoule

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 petajoule

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 gigajoule

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 kilojoule

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 decajoule

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 decijoule

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 millijoule

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 nanojoule

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 femtojoule

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 zeptojoule

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 petawatt_hour

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 gigawatt_hour

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 kilowatt_hour

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 decawatt_hour

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 milliwatt_hour

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 btu_it

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 calorie_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_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 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 foot_poundal

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 kilocalorie_it

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 quad

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_second

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 zettanewton

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 petanewton

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 giganewton

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 kilonewton

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 decanewton

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 decinewton

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 millinewton

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 nanonewton

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 femtonewton

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 zeptonewton

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 dyne

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 kip

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 poundal

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 ton_force

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 zettahertz

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 petahertz

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 gigahertz

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 kilohertz

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 decahertz

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 decihertz

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 millihertz

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 nanohertz

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 femtohertz

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 zeptohertz

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 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 yottagram_square_meter_per_second_squared_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 exagram_square_meter_per_second_squared_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 teragram_square_meter_per_second_squared_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 megagram_square_meter_per_second_squared_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 hectogram_square_meter_per_second_squared_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 gram_square_meter_per_second_squared_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 centigram_square_meter_per_second_squared_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 microgram_square_meter_per_second_squared_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 picogram_square_meter_per_second_squared_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 attogram_square_meter_per_second_squared_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 yoctogram_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 zettajoule_per_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 petajoule_per_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 gigajoule_per_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 kilojoule_per_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 decajoule_per_kelvin

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 decijoule_per_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 millijoule_per_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 nanojoule_per_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 femtojoule_per_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 zeptojoule_per_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 kilojoule_per_degree_celsius

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 millijoule_per_degree_celsius

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 btu_it_per_degree_fahrenheit

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 zettawatt_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 petawatt_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 gigawatt_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 kilowatt_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 decawatt_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 deciwatt_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 milliwatt_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 nanowatt_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 femtowatt_per_square_meter

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 zeptowatt_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 yottagram_per_second_cubed_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 exagram_per_second_cubed_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 teragram_per_second_cubed_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 megagram_per_second_cubed_kelvin

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 hectogram_per_second_cubed_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 gram_per_second_cubed_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 centigram_per_second_cubed_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 microgram_per_second_cubed_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 picogram_per_second_cubed_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 attogram_per_second_cubed_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 yoctogram_per_second_cubed_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 yottawatt_per_square_meter_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 exawatt_per_square_meter_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 terawatt_per_square_meter_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 megawatt_per_square_meter_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 hectowatt_per_square_meter_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 watt_per_square_meter_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 centiwatt_per_square_meter_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 microwatt_per_square_meter_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 picowatt_per_square_meter_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 attowatt_per_square_meter_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 yoctowatt_per_square_meter_kelvin

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_centimeter_degree_celsius

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 joule_per_second_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 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 yottahenry

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 exahenry

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 terahenry

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 megahenry

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 hectohenry

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 henry

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 centihenry

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 microhenry

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 picohenry

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 attohenry

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 yoctohenry

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 stathenry

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 yottabit

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 zettabit

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 exabit

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 petabit

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 terabit

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 gigabit

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 megabit

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 kilobit

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 yobibyte

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 zebibyte

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 exbibyte

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 pebibyte

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 tebibyte

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 gibibyte

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 mebibyte

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 kibibyte

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 byte

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 nibble

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 shannon

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 trit

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 deciban

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 yottabit_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 zettabit_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 exabit_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 petabit_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 terabit_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 gigabit_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 megabit_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 kilobit_per_second

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 yobibyte_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 zebibyte_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 exbibyte_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 pebibyte_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 tebibyte_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 gibibyte_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 mebibyte_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 kibibyte_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 byte_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 yottameter_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 exameter_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 terameter_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 megameter_per_second_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 hectometer_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 meter_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 centimeter_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 micrometer_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 picometer_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 attometer_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 yoctometer_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 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 yottameter

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 exameter

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 terameter

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 megameter

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 hectometer

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 meter

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 centimeter

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 micrometer

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 picometer

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 attometer

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 yoctometer

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 chain

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 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 inch

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 microinch

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 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 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 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 yard

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 zettacandela_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 petacandela_per_square_meter

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 gigacandela_per_square_meter

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 kilocandela_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 decacandela_per_square_meter

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 decicandela_per_square_meter

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 millicandela_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 nanocandela_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 femtocandela_per_square_meter

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 zeptocandela_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 candela_per_square_picometer

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_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_centimeter

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_gigameter

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 candela_per_square_inch

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 lambert

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 yottacandela

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 exacandela

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 teracandela

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 megacandela

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 hectocandela

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 candela

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 centicandela

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 microcandela

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 picocandela

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 attocandela

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 yoctocandela

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 zettaweber

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 petaweber

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 gigaweber

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 kiloweber

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 decaweber

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 deciweber

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 milliweber

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 nanoweber

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 femtoweber

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 zeptoweber

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 maxwell

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 zettatesla

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 petatesla

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 gigatesla

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 kilotesla

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 decatesla

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 decitesla

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 millitesla

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 nanotesla

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 femtotesla

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 zeptotesla

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 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 yottagram

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 exagram

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 teragram

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 megagram

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 hectogram

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 gram

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 centigram

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 microgram

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 picogram

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 attogram

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 yoctogram

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 grain

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 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 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 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 ton

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for yottagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for zettagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for exagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for petagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for teragram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for gigagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for megagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for kilogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for hectogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for decagram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for gram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for decigram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for centigram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for milligram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for microgram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for nanogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for picogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for femtogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for attogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for zeptogram_per_cubic_meter

type T = f32

fn coefficient() -> Self::T

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

impl Conversion<f32> for yoctogram_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 grain_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 ounce_per_cubic_meter

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 pound_per_cubic_meter

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_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_short_per_cubic_meter

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 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 ounce_per_cubic_inch

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_per_gallon

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_yard

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_per_gallon

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 ton_long_per_cubic_yard

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 yottagram_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 exagram_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 teragram_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 megagram_per_second

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 hectogram_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 gram_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 centigram_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 microgram_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 picogram_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 attogram_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 yoctogram_per_second

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_hour

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 gram_per_minute

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_day

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 grain_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 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 pound_per_second

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_hour

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_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 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_short_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_per_second

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 yottajoule_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 exajoule_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 terajoule_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 megajoule_per_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 hectojoule_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 joule_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 centijoule_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 microjoule_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 picojoule_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 attojoule_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 yoctojoule_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 terawatt_hour_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 megawatt_hour_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 hectowatt_hour_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 watt_hour_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 microwatt_hour_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_it_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 calorie_it_nutrition_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 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 foot_poundal_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 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 quad_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_second_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 zettagram_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 petagram_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 gigagram_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 kilogram_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 decagram_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 decigram_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 milligram_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 nanogram_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 femtogram_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 zeptogram_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_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 exagram_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 teragram_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 megagram_meter_per_second

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 hectogram_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 gram_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 centigram_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 microgram_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 picogram_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 attogram_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 yoctogram_meter_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_zettameter_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_petameter_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_gigameter_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_kilometer_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_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_centimeter_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_micrometer_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_picometer_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_attometer_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_yoctometer_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 kilogram_meter_per_minute

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_day

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 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 yottawatt

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 exawatt

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 terawatt

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 megawatt

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 hectowatt

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 watt

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 centiwatt

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 microwatt

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 picowatt

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 attowatt

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 yoctowatt

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 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 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_metric

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 hydraulic_horsepower

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 zettapascal

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 petapascal

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 gigapascal

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 kilopascal

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 decapascal

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 decipascal

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 millipascal

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 nanopascal

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 femtopascal

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 zeptopascal

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 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 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_water

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 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 gram_force_per_square_centimeter

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_water

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 kip_per_square_inch

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 millitorr

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 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 psi

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 ratio

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 percent

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 per_mille

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 basis_point

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_billion

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 part_per_quadrillion

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_centimeter_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 square_micrometer_per_second_squared_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 zettajoule_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 petajoule_per_kilogram_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 gigajoule_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 kilojoule_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 decajoule_per_kilogram_kelvin

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 decijoule_per_kilogram_kelvin

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 millijoule_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 nanojoule_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 femtojoule_per_kilogram_kelvin

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 zeptojoule_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 kilojoule_per_kilogram_degree_celsius

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 joule_per_kilogram_degree_celsius

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 millijoule_per_kilogram_degree_celsius

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 btu_per_ounce_degree_fahrenheit

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_per_pound_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_per_ton_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 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::zettakelvin

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::petakelvin

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::gigakelvin

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::kilokelvin

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::decakelvin

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::decikelvin

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::millikelvin

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::nanokelvin

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::femtokelvin

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::zeptokelvin

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::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 yottagram_meter_per_second_cubed_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 exagram_meter_per_second_cubed_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 teragram_meter_per_second_cubed_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 megagram_meter_per_second_cubed_kelvin

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 hectogram_meter_per_second_cubed_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 gram_meter_per_second_cubed_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 centigram_meter_per_second_cubed_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 microgram_meter_per_second_cubed_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 picogram_meter_per_second_cubed_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 attogram_meter_per_second_cubed_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 yoctogram_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 zettawatt_per_meter_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 petawatt_per_meter_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 gigawatt_per_meter_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 kilowatt_per_meter_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 decawatt_per_meter_kelvin

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 deciwatt_per_meter_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 milliwatt_per_meter_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 nanowatt_per_meter_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 femtowatt_per_meter_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 zeptowatt_per_meter_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 kilogram_meter_per_second_cubed_degree_celsius

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 watt_per_meter_degree_celsius

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 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::zettakelvin

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::petakelvin

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::gigakelvin

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::kilokelvin

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::decakelvin

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::decikelvin

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::millikelvin

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::nanokelvin

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::femtokelvin

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::zeptokelvin

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::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 yottasecond

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 exasecond

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 terasecond

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 megasecond

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 hectosecond

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 uom::si::time::second

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 centisecond

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 microsecond

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 picosecond

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 attosecond

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 yoctosecond

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 hour

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 shake

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 yottanewton_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 exanewton_meter

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 teranewton_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 meganewton_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 hectonewton_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 newton_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 centinewton_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 micronewton_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 piconewton_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 attonewton_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 yoctonewton_meter

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_zettameter

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_petameter

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_gigameter

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_kilometer

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_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_centimeter

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_micrometer

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_picometer

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_attometer

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_yoctometer

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 dyne_centimeter

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 ounce_force_inch

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 yottameter_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 exameter_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 terameter_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 megameter_per_second

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 hectometer_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 meter_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 centimeter_per_second

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 micrometer_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 picometer_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 attometer_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 yoctometer_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 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 knot

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 cubic_yottameter

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 cubic_exameter

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_terameter

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_megameter

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_hectometer

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_meter

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_centimeter

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_micrometer

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_picometer

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_attometer

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_yoctometer

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 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 cord

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_inch

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_yard

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 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_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 gill_imperial

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 yottaliter

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 exaliter

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 teraliter

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 megaliter

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 hectoliter

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 liter

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 centiliter

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 microliter

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 picoliter

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 attoliter

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 yoctoliter

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 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 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 register_ton

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_zettameter_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_petameter_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_gigameter_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_kilometer_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_decameter_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_decimeter_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_millimeter_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_nanometer_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_femtometer_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_zeptometer_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 yottaliter_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<f32> for exaliter_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 teraliter_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 megaliter_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 hectoliter_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 liter_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 centiliter_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 microliter_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 picoliter_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 attoliter_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 yoctoliter_per_second

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 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 cord_per_second

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_foot_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_inch_per_minute

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_yard_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 cup_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 fluid_ounce_imperial_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_second

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_day

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 peck_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 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 register_ton_per_second

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 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 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 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 centimeter_of_mercury_0

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 foot_of_water_39_2

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_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 f32

type T = f32

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

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

Loading content...