Struct Hectopascal 

pub struct Hectopascal;

Hectopascal — SI-prefixed pascal unit (100 Pa).

1 hPa = 100 Pa exactly. Widely used in meteorology and observatory/site metadata to report atmospheric pressure (standard atmosphere ≈ 1013.25 hPa).

Trait Implementations

impl Clone for Hectopascal

fn clone(&self) -> Hectopascal

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for Hectopascal

impl Debug for Hectopascal

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl PartialEq for Hectopascal

fn eq(&self, other: &Hectopascal) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Hectopascal

fn partial_cmp(&self, other: &Hectopascal) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Hectopascal

impl Unit for Hectopascal

const RATIO: f64 = 1e2

Unit-to-canonical conversion factor.

const SYMBOL: &'static str = "hPa"

Printable symbol, shown by core::fmt::Display.

type Dim = Dim<NInt<UInt<UTerm, B1>>, NInt<UInt<UInt<UTerm, B1>, B0>>, PInt<UInt<UTerm, B1>>, Z0, Z0, Z0, Z0, Z0>

Dimension to which this unit belongs.

impl UnitDiv<Arcminute> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Arcminute as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Arcminute as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Arcminute>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Arcsecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Arcsecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Arcsecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Arcsecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<AstronomicalUnit> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<AstronomicalUnit as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<AstronomicalUnit as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, AstronomicalUnit>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<AtomicMassUnit> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<AtomicMassUnit as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<AtomicMassUnit as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, AtomicMassUnit>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Attogram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Attogram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Attogram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Attogram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Attometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Attometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Attometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Attometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Attosecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Attosecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Attosecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Attosecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Attowatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Attowatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Attowatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Attowatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Bar> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Bar as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Bar as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Bar>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<BohrRadius> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<BohrRadius as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<BohrRadius as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, BohrRadius>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Centigram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Centigram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Centigram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Centigram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Centiliter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Centiliter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Centiliter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Centiliter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Centimeter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Centimeter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Centimeter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Centimeter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Centisecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Centisecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Centisecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Centisecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Century> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Century as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Century as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Century>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<ClassicalElectronRadius> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<ClassicalElectronRadius as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<ClassicalElectronRadius as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, ClassicalElectronRadius>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<CubicCentimeter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<CubicCentimeter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<CubicCentimeter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, CubicCentimeter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<CubicKilometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<CubicKilometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<CubicKilometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, CubicKilometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<CubicMeter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<CubicMeter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<CubicMeter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, CubicMeter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<CubicMillimeter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<CubicMillimeter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<CubicMillimeter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, CubicMillimeter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Day> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Day as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Day as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Day>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Decade> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Decade as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Decade as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Decade>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Decagram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Decagram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Decagram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Decagram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Decameter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Decameter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Decameter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Decameter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Decasecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Decasecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Decasecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Decasecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Decawatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Decawatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Decawatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Decawatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Decigram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Decigram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Decigram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Decigram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Deciliter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Deciliter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Deciliter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Deciliter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Decimeter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Decimeter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Decimeter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Decimeter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Decisecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Decisecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Decisecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Decisecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Deciwatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Deciwatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Deciwatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Deciwatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Degree> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Degree as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Degree as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Degree>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Dyne> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Dyne as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Dyne as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Dyne>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<EarthEquatorialRadius> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<EarthEquatorialRadius as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<EarthEquatorialRadius as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, EarthEquatorialRadius>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<EarthPolarRadius> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<EarthPolarRadius as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<EarthPolarRadius as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, EarthPolarRadius>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<EarthRadius> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<EarthRadius as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<EarthRadius as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, EarthRadius>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<ElectronReducedComptonWavelength> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<ElectronReducedComptonWavelength as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<ElectronReducedComptonWavelength as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, ElectronReducedComptonWavelength>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Electronvolt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Electronvolt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Electronvolt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Electronvolt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Erg> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Erg as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Erg as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Erg>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<ErgPerSecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<ErgPerSecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<ErgPerSecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, ErgPerSecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<ErgPerSecondSquareCentimeterSteradian> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<ErgPerSecondSquareCentimeterSteradian as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<ErgPerSecondSquareCentimeterSteradian as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, ErgPerSecondSquareCentimeterSteradian>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<ErgPerSecondSquareCentimeterSteradianAngstrom> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<ErgPerSecondSquareCentimeterSteradianAngstrom as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<ErgPerSecondSquareCentimeterSteradianAngstrom as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, ErgPerSecondSquareCentimeterSteradianAngstrom>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Exagram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Exagram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Exagram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Exagram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Exameter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Exameter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Exameter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Exameter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Exawatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Exawatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Exawatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Exawatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Femtogram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Femtogram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Femtogram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Femtogram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Femtometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Femtometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Femtometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Femtometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Femtosecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Femtosecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Femtosecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Femtosecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Femtowatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Femtowatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Femtowatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Femtowatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Fortnight> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Fortnight as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Fortnight as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Fortnight>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Gigagram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Gigagram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Gigagram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Gigagram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Gigahertz> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Gigahertz as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Gigahertz as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Gigahertz>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Gigajoule> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Gigajoule as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Gigajoule as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Gigajoule>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Gigameter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Gigameter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Gigameter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Gigameter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Giganewton> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Giganewton as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Giganewton as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Giganewton>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Gigaparsec> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Gigaparsec as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Gigaparsec as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Gigaparsec>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Gigapascal> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Gigapascal as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Gigapascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Gigapascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Gigasecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Gigasecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Gigasecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Gigasecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Gigawatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Gigawatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Gigawatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Gigawatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Gram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Gram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Gram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Gram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<GramPerCubicCentimeter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<GramPerCubicCentimeter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<GramPerCubicCentimeter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, GramPerCubicCentimeter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<GramPerMilliliter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<GramPerMilliliter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<GramPerMilliliter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, GramPerMilliliter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectogram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Hectogram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Hectogram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Hectogram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Hectometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Hectometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Hectometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Meter

