Struct metric::composite::Div

pub struct Div<T, U>(pub T, pub PhantomData<U>);

Methods

impl<T, U> Div<T, U> where
    T: Unit,
    U: Unit, 

fn multiply(self, other: U) -> T

impl<T, U> Div<T, Mul<U, U>> where
    T: Unit,
    U: Unit, 

fn integrate(self, other: U) -> Div<T, U>

Trait Implementations

impl<T: Copy, U: Copy> Copy for Div<T, U>

impl<T: Clone, U: Clone> Clone for Div<T, U>

fn clone(&self) -> Div<T, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, U> UnitName for Div<T, U> where
    T: Unit + UnitName,
    U: UnitName, 

fn get_unit(&self) -> &'static str

fn get_unit_static() -> &'static str

fn write_unit_static(f: &mut Formatter) -> Result

impl<T, U> Debug for Div<T, U> where
    T: Unit + UnitName,
    U: UnitName, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T, U> Unit for Div<T, U> where
    T: Unit, 

fn new(val: f64) -> Div<T, U>

fn inner(&self) -> f64

impl<T, U, W, X> Mul<Mul<T, U>> for Div<W, X> where
    W: Copy + Unit,
    T: Copy + Unit, 

type Output = Mul<W, Mul<T, Div<U, X>>>

The resulting type after applying the * operator

fn mul(self, other: Mul<T, U>) -> Self::Output

The method for the * operator

impl<T, U, W, X> Mul<Div<T, U>> for Div<W, X> where
    W: Copy + Unit,
    T: Copy + Unit, 

type Output = Mul<W, Div<T, Mul<X, U>>>

The resulting type after applying the * operator

fn mul(self, other: Div<T, U>) -> Self::Output

The method for the * operator

impl<T, U, W, X> Div<Mul<T, U>> for Div<W, X> where
    W: Copy + Unit,
    T: Copy + Unit, 

type Output = Div<W, Mul<X, Mul<T, U>>>

The resulting type after applying the / operator

fn div(self, other: Mul<T, U>) -> Self::Output

The method for the / operator

impl<T, U, W, X> Div<Div<T, U>> for Div<W, X> where
    W: Copy + Unit,
    T: Copy + Unit, 

type Output = Mul<W, Div<U, Mul<T, X>>>

The resulting type after applying the / operator

fn div(self, other: Div<T, U>) -> Self::Output

The method for the / operator

impl<T, U> Sub for Div<T, U> where
    T: Sub<T, Output = T>, 

type Output = Div<T, U>

The resulting type after applying the - operator

fn sub(self, other: Div<T, U>) -> Self::Output

The method for the - operator

impl<T, U> Add for Div<T, U> where
    T: Add<T, Output = T>, 

type Output = Div<T, U>

The resulting type after applying the + operator

fn add(self, other: Div<T, U>) -> Self::Output

The method for the + operator

impl<T, U> Mul<f64> for Div<T, U> where
    T: Mul<f64, Output = T>, 

type Output = Div<T, U>

The resulting type after applying the * operator

fn mul(self, other: f64) -> Self::Output

The method for the * operator

impl<T, U> Mul<i64> for Div<T, U> where
    T: Mul<f64, Output = T>, 

type Output = Div<T, U>

The resulting type after applying the * operator

fn mul(self, other: i64) -> Self::Output

The method for the * operator

impl<T, U> MulAssign<f64> for Div<T, U> where
    T: MulAssign<f64>, 

fn mul_assign(&mut self, other: f64)

The method for the *= operator

impl<T, U> MulAssign<i64> for Div<T, U> where
    T: MulAssign<f64>, 

fn mul_assign(&mut self, other: i64)

The method for the *= operator

impl<T, U> Div<f64> for Div<T, U> where
    T: Div<f64, Output = T>, 

type Output = Div<T, U>

The resulting type after applying the / operator

fn div(self, other: f64) -> Self::Output

The method for the / operator

impl<T, U> Div<i64> for Div<T, U> where
    T: Div<f64, Output = T>, 

type Output = Div<T, U>

The resulting type after applying the / operator

fn div(self, other: i64) -> Self::Output

The method for the / operator

impl<T, U> DivAssign<f64> for Div<T, U> where
    T: DivAssign<f64>, 

fn div_assign(&mut self, other: f64)

The method for the /= operator

impl<T, U> DivAssign<i64> for Div<T, U> where
    T: DivAssign<f64>, 

fn div_assign(&mut self, other: i64)

The method for the /= operator

impl<T, U> Mul<AU> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<AU, U>>

The resulting type after applying the * operator

fn mul(self, other: AU) -> Self::Output

The method for the * operator

impl<T, U> Div<AU> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<AU, U>>

The resulting type after applying the / operator

fn div(self, other: AU) -> Self::Output

The method for the / operator

impl<T, U> Mul<Lightyear> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Lightyear, U>>

The resulting type after applying the * operator

fn mul(self, other: Lightyear) -> Self::Output

The method for the * operator

impl<T, U> Div<Lightyear> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Lightyear, U>>

The resulting type after applying the / operator

fn div(self, other: Lightyear) -> Self::Output

