Struct uom::si::Quantity

pub struct Quantity<D: ?Sized, U: ?Sized, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V>,  {
    pub dimension: PhantomData<D>,
    pub units: PhantomData<U>,
    pub value: V,
}

Property of a phenomenon, body or substance, where the property has a magnitude that can be expressed as a number and a reference.

The preferred method of creating a Quantity instance is to use the new constructor which is generic over the input unit and accepts the input value as it's only parameter.

// Create a length of 1 meter.
let l = Length::new::<meter>(1.0);

Quantity fields are public to allow for the creation of const values and instances of non-named Quantitys. This functionality will be deprecated and subsequently removed once the const fn feature is stabilized.

// Create a `const` length of 1 meter.
const L: Length = Length { dimension: PhantomData, units: PhantomData, value: 1.0, };
// Create a `const` area of 1 square meter explicitly without using the `Area` alias.
const A: Quantity<ISQ<P2, Z0, Z0, Z0, Z0, Z0, Z0>, SI<f32>, f32> =
    Quantity { dimension: PhantomData, units: PhantomData, value: 1.0, };

Using units for the wrong quantity will cause a compile error:

// error[E0277]: the trait bound `second: length::Unit` is not satisfied
let l = Length::new::<second>(1.0);

Mixing quantities will also cause a compile error:

// error[E0308]: mismatched types
let r = Length::new::<meter>(1.0) + Time::new::<second>(1.0);

// error[E0308]: mismatched types
let v: Velocity = Length::new::<meter>(1.0) * Time::new::<second>(1.0);

• http://jcgm.bipm.org/vim/en/1.1.html

Fields

dimension: PhantomData<D>

Quantity dimension. See Dimension.

units: PhantomData<U>

Quantity base units. See Units.

value: V

Quantity value stored in the base units for the quantity.

Methods

impl<D: ?Sized, U: ?Sized, V> Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V>, 

pub fn is_nan(self) -> bool where
    V: Float, 

Returns true if this value is NAN and false otherwise.

pub fn is_infinite(self) -> bool where
    V: Float, 

Returns true if this value is positive infinity or negative infinity and false otherwise.

pub fn is_finite(self) -> bool where
    V: Float, 

Returns true if this number is neither infinite nor NAN.

pub fn is_normal(self) -> bool where
    V: Float, 

Returns true if the number is neither zero, infinite, subnormal, or NAN.

pub fn classify(self) -> FpCategory where
    V: Float, 

Returns the floating point category of the number. If only one property is going to be tested, it is generally faster to use the specific predicate instead.

pub fn cbrt(
    self
) -> Quantity<ISQ<PartialQuot<D::L, P3>, PartialQuot<D::M, P3>, PartialQuot<D::T, P3>, PartialQuot<D::I, P3>, PartialQuot<D::Th, P3>, PartialQuot<D::N, P3>, PartialQuot<D::J, P3>>, U, V> where
    D::L: PartialDiv<P3>,
    D::M: PartialDiv<P3>,
    D::T: PartialDiv<P3>,
    D::I: PartialDiv<P3>,
    D::Th: PartialDiv<P3>,
    D::N: PartialDiv<P3>,
    D::J: PartialDiv<P3>,
    D::Kind: Div,
    V: Float, 

Takes the cubic root of a number.

let l: Length = Volume::new::<cubic_meter>(8.0).cbrt();

The input type must have dimensions divisible by three:

// error[E0271]: type mismatch resolving ...
let r = Area::new::<square_meter>(8.0).cbrt();

pub fn abs(self) -> Self where
    V: Signed, 

Computes the absolute value of self. Returns NAN if the quantity is NAN.

pub fn signum(self) -> Self where
    V: Signed, 

Returns a quantity that represents the sign of self.

• 1.0 of the base unit if the number is positive, +0.0, or INFINITY.
• -1.0 of the base unit if the number is negative, -0.0, or NEG_INFINITY.
• NAN if the number is NAN.

