[−][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]
impl<D: ?Sized, U: ?Sized, V> Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V>,
pub fn is_nan(self) -> bool where | [src] |
Returns true
if this value is NAN
and false
otherwise.
pub fn is_infinite(self) -> bool where | [src] |
Returns true
if this value is positive infinity or negative infinity and
false
otherwise.
pub fn is_finite(self) -> bool where | [src] |
Returns true
if this number is neither infinite nor NAN
.
pub fn is_normal(self) -> bool where | [src] |
Returns true
if the number is neither zero, infinite, subnormal, or NAN
.
pub fn classify(self) -> FpCategory where | [src] |
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( | [src] |
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 | [src] |
Computes the absolute value of self
. Returns NAN
if the quantity is
NAN
.
pub fn signum(self) -> Self where | [src] |
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 | [src] |
Returns true
if self
's sign bit is positive, including +0.0
and
INFINITY
.
pub fn is_sign_negative(self) -> bool where | [src] |
Returns true
if self
's sign is negative, including -0.0
and
NEG_INFINITY
.
pub fn mul_add<Da: ?Sized, Ua: ?Sized, Ub: ?Sized>( | [src] |
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( | [src] |
Takes the reciprocal (inverse) of a number, 1/x
.
let f: Frequency = Time::new::<second>(1.0).recip();
pub fn powi<E>( | [src] |
Raises a quantity to an integer power.
let a: Area = Length::new::<meter>(3.0).powi(::uom::typenum::P2::new());
pub fn sqrt( | [src] |
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 | [src] |
Returns the maximum of the two quantities.
pub fn min(self, other: Self) -> Self where | [src] |
Returns the minimum of the two quantities.
Trait Implementations
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, usize>> for usize where
U: Units<usize>,
usize: Num + Conversion<usize>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, usize>> for usize where
U: Units<usize>,
usize: Num + Conversion<usize>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, u8>> for u8 where
U: Units<u8>,
u8: Num + Conversion<u8>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, u8>> for u8 where
U: Units<u8>,
u8: Num + Conversion<u8>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, u16>> for u16 where
U: Units<u16>,
u16: Num + Conversion<u16>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, u16>> for u16 where
U: Units<u16>,
u16: Num + Conversion<u16>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, u32>> for u32 where
U: Units<u32>,
u32: Num + Conversion<u32>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, u32>> for u32 where
U: Units<u32>,
u32: Num + Conversion<u32>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, u64>> for u64 where
U: Units<u64>,
u64: Num + Conversion<u64>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, u64>> for u64 where
U: Units<u64>,
u64: Num + Conversion<u64>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, isize>> for isize where
U: Units<isize>,
isize: Num + Conversion<isize>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, isize>> for isize where
U: Units<isize>,
isize: Num + Conversion<isize>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, i8>> for i8 where
U: Units<i8>,
i8: Num + Conversion<i8>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, i8>> for i8 where
U: Units<i8>,
i8: Num + Conversion<i8>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, i16>> for i16 where
U: Units<i16>,
i16: Num + Conversion<i16>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, i16>> for i16 where
U: Units<i16>,
i16: Num + Conversion<i16>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, i32>> for i32 where
U: Units<i32>,
i32: Num + Conversion<i32>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, i32>> for i32 where
U: Units<i32>,
i32: Num + Conversion<i32>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, i64>> for i64 where
U: Units<i64>,
i64: Num + Conversion<i64>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, i64>> for i64 where
U: Units<i64>,
i64: Num + Conversion<i64>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, BigInt>> for BigInt where
U: Units<BigInt>,
BigInt: Num + Conversion<BigInt>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, BigInt>> for BigInt where
U: Units<BigInt>,
BigInt: Num + Conversion<BigInt>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, BigUint>> for BigUint where
U: Units<BigUint>,
BigUint: Num + Conversion<BigUint>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, BigUint>> for BigUint where
U: Units<BigUint>,
BigUint: Num + Conversion<BigUint>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, Ratio<isize>>> for Rational where
U: Units<Rational>,
Rational: Num + Conversion<Rational>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, Ratio<isize>>> for Rational where
U: Units<Rational>,
Rational: Num + Conversion<Rational>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, Ratio<i32>>> for Rational32 where
U: Units<Rational32>,
Rational32: Num + Conversion<Rational32>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, Ratio<i32>>> for Rational32 where
U: Units<Rational32>,
Rational32: Num + Conversion<Rational32>,
fn from(t: Ratio<U, Rational32>) -> Self | [src] |
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, Ratio<i64>>> for Rational64 where
U: Units<Rational64>,
Rational64: Num + Conversion<Rational64>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, Ratio<i64>>> for Rational64 where
U: Units<Rational64>,
Rational64: Num + Conversion<Rational64>,
fn from(t: Ratio<U, Rational64>) -> Self | [src] |
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, Ratio<BigInt>>> for BigRational where
U: Units<BigRational>,
BigRational: Num + Conversion<BigRational>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, Ratio<BigInt>>> for BigRational where
U: Units<BigRational>,
BigRational: Num + Conversion<BigRational>,
fn from(t: Ratio<U, BigRational>) -> Self | [src] |
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, f32>> for f32 where
U: Units<f32>,
f32: Num + Conversion<f32>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, f32>> for f32 where
U: Units<f32>,
f32: Num + Conversion<f32>,
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, f64>> for f64 where
U: Units<f64>,
f64: Num + Conversion<f64>,
[src]
impl<U: ?Sized> From<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = Z0> + 'static, U, f64>> for f64 where
U: Units<f64>,
f64: Num + Conversion<f64>,
impl<D: ?Sized, U: ?Sized, V> Eq for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Eq,
[src]
impl<D: ?Sized, U: ?Sized, V> Eq for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Eq,
impl<D: ?Sized, 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]
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> PartialOrd<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + PartialOrd,
fn partial_cmp(&self, other: &Quantity<D, Ur, V>) -> Option<Ordering> | [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> Copy for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Copy,
[src]
impl<D: ?Sized, U: ?Sized, V> Copy for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Copy,
impl<D: ?Sized, U: ?Sized, V> Default for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Default,
[src]
impl<D: ?Sized, U: ?Sized, V> Default for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Default,
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]
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> PartialEq<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
fn eq(&self, other: &Quantity<D, Ur, V>) -> bool | [src] |
| 1.0.0 [src] |
This method tests for !=
.
impl<D: ?Sized, U: ?Sized, V> Clone for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Clone,
[src]
impl<D: ?Sized, U: ?Sized, V> Clone for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Clone,
fn clone(&self) -> Self | [src] |
fn clone_from(&mut self, source: &Self) | 1.0.0 [src] |
Performs copy-assignment from source
. Read more
impl<D: ?Sized, U: ?Sized, V> Ord for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Ord,
[src]
impl<D: ?Sized, U: ?Sized, V> Ord for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Ord,
fn cmp(&self, other: &Self) -> Ordering | [src] |
fn max(self, other: Self) -> Self | [src] |
fn min(self, other: Self) -> Self | [src] |
impl<D: ?Sized, U: ?Sized, V> Debug for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Debug,
[src]
impl<D: ?Sized, U: ?Sized, V> Debug for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Debug,
impl<D: ?Sized, U: ?Sized, V> Hash for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Hash,
[src]
impl<D: ?Sized, U: ?Sized, V> Hash for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Hash,
fn hash<H: Hasher>(&self, state: &mut H) | [src] |
fn hash_slice<H>(data: &[Self], state: &mut H) where | 1.3.0 [src] |
Feeds a slice of this type into the given [Hasher
]. Read more
impl<Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<dyn Dimension<Kind = dyn Temperature + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = PInt<UInt<UTerm, B1>>> + 'static, Ur, V>> for TemperatureInterval<Ul, V> where
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
[src]
impl<Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<dyn Dimension<Kind = dyn Temperature + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = PInt<UInt<UTerm, B1>>> + 'static, Ur, V>> for TemperatureInterval<Ul, V> where
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
type Output = ThermodynamicTemperature<Ul, V>
The resulting type after applying the +
operator.
fn add(self, rhs: ThermodynamicTemperature<Ur, V>) -> Self::Output | [src] |
impl<Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = PInt<UInt<UTerm, B1>>> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
[src]
impl<Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = PInt<UInt<UTerm, B1>>> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
type Output = ThermodynamicTemperature<Ul, V>
The resulting type after applying the +
operator.
fn add(self, rhs: TemperatureInterval<Ur, V>) -> Self::Output | [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]
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
D::Kind: Add,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
type Output = Quantity<D, Ul, V>
The resulting type after applying the +
operator.
fn add(self, rhs: Quantity<D, Ur, V>) -> Self::Output | [src] |
impl<Ul: ?Sized, Ur: ?Sized, V> Sub<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = PInt<UInt<UTerm, B1>>> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
[src]
impl<Ul: ?Sized, Ur: ?Sized, V> Sub<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = PInt<UInt<UTerm, B1>>> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
type Output = ThermodynamicTemperature<Ul, V>
The resulting type after applying the -
operator.
fn sub(self, rhs: TemperatureInterval<Ur, V>) -> Self::Output | [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]
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Sub<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
D::Kind: Sub,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
type Output = Quantity<D, Ul, V>
The resulting type after applying the -
operator.
fn sub(self, rhs: Quantity<D, Ur, V>) -> Self::Output | [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]
impl<Dl: ?Sized, Dr: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Mul<Quantity<Dr, Ur, V>> for Quantity<Dl, Ul, V> where
Dl: Dimension,
Dl::L: Add<Dr::L>,
Dl::M: Add<Dr::M>,
Dl::T: Add<Dr::T>,
Dl::I: Add<Dr::I>,
Dl::Th: Add<Dr::Th>,
Dl::N: Add<Dr::N>,
Dl::J: Add<Dr::J>,
Dl::Kind: Mul,
Dr: Dimension,
Dr::Kind: Mul,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + Mul<V>,
type Output = Quantity<ISQ<Sum<Dl::L, Dr::L>, Sum<Dl::M, Dr::M>, Sum<Dl::T, Dr::T>, Sum<Dl::I, Dr::I>, Sum<Dl::Th, Dr::Th>, Sum<Dl::N, Dr::N>, Sum<Dl::J, Dr::J>>, Ul, V>
The resulting type after applying the *
operator.
fn mul(self, rhs: Quantity<Dr, Ur, V>) -> Self::Output | [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]
impl<D: ?Sized, U: ?Sized, V> Mul<V> for Quantity<D, U, V> where
D: Dimension,
D::Kind: Mul,
U: Units<V>,
V: Num + Conversion<V>,
type Output = Quantity<D, U, V>
The resulting type after applying the *
operator.
fn mul(self, rhs: V) -> Self::Output | [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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, usize>> for usize where
D: Dimension,
D::Kind: Mul,
U: Units<usize>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u8>> for u8 where
D: Dimension,
D::Kind: Mul,
U: Units<u8>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u16>> for u16 where
D: Dimension,
D::Kind: Mul,
U: Units<u16>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u32>> for u32 where
D: Dimension,
D::Kind: Mul,
U: Units<u32>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u64>> for u64 where
D: Dimension,
D::Kind: Mul,
U: Units<u64>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, isize>> for isize where
D: Dimension,
D::Kind: Mul,
U: Units<isize>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i8>> for i8 where
D: Dimension,
D::Kind: Mul,
U: Units<i8>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i16>> for i16 where
D: Dimension,
D::Kind: Mul,
U: Units<i16>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i32>> for i32 where
D: Dimension,
D::Kind: Mul,
U: Units<i32>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i64>> for i64 where
D: Dimension,
D::Kind: Mul,
U: Units<i64>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, BigInt>> for BigInt where
D: Dimension,
D::Kind: Mul,
U: Units<BigInt>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, BigUint>> for BigUint where
D: Dimension,
D::Kind: Mul,
U: Units<BigUint>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<isize>>> for Rational where
D: Dimension,
D::Kind: Mul,
U: Units<Rational>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<i32>>> for Rational32 where
D: Dimension,
D::Kind: Mul,
U: Units<Rational32>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<i64>>> for Rational64 where
D: Dimension,
D::Kind: Mul,
U: Units<Rational64>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<BigInt>>> for BigRational where
D: Dimension,
D::Kind: Mul,
U: Units<BigRational>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, f32>> for f32 where
D: Dimension,
D::Kind: Mul,
U: Units<f32>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, f64>> for f64 where
D: Dimension,
D::Kind: Mul,
U: Units<f64>,
Z0: Add<D::L>,
Z0: Add<D::M>,
Z0: Add<D::T>,
Z0: Add<D::I>,
Z0: Add<D::Th>,
Z0: Add<D::N>,
Z0: Add<D::J>,
type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>>, 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]
impl<Dl: ?Sized, Dr: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Div<Quantity<Dr, Ur, V>> for Quantity<Dl, Ul, V> where
Dl: Dimension,
Dl::L: Sub<Dr::L>,
Dl::M: Sub<Dr::M>,
Dl::T: Sub<Dr::T>,
Dl::I: Sub<Dr::I>,
Dl::Th: Sub<Dr::Th>,
Dl::N: Sub<Dr::N>,
Dl::J: Sub<Dr::J>,
Dl::Kind: Div,
Dr: Dimension,
Dr::Kind: Div,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + Div<V>,
type Output = Quantity<ISQ<Diff<Dl::L, Dr::L>, Diff<Dl::M, Dr::M>, Diff<Dl::T, Dr::T>, Diff<Dl::I, Dr::I>, Diff<Dl::Th, Dr::Th>, Diff<Dl::N, Dr::N>, Diff<Dl::J, Dr::J>>, Ul, V>
The resulting type after applying the /
operator.
fn div(self, rhs: Quantity<Dr, Ur, V>) -> Self::Output | [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]
impl<D: ?Sized, U: ?Sized, V> Div<V> for Quantity<D, U, V> where
D: Dimension,
D::Kind: Div,
U: Units<V>,
V: Num + Conversion<V>,
type Output = Quantity<D, U, V>
The resulting type after applying the /
operator.
fn div(self, rhs: V) -> Self::Output | [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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, usize>> for usize where
D: Dimension,
D::Kind: Div,
U: Units<usize>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u8>> for u8 where
D: Dimension,
D::Kind: Div,
U: Units<u8>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u16>> for u16 where
D: Dimension,
D::Kind: Div,
U: Units<u16>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u32>> for u32 where
D: Dimension,
D::Kind: Div,
U: Units<u32>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u64>> for u64 where
D: Dimension,
D::Kind: Div,
U: Units<u64>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, isize>> for isize where
D: Dimension,
D::Kind: Div,
U: Units<isize>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i8>> for i8 where
D: Dimension,
D::Kind: Div,
U: Units<i8>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i16>> for i16 where
D: Dimension,
D::Kind: Div,
U: Units<i16>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i32>> for i32 where
D: Dimension,
D::Kind: Div,
U: Units<i32>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i64>> for i64 where
D: Dimension,
D::Kind: Div,
U: Units<i64>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, BigInt>> for BigInt where
D: Dimension,
D::Kind: Div,
U: Units<BigInt>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, BigUint>> for BigUint where
D: Dimension,
D::Kind: Div,
U: Units<BigUint>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<isize>>> for Rational where
D: Dimension,
D::Kind: Div,
U: Units<Rational>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<i32>>> for Rational32 where
D: Dimension,
D::Kind: Div,
U: Units<Rational32>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<i64>>> for Rational64 where
D: Dimension,
D::Kind: Div,
U: Units<Rational64>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<BigInt>>> for BigRational where
D: Dimension,
D::Kind: Div,
U: Units<BigRational>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, f32>> for f32 where
D: Dimension,
D::Kind: Div,
U: Units<f32>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, f64>> for f64 where
D: Dimension,
D::Kind: Div,
U: Units<f64>,
Z0: Sub<D::L>,
Z0: Sub<D::M>,
Z0: Sub<D::T>,
Z0: Sub<D::I>,
Z0: Sub<D::Th>,
Z0: Sub<D::N>,
Z0: Sub<D::J>,
type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>>, 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]
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Rem<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
D::Kind: Rem,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V>,
type Output = Quantity<D, Ul, V>
The resulting type after applying the %
operator.
fn rem(self, rhs: Quantity<D, Ur, V>) -> Self::Output | [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]
impl<D: ?Sized, U: ?Sized, V> Neg for Quantity<D, U, V> where
D: Dimension,
D::Kind: Neg,
U: Units<V>,
V: Signed + Conversion<V>,
type Output = Quantity<D, U, V>
The resulting type after applying the -
operator.
fn neg(self) -> Self::Output | [src] |
impl<Ul: ?Sized, Ur: ?Sized, V> AddAssign<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = PInt<UInt<UTerm, B1>>> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + AddAssign<V>,
[src]
impl<Ul: ?Sized, Ur: ?Sized, V> AddAssign<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = PInt<UInt<UTerm, B1>>> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + AddAssign<V>,
fn add_assign(&mut self, rhs: TemperatureInterval<Ur, V>) | [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]
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> AddAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
D::Kind: AddAssign,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + AddAssign<V>,
fn add_assign(&mut self, rhs: Quantity<D, Ur, V>) | [src] |
impl<Ul: ?Sized, Ur: ?Sized, V> SubAssign<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = PInt<UInt<UTerm, B1>>> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + SubAssign<V>,
[src]
impl<Ul: ?Sized, Ur: ?Sized, V> SubAssign<Quantity<dyn Dimension<Kind = dyn Kind + 'static, J = Z0, I = Z0, N = Z0, T = Z0, M = Z0, L = Z0, Th = PInt<UInt<UTerm, B1>>> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + SubAssign<V>,
fn sub_assign(&mut self, rhs: TemperatureInterval<Ur, V>) | [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]
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> SubAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
D::Kind: SubAssign,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + SubAssign<V>,
fn sub_assign(&mut self, rhs: Quantity<D, Ur, V>) | [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]
impl<D: ?Sized, U: ?Sized, V> MulAssign<V> for Quantity<D, U, V> where
D: Dimension,
D::Kind: MulAssign,
U: Units<V>,
V: Num + Conversion<V> + MulAssign<V>,
fn mul_assign(&mut self, rhs: V) | [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]
impl<D: ?Sized, U: ?Sized, V> DivAssign<V> for Quantity<D, U, V> where
D: Dimension,
D::Kind: DivAssign,
U: Units<V>,
V: Num + Conversion<V> + DivAssign<V>,
fn div_assign(&mut self, rhs: V) | [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]
impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> RemAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension,
D::Kind: RemAssign,
Ul: Units<V>,
Ur: Units<V>,
V: Num + Conversion<V> + RemAssign,
fn rem_assign(&mut self, rhs: Quantity<D, Ur, V>) | [src] |
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]
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,
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]
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>,
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]
impl<D: ?Sized, U: ?Sized, V> Saturating for Quantity<D, U, V> where
D: Dimension,
D::Kind: Saturating,
U: Units<V>,
V: Num + Conversion<V> + Saturating,
fn saturating_add(self, v: Self) -> Self | [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]
impl<D: ?Sized, U: ?Sized, V> Serialize for Quantity<D, U, V> where
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]
impl<'de, D: ?Sized, U: ?Sized, V> Deserialize<'de> for Quantity<D, U, V> where
D: Dimension,
U: Units<V>,
V: Num + Conversion<V> + Deserialize<'de>,
fn deserialize<De>(deserializer: De) -> Result<Self, De::Error> where | [src] |
Auto Trait Implementations
impl<D: ?Sized, U: ?Sized, V> Send for Quantity<D, U, V> where
V: Send,
impl<D: ?Sized, U: ?Sized, V> Send for Quantity<D, U, V> where
V: Send,
impl<D: ?Sized, U: ?Sized, V> Sync for Quantity<D, U, V> where
V: Sync,
impl<D: ?Sized, U: ?Sized, V> Sync for Quantity<D, U, V> where
V: Sync,
Blanket Implementations
impl<T> From for T
[src]
impl<T> From for T
impl<T, U> Into for T where
U: From<T>,
[src]
impl<T, U> Into for T where
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
impl<T> ToOwned for T where
T: Clone,
impl<T, U> TryFrom for T where
T: From<U>,
[src]
impl<T, U> TryFrom for T where
T: From<U>,
type Error = !
try_from
)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> Borrow for T where
T: ?Sized,
[src]
impl<T> Borrow for T where
T: ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
impl<T> BorrowMut for T where
T: ?Sized,
ⓘImportant traits for &'a mut W
fn borrow_mut(&mut self) -> &mut T | [src] |
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
try_from
)The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error> | [src] |
impl<T> Any for T where
T: 'static + ?Sized,
[src]
impl<T> Any for T where
T: 'static + ?Sized,
fn get_type_id(&self) -> TypeId | [src] |
impl<T, Rhs, Output> NumOps 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]
impl<T, Rhs, Output> NumOps for T where
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 for T where
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
[src]
impl<T, Rhs> NumAssignOps for T where
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,
impl<T> DeserializeOwned for T where
T: Deserialize<'de>,
[src]
impl<T> DeserializeOwned for T where
T: Deserialize<'de>,
impl<T> Same for T
[src]
impl<T> Same for T
type Output = T
Should always be Self