[−][src]Struct uom::si::Quantity
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>,
D::Kind: Div,
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>,
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,
[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>,
D::Kind: Mul,
V: Float,
Da: Dimension,
Da::Kind: Mul,
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>,
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,
[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,
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>,
[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>,
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,
[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>,
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,
[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, 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]
fn lt(&self, other: &Quantity<D, Ur, V>) -> bool
[src]
fn le(&self, other: &Quantity<D, Ur, V>) -> bool
[src]
fn gt(&self, other: &Quantity<D, Ur, V>) -> bool
[src]
fn ge(&self, other: &Quantity<D, Ur, V>) -> bool
[src]
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> 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]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
Performs copy-assignment from source
. 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]
#[must_use]
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
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<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>,
[src]
U: Units<usize>,
usize: Num + Conversion<usize>,
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>,
[src]
U: Units<u8>,
u8: Num + Conversion<u8>,
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>,
[src]
U: Units<u16>,
u16: Num + Conversion<u16>,
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>,
[src]
U: Units<u32>,
u32: Num + Conversion<u32>,
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>,
[src]
U: Units<u64>,
u64: Num + Conversion<u64>,
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>,
[src]
U: Units<isize>,
isize: Num + Conversion<isize>,
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>,
[src]
U: Units<i8>,
i8: Num + Conversion<i8>,
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>,
[src]
U: Units<i16>,
i16: Num + Conversion<i16>,
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>,
[src]
U: Units<i32>,
i32: Num + Conversion<i32>,
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>,
[src]
U: Units<i64>,
i64: Num + Conversion<i64>,
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>,
[src]
U: Units<BigInt>,
BigInt: Num + Conversion<BigInt>,
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>,
[src]
U: Units<BigUint>,
BigUint: Num + Conversion<BigUint>,
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>,
[src]
U: Units<Rational>,
Rational: Num + Conversion<Rational>,
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>,
[src]
U: Units<Rational32>,
Rational32: Num + Conversion<Rational32>,
fn from(t: Angle<U, Rational32>) -> Self
[src]
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>,
[src]
U: Units<Rational64>,
Rational64: Num + Conversion<Rational64>,
fn from(t: Angle<U, Rational64>) -> Self
[src]
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>,
[src]
U: Units<BigRational>,
BigRational: Num + Conversion<BigRational>,
fn from(t: Angle<U, BigRational>) -> Self
[src]
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>,
[src]
U: Units<f32>,
f32: Num + Conversion<f32>,
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>,
[src]
U: Units<f64>,
f64: Num + Conversion<f64>,
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>,
[src]
U: Units<usize>,
usize: Num + Conversion<usize>,
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>,
[src]
U: Units<u8>,
u8: Num + Conversion<u8>,
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>,
[src]
U: Units<u16>,
u16: Num + Conversion<u16>,
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>,
[src]
U: Units<u32>,
u32: Num + Conversion<u32>,
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>,
[src]
U: Units<u64>,
u64: Num + Conversion<u64>,
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>,
[src]
U: Units<isize>,
isize: Num + Conversion<isize>,
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>,
[src]
U: Units<i8>,
i8: Num + Conversion<i8>,
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>,
[src]
U: Units<i16>,
i16: Num + Conversion<i16>,
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>,
[src]
U: Units<i32>,
i32: Num + Conversion<i32>,
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>,
[src]
U: Units<i64>,
i64: Num + Conversion<i64>,
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>,
[src]
U: Units<BigInt>,
BigInt: Num + Conversion<BigInt>,
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>,
[src]
U: Units<BigUint>,
BigUint: Num + Conversion<BigUint>,
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>,
[src]
U: Units<Rational>,
Rational: Num + Conversion<Rational>,
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>,
[src]
U: Units<Rational32>,
Rational32: Num + Conversion<Rational32>,
fn from(t: Ratio<U, Rational32>) -> Self
[src]
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>,
[src]
U: Units<Rational64>,
Rational64: Num + Conversion<Rational64>,
fn from(t: Ratio<U, Rational64>) -> Self
[src]
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>,
[src]
U: Units<BigRational>,
BigRational: Num + Conversion<BigRational>,
fn from(t: Ratio<U, BigRational>) -> Self
[src]
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>,
[src]
U: Units<f32>,
f32: Num + Conversion<f32>,
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>,
[src]
U: Units<f64>,
f64: Num + Conversion<f64>,
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>,
[src]
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>
[src]
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>
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>,
[src]
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>
[src]
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>
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]
fn max(self, other: Self) -> Self
[src]
fn min(self, other: Self) -> Self
[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
clamp
)Restrict a value to a certain interval. 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,
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[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>,
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[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>,
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
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
[src]
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>,
[src]
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + AddAssign<V>,
fn add_assign(&mut self, rhs: TemperatureInterval<Ur, V>)
[src]
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>,
[src]
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>)
[src]
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>,
[src]
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + SubAssign<V>,
fn sub_assign(&mut self, rhs: TemperatureInterval<Ur, V>)
[src]
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>,
[src]
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>)
[src]
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>,
[src]
D: Dimension,
D::Kind: MulAssign,
U: Units<V>,
V: Num + Conversion<V> + MulAssign<V>,
fn mul_assign(&mut self, rhs: V)
[src]
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>,
[src]
D: Dimension,
D::Kind: DivAssign,
U: Units<V>,
V: Num + Conversion<V> + DivAssign<V>,
fn div_assign(&mut self, rhs: V)
[src]
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,
[src]
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>)
[src]
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]
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> Sum<Quantity<D, U, V>> for Quantity<D, U, V> where
D: Dimension,
D::Kind: Add,
U: Units<V>,
V: Num + Conversion<V> + Sum,
[src]
D: Dimension,
D::Kind: Add,
U: Units<V>,
V: Num + Conversion<V> + Sum,
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>,
[src]
D: Dimension,
D::Kind: Add,
U: Units<V>,
V: Num + Conversion<V>,
fn zero() -> Self
[src]
fn is_zero(&self) -> bool
[src]
fn set_zero(&mut self)
[src]
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,
[src]
D: Dimension,
D::Kind: Saturating,
U: Units<V>,
V: Num + Conversion<V> + Saturating,
fn saturating_add(self, v: Self) -> Self
[src]
fn saturating_sub(self, v: Self) -> Self
[src]
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,
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>,
Auto Trait Implementations
impl<D: ?Sized, U: ?Sized, V> Send for Quantity<D, U, V> where
V: Send,
V: Send,
impl<D: ?Sized, U: ?Sized, V> Sync for Quantity<D, U, V> where
V: Sync,
V: Sync,
Blanket Implementations
impl<T> From<T> for T
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
ⓘImportant traits for &'_ mut Rfn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
[src]
T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>,
impl<T, Rhs> NumAssignOps<Rhs> for T where
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
[src]
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
impl<T> DeserializeOwned for T where
T: Deserialize<'de>,
[src]
T: Deserialize<'de>,
impl<T> Same<T> for T
[src]
type Output = T
Should always be Self