#[repr(transparent)]pub struct Quantity<D, U, 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 Quantity
s. This functionality will be deprecated and subsequently removed
once the const fn
feature is
stabilized.
// Create a `const` length of 1 meter.
const L: Length = Length { dimension: PhantomData, units: PhantomData, value: 1.0, };
// Create a `const` area of 1 square meter explicitly without using the `Area` alias.
const A: Quantity<ISQ<P2, Z0, Z0, Z0, Z0, Z0, Z0>, SI<f32>, f32> =
Quantity { dimension: PhantomData, units: PhantomData, value: 1.0, };
Using units for the wrong quantity will cause a compile error:
// error[E0277]: the trait bound `second: length::Unit` is not satisfied
let l = Length::new::<second>(1.0);
Mixing quantities will also cause a compile error:
// error[E0308]: mismatched types
let r = Length::new::<meter>(1.0) + Time::new::<second>(1.0);
// error[E0308]: mismatched types
let v: Velocity = Length::new::<meter>(1.0) * Time::new::<second>(1.0);
§Generic Parameters
Fields§
§dimension: PhantomData<D>
Quantity dimension. See Dimension
.
units: PhantomData<U>
Quantity base units. See Units
.
value: V
Quantity value stored in the base units for the quantity.
Implementations§
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, T = PInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, T = PInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, Th = Z0, I = PInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, Th = Z0, I = PInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = NInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = NInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = NInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = NInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, Th = Z0, I = PInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, Th = Z0, I = PInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = NInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = NInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = PInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = PInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = PInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = PInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = PInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = PInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = PInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = PInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = NInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = NInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = NInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = NInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = NInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = NInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn InformationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn InformationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn InformationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn InformationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = PInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = PInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = PInt<UInt<UTerm, B1>>, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = PInt<UInt<UTerm, B1>>, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = PInt<UInt<UTerm, B1>>, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = PInt<UInt<UTerm, B1>>, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = NInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = NInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = NInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = NInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = NInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = NInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = NInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = NInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = PInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = NInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = NInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = NInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = NInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = NInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = NInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = NInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = NInt<UInt<UTerm, B1>>, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn SolidAngleKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn SolidAngleKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = Z0, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = Z0, I = PInt<UInt<UTerm, B1>>, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UInt<UTerm, B1>, B1>>, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B0>>, T = PInt<UInt<UInt<UTerm, B1>, B1>>, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn TemperatureKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn TemperatureKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = Z0, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = Z0, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B0>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn AngleKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UTerm, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = PInt<UInt<UInt<UTerm, B1>, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>, T = PInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>, T = PInt<UInt<UInt<UTerm, B1>, B0>>, Th = Z0, I = Z0, M = NInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, Th = NInt<UInt<UTerm, B1>>, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UInt<UTerm, B1>, B1>>, T = NInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn ConstituentConcentrationKind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
impl<U, V> Quantity<dyn Dimension<L = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, Th = Z0, I = Z0, M = PInt<UInt<UTerm, B1>>, N = Z0, J = Z0, Kind = dyn Kind>, U, V>
sourcepub fn floor<N>(self) -> Self
pub fn floor<N>(self) -> Self
Returns the largest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn ceil<N>(self) -> Self
pub fn ceil<N>(self) -> Self
Returns the smallest integer less than or equal to a number in the given measurement unit.
§Generic Parameters
N
: Unit.
sourcepub fn round<N>(self) -> Self
pub fn round<N>(self) -> Self
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.
sourcepub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
N: Unit,
pub fn format_args<N>(_unit: N, style: DisplayStyle) -> Arguments<Dimension, N>where
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.
sourcepub 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.
source§impl<D, U, V> Quantity<D, U, V>
impl<D, U, V> Quantity<D, U, V>
sourcepub fn classify(self) -> FpCategorywhere
V: Float,
pub fn classify(self) -> FpCategorywhere
V: Float,
Returns the floating point category of the number. If only one property is going to be tested, it is generally faster to use the specific predicate instead.
sourcepub fn abs(self) -> Selfwhere
V: Signed,
pub fn abs(self) -> Selfwhere
V: Signed,
Computes the absolute value of self
. Returns NAN
if the quantity is
NAN
.
sourcepub fn signum(self) -> Selfwhere
V: Signed,
pub fn signum(self) -> Selfwhere
V: Signed,
Returns a quantity that represents the sign of self
.
1.0
of the base unit if the number is positive,+0.0
, orINFINITY
.-1.0
of the base unit if the number is negative,-0.0
, orNEG_INFINITY
.NAN
if the number isNAN
.
sourcepub fn is_sign_positive(self) -> boolwhere
V: Float,
pub fn is_sign_positive(self) -> boolwhere
V: Float,
Returns true
if self
’s sign bit is positive, including +0.0
and
INFINITY
.
sourcepub fn is_sign_negative(self) -> boolwhere
V: Float,
pub fn is_sign_negative(self) -> boolwhere
V: Float,
Returns true
if self
’s sign is negative, including -0.0
and
NEG_INFINITY
.
sourcepub 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();
Trait Implementations§
source§impl<Ul, Ur, V> Add<Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, Ur, V>> for ThermodynamicTemperature<Ul, V>
impl<Ul, Ur, V> Add<Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, Ur, V>> for ThermodynamicTemperature<Ul, V>
source§impl<Ul, Ur, V> Add<Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn TemperatureKind>, Ur, V>> for TemperatureInterval<Ul, V>
impl<Ul, Ur, V> Add<Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn TemperatureKind>, Ur, V>> for TemperatureInterval<Ul, V>
source§impl<D, Ul, Ur, V> AddAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V>
impl<D, Ul, Ur, V> AddAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V>
source§fn add_assign(&mut self, rhs: Quantity<D, Ur, V>)
fn add_assign(&mut self, rhs: Quantity<D, Ur, V>)
+=
operation. Read moresource§impl<Ul, Ur, V> AddAssign<Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, Ur, V>> for ThermodynamicTemperature<Ul, V>
impl<Ul, Ur, V> AddAssign<Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, Ur, V>> for ThermodynamicTemperature<Ul, V>
source§fn add_assign(&mut self, rhs: TemperatureInterval<Ur, V>)
fn add_assign(&mut self, rhs: TemperatureInterval<Ur, V>)
+=
operation. Read moresource§impl<D, U> Div<Quantity<D, U, u16>> for u16where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<u16> + ?Sized,
Z0: Sub<D::L> + Sub<D::M> + Sub<D::T> + Sub<D::I> + Sub<D::Th> + Sub<D::N> + Sub<D::J>,
<Z0 as Sub<D::L>>::Output: Integer,
<Z0 as Sub<D::M>>::Output: Integer,
<Z0 as Sub<D::T>>::Output: Integer,
<Z0 as Sub<D::I>>::Output: Integer,
<Z0 as Sub<D::Th>>::Output: Integer,
<Z0 as Sub<D::N>>::Output: Integer,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, u16>> for u16where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<u16> + ?Sized,
Z0: Sub<D::L> + Sub<D::M> + Sub<D::T> + Sub<D::I> + Sub<D::Th> + Sub<D::N> + Sub<D::J>,
<Z0 as Sub<D::L>>::Output: Integer,
<Z0 as Sub<D::M>>::Output: Integer,
<Z0 as Sub<D::T>>::Output: Integer,
<Z0 as Sub<D::I>>::Output: Integer,
<Z0 as Sub<D::Th>>::Output: Integer,
<Z0 as Sub<D::N>>::Output: Integer,
<Z0 as Sub<D::J>>::Output: Integer,
§type Output = Quantity<dyn Dimension<L = <Z0 as Sub<<D as Dimension>::L>>::Output, T = <Z0 as Sub<<D as Dimension>::T>>::Output, Th = <Z0 as Sub<<D as Dimension>::Th>>::Output, I = <Z0 as Sub<<D as Dimension>::I>>::Output, M = <Z0 as Sub<<D as Dimension>::M>>::Output, N = <Z0 as Sub<<D as Dimension>::N>>::Output, J = <Z0 as Sub<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u16>
type Output = Quantity<dyn Dimension<L = <Z0 as Sub<<D as Dimension>::L>>::Output, T = <Z0 as Sub<<D as Dimension>::T>>::Output, Th = <Z0 as Sub<<D as Dimension>::Th>>::Output, I = <Z0 as Sub<<D as Dimension>::I>>::Output, M = <Z0 as Sub<<D as Dimension>::M>>::Output, N = <Z0 as Sub<<D as Dimension>::N>>::Output, J = <Z0 as Sub<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u16>
/
operator.source§impl<D, U> Div<Quantity<D, U, u32>> for u32where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<u32> + ?Sized,
Z0: Sub<D::L> + Sub<D::M> + Sub<D::T> + Sub<D::I> + Sub<D::Th> + Sub<D::N> + Sub<D::J>,
<Z0 as Sub<D::L>>::Output: Integer,
<Z0 as Sub<D::M>>::Output: Integer,
<Z0 as Sub<D::T>>::Output: Integer,
<Z0 as Sub<D::I>>::Output: Integer,
<Z0 as Sub<D::Th>>::Output: Integer,
<Z0 as Sub<D::N>>::Output: Integer,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, u32>> for u32where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<u32> + ?Sized,
Z0: Sub<D::L> + Sub<D::M> + Sub<D::T> + Sub<D::I> + Sub<D::Th> + Sub<D::N> + Sub<D::J>,
<Z0 as Sub<D::L>>::Output: Integer,
<Z0 as Sub<D::M>>::Output: Integer,
<Z0 as Sub<D::T>>::Output: Integer,
<Z0 as Sub<D::I>>::Output: Integer,
<Z0 as Sub<D::Th>>::Output: Integer,
<Z0 as Sub<D::N>>::Output: Integer,
<Z0 as Sub<D::J>>::Output: Integer,
§type Output = Quantity<dyn Dimension<L = <Z0 as Sub<<D as Dimension>::L>>::Output, T = <Z0 as Sub<<D as Dimension>::T>>::Output, Th = <Z0 as Sub<<D as Dimension>::Th>>::Output, I = <Z0 as Sub<<D as Dimension>::I>>::Output, M = <Z0 as Sub<<D as Dimension>::M>>::Output, N = <Z0 as Sub<<D as Dimension>::N>>::Output, J = <Z0 as Sub<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u32>
type Output = Quantity<dyn Dimension<L = <Z0 as Sub<<D as Dimension>::L>>::Output, T = <Z0 as Sub<<D as Dimension>::T>>::Output, Th = <Z0 as Sub<<D as Dimension>::Th>>::Output, I = <Z0 as Sub<<D as Dimension>::I>>::Output, M = <Z0 as Sub<<D as Dimension>::M>>::Output, N = <Z0 as Sub<<D as Dimension>::N>>::Output, J = <Z0 as Sub<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u32>
/
operator.source§impl<D, U> Div<Quantity<D, U, u8>> for u8where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<u8> + ?Sized,
Z0: Sub<D::L> + Sub<D::M> + Sub<D::T> + Sub<D::I> + Sub<D::Th> + Sub<D::N> + Sub<D::J>,
<Z0 as Sub<D::L>>::Output: Integer,
<Z0 as Sub<D::M>>::Output: Integer,
<Z0 as Sub<D::T>>::Output: Integer,
<Z0 as Sub<D::I>>::Output: Integer,
<Z0 as Sub<D::Th>>::Output: Integer,
<Z0 as Sub<D::N>>::Output: Integer,
<Z0 as Sub<D::J>>::Output: Integer,
impl<D, U> Div<Quantity<D, U, u8>> for u8where
D: Dimension + ?Sized,
D::Kind: Div,
U: Units<u8> + ?Sized,
Z0: Sub<D::L> + Sub<D::M> + Sub<D::T> + Sub<D::I> + Sub<D::Th> + Sub<D::N> + Sub<D::J>,
<Z0 as Sub<D::L>>::Output: Integer,
<Z0 as Sub<D::M>>::Output: Integer,
<Z0 as Sub<D::T>>::Output: Integer,
<Z0 as Sub<D::I>>::Output: Integer,
<Z0 as Sub<D::Th>>::Output: Integer,
<Z0 as Sub<D::N>>::Output: Integer,
<Z0 as Sub<D::J>>::Output: Integer,
§type Output = Quantity<dyn Dimension<L = <Z0 as Sub<<D as Dimension>::L>>::Output, T = <Z0 as Sub<<D as Dimension>::T>>::Output, Th = <Z0 as Sub<<D as Dimension>::Th>>::Output, I = <Z0 as Sub<<D as Dimension>::I>>::Output, M = <Z0 as Sub<<D as Dimension>::M>>::Output, N = <Z0 as Sub<<D as Dimension>::N>>::Output, J = <Z0 as Sub<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u8>
type Output = Quantity<dyn Dimension<L = <Z0 as Sub<<D as Dimension>::L>>::Output, T = <Z0 as Sub<<D as Dimension>::T>>::Output, Th = <Z0 as Sub<<D as Dimension>::Th>>::Output, I = <Z0 as Sub<<D as Dimension>::I>>::Output, M = <Z0 as Sub<<D as Dimension>::M>>::Output, N = <Z0 as Sub<<D as Dimension>::N>>::Output, J = <Z0 as Sub<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u8>
/
operator.source§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>,
§type Output = Quantity<dyn Dimension<L = <<Dl as Dimension>::L as Sub<<Dr as Dimension>::L>>::Output, T = <<Dl as Dimension>::T as Sub<<Dr as Dimension>::T>>::Output, Th = <<Dl as Dimension>::Th as Sub<<Dr as Dimension>::Th>>::Output, I = <<Dl as Dimension>::I as Sub<<Dr as Dimension>::I>>::Output, M = <<Dl as Dimension>::M as Sub<<Dr as Dimension>::M>>::Output, N = <<Dl as Dimension>::N as Sub<<Dr as Dimension>::N>>::Output, J = <<Dl as Dimension>::J as Sub<<Dr as Dimension>::J>>::Output, Kind = dyn Kind>, Ul, V>
type Output = Quantity<dyn Dimension<L = <<Dl as Dimension>::L as Sub<<Dr as Dimension>::L>>::Output, T = <<Dl as Dimension>::T as Sub<<Dr as Dimension>::T>>::Output, Th = <<Dl as Dimension>::Th as Sub<<Dr as Dimension>::Th>>::Output, I = <<Dl as Dimension>::I as Sub<<Dr as Dimension>::I>>::Output, M = <<Dl as Dimension>::M as Sub<<Dr as Dimension>::M>>::Output, N = <<Dl as Dimension>::N as Sub<<Dr as Dimension>::N>>::Output, J = <<Dl as Dimension>::J as Sub<<Dr as Dimension>::J>>::Output, Kind = dyn Kind>, Ul, V>
/
operator.source§impl<D, U, V> DivAssign<V> for Quantity<D, U, V>
impl<D, U, V> DivAssign<V> for Quantity<D, U, V>
source§fn div_assign(&mut self, rhs: V)
fn div_assign(&mut self, rhs: V)
/=
operation. Read moresource§impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn AngleKind>, 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>
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn AngleKind>, 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>
source§impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn ConstituentConcentrationKind>, 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>
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn ConstituentConcentrationKind>, 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>
source§impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn InformationKind>, 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>
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn InformationKind>, 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>
source§impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn Kind>, 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>
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn Kind>, 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>
source§impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn Kind>, 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>
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn Kind>, 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>
source§impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn Kind>, 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>
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn Kind>, 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>
source§impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn Kind>, 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>
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn Kind>, 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>
source§impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn SolidAngleKind>, 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>
impl<L, M, T, I, Th, N, J, Ul, Ur, V> From<Quantity<dyn Dimension<L = L, T = T, Th = Th, I = I, M = M, N = N, J = J, Kind = dyn SolidAngleKind>, 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>
source§impl<U> From<Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, u16>> for u16
impl<U> From<Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, u16>> for u16
source§impl<U> From<Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, u32>> for u32
impl<U> From<Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, u32>> for u32
source§impl<U> From<Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, u8>> for u8
impl<U> From<Quantity<dyn Dimension<L = Z0, T = Z0, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, u8>> for u8
source§impl<D, U> Mul<Quantity<D, U, u16>> for u16where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<u16> + ?Sized,
Z0: Add<D::L> + Add<D::M> + Add<D::T> + Add<D::I> + Add<D::Th> + Add<D::N> + Add<D::J>,
<Z0 as Add<D::L>>::Output: Integer,
<Z0 as Add<D::M>>::Output: Integer,
<Z0 as Add<D::T>>::Output: Integer,
<Z0 as Add<D::I>>::Output: Integer,
<Z0 as Add<D::Th>>::Output: Integer,
<Z0 as Add<D::N>>::Output: Integer,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, u16>> for u16where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<u16> + ?Sized,
Z0: Add<D::L> + Add<D::M> + Add<D::T> + Add<D::I> + Add<D::Th> + Add<D::N> + Add<D::J>,
<Z0 as Add<D::L>>::Output: Integer,
<Z0 as Add<D::M>>::Output: Integer,
<Z0 as Add<D::T>>::Output: Integer,
<Z0 as Add<D::I>>::Output: Integer,
<Z0 as Add<D::Th>>::Output: Integer,
<Z0 as Add<D::N>>::Output: Integer,
<Z0 as Add<D::J>>::Output: Integer,
§type Output = Quantity<dyn Dimension<L = <Z0 as Add<<D as Dimension>::L>>::Output, T = <Z0 as Add<<D as Dimension>::T>>::Output, Th = <Z0 as Add<<D as Dimension>::Th>>::Output, I = <Z0 as Add<<D as Dimension>::I>>::Output, M = <Z0 as Add<<D as Dimension>::M>>::Output, N = <Z0 as Add<<D as Dimension>::N>>::Output, J = <Z0 as Add<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u16>
type Output = Quantity<dyn Dimension<L = <Z0 as Add<<D as Dimension>::L>>::Output, T = <Z0 as Add<<D as Dimension>::T>>::Output, Th = <Z0 as Add<<D as Dimension>::Th>>::Output, I = <Z0 as Add<<D as Dimension>::I>>::Output, M = <Z0 as Add<<D as Dimension>::M>>::Output, N = <Z0 as Add<<D as Dimension>::N>>::Output, J = <Z0 as Add<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u16>
*
operator.source§impl<D, U> Mul<Quantity<D, U, u32>> for u32where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<u32> + ?Sized,
Z0: Add<D::L> + Add<D::M> + Add<D::T> + Add<D::I> + Add<D::Th> + Add<D::N> + Add<D::J>,
<Z0 as Add<D::L>>::Output: Integer,
<Z0 as Add<D::M>>::Output: Integer,
<Z0 as Add<D::T>>::Output: Integer,
<Z0 as Add<D::I>>::Output: Integer,
<Z0 as Add<D::Th>>::Output: Integer,
<Z0 as Add<D::N>>::Output: Integer,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, u32>> for u32where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<u32> + ?Sized,
Z0: Add<D::L> + Add<D::M> + Add<D::T> + Add<D::I> + Add<D::Th> + Add<D::N> + Add<D::J>,
<Z0 as Add<D::L>>::Output: Integer,
<Z0 as Add<D::M>>::Output: Integer,
<Z0 as Add<D::T>>::Output: Integer,
<Z0 as Add<D::I>>::Output: Integer,
<Z0 as Add<D::Th>>::Output: Integer,
<Z0 as Add<D::N>>::Output: Integer,
<Z0 as Add<D::J>>::Output: Integer,
§type Output = Quantity<dyn Dimension<L = <Z0 as Add<<D as Dimension>::L>>::Output, T = <Z0 as Add<<D as Dimension>::T>>::Output, Th = <Z0 as Add<<D as Dimension>::Th>>::Output, I = <Z0 as Add<<D as Dimension>::I>>::Output, M = <Z0 as Add<<D as Dimension>::M>>::Output, N = <Z0 as Add<<D as Dimension>::N>>::Output, J = <Z0 as Add<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u32>
type Output = Quantity<dyn Dimension<L = <Z0 as Add<<D as Dimension>::L>>::Output, T = <Z0 as Add<<D as Dimension>::T>>::Output, Th = <Z0 as Add<<D as Dimension>::Th>>::Output, I = <Z0 as Add<<D as Dimension>::I>>::Output, M = <Z0 as Add<<D as Dimension>::M>>::Output, N = <Z0 as Add<<D as Dimension>::N>>::Output, J = <Z0 as Add<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u32>
*
operator.source§impl<D, U> Mul<Quantity<D, U, u8>> for u8where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<u8> + ?Sized,
Z0: Add<D::L> + Add<D::M> + Add<D::T> + Add<D::I> + Add<D::Th> + Add<D::N> + Add<D::J>,
<Z0 as Add<D::L>>::Output: Integer,
<Z0 as Add<D::M>>::Output: Integer,
<Z0 as Add<D::T>>::Output: Integer,
<Z0 as Add<D::I>>::Output: Integer,
<Z0 as Add<D::Th>>::Output: Integer,
<Z0 as Add<D::N>>::Output: Integer,
<Z0 as Add<D::J>>::Output: Integer,
impl<D, U> Mul<Quantity<D, U, u8>> for u8where
D: Dimension + ?Sized,
D::Kind: Mul,
U: Units<u8> + ?Sized,
Z0: Add<D::L> + Add<D::M> + Add<D::T> + Add<D::I> + Add<D::Th> + Add<D::N> + Add<D::J>,
<Z0 as Add<D::L>>::Output: Integer,
<Z0 as Add<D::M>>::Output: Integer,
<Z0 as Add<D::T>>::Output: Integer,
<Z0 as Add<D::I>>::Output: Integer,
<Z0 as Add<D::Th>>::Output: Integer,
<Z0 as Add<D::N>>::Output: Integer,
<Z0 as Add<D::J>>::Output: Integer,
§type Output = Quantity<dyn Dimension<L = <Z0 as Add<<D as Dimension>::L>>::Output, T = <Z0 as Add<<D as Dimension>::T>>::Output, Th = <Z0 as Add<<D as Dimension>::Th>>::Output, I = <Z0 as Add<<D as Dimension>::I>>::Output, M = <Z0 as Add<<D as Dimension>::M>>::Output, N = <Z0 as Add<<D as Dimension>::N>>::Output, J = <Z0 as Add<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u8>
type Output = Quantity<dyn Dimension<L = <Z0 as Add<<D as Dimension>::L>>::Output, T = <Z0 as Add<<D as Dimension>::T>>::Output, Th = <Z0 as Add<<D as Dimension>::Th>>::Output, I = <Z0 as Add<<D as Dimension>::I>>::Output, M = <Z0 as Add<<D as Dimension>::M>>::Output, N = <Z0 as Add<<D as Dimension>::N>>::Output, J = <Z0 as Add<<D as Dimension>::J>>::Output, Kind = <D as Dimension>::Kind>, U, u8>
*
operator.source§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>,
§type Output = Quantity<dyn Dimension<L = <<Dl as Dimension>::L as Add<<Dr as Dimension>::L>>::Output, T = <<Dl as Dimension>::T as Add<<Dr as Dimension>::T>>::Output, Th = <<Dl as Dimension>::Th as Add<<Dr as Dimension>::Th>>::Output, I = <<Dl as Dimension>::I as Add<<Dr as Dimension>::I>>::Output, M = <<Dl as Dimension>::M as Add<<Dr as Dimension>::M>>::Output, N = <<Dl as Dimension>::N as Add<<Dr as Dimension>::N>>::Output, J = <<Dl as Dimension>::J as Add<<Dr as Dimension>::J>>::Output, Kind = dyn Kind>, Ul, V>
type Output = Quantity<dyn Dimension<L = <<Dl as Dimension>::L as Add<<Dr as Dimension>::L>>::Output, T = <<Dl as Dimension>::T as Add<<Dr as Dimension>::T>>::Output, Th = <<Dl as Dimension>::Th as Add<<Dr as Dimension>::Th>>::Output, I = <<Dl as Dimension>::I as Add<<Dr as Dimension>::I>>::Output, M = <<Dl as Dimension>::M as Add<<Dr as Dimension>::M>>::Output, N = <<Dl as Dimension>::N as Add<<Dr as Dimension>::N>>::Output, J = <<Dl as Dimension>::J as Add<<Dr as Dimension>::J>>::Output, Kind = dyn Kind>, Ul, V>
*
operator.source§impl<D, U, V> MulAssign<V> for Quantity<D, U, V>
impl<D, U, V> MulAssign<V> for Quantity<D, U, V>
source§fn mul_assign(&mut self, rhs: V)
fn mul_assign(&mut self, rhs: V)
*=
operation. Read moresource§impl<D, Ul, Ur, V> PartialEq<Quantity<D, Ur, V>> for Quantity<D, Ul, V>
impl<D, Ul, Ur, V> PartialEq<Quantity<D, Ur, V>> for Quantity<D, Ul, V>
source§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,
source§fn le(&self, other: &Quantity<D, Ur, V>) -> bool
fn le(&self, other: &Quantity<D, Ur, V>) -> bool
self
and other
) and is used by the <=
operator. Read moresource§impl<D, Ul, Ur, V> RemAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V>
impl<D, Ul, Ur, V> RemAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V>
source§fn rem_assign(&mut self, rhs: Quantity<D, Ur, V>)
fn rem_assign(&mut self, rhs: Quantity<D, Ur, V>)
%=
operation. Read moresource§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,
source§fn saturating_add(self, v: Self) -> Self
fn saturating_add(self, v: Self) -> Self
source§fn saturating_sub(self, v: Self) -> Self
fn saturating_sub(self, v: Self) -> Self
source§impl<Ul, Ur, V> Sub<Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, Ur, V>> for ThermodynamicTemperature<Ul, V>
impl<Ul, Ur, V> Sub<Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, Ur, V>> for ThermodynamicTemperature<Ul, V>
source§impl<D, Ul, Ur, V> SubAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V>
impl<D, Ul, Ur, V> SubAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V>
source§fn sub_assign(&mut self, rhs: Quantity<D, Ur, V>)
fn sub_assign(&mut self, rhs: Quantity<D, Ur, V>)
-=
operation. Read moresource§impl<Ul, Ur, V> SubAssign<Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, Ur, V>> for ThermodynamicTemperature<Ul, V>
impl<Ul, Ur, V> SubAssign<Quantity<dyn Dimension<L = Z0, T = Z0, Th = PInt<UInt<UTerm, B1>>, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, Ur, V>> for ThermodynamicTemperature<Ul, V>
source§fn sub_assign(&mut self, rhs: TemperatureInterval<Ur, V>)
fn sub_assign(&mut self, rhs: TemperatureInterval<Ur, V>)
-=
operation. Read moresource§impl<U, V> TryFrom<Quantity<dyn Dimension<L = Z0, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>> for Durationwhere
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<L = Z0, T = PInt<UInt<UTerm, B1>>, Th = Z0, I = Z0, M = Z0, N = Z0, J = Z0, Kind = dyn Kind>, U, V>> for Durationwhere
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.