where <Meter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Meter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Meter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Kilometer

where <Kilometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Kilometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Kilometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Centimeter

where <Centimeter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Centimeter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Centimeter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Millimeter

where <Millimeter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Millimeter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Millimeter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Micrometer

where <Micrometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Micrometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Micrometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Nanometer

where <Nanometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Nanometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Nanometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Picometer

where <Picometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Picometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Picometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Femtometer

where <Femtometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Femtometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Femtometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Attometer

where <Attometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Attometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Attometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Zeptometer

where <Zeptometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Zeptometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Zeptometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Yoctometer

where <Yoctometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Yoctometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Yoctometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Megameter

where <Megameter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Megameter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Megameter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Decimeter

where <Decimeter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Decimeter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Decimeter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Decameter

where <Decameter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Decameter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Decameter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Hectometer

where <Hectometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Hectometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Gigameter

where <Gigameter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Gigameter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Gigameter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Terameter

where <Terameter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Terameter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Terameter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Petameter

where <Petameter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Petameter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Petameter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Exameter

where <Exameter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Exameter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Exameter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Zettameter

where <Zettameter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Zettameter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Zettameter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Yottameter

where <Yottameter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Yottameter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Yottameter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Attosecond

where <Attosecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Attosecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Attosecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Femtosecond

where <Femtosecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Femtosecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Femtosecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Picosecond

where <Picosecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Picosecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Picosecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Nanosecond

where <Nanosecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Nanosecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Nanosecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Microsecond

where <Microsecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Microsecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Microsecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Millisecond

where <Millisecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Millisecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Millisecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Centisecond

where <Centisecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Centisecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Centisecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Decisecond

where <Decisecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Decisecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Decisecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Second

where <Second as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Second as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Second, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Decasecond

where <Decasecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Decasecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Decasecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Hectosecond

where <Hectosecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Hectosecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectosecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Kilosecond

where <Kilosecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Kilosecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Kilosecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Megasecond

where <Megasecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Megasecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Megasecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Gigasecond

where <Gigasecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Gigasecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Gigasecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Terasecond

where <Terasecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Terasecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Terasecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Minute

where <Minute as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Minute as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Minute, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Hour

where <Hour as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Hour as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hour, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Day

where <Day as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Day as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Day, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Week

where <Week as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Week as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Week, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Fortnight

where <Fortnight as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Fortnight as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Fortnight, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Year

where <Year as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Year as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Year, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Decade

where <Decade as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Decade as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Decade, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Century

where <Century as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Century as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Century, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Millennium

where <Millennium as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Millennium as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Millennium, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Gram

where <Gram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Gram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Gram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Yoctogram

where <Yoctogram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Yoctogram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Yoctogram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Zeptogram

