Struct uom::si::Quantity
[−]
[src]
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 Quantity
s. 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);
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>,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V>,
pub fn is_nan(self) -> bool where
V: Float,
[src]
V: Float,
Returns true
if this value is NAN
and false
otherwise.
pub fn is_infinite(self) -> bool where
V: Float,
[src]
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,
[src]
V: Float,
Returns true
if this number is neither infinite nor NAN
.
pub fn is_normal(self) -> bool where
V: Float,
[src]
V: Float,
Returns true
if the number is neither zero, infinite, subnormal, or NAN
.
pub fn classify(self) -> FpCategory where
V: Float,
[src]
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>,
V: Float,
[src]
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>,
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,
[src]
V: Signed,
Computes the absolute value of self
. Returns NAN
if the quantity is
NAN
.
pub fn signum(self) -> Self where
V: Signed,
[src]
V: Signed,
Returns a quantity that represents the sign of self
.
1.0
of the base unit if the number is positive,+0.0
, orINFINITY
.-1.0
of the base unit if the number is negative,-0.0
, orNEG_INFINITY
.NAN
if the number isNAN
.
pub fn is_sign_positive(self) -> bool where
V: Float,
[src]
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,
[src]
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>,
V: Float,
Da: Dimension,
Ua: Units<V>,
Ub: Units<V>,
[src]
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>,
V: Float,
Da: Dimension,
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,
V: Float,
[src]
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,
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>,
E: Integer,
V: Pow<E, Output = V> + Conversion<V>,
[src]
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>,
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>,
V: Float,
[src]
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>,
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,
[src]
V: Float,
Returns the maximum of the two quantities.
pub fn min(self, other: Self) -> Self where
V: Float,
[src]
V: Float,
Returns the minimum of the two quantities.
Trait Implementations
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, usize>> for usize where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, usize>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, usize>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u8>> for u8 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, u8>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, u8>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u16>> for u16 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, u16>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, u16>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u32>> for u32 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, u32>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, u32>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u64>> for u64 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, u64>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, u64>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, isize>> for isize where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, isize>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, isize>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i8>> for i8 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, i8>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, i8>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i16>> for i16 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, i16>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, i16>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i32>> for i32 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, i32>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, i32>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i64>> for i64 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, i64>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, i64>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, BigInt>> for BigInt where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, BigInt>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, BigInt>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, BigUint>> for BigUint where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, BigUint>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, BigUint>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Rational>> for Rational where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, Rational>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, Rational>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Rational32>> for Rational32 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, Rational32>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, Rational32>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Rational64>> for Rational64 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, Rational64>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, Rational64>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, BigRational>> for BigRational where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, BigRational>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, BigRational>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, f32>> for f32 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, f32>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, f32>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, f64>> for f64 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, f64>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<D, U, f64>) -> Self::Output
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, usize>> for usize where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, usize>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, usize>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u8>> for u8 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, u8>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, u8>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u16>> for u16 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, u16>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, u16>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u32>> for u32 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, u32>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, u32>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u64>> for u64 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, u64>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, u64>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, isize>> for isize where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, isize>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, isize>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i8>> for i8 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, i8>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, i8>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i16>> for i16 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, i16>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, i16>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i32>> for i32 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, i32>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, i32>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i64>> for i64 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, i64>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, i64>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, BigInt>> for BigInt where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, BigInt>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, BigInt>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, BigUint>> for BigUint where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, BigUint>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, BigUint>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Rational>> for Rational where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, Rational>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, Rational>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Rational32>> for Rational32 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, Rational32>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, Rational32>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Rational64>> for Rational64 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, Rational64>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, Rational64>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, BigRational>> for BigRational where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, BigRational>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, BigRational>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, f32>> for f32 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, f32>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, f32>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, f64>> for f64 where
D: Dimension,
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>,
[src]
D: Dimension,
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>>, U, f64>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<D, U, f64>) -> Self::Output
[src]
Performs the /
operation.
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
[src]
D: Dimension,
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
[src]
Performs the +
operation.
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> AddAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + AddAssign<V>,
[src]
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + AddAssign<V>,
fn add_assign(&mut self, rhs: Quantity<D, Ur, V>)
[src]
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>,
Dr: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + Mul<V>,
[src]
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>,
Dr: Dimension,
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
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized, V> Mul<V> for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V>,
[src]
D: Dimension,
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
[src]
Performs the *
operation.
impl<D: ?Sized, U: ?Sized, V> MulAssign<V> for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + MulAssign<V>,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + MulAssign<V>,
fn mul_assign(&mut self, rhs: V)
[src]
Performs the *=
operation.
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Sub<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
[src]
D: Dimension,
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
[src]
Performs the -
operation.
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> SubAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + SubAssign<V>,
[src]
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + SubAssign<V>,
fn sub_assign(&mut self, rhs: Quantity<D, Ur, V>)
[src]
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>,
Dr: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + Div<V>,
[src]
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>,
Dr: Dimension,
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
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized, V> Div<V> for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V>,
[src]
D: Dimension,
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
[src]
Performs the /
operation.
impl<D: ?Sized, U: ?Sized, V> DivAssign<V> for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + DivAssign<V>,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + DivAssign<V>,
fn div_assign(&mut self, rhs: V)
[src]
Performs the /=
operation.
impl<D: ?Sized, U: ?Sized, V> Clone for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Clone,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Clone,
fn clone(&self) -> Self
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. Read more
impl<D: ?Sized, U: ?Sized, V> Copy for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Copy,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Copy,
impl<D: ?Sized, U: ?Sized, V> Debug for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Debug,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Debug,
fn fmt(&self, f: &mut Formatter) -> Result
[src]
Formats the value using the given formatter. Read more
impl<D: ?Sized, U: ?Sized, V> Default for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Default,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Default,
impl<D: ?Sized, U: ?Sized, V> Eq for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Eq,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Eq,
impl<D: ?Sized, U: ?Sized, V> Hash for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Hash,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Hash,
fn hash<H: Hasher>(&self, state: &mut H)
[src]
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<D: ?Sized, U: ?Sized, V> Neg for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Signed + Conversion<V>,
[src]
D: Dimension,
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
[src]
Performs the unary -
operation.
impl<D: ?Sized, U: ?Sized, V> Ord for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Ord,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Ord,
fn cmp(&self, other: &Self) -> Ordering
[src]
This method returns an Ordering
between self
and other
. Read more
fn max(self, other: Self) -> Self
1.21.0[src]
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
1.21.0[src]
Compares and returns the minimum of two values. Read more
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>,
[src]
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
fn eq(&self, other: &Quantity<D, Ur, V>) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
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,
[src]
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + PartialOrd,
fn partial_cmp(&self, other: &Quantity<D, Ur, V>) -> Option<Ordering>
[src]
This method returns an ordering between self
and other
values if one exists. Read more
fn lt(&self, other: &Quantity<D, Ur, V>) -> bool
[src]
This method tests less than (for self
and other
) and is used by the <
operator. Read more
fn le(&self, other: &Quantity<D, Ur, V>) -> bool
[src]
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
fn gt(&self, other: &Quantity<D, Ur, V>) -> bool
[src]
This method tests greater than (for self
and other
) and is used by the >
operator. Read more
fn ge(&self, other: &Quantity<D, Ur, V>) -> bool
[src]
This method tests greater than or equal to (for self
and other
) and is used by the >=
operator. Read more
impl<D: ?Sized, U: ?Sized, V> Product for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Product,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Product,
fn product<I>(iter: I) -> Self where
I: Iterator<Item = Self>,
[src]
I: Iterator<Item = Self>,
Method which takes an iterator and generates Self
from the elements by multiplying the items. Read more
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Rem<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
[src]
D: Dimension,
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
[src]
Performs the %
operation.
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> RemAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + RemAssign,
[src]
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + RemAssign,
fn rem_assign(&mut self, rhs: Quantity<D, Ur, V>)
[src]
Performs the %=
operation.
impl<D: ?Sized, U: ?Sized, V> Saturating for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Saturating,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Saturating,
fn saturating_add(self, v: Self) -> Self
[src]
Saturating addition operator. Returns a+b, saturating at the numeric bounds instead of overflowing. Read more
fn saturating_sub(self, v: Self) -> Self
[src]
Saturating subtraction operator. Returns a-b, saturating at the numeric bounds instead of overflowing. Read more
impl<D: ?Sized, U: ?Sized, V> Sum for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Sum,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Sum,
fn sum<I>(iter: I) -> Self where
I: Iterator<Item = Self>,
[src]
I: Iterator<Item = Self>,
Method which takes an iterator and generates Self
from the elements by "summing up" the items. Read more
impl<D: ?Sized, U: ?Sized, V> Zero for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V>,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V>,
fn zero() -> Self
[src]
Returns the additive identity element of Self
, 0
. Read more
fn is_zero(&self) -> bool
[src]
Returns true
if self
is equal to the additive identity.
impl<D: ?Sized, U: ?Sized, V> Serialize for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Serialize,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Serialize,
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
S: Serializer,
[src]
S: Serializer,
Serialize this value into the given Serde serializer. Read more
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>,
[src]
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Deserialize<'de>,
fn deserialize<De>(deserializer: De) -> Result<Self, De::Error> where
De: Deserializer<'de>,
[src]
De: Deserializer<'de>,
Deserialize this value from the given Serde deserializer. Read more