Struct metric::composite::Mul

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

Methods

impl<T> Mul<T, T> where
    T: Copy + Unit, 

fn sqrt(&self) -> T

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

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

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

Trait Implementations

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

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

fn clone(&self) -> Mul<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 Mul<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 Mul<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 Mul<T, U> where
    T: Unit, 

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

fn inner(&self) -> f64

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Mul<T, U>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Mul<T, U>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Mul<T, U>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Mul<T, U>

The resulting type after applying the * operator.

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

Performs the * operation.

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

fn mul_assign(&mut self, other: f64)

Performs the *= operation.

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

fn mul_assign(&mut self, other: i64)

Performs the *= operation.

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

type Output = Mul<T, U>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Mul<T, U>

The resulting type after applying the / operator.

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

Performs the / operation.

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

fn div_assign(&mut self, other: f64)

Performs the /= operation.

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

fn div_assign(&mut self, other: i64)

Performs the /= operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

The resulting type after applying the / operator.

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

Performs the / operation.