where <Zeptogram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Zeptogram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Zeptogram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Attogram

where <Attogram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Attogram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Attogram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Femtogram

where <Femtogram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Femtogram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Femtogram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Picogram

where <Picogram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Picogram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Picogram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Nanogram

where <Nanogram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Nanogram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Nanogram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Microgram

where <Microgram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Microgram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Microgram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Milligram

where <Milligram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Milligram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Milligram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Centigram

where <Centigram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Centigram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Centigram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Decigram

where <Decigram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Decigram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Decigram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Decagram

where <Decagram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Decagram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Decagram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Hectogram

where <Hectogram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Hectogram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectogram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Kilogram

where <Kilogram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Kilogram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Kilogram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Megagram

where <Megagram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Megagram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Megagram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Gigagram

where <Gigagram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Gigagram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Gigagram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Teragram

where <Teragram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Teragram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Teragram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Petagram

where <Petagram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Petagram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Petagram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Exagram

where <Exagram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Exagram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Exagram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Zettagram

where <Zettagram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Zettagram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Zettagram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Yottagram

where <Yottagram as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Yottagram as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Yottagram, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Tonne

where <Tonne as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Tonne as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Tonne, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Degree

where <Degree as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Degree as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Degree, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Radian

where <Radian as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Radian as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Radian, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Milliradian

where <Milliradian as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Milliradian as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Milliradian, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Turn

where <Turn as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Turn as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Turn, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Watt

where <Watt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Watt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Watt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Yoctowatt

where <Yoctowatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Yoctowatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Yoctowatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Zeptowatt

where <Zeptowatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Zeptowatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Zeptowatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Attowatt

where <Attowatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Attowatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Attowatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Femtowatt

where <Femtowatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Femtowatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Femtowatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Picowatt

where <Picowatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Picowatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Picowatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Nanowatt

where <Nanowatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Nanowatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Nanowatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Microwatt

where <Microwatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Microwatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Microwatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Milliwatt

where <Milliwatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Milliwatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Milliwatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Deciwatt

where <Deciwatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Deciwatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Deciwatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Decawatt

where <Decawatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Decawatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Decawatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Hectowatt

where <Hectowatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Hectowatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectowatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Kilowatt

where <Kilowatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Kilowatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Kilowatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Megawatt

where <Megawatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Megawatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Megawatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Gigawatt

where <Gigawatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Gigawatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Gigawatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Terawatt

where <Terawatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Terawatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Terawatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Petawatt

where <Petawatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Petawatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Petawatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Exawatt

where <Exawatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Exawatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Exawatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Zettawatt

where <Zettawatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Zettawatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Zettawatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Yottawatt

where <Yottawatt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Yottawatt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Yottawatt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Prod<Meter, Meter>

where <Prod<Meter, Meter> as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Prod<Meter, Meter> as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Prod<Meter, Meter>, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Prod<Kilometer, Kilometer>

where <Prod<Kilometer, Kilometer> as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Prod<Kilometer, Kilometer> as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Prod<Kilometer, Kilometer>, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Prod<Centimeter, Centimeter>

where <Prod<Centimeter, Centimeter> as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Prod<Centimeter, Centimeter> as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Prod<Centimeter, Centimeter>, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Prod<Millimeter, Millimeter>

where <Prod<Millimeter, Millimeter> as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Prod<Millimeter, Millimeter> as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Prod<Millimeter, Millimeter>, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for CubicMeter

where <CubicMeter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<CubicMeter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<CubicMeter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for CubicKilometer

where <CubicKilometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<CubicKilometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<CubicKilometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for CubicCentimeter

where <CubicCentimeter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<CubicCentimeter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<CubicCentimeter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for CubicMillimeter

where <CubicMillimeter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<CubicMillimeter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<CubicMillimeter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Liter

where <Liter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Liter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Liter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Milliliter

where <Milliliter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Milliliter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Milliliter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Microliter

where <Microliter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Microliter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Microliter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Centiliter

where <Centiliter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Centiliter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Centiliter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Deciliter

where <Deciliter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Deciliter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Deciliter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for MeterPerSecondSquared

where <MeterPerSecondSquared as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<MeterPerSecondSquared as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<MeterPerSecondSquared, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for StandardGravity

where <StandardGravity as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<StandardGravity as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<StandardGravity, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Newton

where <Newton as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Newton as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Newton, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Micronewton