pub fn is_sign_positive(self) -> bool where
    V: Float, 

Returns true if self's sign bit is positive, including +0.0 and INFINITY.

pub fn is_sign_negative(self) -> bool where
    V: Float, 

Returns true if self's sign is negative, including -0.0 and NEG_INFINITY.

pub fn mul_add<Da: ?Sized, Ua: ?Sized, Ub: ?Sized>(
    self,
    a: Quantity<Da, Ua, V>,
    b: Quantity<ISQ<Sum<D::L, Da::L>, Sum<D::M, Da::M>, Sum<D::T, Da::T>, Sum<D::I, Da::I>, Sum<D::Th, Da::Th>, Sum<D::N, Da::N>, Sum<D::J, Da::J>>, Ub, V>
) -> Quantity<ISQ<Sum<D::L, Da::L>, Sum<D::M, Da::M>, Sum<D::T, Da::T>, Sum<D::I, Da::I>, Sum<D::Th, Da::Th>, Sum<D::N, Da::N>, Sum<D::J, Da::J>>, U, V> where
    D::L: Add<Da::L>,
    D::M: Add<Da::M>,
    D::T: Add<Da::T>,
    D::I: Add<Da::I>,
    D::Th: Add<Da::Th>,
    D::N: Add<Da::N>,
    D::J: Add<Da::J>,
    D::Kind: Mul,
    V: Float,
    Da: Dimension,
    Da::Kind: Mul,
    Ua: Units<V>,
    Ub: Units<V>, 

Fused multiply-add. Computes (self * a) + b with only one rounding error. This produces a more accurate result with better performance than a separate multiplication operation followed by an add.

pub fn recip(
    self
) -> Quantity<ISQ<Negate<D::L>, Negate<D::M>, Negate<D::T>, Negate<D::I>, Negate<D::Th>, Negate<D::N>, Negate<D::J>>, U, V> where
    D::L: Neg,
    D::M: Neg,
    D::T: Neg,
    D::I: Neg,
    D::Th: Neg,
    D::N: Neg,
    D::J: Neg,
    D::Kind: Div,
    V: Float, 

Takes the reciprocal (inverse) of a number, 1/x.

let f: Frequency = Time::new::<second>(1.0).recip();

pub fn powi<E>(
    self,
    e: E
) -> Quantity<ISQ<Prod<D::L, E>, Prod<D::M, E>, Prod<D::T, E>, Prod<D::I, E>, Prod<D::Th, E>, Prod<D::N, E>, Prod<D::J, E>>, U, V> where
    D::L: Mul<E>,
    D::M: Mul<E>,
    D::T: Mul<E>,
    D::I: Mul<E>,
    D::Th: Mul<E>,
    D::N: Mul<E>,
    D::J: Mul<E>,
    D::Kind: Mul,
    E: Integer,
    V: Pow<E, Output = V> + Conversion<V>, 

Raises a quantity to an integer power.

let a: Area = Length::new::<meter>(3.0).powi(::uom::typenum::P2::new());

pub fn sqrt(
    self
) -> Quantity<ISQ<PartialQuot<D::L, P2>, PartialQuot<D::M, P2>, PartialQuot<D::T, P2>, PartialQuot<D::I, P2>, PartialQuot<D::Th, P2>, PartialQuot<D::N, P2>, PartialQuot<D::J, P2>>, U, V> where
    D::L: PartialDiv<P2>,
    D::M: PartialDiv<P2>,
    D::T: PartialDiv<P2>,
    D::I: PartialDiv<P2>,
    D::Th: PartialDiv<P2>,
    D::N: PartialDiv<P2>,
    D::J: PartialDiv<P2>,
    D::Kind: Div,
    V: Float, 

Takes the square root of a number. Returns NAN if self is a negative number.

let l: Length = Area::new::<square_meter>(4.0).sqrt();