The method for the / operator

impl<T, U> Mul<Kilometer> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Kilometer, U>>

The resulting type after applying the * operator

fn mul(self, other: Kilometer) -> Self::Output

The method for the * operator

impl<T, U> Div<Kilometer> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Kilometer, U>>

The resulting type after applying the / operator

fn div(self, other: Kilometer) -> Self::Output

The method for the / operator

impl<T, U> Mul<Meter> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Meter, U>>

The resulting type after applying the * operator

fn mul(self, other: Meter) -> Self::Output

The method for the * operator

impl<T, U> Div<Meter> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Meter, U>>

The resulting type after applying the / operator

fn div(self, other: Meter) -> Self::Output

The method for the / operator

impl<T, U> Mul<Centimeter> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Centimeter, U>>

The resulting type after applying the * operator

fn mul(self, other: Centimeter) -> Self::Output

The method for the * operator

impl<T, U> Div<Centimeter> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Centimeter, U>>

The resulting type after applying the / operator

fn div(self, other: Centimeter) -> Self::Output

The method for the / operator

impl<T, U> Mul<Millimeter> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Millimeter, U>>

The resulting type after applying the * operator

fn mul(self, other: Millimeter) -> Self::Output

The method for the * operator

impl<T, U> Div<Millimeter> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Millimeter, U>>

The resulting type after applying the / operator

fn div(self, other: Millimeter) -> Self::Output

The method for the / operator

impl<T, U> Mul<Micrometer> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Micrometer, U>>

The resulting type after applying the * operator

fn mul(self, other: Micrometer) -> Self::Output

The method for the * operator

impl<T, U> Div<Micrometer> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Micrometer, U>>

The resulting type after applying the / operator

fn div(self, other: Micrometer) -> Self::Output

The method for the / operator

impl<T, U> Mul<Picometer> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Picometer, U>>

The resulting type after applying the * operator

fn mul(self, other: Picometer) -> Self::Output

The method for the * operator

impl<T, U> Div<Picometer> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Picometer, U>>

The resulting type after applying the / operator

fn div(self, other: Picometer) -> Self::Output

The method for the / operator

impl<T, U> Mul<Femtometer> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Femtometer, U>>

The resulting type after applying the * operator

fn mul(self, other: Femtometer) -> Self::Output

The method for the * operator

impl<T, U> Div<Femtometer> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Femtometer, U>>

The resulting type after applying the / operator

fn div(self, other: Femtometer) -> Self::Output

The method for the / operator

impl<T, U> Mul<Inch> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Inch, U>>

The resulting type after applying the * operator

fn mul(self, other: Inch) -> Self::Output

The method for the * operator

impl<T, U> Div<Inch> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Inch, U>>

The resulting type after applying the / operator

fn div(self, other: Inch) -> Self::Output

The method for the / operator

impl<T, U> Mul<Foot> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Foot, U>>

The resulting type after applying the * operator

fn mul(self, other: Foot) -> Self::Output

The method for the * operator

impl<T, U> Div<Foot> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Foot, U>>

The resulting type after applying the / operator

fn div(self, other: Foot) -> Self::Output

The method for the / operator

impl<T, U> Mul<Yard> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Yard, U>>

The resulting type after applying the * operator

fn mul(self, other: Yard) -> Self::Output

The method for the * operator

impl<T, U> Div<Yard> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Yard, U>>

The resulting type after applying the / operator

fn div(self, other: Yard) -> Self::Output

The method for the / operator

impl<T, U> Mul<Mile> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Mile, U>>

The resulting type after applying the * operator

fn mul(self, other: Mile) -> Self::Output

The method for the * operator

impl<T, U> Div<Mile> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Mile, U>>

The resulting type after applying the / operator

fn div(self, other: Mile) -> Self::Output

The method for the / operator

impl<T, U> Mul<Fahrenheit> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Fahrenheit, U>>

The resulting type after applying the * operator

fn mul(self, other: Fahrenheit) -> Self::Output

The method for the * operator

impl<T, U> Div<Fahrenheit> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Fahrenheit, U>>

The resulting type after applying the / operator

fn div(self, other: Fahrenheit) -> Self::Output

The method for the / operator

impl<T, U> Mul<Celsius> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Celsius, U>>

The resulting type after applying the * operator

fn mul(self, other: Celsius) -> Self::Output

The method for the * operator

impl<T, U> Div<Celsius> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Celsius, U>>

The resulting type after applying the / operator

fn div(self, other: Celsius) -> Self::Output

The method for the / operator

impl<T, U> Mul<Kelvin> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Kelvin, U>>

The resulting type after applying the * operator

fn mul(self, other: Kelvin) -> Self::Output

The method for the * operator

impl<T, U> Div<Kelvin> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Kelvin, U>>

The resulting type after applying the / operator

fn div(self, other: Kelvin) -> Self::Output

The method for the / operator

impl<T, U> Mul<Ounce> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Ounce, U>>

The resulting type after applying the * operator

fn mul(self, other: Ounce) -> Self::Output

The method for the * operator

impl<T, U> Div<Ounce> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Ounce, U>>

The resulting type after applying the / operator