where <Micronewton as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Micronewton as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Micronewton, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Millinewton

where <Millinewton as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Millinewton as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Millinewton, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Kilonewton

where <Kilonewton as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Kilonewton as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Kilonewton, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Meganewton

where <Meganewton as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Meganewton as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Meganewton, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Giganewton

where <Giganewton as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Giganewton as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Giganewton, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Joule

where <Joule as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Joule as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Joule, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Picojoule

where <Picojoule as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Picojoule as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Picojoule, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Nanojoule

where <Nanojoule as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Nanojoule as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Nanojoule, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Microjoule

where <Microjoule as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Microjoule as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Microjoule, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Millijoule

where <Millijoule as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Millijoule as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Millijoule, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Kilojoule

where <Kilojoule as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Kilojoule as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Kilojoule, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Megajoule

where <Megajoule as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Megajoule as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Megajoule, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Gigajoule

where <Gigajoule as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Gigajoule as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Gigajoule, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Terajoule

where <Terajoule as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Terajoule as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Terajoule, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for WattHour

where <WattHour as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<WattHour as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<WattHour, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for KilowattHour

where <KilowattHour as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<KilowattHour as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<KilowattHour, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Pascal

where <Pascal as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Pascal as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Pascal, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Millipascal

where <Millipascal as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Millipascal as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Millipascal, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Kilopascal

where <Kilopascal as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Kilopascal as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Kilopascal, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Megapascal

where <Megapascal as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Megapascal as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Megapascal, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Gigapascal

where <Gigapascal as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Gigapascal as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Gigapascal, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Bar

where <Bar as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Bar as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Bar, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Kelvin

where <Kelvin as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Kelvin as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Kelvin, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Rankine

where <Rankine as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Rankine as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Rankine, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Prod<Degree, Degree>

where <Prod<Degree, Degree> as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Prod<Degree, Degree> as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Prod<Degree, Degree>, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Prod<Radian, Radian>

where <Prod<Radian, Radian> as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Prod<Radian, Radian> as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Prod<Radian, Radian>, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Prod<Milliradian, Milliradian>

where <Prod<Milliradian, Milliradian> as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Prod<Milliradian, Milliradian> as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Prod<Milliradian, Milliradian>, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for AstronomicalUnit

where <AstronomicalUnit as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<AstronomicalUnit as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<AstronomicalUnit, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for LightYear

where <LightYear as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<LightYear as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<LightYear, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Parsec

where <Parsec as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Parsec as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Parsec, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Kiloparsec

where <Kiloparsec as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Kiloparsec as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Kiloparsec, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Megaparsec

where <Megaparsec as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Megaparsec as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Megaparsec, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Gigaparsec

where <Gigaparsec as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Gigaparsec as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Gigaparsec, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for SolarRadius

where <SolarRadius as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<SolarRadius as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<SolarRadius, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for SolarDiameter

where <SolarDiameter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<SolarDiameter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<SolarDiameter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for EarthRadius

where <EarthRadius as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<EarthRadius as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<EarthRadius, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for EarthEquatorialRadius

where <EarthEquatorialRadius as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<EarthEquatorialRadius as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<EarthEquatorialRadius, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for EarthPolarRadius

where <EarthPolarRadius as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<EarthPolarRadius as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<EarthPolarRadius, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for JupiterRadius

where <JupiterRadius as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<JupiterRadius as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<JupiterRadius, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for LunarRadius

where <LunarRadius as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<LunarRadius as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<LunarRadius, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for LunarDistance

where <LunarDistance as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<LunarDistance as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<LunarDistance, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for SiderealDay

where <SiderealDay as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<SiderealDay as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<SiderealDay, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for SynodicMonth

where <SynodicMonth as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<SynodicMonth as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<SynodicMonth, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for SiderealYear

where <SiderealYear as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<SiderealYear as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<SiderealYear, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for SolarMass

where <SolarMass as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<SolarMass as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<SolarMass, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Arcminute

where <Arcminute as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Arcminute as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Arcminute, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Arcsecond

where <Arcsecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Arcsecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Arcsecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for MilliArcsecond

where <MilliArcsecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<MilliArcsecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<MilliArcsecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for MicroArcsecond

where <MicroArcsecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<MicroArcsecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<MicroArcsecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for HourAngle

where <HourAngle as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<HourAngle as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<HourAngle, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for SolarLuminosity