The input type must have dimensions divisible by two:

// error[E0271]: type mismatch resolving ...
let r = Length::new::<meter>(4.0).sqrt();

pub fn max(self, other: Self) -> Self where
    V: Float, 

Returns the maximum of the two quantities.

pub fn min(self, other: Self) -> Self where
    V: Float, 

Returns the minimum of the two quantities.

Trait Implementations

impl<D: ?Sized, U: ?Sized, V> Eq for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Eq, 

impl<D: ?Sized, U: ?Sized, V> Ord for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Ord, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> PartialEq<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 

fn eq(&self, other: &Quantity<D, Ur, V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]

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

This method tests for !=.

impl<D: ?Sized, U: ?Sized, V> Clone for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> PartialOrd<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + PartialOrd, 

fn partial_cmp(&self, other: &Quantity<D, Ur, V>) -> Option<Ordering>

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

fn lt(&self, other: &Quantity<D, Ur, V>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Quantity<D, Ur, V>) -> bool

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

fn gt(&self, other: &Quantity<D, Ur, V>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Quantity<D, Ur, V>) -> bool

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

impl<D: ?Sized, U: ?Sized, V> Copy for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Copy, 

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, usize>> for usize where
    U: Units<usize>,
    usize: Num + Conversion<usize>, 