fn div(self, other: Ounce) -> Self::Output

The method for the / operator

impl<T, U> Mul<Pound> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Pound, U>>

The resulting type after applying the * operator

fn mul(self, other: Pound) -> Self::Output

The method for the * operator

impl<T, U> Div<Pound> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Pound, U>>

The resulting type after applying the / operator

fn div(self, other: Pound) -> Self::Output

The method for the / operator

impl<T, U> Mul<ITon> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<ITon, U>>

The resulting type after applying the * operator

fn mul(self, other: ITon) -> Self::Output

The method for the * operator

impl<T, U> Div<ITon> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<ITon, U>>

The resulting type after applying the / operator

fn div(self, other: ITon) -> Self::Output

The method for the / operator

impl<T, U> Mul<MTon> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<MTon, U>>

The resulting type after applying the * operator

fn mul(self, other: MTon) -> Self::Output

The method for the * operator

impl<T, U> Div<MTon> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<MTon, U>>

The resulting type after applying the / operator

fn div(self, other: MTon) -> Self::Output

The method for the / operator

impl<T, U> Mul<Kilogram> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Kilogram, U>>

The resulting type after applying the * operator

fn mul(self, other: Kilogram) -> Self::Output

The method for the * operator

impl<T, U> Div<Kilogram> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Kilogram, U>>

The resulting type after applying the / operator

fn div(self, other: Kilogram) -> Self::Output

The method for the / operator

impl<T, U> Mul<Gram> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Gram, U>>

The resulting type after applying the * operator

fn mul(self, other: Gram) -> Self::Output

The method for the * operator

impl<T, U> Div<Gram> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Gram, U>>

The resulting type after applying the / operator

fn div(self, other: Gram) -> Self::Output

The method for the / operator

impl<T, U> Mul<Centigram> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Centigram, U>>

The resulting type after applying the * operator

fn mul(self, other: Centigram) -> Self::Output

The method for the * operator

impl<T, U> Div<Centigram> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Centigram, U>>

The resulting type after applying the / operator

fn div(self, other: Centigram) -> Self::Output

The method for the / operator

impl<T, U> Mul<Milligram> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Milligram, U>>

The resulting type after applying the * operator

fn mul(self, other: Milligram) -> Self::Output

The method for the * operator

impl<T, U> Div<Milligram> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Milligram, U>>

The resulting type after applying the / operator

fn div(self, other: Milligram) -> Self::Output

The method for the / operator

impl<T, U> Mul<Second> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Second, U>>

The resulting type after applying the * operator

fn mul(self, other: Second) -> Self::Output

The method for the * operator

impl<T, U> Div<Second> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Second, U>>

The resulting type after applying the / operator

fn div(self, other: Second) -> Self::Output

The method for the / operator

impl<T, U> Mul<Minute> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Minute, U>>

The resulting type after applying the * operator

fn mul(self, other: Minute) -> Self::Output

The method for the * operator

impl<T, U> Div<Minute> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Minute, U>>

The resulting type after applying the / operator

fn div(self, other: Minute) -> Self::Output

The method for the / operator

impl<T, U> Mul<Hour> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Hour, U>>

The resulting type after applying the * operator

fn mul(self, other: Hour) -> Self::Output

The method for the * operator

impl<T, U> Div<Hour> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Hour, U>>

The resulting type after applying the / operator

fn div(self, other: Hour) -> Self::Output

The method for the / operator

impl<T, U> Mul<Day> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Day, U>>

The resulting type after applying the * operator

fn mul(self, other: Day) -> Self::Output

The method for the * operator

impl<T, U> Div<Day> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Day, U>>

The resulting type after applying the / operator

fn div(self, other: Day) -> Self::Output

The method for the / operator

impl<T, U> Mul<Year> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Year, U>>

The resulting type after applying the * operator

fn mul(self, other: Year) -> Self::Output

The method for the * operator

impl<T, U> Div<Year> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Year, U>>

The resulting type after applying the / operator

fn div(self, other: Year) -> Self::Output

The method for the / operator

impl<T, U> Mul<Decade> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Decade, U>>

The resulting type after applying the * operator

fn mul(self, other: Decade) -> Self::Output

The method for the * operator

impl<T, U> Div<Decade> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Decade, U>>

The resulting type after applying the / operator

fn div(self, other: Decade) -> Self::Output

The method for the / operator

impl<T, U> Mul<Century> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Century, U>>

The resulting type after applying the * operator

fn mul(self, other: Century) -> Self::Output

The method for the * operator

impl<T, U> Div<Century> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Century, U>>

The resulting type after applying the / operator

fn div(self, other: Century) -> Self::Output

The method for the / operator

impl<T, U> Mul<Millennium> for Div<T, U> where
    T: Unit, 

type Output = Mul<T, Div<Millennium, U>>

The resulting type after applying the * operator

fn mul(self, other: Millennium) -> Self::Output

The method for the * operator

impl<T, U> Div<Millennium> for Div<T, U> where
    T: Unit, 

type Output = Div<T, Mul<Millennium, U>>

The resulting type after applying the / operator

fn div(self, other: Millennium) -> Self::Output

The method for the / operator