#[repr(transparent)]pub struct Quantity<D, U, V> where
D: Dimension + ?Sized,
U: Units<V> + ?Sized,
V: Num + Conversion<V>, {
pub dimension: PhantomData<D>,
pub units: PhantomData<U>,
pub value: V,
}Expand description
Property of a phenomenon, body or substance, where the property has a magnitude that can be expressed as a number and a reference.
The preferred method of creating a Quantity instance is to use the new constructor
which is generic over the input unit and accepts the input value as it’s only
parameter.
// Create a length of 1 meter.
let l = Length::new::<meter>(1.0);Quantity fields are public to allow for the creation of const values and instances
of non-named Quantitys. This functionality will be deprecated and subsequently removed
once the const fn feature is
stabilized.
// Create a `const` length of 1 meter.
const L: Length = Length { dimension: PhantomData, units: PhantomData, value: 1.0, };
// Create a `const` area of 1 square meter explicitly without using the `Area` alias.
const A: Quantity<ISQ<P2, Z0, Z0, Z0, Z0, Z0, Z0>, SI<f32>, f32> =
Quantity { dimension: PhantomData, units: PhantomData, value: 1.0, };Using units for the wrong quantity will cause a compile error:
// error[E0277]: the trait bound `second: length::Unit` is not satisfied
let l = Length::new::<second>(1.0);Mixing quantities will also cause a compile error:
// error[E0308]: mismatched types
let r = Length::new::<meter>(1.0) + Time::new::<second>(1.0);// error[E0308]: mismatched types
let v: Velocity = Length::new::<meter>(1.0) * Time::new::<second>(1.0);Generic Parameters
Fields
dimension: PhantomData<D>Quantity dimension. See Dimension.
units: PhantomData<U>Quantity base units. See Units.
value: VQuantity value stored in the base units for the quantity.
Implementations
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Implementation of various stdlib trigonometric functions
Computes the value of both the sine and cosine of the angle.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
impl<U, V> Quantity<dyn Dimension<T = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, Kind = dyn Kind + 'static, J = Z0, N = Z0, Th = Z0, I = PInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, L = NInt<UInt<UInt<UTerm, B1>, B0>>> + 'static, U, V> where
U: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<U, V> Quantity<dyn Dimension<T = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, Kind = dyn Kind + 'static, J = Z0, N = Z0, Th = Z0, I = PInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, L = NInt<UInt<UInt<UTerm, B1>, B0>>> + 'static, U, V> where
U: Units<V> + ?Sized,
V: Num + Conversion<V>,
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
impl<U, V> Quantity<dyn Dimension<T = NInt<UInt<UInt<UTerm, B1>, B0>>, Kind = dyn Kind + 'static, J = Z0, N = NInt<UInt<UTerm, B1>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, L = PInt<UInt<UInt<UTerm, B1>, B0>>> + 'static, U, V> where
U: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<U, V> Quantity<dyn Dimension<T = NInt<UInt<UInt<UTerm, B1>, B0>>, Kind = dyn Kind + 'static, J = Z0, N = NInt<UInt<UTerm, B1>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, L = PInt<UInt<UInt<UTerm, B1>, B0>>> + 'static, U, V> where
U: Units<V> + ?Sized,
V: Num + Conversion<V>,
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Implementation of various stdlib inverse trigonometric functions
Computes the value of the inverse hyperbolic cosine of the ratio.
Computes the value of the inverse hyperbolic sine of the ratio.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns the largest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the smallest integer less than or equal to a number in the given measurement unit.
Generic Parameters
N: Unit.
Returns the nearest integer to a number in the in given measurement unit. Round half-way cases away from 0.0.
Generic Parameters
N: Unit.
Creates a struct that can be used to format a compatible quantity for display.
Notes
The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.
If you do not need to format multiple quantities, consider using
into_format_args instead.
Examples
let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);
assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));Generic Parameters
N: Unit.
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
pub fn into_format_args<N>(
self,
unit: N,
style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
N: Unit,
Creates a struct that formats self for display.
Notes
Unlike format_args, the return value of this method can be
used directly for display. It will format the value of self for the quantity on
which it is called and nothing else.
If you wish to reuse the return value to format multiple quantities, use
format_args instead.
Examples
let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);
assert_eq!("100 femtoseconds", format!("{}", a));Generic Parameters
N: Unit.
Returns true if this value is NAN and false otherwise.
Returns true if this value is positive infinity or negative infinity and
false otherwise.
Returns true if this number is neither infinite nor NAN.
Returns true if the number is neither zero, infinite, subnormal, or NAN.
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::L as PartialDiv<P3>>::Output: Integer,
D::M: PartialDiv<P3>,
<D::M as PartialDiv<P3>>::Output: Integer,
D::T: PartialDiv<P3>,
<D::T as PartialDiv<P3>>::Output: Integer,
D::I: PartialDiv<P3>,
<D::I as PartialDiv<P3>>::Output: Integer,
D::Th: PartialDiv<P3>,
<D::Th as PartialDiv<P3>>::Output: Integer,
D::N: PartialDiv<P3>,
<D::N as PartialDiv<P3>>::Output: Integer,
D::J: PartialDiv<P3>,
<D::J as PartialDiv<P3>>::Output: Integer,
D::Kind: Div,
V: Float,
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::L as PartialDiv<P3>>::Output: Integer,
D::M: PartialDiv<P3>,
<D::M as PartialDiv<P3>>::Output: Integer,
D::T: PartialDiv<P3>,
<D::T as PartialDiv<P3>>::Output: Integer,
D::I: PartialDiv<P3>,
<D::I as PartialDiv<P3>>::Output: Integer,
D::Th: PartialDiv<P3>,
<D::Th as PartialDiv<P3>>::Output: Integer,
D::N: PartialDiv<P3>,
<D::N as PartialDiv<P3>>::Output: Integer,
D::J: PartialDiv<P3>,
<D::J as PartialDiv<P3>>::Output: Integer,
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();Calculates the length of the hypotenuse of a right-angle triangle given the legs.
Computes the absolute value of self. Returns NAN if the quantity is
NAN.
Returns a quantity that represents the sign of self.
1.0of the base unit if the number is positive,+0.0, orINFINITY.-1.0of the base unit if the number is negative,-0.0, orNEG_INFINITY.NANif the number isNAN.
Returns true if self’s sign bit is positive, including +0.0 and
INFINITY.
Returns true if self’s sign is negative, including -0.0 and
NEG_INFINITY.
pub fn mul_add<Da, Ua, Ub>(
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::L as Add<Da::L>>::Output: Integer,
D::M: Add<Da::M>,
<D::M as Add<Da::M>>::Output: Integer,
D::T: Add<Da::T>,
<D::T as Add<Da::T>>::Output: Integer,
D::I: Add<Da::I>,
<D::I as Add<Da::I>>::Output: Integer,
D::Th: Add<Da::Th>,
<D::Th as Add<Da::Th>>::Output: Integer,
D::N: Add<Da::N>,
<D::N as Add<Da::N>>::Output: Integer,
D::J: Add<Da::J>,
<D::J as Add<Da::J>>::Output: Integer,
D::Kind: Mul,
V: Float,
Da: Dimension + ?Sized,
Da::Kind: Mul,
Ua: Units<V> + ?Sized,
Ub: Units<V> + ?Sized,
pub fn mul_add<Da, Ua, Ub>(
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::L as Add<Da::L>>::Output: Integer,
D::M: Add<Da::M>,
<D::M as Add<Da::M>>::Output: Integer,
D::T: Add<Da::T>,
<D::T as Add<Da::T>>::Output: Integer,
D::I: Add<Da::I>,
<D::I as Add<Da::I>>::Output: Integer,
D::Th: Add<Da::Th>,
<D::Th as Add<Da::Th>>::Output: Integer,
D::N: Add<Da::N>,
<D::N as Add<Da::N>>::Output: Integer,
D::J: Add<Da::J>,
<D::J as Add<Da::J>>::Output: Integer,
D::Kind: Mul,
V: Float,
Da: Dimension + ?Sized,
Da::Kind: Mul,
Ua: Units<V> + ?Sized,
Ub: Units<V> + ?Sized,
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.
Generic Parameters
Da: Dimension for parametera.Ua: Base units for parametera.Ub: Base units for parameterb.
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::L as Neg>::Output: Integer,
D::M: Neg,
<D::M as Neg>::Output: Integer,
D::T: Neg,
<D::T as Neg>::Output: Integer,
D::I: Neg,
<D::I as Neg>::Output: Integer,
D::Th: Neg,
<D::Th as Neg>::Output: Integer,
D::N: Neg,
<D::N as Neg>::Output: Integer,
D::J: Neg,
<D::J as Neg>::Output: Integer,
D::Kind: Div,
V: Float,
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::L as Neg>::Output: Integer,
D::M: Neg,
<D::M as Neg>::Output: Integer,
D::T: Neg,
<D::T as Neg>::Output: Integer,
D::I: Neg,
<D::I as Neg>::Output: Integer,
D::Th: Neg,
<D::Th as Neg>::Output: Integer,
D::N: Neg,
<D::N as Neg>::Output: Integer,
D::J: Neg,
<D::J as Neg>::Output: Integer,
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::L as Mul<E>>::Output: Integer,
D::M: Mul<E>,
<D::M as Mul<E>>::Output: Integer,
D::T: Mul<E>,
<D::T as Mul<E>>::Output: Integer,
D::I: Mul<E>,
<D::I as Mul<E>>::Output: Integer,
D::Th: Mul<E>,
<D::Th as Mul<E>>::Output: Integer,
D::N: Mul<E>,
<D::N as Mul<E>>::Output: Integer,
D::J: Mul<E>,
<D::J as Mul<E>>::Output: Integer,
D::Kind: Mul,
E: Integer,
V: Float,
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::L as Mul<E>>::Output: Integer,
D::M: Mul<E>,
<D::M as Mul<E>>::Output: Integer,
D::T: Mul<E>,
<D::T as Mul<E>>::Output: Integer,
D::I: Mul<E>,
<D::I as Mul<E>>::Output: Integer,
D::Th: Mul<E>,
<D::Th as Mul<E>>::Output: Integer,
D::N: Mul<E>,
<D::N as Mul<E>>::Output: Integer,
D::J: Mul<E>,
<D::J as Mul<E>>::Output: Integer,
D::Kind: Mul,
E: Integer,
V: Float,
Raises a quantity to an integer power.
use uom::typenum::P2;
let a: Area = Length::new::<meter>(3.0).powi(P2::new());Generic Parameters
E:typenum::Integerpower.
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::L as PartialDiv<P2>>::Output: Integer,
D::M: PartialDiv<P2>,
<D::M as PartialDiv<P2>>::Output: Integer,
D::T: PartialDiv<P2>,
<D::T as PartialDiv<P2>>::Output: Integer,
D::I: PartialDiv<P2>,
<D::I as PartialDiv<P2>>::Output: Integer,
D::Th: PartialDiv<P2>,
<D::Th as PartialDiv<P2>>::Output: Integer,
D::N: PartialDiv<P2>,
<D::N as PartialDiv<P2>>::Output: Integer,
D::J: PartialDiv<P2>,
<D::J as PartialDiv<P2>>::Output: Integer,
D::Kind: Div,
V: Float,
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::L as PartialDiv<P2>>::Output: Integer,
D::M: PartialDiv<P2>,
<D::M as PartialDiv<P2>>::Output: Integer,
D::T: PartialDiv<P2>,
<D::T as PartialDiv<P2>>::Output: Integer,
D::I: PartialDiv<P2>,
<D::I as PartialDiv<P2>>::Output: Integer,
D::Th: PartialDiv<P2>,
<D::Th as PartialDiv<P2>>::Output: Integer,
D::N: PartialDiv<P2>,
<D::N as PartialDiv<P2>>::Output: Integer,
D::J: PartialDiv<P2>,
<D::J as PartialDiv<P2>>::Output: Integer,
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();Returns the maximum of the two quantities.
Trait Implementations
type Output = ThermodynamicTemperature<Ul, V>
type Output = ThermodynamicTemperature<Ul, V>
The resulting type after applying the + operator.
Performs the + operation. Read more
type Output = ThermodynamicTemperature<Ul, V>
type Output = ThermodynamicTemperature<Ul, V>
The resulting type after applying the + operator.
Performs the + operation. Read more
Performs the += operation. Read more
Performs the += operation. Read more
impl<'de, D, U, V> Deserialize<'de> for Quantity<D, U, V> where
D: Dimension + ?Sized,
U: Units<V> + ?Sized,
V: Num + Conversion<V> + Deserialize<'de>,
impl<'de, D, U, V> Deserialize<'de> for Quantity<D, U, V> where
D: Dimension + ?Sized,
U: Units<V> + ?Sized,
V: Num + Conversion<V> + Deserialize<'de>,
Deserialize this value from the given Serde deserializer. Read more
impl<D, U> Div<Quantity<D, U, BigInt>> for BigInt where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<BigInt> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, BigInt>> for BigInt where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<BigInt> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, BigUint>> for BigUint where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<BigUint> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, BigUint>> for BigUint where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<BigUint> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, Ratio<BigInt>>> for BigRational where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<BigRational> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, Ratio<BigInt>>> for BigRational where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<BigRational> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, Ratio<i32>>> for Rational32 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<Rational32> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, Ratio<i32>>> for Rational32 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<Rational32> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, Ratio<i64>>> for Rational64 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<Rational64> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, Ratio<i64>>> for Rational64 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<Rational64> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, f32>> for f32 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<f32> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, f32>> for f32 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<f32> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, f64>> for f64 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<f64> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, f64>> for f64 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<f64> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, i32>> for i32 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<i32> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, i32>> for i32 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<i32> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, i64>> for i64 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<i64> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, i64>> for i64 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<i64> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, isize>> for isize where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<isize> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, isize>> for isize where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<isize> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, u32>> for u32 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<u32> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, u32>> for u32 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<u32> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, u64>> for u64 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<u64> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, u64>> for u64 where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<u64> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<D, U> Div<Quantity<D, U, usize>> for usize where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<usize> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, usize>> for usize where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<usize> + ?Sized,
Z0: Sub<D::L>,
<Z0 as Sub<D::L>>::Output: Integer,
Z0: Sub<D::M>,
<Z0 as Sub<D::M>>::Output: Integer,
Z0: Sub<D::T>,
<Z0 as Sub<D::T>>::Output: Integer,
Z0: Sub<D::I>,
<Z0 as Sub<D::I>>::Output: Integer,
Z0: Sub<D::Th>,
<Z0 as Sub<D::Th>>::Output: Integer,
Z0: Sub<D::N>,
<Z0 as Sub<D::N>>::Output: Integer,
Z0: Sub<D::J>,
<Z0 as Sub<D::J>>::Output: Integer,
The resulting type after applying the / operator.
impl<Dl, Dr, Ul, Ur, V> Div<Quantity<Dr, Ur, V>> for Quantity<Dl, Ul, V> where
Dl: Dimension + ?Sized,
Dl::L: Sub<Dr::L>,
<Dl::L as Sub<Dr::L>>::Output: Integer,
Dl::M: Sub<Dr::M>,
<Dl::M as Sub<Dr::M>>::Output: Integer,
Dl::T: Sub<Dr::T>,
<Dl::T as Sub<Dr::T>>::Output: Integer,
Dl::I: Sub<Dr::I>,
<Dl::I as Sub<Dr::I>>::Output: Integer,
Dl::Th: Sub<Dr::Th>,
<Dl::Th as Sub<Dr::Th>>::Output: Integer,
Dl::N: Sub<Dr::N>,
<Dl::N as Sub<Dr::N>>::Output: Integer,
Dl::J: Sub<Dr::J>,
<Dl::J as Sub<Dr::J>>::Output: Integer,
Dl::Kind: Div,
Dr: Dimension + ?Sized,
Dr::Kind: Div,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V> + Div<V>,
impl<Dl, Dr, Ul, Ur, V> Div<Quantity<Dr, Ur, V>> for Quantity<Dl, Ul, V> where
Dl: Dimension + ?Sized,
Dl::L: Sub<Dr::L>,
<Dl::L as Sub<Dr::L>>::Output: Integer,
Dl::M: Sub<Dr::M>,
<Dl::M as Sub<Dr::M>>::Output: Integer,
Dl::T: Sub<Dr::T>,
<Dl::T as Sub<Dr::T>>::Output: Integer,
Dl::I: Sub<Dr::I>,
<Dl::I as Sub<Dr::I>>::Output: Integer,
Dl::Th: Sub<Dr::Th>,
<Dl::Th as Sub<Dr::Th>>::Output: Integer,
Dl::N: Sub<Dr::N>,
<Dl::N as Sub<Dr::N>>::Output: Integer,
Dl::J: Sub<Dr::J>,
<Dl::J as Sub<Dr::J>>::Output: Integer,
Dl::Kind: Div,
Dr: Dimension + ?Sized,
Dr::Kind: Div,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V> + Div<V>,
The resulting type after applying the / operator.
Performs the /= operation. Read more
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn AngleKind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + '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
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn AngleKind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + '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
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn ConstituentConcentrationKind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + '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
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn ConstituentConcentrationKind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + '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
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn InformationKind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + '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
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn InformationKind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + '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
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn Kind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + '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
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn Kind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + '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
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn Kind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn SolidAngleKind>, Ul, V> where
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn Kind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn SolidAngleKind>, Ul, V> where
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn Kind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn InformationKind>, Ul, V> where
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn Kind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn InformationKind>, Ul, V> where
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn Kind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn ConstituentConcentrationKind>, Ul, V> where
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn Kind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn ConstituentConcentrationKind>, Ul, V> where
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn SolidAngleKind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + '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
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<T = T, Kind = dyn SolidAngleKind + 'static, J = J, N = N, Th = Th, I = I, M = M, L = L> + '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
L: Integer,
M: Integer,
T: Integer,
I: Integer,
Th: Integer,
N: Integer,
J: Integer,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V>,
impl<U> From<Quantity<dyn Dimension<T = Z0, Kind = dyn Kind + 'static, J = Z0, N = Z0, Th = Z0, I = Z0, M = Z0, L = Z0> + 'static, U, Ratio<BigInt>>> for BigRational where
U: Units<BigRational> + ?Sized,
BigRational: Num + Conversion<BigRational>,
impl<U> From<Quantity<dyn Dimension<T = Z0, Kind = dyn Kind + 'static, J = Z0, N = Z0, Th = Z0, I = Z0, M = Z0, L = Z0> + 'static, U, Ratio<BigInt>>> for BigRational where
U: Units<BigRational> + ?Sized,
BigRational: Num + Conversion<BigRational>,
Performs the conversion.
impl<U> From<Quantity<dyn Dimension<T = Z0, Kind = dyn Kind + 'static, J = Z0, N = Z0, Th = Z0, I = Z0, M = Z0, L = Z0> + 'static, U, Ratio<i32>>> for Rational32 where
U: Units<Rational32> + ?Sized,
Rational32: Num + Conversion<Rational32>,
impl<U> From<Quantity<dyn Dimension<T = Z0, Kind = dyn Kind + 'static, J = Z0, N = Z0, Th = Z0, I = Z0, M = Z0, L = Z0> + 'static, U, Ratio<i32>>> for Rational32 where
U: Units<Rational32> + ?Sized,
Rational32: Num + Conversion<Rational32>,
Performs the conversion.
impl<U> From<Quantity<dyn Dimension<T = Z0, Kind = dyn Kind + 'static, J = Z0, N = Z0, Th = Z0, I = Z0, M = Z0, L = Z0> + 'static, U, Ratio<i64>>> for Rational64 where
U: Units<Rational64> + ?Sized,
Rational64: Num + Conversion<Rational64>,
impl<U> From<Quantity<dyn Dimension<T = Z0, Kind = dyn Kind + 'static, J = Z0, N = Z0, Th = Z0, I = Z0, M = Z0, L = Z0> + 'static, U, Ratio<i64>>> for Rational64 where
U: Units<Rational64> + ?Sized,
Rational64: Num + Conversion<Rational64>,
Performs the conversion.
impl<D, U> Mul<Quantity<D, U, BigInt>> for BigInt where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<BigInt> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, BigInt>> for BigInt where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<BigInt> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
The resulting type after applying the * operator.
impl<D, U> Mul<Quantity<D, U, BigUint>> for BigUint where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<BigUint> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, BigUint>> for BigUint where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<BigUint> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
The resulting type after applying the * operator.
impl<D, U> Mul<Quantity<D, U, Ratio<BigInt>>> for BigRational where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<BigRational> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, Ratio<BigInt>>> for BigRational where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<BigRational> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
The resulting type after applying the * operator.
impl<D, U> Mul<Quantity<D, U, Ratio<i32>>> for Rational32 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<Rational32> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, Ratio<i32>>> for Rational32 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<Rational32> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
The resulting type after applying the * operator.
impl<D, U> Mul<Quantity<D, U, Ratio<i64>>> for Rational64 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<Rational64> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, Ratio<i64>>> for Rational64 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<Rational64> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
The resulting type after applying the * operator.
impl<D, U> Mul<Quantity<D, U, f32>> for f32 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<f32> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, f32>> for f32 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<f32> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, f64>> for f64 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<f64> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, f64>> for f64 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<f64> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, i32>> for i32 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<i32> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, i32>> for i32 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<i32> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, i64>> for i64 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<i64> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, i64>> for i64 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<i64> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, isize>> for isize where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<isize> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, isize>> for isize where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<isize> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, u32>> for u32 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<u32> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, u32>> for u32 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<u32> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, u64>> for u64 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<u64> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, u64>> for u64 where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<u64> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, usize>> for usize where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<usize> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, usize>> for usize where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<usize> + ?Sized,
Z0: Add<D::L>,
<Z0 as Add<D::L>>::Output: Integer,
Z0: Add<D::M>,
<Z0 as Add<D::M>>::Output: Integer,
Z0: Add<D::T>,
<Z0 as Add<D::T>>::Output: Integer,
Z0: Add<D::I>,
<Z0 as Add<D::I>>::Output: Integer,
Z0: Add<D::Th>,
<Z0 as Add<D::Th>>::Output: Integer,
Z0: Add<D::N>,
<Z0 as Add<D::N>>::Output: Integer,
Z0: Add<D::J>,
<Z0 as Add<D::J>>::Output: Integer,
impl<Dl, Dr, Ul, Ur, V> Mul<Quantity<Dr, Ur, V>> for Quantity<Dl, Ul, V> where
Dl: Dimension + ?Sized,
Dl::L: Add<Dr::L>,
<Dl::L as Add<Dr::L>>::Output: Integer,
Dl::M: Add<Dr::M>,
<Dl::M as Add<Dr::M>>::Output: Integer,
Dl::T: Add<Dr::T>,
<Dl::T as Add<Dr::T>>::Output: Integer,
Dl::I: Add<Dr::I>,
<Dl::I as Add<Dr::I>>::Output: Integer,
Dl::Th: Add<Dr::Th>,
<Dl::Th as Add<Dr::Th>>::Output: Integer,
Dl::N: Add<Dr::N>,
<Dl::N as Add<Dr::N>>::Output: Integer,
Dl::J: Add<Dr::J>,
<Dl::J as Add<Dr::J>>::Output: Integer,
Dl::Kind: Mul,
Dr: Dimension + ?Sized,
Dr::Kind: Mul,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V> + Mul<V>,
impl<Dl, Dr, Ul, Ur, V> Mul<Quantity<Dr, Ur, V>> for Quantity<Dl, Ul, V> where
Dl: Dimension + ?Sized,
Dl::L: Add<Dr::L>,
<Dl::L as Add<Dr::L>>::Output: Integer,
Dl::M: Add<Dr::M>,
<Dl::M as Add<Dr::M>>::Output: Integer,
Dl::T: Add<Dr::T>,
<Dl::T as Add<Dr::T>>::Output: Integer,
Dl::I: Add<Dr::I>,
<Dl::I as Add<Dr::I>>::Output: Integer,
Dl::Th: Add<Dr::Th>,
<Dl::Th as Add<Dr::Th>>::Output: Integer,
Dl::N: Add<Dr::N>,
<Dl::N as Add<Dr::N>>::Output: Integer,
Dl::J: Add<Dr::J>,
<Dl::J as Add<Dr::J>>::Output: Integer,
Dl::Kind: Mul,
Dr: Dimension + ?Sized,
Dr::Kind: Mul,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V> + Mul<V>,
The resulting type after applying the * operator.
Performs the *= operation. Read more
impl<D, Ul, Ur, V> PartialOrd<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension + ?Sized,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V> + PartialOrd,
impl<D, Ul, Ur, V> PartialOrd<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
D: Dimension + ?Sized,
Ul: Units<V> + ?Sized,
Ur: Units<V> + ?Sized,
V: Num + Conversion<V> + PartialOrd,
This method returns an ordering between self and other values if one exists. Read more
This method tests less than (for self and other) and is used by the < operator. Read more
This method tests less than or equal to (for self and other) and is used by the <=
operator. Read more
This method tests greater than (for self and other) and is used by the > operator. Read more
Performs the %= operation. Read more
impl<D, U, V> Saturating for Quantity<D, U, V> where
D: Dimension + ?Sized,
D::Kind: Saturating,
U: Units<V> + ?Sized,
V: Num + Conversion<V> + Saturating,
impl<D, U, V> Saturating for Quantity<D, U, V> where
D: Dimension + ?Sized,
D::Kind: Saturating,
U: Units<V> + ?Sized,
V: Num + Conversion<V> + Saturating,
type Output = ThermodynamicTemperature<Ul, V>
type Output = ThermodynamicTemperature<Ul, V>
The resulting type after applying the - operator.
Performs the - operation. Read more
Performs the -= operation. Read more
Performs the -= operation. Read more
impl<U, V> TryFrom<Quantity<dyn Dimension<T = PInt<UInt<UTerm, B1>>, Kind = dyn Kind + 'static, J = Z0, N = Z0, Th = Z0, I = Z0, M = Z0, L = Z0> + 'static, U, V>> for Duration where
U: Units<V> + ?Sized,
V: Num + Conversion<V> + PartialOrd + ToPrimitive,
second: Conversion<V, T = V::T>,
nanosecond: Conversion<V, T = V::T>,
impl<U, V> TryFrom<Quantity<dyn Dimension<T = PInt<UInt<UTerm, B1>>, Kind = dyn Kind + 'static, J = Z0, N = Z0, Th = Z0, I = Z0, M = Z0, L = Z0> + 'static, U, V>> for Duration where
U: Units<V> + ?Sized,
V: Num + Conversion<V> + PartialOrd + ToPrimitive,
second: Conversion<V, T = V::T>,
nanosecond: Conversion<V, T = V::T>,
Attempt to convert the given Time to a Duration.
For possible failure modes see TryFromError.
Notes
The Duration to Time conversion is tested to be accurate to within 1 nanosecond (to allow
for floating point rounding error). If greater precision is needed, consider using a different
underlying storage type or avoiding the conversion altogether.
Auto Trait Implementations
impl<D: ?Sized, U: ?Sized, V> RefUnwindSafe for Quantity<D, U, V> where
V: RefUnwindSafe,
impl<D: ?Sized, U: ?Sized, V> UnwindSafe for Quantity<D, U, V> where
V: UnwindSafe,
Blanket Implementations
Mutably borrows from an owned value. Read more