fn from(t: Angle<U, usize>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u8>> for u8 where
    U: Units<u8>,
    u8: Num + Conversion<u8>, 

fn from(t: Angle<U, u8>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u16>> for u16 where
    U: Units<u16>,
    u16: Num + Conversion<u16>, 

fn from(t: Angle<U, u16>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u32>> for u32 where
    U: Units<u32>,
    u32: Num + Conversion<u32>, 

fn from(t: Angle<U, u32>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u64>> for u64 where
    U: Units<u64>,
    u64: Num + Conversion<u64>, 

fn from(t: Angle<U, u64>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, isize>> for isize where
    U: Units<isize>,
    isize: Num + Conversion<isize>, 

fn from(t: Angle<U, isize>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i8>> for i8 where
    U: Units<i8>,
    i8: Num + Conversion<i8>, 

fn from(t: Angle<U, i8>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i16>> for i16 where
    U: Units<i16>,
    i16: Num + Conversion<i16>, 

fn from(t: Angle<U, i16>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i32>> for i32 where
    U: Units<i32>,
    i32: Num + Conversion<i32>, 

fn from(t: Angle<U, i32>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i64>> for i64 where
    U: Units<i64>,
    i64: Num + Conversion<i64>, 

fn from(t: Angle<U, i64>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, BigInt>> for BigInt where
    U: Units<BigInt>,
    BigInt: Num + Conversion<BigInt>, 

fn from(t: Angle<U, BigInt>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, BigUint>> for BigUint where
    U: Units<BigUint>,
    BigUint: Num + Conversion<BigUint>, 

fn from(t: Angle<U, BigUint>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<isize>>> for Rational where
    U: Units<Rational>,
    Rational: Num + Conversion<Rational>, 

fn from(t: Angle<U, Rational>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<i32>>> for Rational32 where
    U: Units<Rational32>,
    Rational32: Num + Conversion<Rational32>, 

fn from(t: Angle<U, Rational32>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<i64>>> for Rational64 where
    U: Units<Rational64>,
    Rational64: Num + Conversion<Rational64>, 

fn from(t: Angle<U, Rational64>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<BigInt>>> for BigRational where
    U: Units<BigRational>,
    BigRational: Num + Conversion<BigRational>, 

fn from(t: Angle<U, BigRational>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, f32>> for f32 where
    U: Units<f32>,
    f32: Num + Conversion<f32>, 

fn from(t: Angle<U, f32>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, f64>> for f64 where
    U: Units<f64>,
    f64: Num + Conversion<f64>, 

fn from(t: Angle<U, f64>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, usize>> for usize where
    U: Units<usize>,
    usize: Num + Conversion<usize>, 

fn from(t: Ratio<U, usize>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u8>> for u8 where
    U: Units<u8>,
    u8: Num + Conversion<u8>, 

fn from(t: Ratio<U, u8>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u16>> for u16 where
    U: Units<u16>,
    u16: Num + Conversion<u16>, 

fn from(t: Ratio<U, u16>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u32>> for u32 where
    U: Units<u32>,
    u32: Num + Conversion<u32>, 

fn from(t: Ratio<U, u32>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u64>> for u64 where
    U: Units<u64>,
    u64: Num + Conversion<u64>, 

fn from(t: Ratio<U, u64>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, isize>> for isize where
    U: Units<isize>,
    isize: Num + Conversion<isize>, 

fn from(t: Ratio<U, isize>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i8>> for i8 where
    U: Units<i8>,
    i8: Num + Conversion<i8>, 

fn from(t: Ratio<U, i8>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i16>> for i16 where
    U: Units<i16>,
    i16: Num + Conversion<i16>, 

fn from(t: Ratio<U, i16>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i32>> for i32 where
    U: Units<i32>,
    i32: Num + Conversion<i32>, 

fn from(t: Ratio<U, i32>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i64>> for i64 where
    U: Units<i64>,
    i64: Num + Conversion<i64>, 

fn from(t: Ratio<U, i64>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, BigInt>> for BigInt where
    U: Units<BigInt>,
    BigInt: Num + Conversion<BigInt>, 

fn from(t: Ratio<U, BigInt>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, BigUint>> for BigUint where
    U: Units<BigUint>,
    BigUint: Num + Conversion<BigUint>, 

fn from(t: Ratio<U, BigUint>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<isize>>> for Rational where
    U: Units<Rational>,
    Rational: Num + Conversion<Rational>, 

fn from(t: Ratio<U, Rational>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<i32>>> for Rational32 where
    U: Units<Rational32>,
    Rational32: Num + Conversion<Rational32>, 

fn from(t: Ratio<U, Rational32>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<i64>>> for Rational64 where
    U: Units<Rational64>,
    Rational64: Num + Conversion<Rational64>, 

fn from(t: Ratio<U, Rational64>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<BigInt>>> for BigRational where
    U: Units<BigRational>,
    BigRational: Num + Conversion<BigRational>, 

fn from(t: Ratio<U, BigRational>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, f32>> for f32 where
    U: Units<f32>,
    f32: Num + Conversion<f32>, 

fn from(t: Ratio<U, f32>) -> Self

Performs the conversion.

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, f64>> for f64 where
    U: Units<f64>,
    f64: Num + Conversion<f64>, 

fn from(t: Ratio<U, f64>) -> Self

Performs the conversion.

impl<L, M, T, I, Th, N, J, Ul: ?Sized, Ur: ?Sized, V> From<Quantity<dyn Dimension<J = J, Kind = dyn AngleKind + 'static, I = I, L = L, M = M, Th = Th, T = T, N = N> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn Kind>, Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 

fn from(
    val: Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn AngleKind>, Ur, V>
) -> Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn Kind>, Ul, V>

Performs the conversion.

impl<L, M, T, I, Th, N, J, Ul: ?Sized, Ur: ?Sized, V> From<Quantity<dyn Dimension<J = J, Kind = dyn Kind + 'static, I = I, L = L, M = M, Th = Th, T = T, N = N> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn AngleKind>, Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 

fn from(
    val: Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn Kind>, Ur, V>
) -> Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn AngleKind>, Ul, V>

Performs the conversion.

impl<D: ?Sized, U: ?Sized, V> Default for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Default, 

fn default() -> Self

Returns the "default value" for a type.

impl<D: ?Sized, U: ?Sized, V> Debug for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Debug, 

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

Formats the value using the given formatter.

impl<Ul: ?Sized, Ur: ?Sized, V> Sub<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 

type Output = ThermodynamicTemperature<Ul, V>

The resulting type after applying the - operator.

fn sub(self, rhs: TemperatureInterval<Ur, V>) -> Self::Output

Performs the - operation.

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Sub<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: Sub,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 

type Output = Quantity<D, Ul, V>

The resulting type after applying the - operator.

fn sub(self, rhs: Quantity<D, Ur, V>) -> Self::Output

Performs the - operation.

impl<Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<dyn Dimension<J = Z0, Kind = dyn TemperatureKind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, Ur, V>> for TemperatureInterval<Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 

type Output = ThermodynamicTemperature<Ul, V>

The resulting type after applying the + operator.

fn add(self, rhs: ThermodynamicTemperature<Ur, V>) -> Self::Output

Performs the + operation.

impl<Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 

type Output = ThermodynamicTemperature<Ul, V>

The resulting type after applying the + operator.

fn add(self, rhs: TemperatureInterval<Ur, V>) -> Self::Output

Performs the + operation.

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: Add,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 

type Output = Quantity<D, Ul, V>

The resulting type after applying the + operator.

fn add(self, rhs: Quantity<D, Ur, V>) -> Self::Output

Performs the + operation.

impl<Dl: ?Sized, Dr: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Mul<Quantity<Dr, Ur, V>> for Quantity<Dl, Ul, V> where
    Dl: Dimension,
    Dl::L: Add<Dr::L>,
    Dl::M: Add<Dr::M>,
    Dl::T: Add<Dr::T>,
    Dl::I: Add<Dr::I>,
    Dl::Th: Add<Dr::Th>,
    Dl::N: Add<Dr::N>,
    Dl::J: Add<Dr::J>,
    Dl::Kind: Mul,
    Dr: Dimension,
    Dr::Kind: Mul,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + Mul<V>, 

type Output = Quantity<ISQ<Sum<Dl::L, Dr::L>, Sum<Dl::M, Dr::M>, Sum<Dl::T, Dr::T>, Sum<Dl::I, Dr::I>, Sum<Dl::Th, Dr::Th>, Sum<Dl::N, Dr::N>, Sum<Dl::J, Dr::J>>, Ul, V>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<Dr, Ur, V>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized, V> Mul<V> for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Mul,
    U: Units<V>,
    V: Num + Conversion<V>, 

type Output = Quantity<D, U, V>

The resulting type after applying the * operator.

fn mul(self, rhs: V) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, usize>> for usize where
    D: Dimension,
    D::Kind: Mul,
    U: Units<usize>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, usize>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, usize>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u8>> for u8 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<u8>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, u8>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, u8>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u16>> for u16 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<u16>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, u16>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, u16>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u32>> for u32 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<u32>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, u32>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, u32>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u64>> for u64 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<u64>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, u64>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, u64>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, isize>> for isize where
    D: Dimension,
    D::Kind: Mul,
    U: Units<isize>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, isize>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, isize>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i8>> for i8 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<i8>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, i8>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, i8>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i16>> for i16 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<i16>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, i16>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, i16>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i32>> for i32 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<i32>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, i32>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, i32>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i64>> for i64 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<i64>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, i64>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, i64>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, BigInt>> for BigInt where
    D: Dimension,
    D::Kind: Mul,
    U: Units<BigInt>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, BigInt>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, BigInt>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, BigUint>> for BigUint where
    D: Dimension,
    D::Kind: Mul,
    U: Units<BigUint>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, BigUint>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, BigUint>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<isize>>> for Rational where
    D: Dimension,
    D::Kind: Mul,
    U: Units<Rational>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, Rational>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, Rational>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<i32>>> for Rational32 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<Rational32>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, Rational32>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, Rational32>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<i64>>> for Rational64 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<Rational64>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, Rational64>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, Rational64>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<BigInt>>> for BigRational where
    D: Dimension,
    D::Kind: Mul,
    U: Units<BigRational>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, BigRational>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, BigRational>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, f32>> for f32 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<f32>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, f32>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, f32>) -> Self::Output

Performs the * operation.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, f64>> for f64 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<f64>,
    Z0: Add<D::L>,
    Z0: Add<D::M>,
    Z0: Add<D::T>,
    Z0: Add<D::I>,
    Z0: Add<D::Th>,
    Z0: Add<D::N>,
    Z0: Add<D::J>, 

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, f64>

The resulting type after applying the * operator.

fn mul(self, rhs: Quantity<D, U, f64>) -> Self::Output

Performs the * operation.

impl<Dl: ?Sized, Dr: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Div<Quantity<Dr, Ur, V>> for Quantity<Dl, Ul, V> where
    Dl: Dimension,
    Dl::L: Sub<Dr::L>,
    Dl::M: Sub<Dr::M>,
    Dl::T: Sub<Dr::T>,
    Dl::I: Sub<Dr::I>,
    Dl::Th: Sub<Dr::Th>,
    Dl::N: Sub<Dr::N>,
    Dl::J: Sub<Dr::J>,
    Dl::Kind: Div,
    Dr: Dimension,
    Dr::Kind: Div,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + Div<V>, 

type Output = Quantity<ISQ<Diff<Dl::L, Dr::L>, Diff<Dl::M, Dr::M>, Diff<Dl::T, Dr::T>, Diff<Dl::I, Dr::I>, Diff<Dl::Th, Dr::Th>, Diff<Dl::N, Dr::N>, Diff<Dl::J, Dr::J>>, Ul, V>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<Dr, Ur, V>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized, V> Div<V> for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Div,
    U: Units<V>,
    V: Num + Conversion<V>, 

type Output = Quantity<D, U, V>

The resulting type after applying the / operator.

fn div(self, rhs: V) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, usize>> for usize where
    D: Dimension,
    D::Kind: Div,
    U: Units<usize>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, usize>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, usize>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u8>> for u8 where
    D: Dimension,
    D::Kind: Div,
    U: Units<u8>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, u8>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, u8>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u16>> for u16 where
    D: Dimension,
    D::Kind: Div,
    U: Units<u16>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, u16>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, u16>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u32>> for u32 where
    D: Dimension,
    D::Kind: Div,
    U: Units<u32>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, u32>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, u32>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u64>> for u64 where
    D: Dimension,
    D::Kind: Div,
    U: Units<u64>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, u64>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, u64>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, isize>> for isize where
    D: Dimension,
    D::Kind: Div,
    U: Units<isize>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, isize>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, isize>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i8>> for i8 where
    D: Dimension,
    D::Kind: Div,
    U: Units<i8>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, i8>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, i8>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i16>> for i16 where
    D: Dimension,
    D::Kind: Div,
    U: Units<i16>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, i16>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, i16>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i32>> for i32 where
    D: Dimension,
    D::Kind: Div,
    U: Units<i32>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, i32>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, i32>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i64>> for i64 where
    D: Dimension,
    D::Kind: Div,
    U: Units<i64>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, i64>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, i64>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, BigInt>> for BigInt where
    D: Dimension,
    D::Kind: Div,
    U: Units<BigInt>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, BigInt>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, BigInt>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, BigUint>> for BigUint where
    D: Dimension,
    D::Kind: Div,
    U: Units<BigUint>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, BigUint>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, BigUint>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<isize>>> for Rational where
    D: Dimension,
    D::Kind: Div,
    U: Units<Rational>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, Rational>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, Rational>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<i32>>> for Rational32 where
    D: Dimension,
    D::Kind: Div,
    U: Units<Rational32>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, Rational32>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, Rational32>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<i64>>> for Rational64 where
    D: Dimension,
    D::Kind: Div,
    U: Units<Rational64>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, Rational64>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, Rational64>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<BigInt>>> for BigRational where
    D: Dimension,
    D::Kind: Div,
    U: Units<BigRational>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, BigRational>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, BigRational>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, f32>> for f32 where
    D: Dimension,
    D::Kind: Div,
    U: Units<f32>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, f32>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, f32>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, f64>> for f64 where
    D: Dimension,
    D::Kind: Div,
    U: Units<f64>,
    Z0: Sub<D::L>,
    Z0: Sub<D::M>,
    Z0: Sub<D::T>,
    Z0: Sub<D::I>,
    Z0: Sub<D::Th>,
    Z0: Sub<D::N>,
    Z0: Sub<D::J>, 

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, f64>

The resulting type after applying the / operator.

fn div(self, rhs: Quantity<D, U, f64>) -> Self::Output

Performs the / operation.

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Rem<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: Rem,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 

type Output = Quantity<D, Ul, V>

The resulting type after applying the % operator.

fn rem(self, rhs: Quantity<D, Ur, V>) -> Self::Output

Performs the % operation.

impl<D: ?Sized, U: ?Sized, V> Neg for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Neg,
    U: Units<V>,
    V: Signed + Conversion<V>, 

type Output = Quantity<D, U, V>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<Ul: ?Sized, Ur: ?Sized, V> AddAssign<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + AddAssign<V>, 

fn add_assign(&mut self, rhs: TemperatureInterval<Ur, V>)

Performs the += operation.

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> AddAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: AddAssign,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + AddAssign<V>, 

fn add_assign(&mut self, rhs: Quantity<D, Ur, V>)

Performs the += operation.

impl<Ul: ?Sized, Ur: ?Sized, V> SubAssign<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + SubAssign<V>, 

fn sub_assign(&mut self, rhs: TemperatureInterval<Ur, V>)

Performs the -= operation.

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> SubAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: SubAssign,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + SubAssign<V>, 

fn sub_assign(&mut self, rhs: Quantity<D, Ur, V>)

Performs the -= operation.

impl<D: ?Sized, U: ?Sized, V> MulAssign<V> for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: MulAssign,
    U: Units<V>,
    V: Num + Conversion<V> + MulAssign<V>, 

fn mul_assign(&mut self, rhs: V)

Performs the *= operation.

impl<D: ?Sized, U: ?Sized, V> DivAssign<V> for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: DivAssign,
    U: Units<V>,
    V: Num + Conversion<V> + DivAssign<V>, 

fn div_assign(&mut self, rhs: V)

Performs the /= operation.

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> RemAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: RemAssign,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + RemAssign, 

fn rem_assign(&mut self, rhs: Quantity<D, Ur, V>)

Performs the %= operation.

impl<D: ?Sized, U: ?Sized, V> Hash for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Hash, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<D: ?Sized, U: ?Sized, V> Sum<Quantity<D, U, V>> for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Add,
    U: Units<V>,
    V: Num + Conversion<V> + Sum, 

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = Self>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<D: ?Sized, U: ?Sized, V> Zero for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Add,
    U: Units<V>,
    V: Num + Conversion<V>, 

fn zero() -> Self

Returns the additive identity element of Self, 0. # Purity

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<D: ?Sized, U: ?Sized, V> Saturating for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Saturating,
    U: Units<V>,
    V: Num + Conversion<V> + Saturating, 

fn saturating_add(self, v: Self) -> Self

Saturating addition operator. Returns a+b, saturating at the numeric bounds instead of overflowing.

fn saturating_sub(self, v: Self) -> Self

Saturating subtraction operator. Returns a-b, saturating at the numeric bounds instead of overflowing.

impl<D: ?Sized, U: ?Sized, V> Serialize for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Serialize, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de, D: ?Sized, U: ?Sized, V> Deserialize<'de> for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Deserialize<'de>, 

fn deserialize<De>(deserializer: De) -> Result<Self, De::Error> where
    De: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.