where <SolarLuminosity as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<SolarLuminosity as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<SolarLuminosity, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Prod<Arcminute, Arcminute>

where <Prod<Arcminute, Arcminute> as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Prod<Arcminute, Arcminute> as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Prod<Arcminute, Arcminute>, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Prod<Arcsecond, Arcsecond>

where <Prod<Arcsecond, Arcsecond> as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Prod<Arcsecond, Arcsecond> as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Prod<Arcsecond, Arcsecond>, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for JulianYear

where <JulianYear as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<JulianYear as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<JulianYear, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for JulianCentury

where <JulianCentury as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<JulianCentury as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<JulianCentury, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for BohrRadius

where <BohrRadius as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<BohrRadius as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<BohrRadius, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for ClassicalElectronRadius

where <ClassicalElectronRadius as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<ClassicalElectronRadius as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<ClassicalElectronRadius, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for PlanckLength

where <PlanckLength as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<PlanckLength as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<PlanckLength, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for ElectronReducedComptonWavelength

where <ElectronReducedComptonWavelength as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<ElectronReducedComptonWavelength as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<ElectronReducedComptonWavelength, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for AtomicMassUnit

where <AtomicMassUnit as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<AtomicMassUnit as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<AtomicMassUnit, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for ErgPerSecond

where <ErgPerSecond as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<ErgPerSecond as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<ErgPerSecond, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Dyne

where <Dyne as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Dyne as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Dyne, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Erg

where <Erg as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Erg as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Erg, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Electronvolt

where <Electronvolt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Electronvolt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Electronvolt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Kiloelectronvolt

where <Kiloelectronvolt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Kiloelectronvolt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Kiloelectronvolt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Megaelectronvolt

where <Megaelectronvolt as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Megaelectronvolt as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Megaelectronvolt, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for WattPerSquareMeterSteradian

where <WattPerSquareMeterSteradian as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<WattPerSquareMeterSteradian as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<WattPerSquareMeterSteradian, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for ErgPerSecondSquareCentimeterSteradian

where <ErgPerSecondSquareCentimeterSteradian as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<ErgPerSecondSquareCentimeterSteradian as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<ErgPerSecondSquareCentimeterSteradian, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for WattPerSquareMeterSteradianMeter

where <WattPerSquareMeterSteradianMeter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<WattPerSquareMeterSteradianMeter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<WattPerSquareMeterSteradianMeter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for WattPerSquareMeterSteradianNanometer

where <WattPerSquareMeterSteradianNanometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<WattPerSquareMeterSteradianNanometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<WattPerSquareMeterSteradianNanometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for ErgPerSecondSquareCentimeterSteradianAngstrom

where <ErgPerSecondSquareCentimeterSteradianAngstrom as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<ErgPerSecondSquareCentimeterSteradianAngstrom as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<ErgPerSecondSquareCentimeterSteradianAngstrom, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for PhotonPerSquareMeterSecondSteradian

where <PhotonPerSquareMeterSecondSteradian as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<PhotonPerSquareMeterSecondSteradian as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<PhotonPerSquareMeterSecondSteradian, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for PhotonPerSquareCentimeterSecondSteradian

where <PhotonPerSquareCentimeterSecondSteradian as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<PhotonPerSquareCentimeterSecondSteradian as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<PhotonPerSquareCentimeterSecondSteradian, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for PhotonPerSquareCentimeterNanosecondSteradian

where <PhotonPerSquareCentimeterNanosecondSteradian as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<PhotonPerSquareCentimeterNanosecondSteradian as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<PhotonPerSquareCentimeterNanosecondSteradian, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for PhotonPerSquareMeterSecondSteradianMeter

where <PhotonPerSquareMeterSecondSteradianMeter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<PhotonPerSquareMeterSecondSteradianMeter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<PhotonPerSquareMeterSecondSteradianMeter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for PhotonPerSquareCentimeterSecondSteradianAngstrom

where <PhotonPerSquareCentimeterSecondSteradianAngstrom as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<PhotonPerSquareCentimeterSecondSteradianAngstrom as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<PhotonPerSquareCentimeterSecondSteradianAngstrom, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for PhotonPerSquareCentimeterSecondSteradianNanometer

where <PhotonPerSquareCentimeterSecondSteradianNanometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<PhotonPerSquareCentimeterSecondSteradianNanometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<PhotonPerSquareCentimeterSecondSteradianNanometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for PhotonPerSquareCentimeterNanosecondSteradianNanometer

where <PhotonPerSquareCentimeterNanosecondSteradianNanometer as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<PhotonPerSquareCentimeterNanosecondSteradianNanometer as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<PhotonPerSquareCentimeterNanosecondSteradianNanometer, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for S10

where <S10 as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<S10 as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<S10, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Hertz

where <Hertz as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Hertz as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hertz, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Millihertz

where <Millihertz as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Millihertz as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Millihertz, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Kilohertz

where <Kilohertz as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Kilohertz as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Kilohertz, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Megahertz

where <Megahertz as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Megahertz as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Megahertz, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Gigahertz

where <Gigahertz as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Gigahertz as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Gigahertz, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for Terahertz

where <Terahertz as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<Terahertz as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Terahertz, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for KilogramPerCubicMeter

where <KilogramPerCubicMeter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<KilogramPerCubicMeter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<KilogramPerCubicMeter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for GramPerCubicCentimeter

where <GramPerCubicCentimeter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<GramPerCubicCentimeter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<GramPerCubicCentimeter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectopascal> for GramPerMilliliter

where <GramPerMilliliter as Unit>::Dim: DimDiv<<Hectopascal as Unit>::Dim>, <<GramPerMilliliter as Unit>::Dim as DimDiv<<Hectopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<GramPerMilliliter, Hectopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectosecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Hectosecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Hectosecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Hectosecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hectowatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Hectowatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Hectowatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Hectowatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hertz> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Hertz as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Hertz as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Hertz>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Hour> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Hour as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Hour as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Hour>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<HourAngle> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<HourAngle as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<HourAngle as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, HourAngle>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Joule> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Joule as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Joule as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Joule>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<JulianCentury> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<JulianCentury as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<JulianCentury as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, JulianCentury>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<JulianYear> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<JulianYear as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<JulianYear as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, JulianYear>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<JupiterRadius> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<JupiterRadius as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<JupiterRadius as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, JupiterRadius>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Kelvin> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Kelvin as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Kelvin as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Kelvin>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Kiloelectronvolt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Kiloelectronvolt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Kiloelectronvolt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Kiloelectronvolt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Kilogram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Kilogram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Kilogram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Kilogram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<KilogramPerCubicMeter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<KilogramPerCubicMeter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<KilogramPerCubicMeter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, KilogramPerCubicMeter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Kilohertz> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Kilohertz as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Kilohertz as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Kilohertz>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Kilojoule> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Kilojoule as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Kilojoule as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Kilojoule>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Kilometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Kilometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Kilometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Kilometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Kilonewton> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Kilonewton as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Kilonewton as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Kilonewton>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Kiloparsec> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Kiloparsec as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Kiloparsec as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Kiloparsec>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Kilopascal> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Kilopascal as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Kilopascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Kilopascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Kilosecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Kilosecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Kilosecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Kilosecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Kilowatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Kilowatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Kilowatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Kilowatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<KilowattHour> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<KilowattHour as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<KilowattHour as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, KilowattHour>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<LightYear> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<LightYear as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<LightYear as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, LightYear>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Liter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Liter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Liter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Liter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<LunarDistance> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<LunarDistance as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<LunarDistance as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, LunarDistance>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<LunarRadius> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<LunarRadius as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<LunarRadius as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, LunarRadius>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Megaelectronvolt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Megaelectronvolt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Megaelectronvolt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Megaelectronvolt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Megagram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Megagram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Megagram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Megagram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Megahertz> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Megahertz as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Megahertz as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Megahertz>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Megajoule> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Megajoule as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Megajoule as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Megajoule>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Megameter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Megameter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Megameter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Megameter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Meganewton> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Meganewton as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Meganewton as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Meganewton>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Megaparsec> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Megaparsec as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Megaparsec as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Megaparsec>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Megapascal> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Megapascal as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Megapascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Megapascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Megasecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Megasecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Megasecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Megasecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Megawatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Megawatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Megawatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Megawatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Meter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Meter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Meter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Meter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<MeterPerSecondSquared> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<MeterPerSecondSquared as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<MeterPerSecondSquared as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, MeterPerSecondSquared>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<MicroArcsecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<MicroArcsecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<MicroArcsecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, MicroArcsecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Microgram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Microgram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Microgram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Microgram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Microjoule> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Microjoule as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Microjoule as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Microjoule>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Microliter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Microliter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Microliter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Microliter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Micrometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Micrometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Micrometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Micrometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Micronewton> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Micronewton as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Micronewton as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Micronewton>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Microsecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Microsecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Microsecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Microsecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Microwatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Microwatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Microwatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Microwatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Millennium> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Millennium as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Millennium as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Millennium>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<MilliArcsecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<MilliArcsecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<MilliArcsecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, MilliArcsecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Milligram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Milligram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Milligram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Milligram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Millihertz> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Millihertz as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Millihertz as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Millihertz>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Millijoule> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Millijoule as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Millijoule as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Millijoule>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Milliliter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Milliliter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Milliliter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Milliliter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Millimeter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Millimeter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Millimeter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Millimeter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Millinewton> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Millinewton as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Millinewton as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Millinewton>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Millipascal> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Millipascal as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Millipascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Millipascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Milliradian> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Milliradian as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Milliradian as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Milliradian>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Millisecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Millisecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Millisecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Millisecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Milliwatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Milliwatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Milliwatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Milliwatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Minute> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Minute as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Minute as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Minute>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Nanogram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Nanogram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Nanogram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Nanogram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Nanojoule> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Nanojoule as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Nanojoule as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Nanojoule>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Nanometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Nanometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Nanometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Nanometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Nanosecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Nanosecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Nanosecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Nanosecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Nanowatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Nanowatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Nanowatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Nanowatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Newton> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Newton as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Newton as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Newton>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Parsec> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Parsec as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Parsec as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Parsec>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Pascal> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Pascal as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Pascal as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Pascal>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Petagram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Petagram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Petagram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Petagram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Petameter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Petameter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Petameter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Petameter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Petawatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Petawatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Petawatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Petawatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<PhotonPerSquareCentimeterNanosecondSteradian> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<PhotonPerSquareCentimeterNanosecondSteradian as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<PhotonPerSquareCentimeterNanosecondSteradian as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, PhotonPerSquareCentimeterNanosecondSteradian>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<PhotonPerSquareCentimeterNanosecondSteradianNanometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<PhotonPerSquareCentimeterNanosecondSteradianNanometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<PhotonPerSquareCentimeterNanosecondSteradianNanometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, PhotonPerSquareCentimeterNanosecondSteradianNanometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<PhotonPerSquareCentimeterSecondSteradian> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<PhotonPerSquareCentimeterSecondSteradian as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<PhotonPerSquareCentimeterSecondSteradian as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, PhotonPerSquareCentimeterSecondSteradian>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<PhotonPerSquareCentimeterSecondSteradianAngstrom> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<PhotonPerSquareCentimeterSecondSteradianAngstrom as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<PhotonPerSquareCentimeterSecondSteradianAngstrom as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, PhotonPerSquareCentimeterSecondSteradianAngstrom>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<PhotonPerSquareCentimeterSecondSteradianNanometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<PhotonPerSquareCentimeterSecondSteradianNanometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<PhotonPerSquareCentimeterSecondSteradianNanometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, PhotonPerSquareCentimeterSecondSteradianNanometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<PhotonPerSquareMeterSecondSteradian> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<PhotonPerSquareMeterSecondSteradian as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<PhotonPerSquareMeterSecondSteradian as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, PhotonPerSquareMeterSecondSteradian>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<PhotonPerSquareMeterSecondSteradianMeter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<PhotonPerSquareMeterSecondSteradianMeter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<PhotonPerSquareMeterSecondSteradianMeter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, PhotonPerSquareMeterSecondSteradianMeter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Picogram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Picogram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Picogram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Picogram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Picojoule> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Picojoule as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Picojoule as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Picojoule>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Picometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Picometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Picometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Picometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Picosecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Picosecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Picosecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Picosecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Picowatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Picowatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Picowatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Picowatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<PlanckLength> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<PlanckLength as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<PlanckLength as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, PlanckLength>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Prod<Arcminute, Arcminute>> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Prod<Arcminute, Arcminute> as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Prod<Arcminute, Arcminute> as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Prod<Arcminute, Arcminute>>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Prod<Arcsecond, Arcsecond>> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Prod<Arcsecond, Arcsecond> as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Prod<Arcsecond, Arcsecond> as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Prod<Arcsecond, Arcsecond>>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Prod<Centimeter, Centimeter>> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Prod<Centimeter, Centimeter> as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Prod<Centimeter, Centimeter> as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Prod<Centimeter, Centimeter>>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Prod<Degree, Degree>> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Prod<Degree, Degree> as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Prod<Degree, Degree> as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Prod<Degree, Degree>>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Prod<Kilometer, Kilometer>> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Prod<Kilometer, Kilometer> as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Prod<Kilometer, Kilometer> as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Prod<Kilometer, Kilometer>>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Prod<Meter, Meter>> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Prod<Meter, Meter> as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Prod<Meter, Meter> as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Prod<Meter, Meter>>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Prod<Millimeter, Millimeter>> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Prod<Millimeter, Millimeter> as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Prod<Millimeter, Millimeter> as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Prod<Millimeter, Millimeter>>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Prod<Milliradian, Milliradian>> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Prod<Milliradian, Milliradian> as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Prod<Milliradian, Milliradian> as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Prod<Milliradian, Milliradian>>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Prod<Radian, Radian>> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Prod<Radian, Radian> as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Prod<Radian, Radian> as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Prod<Radian, Radian>>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Radian> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Radian as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Radian as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Radian>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Rankine> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Rankine as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Rankine as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Rankine>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<S10> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<S10 as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<S10 as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, S10>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Second> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Second as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Second as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Second>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<SiderealDay> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<SiderealDay as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<SiderealDay as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, SiderealDay>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<SiderealYear> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<SiderealYear as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<SiderealYear as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, SiderealYear>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<SolarDiameter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<SolarDiameter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<SolarDiameter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, SolarDiameter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<SolarLuminosity> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<SolarLuminosity as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<SolarLuminosity as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, SolarLuminosity>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<SolarMass> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<SolarMass as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<SolarMass as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, SolarMass>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<SolarRadius> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<SolarRadius as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<SolarRadius as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, SolarRadius>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<StandardGravity> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<StandardGravity as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<StandardGravity as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, StandardGravity>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<SynodicMonth> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<SynodicMonth as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<SynodicMonth as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, SynodicMonth>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Teragram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Teragram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Teragram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Teragram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Terahertz> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Terahertz as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Terahertz as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Terahertz>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Terajoule> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Terajoule as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Terajoule as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Terajoule>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Terameter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Terameter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Terameter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Terameter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Terasecond> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Terasecond as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Terasecond as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Terasecond>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Terawatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Terawatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Terawatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Terawatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Tonne> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Tonne as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Tonne as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Tonne>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Turn> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Turn as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Turn as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Turn>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Watt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Watt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Watt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Watt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<WattHour> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<WattHour as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<WattHour as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, WattHour>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<WattPerSquareMeterSteradian> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<WattPerSquareMeterSteradian as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<WattPerSquareMeterSteradian as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, WattPerSquareMeterSteradian>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<WattPerSquareMeterSteradianMeter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<WattPerSquareMeterSteradianMeter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<WattPerSquareMeterSteradianMeter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, WattPerSquareMeterSteradianMeter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<WattPerSquareMeterSteradianNanometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<WattPerSquareMeterSteradianNanometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<WattPerSquareMeterSteradianNanometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, WattPerSquareMeterSteradianNanometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Week> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Week as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Week as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Week>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Year> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Year as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Year as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Year>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Yoctogram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Yoctogram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Yoctogram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Yoctogram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Yoctometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Yoctometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Yoctometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Yoctometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Yoctowatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Yoctowatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Yoctowatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Yoctowatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Yottagram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Yottagram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Yottagram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Yottagram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Yottameter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Yottameter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Yottameter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Yottameter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Yottawatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Yottawatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Yottawatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Yottawatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Zeptogram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Zeptogram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Zeptogram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Zeptogram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Zeptometer> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Zeptometer as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Zeptometer as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Zeptometer>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Zeptowatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Zeptowatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Zeptowatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Zeptowatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Zettagram> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Zettagram as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Zettagram as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Zettagram>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Zettameter> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Zettameter as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Zettameter as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Zettameter>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).

impl UnitDiv<Zettawatt> for Hectopascal

where <Hectopascal as Unit>::Dim: DimDiv<<Zettawatt as Unit>::Dim>, <<Hectopascal as Unit>::Dim as DimDiv<<Zettawatt as Unit>::Dim>>::Output: Dimension,

type Output = Per<Hectopascal, Zettawatt>

The resulting type token. Either a Unit (wrapped in Quantity by the Div impl) or SameDivOutput (unwrapped to the raw scalar).