[][src]Struct uom::si::Quantity

#[repr(transparent)]pub struct Quantity<D: ?Sized, U: ?Sized, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V>, 
{ pub dimension: PhantomData<D>, pub units: PhantomData<U>, pub value: V, }

Property of a phenomenon, body or substance, where the property has a magnitude that can be expressed as a number and a reference.

The preferred method of creating a Quantity instance is to use the new constructor which is generic over the input unit and accepts the input value as it's only parameter.

// Create a length of 1 meter.
let l = Length::new::<meter>(1.0);

Quantity fields are public to allow for the creation of const values and instances of non-named Quantitys. This functionality will be deprecated and subsequently removed once the const fn feature is stabilized.

// Create a `const` length of 1 meter.
const L: Length = Length { dimension: PhantomData, units: PhantomData, value: 1.0, };
// Create a `const` area of 1 square meter explicitly without using the `Area` alias.
const A: Quantity<ISQ<P2, Z0, Z0, Z0, Z0, Z0, Z0>, SI<f32>, f32> =
    Quantity { dimension: PhantomData, units: PhantomData, value: 1.0, };

Using units for the wrong quantity will cause a compile error:

This example deliberately fails to compile
// 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:

This example deliberately fails to compile
// error[E0308]: mismatched types
let r = Length::new::<meter>(1.0) + Time::new::<second>(1.0);
This example deliberately fails to compile
// error[E0308]: mismatched types
let v: Velocity = Length::new::<meter>(1.0) * Time::new::<second>(1.0);

Generic Parameters

  • D: Quantity dimension. See Dimension.
  • U: Quantity base units. See Units.
  • V: Quantity value underlying storage type.

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

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UTerm, B1>>, M = Z0, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = PInt<UInt<UTerm, B1>>> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V>[src]

pub const HALF_TURN: Self[src]

A half turn, i.e. an angle with a value of π as measured in radians

pub const FULL_TURN: Self[src]

A full turn, i.e. an angle with a value of 2π as measured in radians

impl Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V>[src]

pub const HALF_TURN: Self[src]

A half turn, i.e. an angle with a value of π as measured in radians

pub const FULL_TURN: Self[src]

A full turn, i.e. an angle with a value of 2π as measured in radians

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Float + Conversion<V>, 
[src]

Implementation of various stdlib trigonometric functions

pub fn cos(self) -> Ratio<U, V>[src]

Computes the value of the cosine of the angle.

pub fn cosh(self) -> Ratio<U, V>[src]

Computes the value of the hyperbolic cosine of the angle.

pub fn sin(self) -> Ratio<U, V>[src]

Computes the value of the sine of the angle.

pub fn sinh(self) -> Ratio<U, V>[src]

Computes the value of the hyperbolic sine of the angle.

pub fn sin_cos(self) -> (Ratio<U, V>, Ratio<U, V>)[src]

Computes the value of both the sine and cosine of the angle.

pub fn tan(self) -> Ratio<U, V>[src]

Computes the value of the tangent of the angle.

pub fn tanh(self) -> Ratio<U, V>[src]

Computes the value of the hyperbolic tangent of the angle.

impl<D: ?Sized, U: ?Sized, V> Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Float + Conversion<V>,
    radian: Conversion<V, T = V::T>, 
[src]

pub fn atan2(self, other: Self) -> Angle<U, V>[src]

Computes the four quadrant arctangent of self (y) and other (x).

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = NInt<UInt<UTerm, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = Z0, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = PInt<UInt<UInt<UTerm, B1>, B0>>, L = NInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, Th = Z0, T = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = NInt<UInt<UTerm, B1>>, N = PInt<UInt<UTerm, B1>>> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn ConstituentConcentrationKind + 'static, I = Z0, L = NInt<UInt<UInt<UTerm, B1>, B1>>, M = Z0, Th = Z0, T = NInt<UInt<UTerm, B1>>, N = PInt<UInt<UTerm, B1>>> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = NInt<UInt<UTerm, B1>>, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = PInt<UInt<UTerm, B1>>, L = Z0, M = Z0, Th = Z0, T = PInt<UInt<UTerm, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = PInt<UInt<UTerm, B1>>, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = NInt<UInt<UTerm, B1>>, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = PInt<UInt<UInt<UTerm, B1>, B0>>, L = NInt<UInt<UInt<UTerm, B1>, B0>>, M = NInt<UInt<UTerm, B1>>, Th = Z0, T = PInt<UInt<UInt<UTerm, B1>, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = NInt<UInt<UInt<UTerm, B1>, B0>>, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = NInt<UInt<UTerm, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, Th = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = PInt<UInt<UTerm, B1>>, Th = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = NInt<UInt<UInt<UTerm, B1>, B0>>, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn InformationKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn InformationKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = NInt<UInt<UTerm, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UTerm, B1>>, M = Z0, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UTerm, B1>>, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = PInt<UInt<UTerm, B1>>, Kind = dyn Kind + 'static, I = Z0, L = NInt<UInt<UInt<UTerm, B1>, B0>>, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = PInt<UInt<UTerm, B1>>, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = NInt<UInt<UTerm, B1>>, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = NInt<UInt<UTerm, B1>>, L = Z0, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn ConstituentConcentrationKind + 'static, I = Z0, L = NInt<UInt<UInt<UTerm, B1>, B1>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = NInt<UInt<UInt<UTerm, B1>, B1>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UTerm, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn ConstituentConcentrationKind + 'static, I = Z0, L = NInt<UInt<UInt<UTerm, B1>, B1>>, M = Z0, Th = Z0, T = Z0, N = PInt<UInt<UTerm, B1>>> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = NInt<UInt<UTerm, B1>>> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = Z0, N = NInt<UInt<UTerm, B1>>> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UTerm, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = NInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Float + Conversion<V>,
    radian: Conversion<V, T = V::T>, 
[src]

Implementation of various stdlib inverse trigonometric functions

pub fn acos(self) -> Angle<U, V>[src]

Computes the value of the inverse cosine of the ratio.

pub fn acosh(self) -> Angle<U, V>[src]

Computes the value of the inverse hyperbolic cosine of the ratio.

pub fn asin(self) -> Angle<U, V>[src]

Computes the value of the inverse sine of the ratio.

pub fn asinh(self) -> Angle<U, V>[src]

Computes the value of the inverse hyperbolic sine of the ratio.

pub fn atan(self) -> Angle<U, V>[src]

Computes the value of the inverse tangent of the ratio.

pub fn atanh(self) -> Angle<U, V>[src]

Computes the value of the inverse hyperbolic tangent of the ratio.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = Z0, Th = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn SolidAngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl Quantity<dyn Dimension<J = Z0, Kind = dyn SolidAngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V>[src]

pub const SPHERE: Self[src]

The solid angle subtended by a sphere at its center, i.e. with a value 4π as measured in steradians.

impl Quantity<dyn Dimension<J = Z0, Kind = dyn SolidAngleKind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V>[src]

pub const SPHERE: Self[src]

The solid angle subtended by a sphere at its center, i.e. with a value 4π as measured in steradians.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UTerm, B1>>, M = PInt<UInt<UTerm, B1>>, Th = NInt<UInt<UTerm, B1>>, T = NInt<UInt<UInt<UTerm, B1>, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn TemperatureKind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = PInt<UInt<UTerm, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn AngleKind + 'static, I = Z0, L = PInt<UInt<UInt<UTerm, B1>, B0>>, M = PInt<UInt<UTerm, B1>>, Th = Z0, T = NInt<UInt<UInt<UTerm, B1>, B0>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UTerm, B1>>, M = Z0, Th = Z0, T = NInt<UInt<UTerm, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UInt<UTerm, B1>, B1>>, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<U: ?Sized, V> Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = PInt<UInt<UInt<UTerm, B1>, B1>>, M = Z0, Th = Z0, T = NInt<UInt<UTerm, B1>>, N = Z0> + 'static, U, V> where
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn new<N>(v: V) -> Self where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Create a new quantity from the given value and measurement unit.

Generic Parameters

  • N: Unit.

pub fn get<N>(&self) -> V where
    N: Unit + Conversion<V, T = V::T>, 
[src]

Retrieve the value of the quantity in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn floor<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the largest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn ceil<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the smallest integer less than or equal to a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn round<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

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.

pub fn trunc<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the integer part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn fract<N>(self) -> Self where
    V: Float,
    N: Unit + Conversion<V, T = V::T>, 
[src]

Returns the fractional part of a number in the given measurement unit.

Generic Parameters

  • N: Unit.

pub fn format_args<N>(unit: N, style: DisplayStyle) -> Arguments<Dimension, N> where
    N: Unit
[src]

Creates a struct that can be used to format a compatible quantity for display.

Notes

The return value of this method cannot be used to print directly, but is instead used to format quantities and can be reused; see Arguments::with and the examples below.

If you do not need to format multiple quantities, consider using into_format_args instead.

Examples

let t1 = Time::new::<femtosecond>(1.0_E-1);
let t2 = Time::new::<picosecond>(1.0_E-1);
let a = Time::format_args(femtosecond, Description);

assert_eq!("0.1 femtoseconds", format!("{}", a.with(t1)));
assert_eq!("100 femtoseconds", format!("{}", a.with(t2)));

Generic Parameters

  • N: Unit.

pub fn into_format_args<N>(
    self,
    unit: N,
    style: DisplayStyle
) -> QuantityArguments<Dimension, U, V, N> where
    N: Unit
[src]

Creates a struct that formats self for display.

Notes

Unlike format_args, the return value of this method can be used directly for display. It will format the value of self for the quantity on which it is called and nothing else.

If you wish to reuse the return value to format multiple quantities, use format_args instead.

Examples

let t = Time::new::<picosecond>(1.0_E-1);
let a = t.into_format_args(femtosecond, Description);

assert_eq!("100 femtoseconds", format!("{}", a));

Generic Parameters

  • N: Unit.

impl<D: ?Sized, U: ?Sized, V> Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

pub fn is_nan(self) -> bool where
    V: Float
[src]

Returns true if this value is NAN and false otherwise.

pub fn is_infinite(self) -> bool where
    V: Float
[src]

Returns true if this value is positive infinity or negative infinity and false otherwise.

pub fn is_finite(self) -> bool where
    V: Float
[src]

Returns true if this number is neither infinite nor NAN.

pub fn is_normal(self) -> bool where
    V: Float
[src]

Returns true if the number is neither zero, infinite, subnormal, or NAN.

pub fn classify(self) -> FpCategory where
    V: Float
[src]

Returns the floating point category of the number. If only one property is going to be tested, it is generally faster to use the specific predicate instead.

pub fn cbrt(
    self
) -> Quantity<ISQ<PartialQuot<D::L, P3>, PartialQuot<D::M, P3>, PartialQuot<D::T, P3>, PartialQuot<D::I, P3>, PartialQuot<D::Th, P3>, PartialQuot<D::N, P3>, PartialQuot<D::J, P3>>, U, V> where
    D::L: PartialDiv<P3>,
    <D::L as PartialDiv<P3>>::Output: Integer,
    D::M: PartialDiv<P3>,
    <D::M as PartialDiv<P3>>::Output: Integer,
    D::T: PartialDiv<P3>,
    <D::T as PartialDiv<P3>>::Output: Integer,
    D::I: PartialDiv<P3>,
    <D::I as PartialDiv<P3>>::Output: Integer,
    D::Th: PartialDiv<P3>,
    <D::Th as PartialDiv<P3>>::Output: Integer,
    D::N: PartialDiv<P3>,
    <D::N as PartialDiv<P3>>::Output: Integer,
    D::J: PartialDiv<P3>,
    <D::J as PartialDiv<P3>>::Output: Integer,
    D::Kind: Div,
    V: Float
[src]

Takes the cubic root of a number.

let l: Length = Volume::new::<cubic_meter>(8.0).cbrt();

The input type must have dimensions divisible by three:

This example deliberately fails to compile
// error[E0271]: type mismatch resolving ...
let r = Area::new::<square_meter>(8.0).cbrt();

pub fn hypot<Ur: ?Sized>(self, other: Quantity<D, Ur, V>) -> Self where
    V: Float,
    Ur: Units<V>, 
[src]

Calculates the length of the hypotenuse of a right-angle triangle given the legs.

pub fn abs(self) -> Self where
    V: Signed
[src]

Computes the absolute value of self. Returns NAN if the quantity is NAN.

pub fn signum(self) -> Self where
    V: Signed
[src]

Returns a quantity that represents the sign of self.

  • 1.0 of the base unit if the number is positive, +0.0, or INFINITY.
  • -1.0 of the base unit if the number is negative, -0.0, or NEG_INFINITY.
  • NAN if the number is NAN.

pub fn is_sign_positive(self) -> bool where
    V: Float
[src]

Returns true if self's sign bit is positive, including +0.0 and INFINITY.

pub fn is_sign_negative(self) -> bool where
    V: Float
[src]

Returns true if self's sign is negative, including -0.0 and NEG_INFINITY.

pub fn mul_add<Da: ?Sized, Ua: ?Sized, Ub: ?Sized>(
    self,
    a: Quantity<Da, Ua, V>,
    b: Quantity<ISQ<Sum<D::L, Da::L>, Sum<D::M, Da::M>, Sum<D::T, Da::T>, Sum<D::I, Da::I>, Sum<D::Th, Da::Th>, Sum<D::N, Da::N>, Sum<D::J, Da::J>>, Ub, V>
) -> Quantity<ISQ<Sum<D::L, Da::L>, Sum<D::M, Da::M>, Sum<D::T, Da::T>, Sum<D::I, Da::I>, Sum<D::Th, Da::Th>, Sum<D::N, Da::N>, Sum<D::J, Da::J>>, U, V> where
    D::L: Add<Da::L>,
    <D::L as Add<Da::L>>::Output: Integer,
    D::M: Add<Da::M>,
    <D::M as Add<Da::M>>::Output: Integer,
    D::T: Add<Da::T>,
    <D::T as Add<Da::T>>::Output: Integer,
    D::I: Add<Da::I>,
    <D::I as Add<Da::I>>::Output: Integer,
    D::Th: Add<Da::Th>,
    <D::Th as Add<Da::Th>>::Output: Integer,
    D::N: Add<Da::N>,
    <D::N as Add<Da::N>>::Output: Integer,
    D::J: Add<Da::J>,
    <D::J as Add<Da::J>>::Output: Integer,
    D::Kind: Mul,
    V: Float,
    Da: Dimension,
    Da::Kind: Mul,
    Ua: Units<V>,
    Ub: Units<V>, 
[src]

Fused multiply-add. Computes (self * a) + b with only one rounding error. This produces a more accurate result with better performance than a separate multiplication operation followed by an add.

Generic Parameters

  • Da: Dimension for parameter a.
  • Ua: Base units for parameter a.
  • Ub: Base units for parameter b.

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
[src]

Takes the reciprocal (inverse) of a number, 1/x.

let f: Frequency = Time::new::<second>(1.0).recip();

pub fn powi<E>(
    self,
    _e: E
) -> Quantity<ISQ<Prod<D::L, E>, Prod<D::M, E>, Prod<D::T, E>, Prod<D::I, E>, Prod<D::Th, E>, Prod<D::N, E>, Prod<D::J, E>>, U, V> where
    D::L: Mul<E>,
    <D::L as Mul<E>>::Output: Integer,
    D::M: Mul<E>,
    <D::M as Mul<E>>::Output: Integer,
    D::T: Mul<E>,
    <D::T as Mul<E>>::Output: Integer,
    D::I: Mul<E>,
    <D::I as Mul<E>>::Output: Integer,
    D::Th: Mul<E>,
    <D::Th as Mul<E>>::Output: Integer,
    D::N: Mul<E>,
    <D::N as Mul<E>>::Output: Integer,
    D::J: Mul<E>,
    <D::J as Mul<E>>::Output: Integer,
    D::Kind: Mul,
    E: Integer,
    V: Float
[src]

Raises a quantity to an integer power.

let a: Area = Length::new::<meter>(3.0).powi(crate::uom::typenum::P2::new());

Generic Parameters

  • E: typenum::Integer power.

pub fn sqrt(
    self
) -> Quantity<ISQ<PartialQuot<D::L, P2>, PartialQuot<D::M, P2>, PartialQuot<D::T, P2>, PartialQuot<D::I, P2>, PartialQuot<D::Th, P2>, PartialQuot<D::N, P2>, PartialQuot<D::J, P2>>, U, V> where
    D::L: PartialDiv<P2>,
    <D::L as PartialDiv<P2>>::Output: Integer,
    D::M: PartialDiv<P2>,
    <D::M as PartialDiv<P2>>::Output: Integer,
    D::T: PartialDiv<P2>,
    <D::T as PartialDiv<P2>>::Output: Integer,
    D::I: PartialDiv<P2>,
    <D::I as PartialDiv<P2>>::Output: Integer,
    D::Th: PartialDiv<P2>,
    <D::Th as PartialDiv<P2>>::Output: Integer,
    D::N: PartialDiv<P2>,
    <D::N as PartialDiv<P2>>::Output: Integer,
    D::J: PartialDiv<P2>,
    <D::J as PartialDiv<P2>>::Output: Integer,
    D::Kind: Div,
    V: Float
[src]

Takes the square root of a number. Returns NAN if self is a negative number.

let l: Length = Area::new::<square_meter>(4.0).sqrt();

The input type must have dimensions divisible by two:

This example deliberately fails to compile
// error[E0271]: type mismatch resolving ...
let r = Length::new::<meter>(4.0).sqrt();

pub fn max(self, other: Self) -> Self where
    V: Float
[src]

Returns the maximum of the two quantities.

pub fn min(self, other: Self) -> Self where
    V: Float
[src]

Returns the minimum of the two quantities.

Trait Implementations

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: Add,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

type Output = Quantity<D, Ul, V>

The resulting type after applying the + operator.

impl<Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

type Output = ThermodynamicTemperature<Ul, V>

The resulting type after applying the + operator.

impl<Ul: ?Sized, Ur: ?Sized, V> Add<Quantity<dyn Dimension<J = Z0, Kind = dyn TemperatureKind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, Ur, V>> for TemperatureInterval<Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

type Output = ThermodynamicTemperature<Ul, V>

The resulting type after applying the + operator.

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> AddAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: AddAssign,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + AddAssign<V>, 
[src]

impl<Ul: ?Sized, Ur: ?Sized, V> AddAssign<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + AddAssign<V>, 
[src]

impl<D: ?Sized, U: ?Sized, V> Clone for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Clone
[src]

impl<D: ?Sized, U: ?Sized, V> Copy for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Copy
[src]

impl<D: ?Sized, U: ?Sized, V> Debug for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Debug
[src]

impl<D: ?Sized, U: ?Sized, V> Default for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Default
[src]

impl<'de, D: ?Sized, U: ?Sized, V> Deserialize<'de> for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Deserialize<'de>, 
[src]

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, BigInt>> for BigInt where
    D: Dimension,
    D::Kind: Div,
    U: Units<BigInt>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, BigInt>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, BigUint>> for BigUint where
    D: Dimension,
    D::Kind: Div,
    U: Units<BigUint>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, BigUint>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<BigInt>>> for BigRational where
    D: Dimension,
    D::Kind: Div,
    U: Units<BigRational>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, BigRational>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<i32>>> for Rational32 where
    D: Dimension,
    D::Kind: Div,
    U: Units<Rational32>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, Rational32>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<i64>>> for Rational64 where
    D: Dimension,
    D::Kind: Div,
    U: Units<Rational64>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, Rational64>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, Ratio<isize>>> for Rational where
    D: Dimension,
    D::Kind: Div,
    U: Units<Rational>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, Rational>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, f32>> for f32 where
    D: Dimension,
    D::Kind: Div,
    U: Units<f32>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, f32>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, f64>> for f64 where
    D: Dimension,
    D::Kind: Div,
    U: Units<f64>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, f64>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i128>> for i128 where
    D: Dimension,
    D::Kind: Div,
    U: Units<i128>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, i128>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i16>> for i16 where
    D: Dimension,
    D::Kind: Div,
    U: Units<i16>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, i16>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i32>> for i32 where
    D: Dimension,
    D::Kind: Div,
    U: Units<i32>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, i32>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i64>> for i64 where
    D: Dimension,
    D::Kind: Div,
    U: Units<i64>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, i64>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, i8>> for i8 where
    D: Dimension,
    D::Kind: Div,
    U: Units<i8>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, i8>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, isize>> for isize where
    D: Dimension,
    D::Kind: Div,
    U: Units<isize>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, isize>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u128>> for u128 where
    D: Dimension,
    D::Kind: Div,
    U: Units<u128>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, u128>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u16>> for u16 where
    D: Dimension,
    D::Kind: Div,
    U: Units<u16>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, u16>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u32>> for u32 where
    D: Dimension,
    D::Kind: Div,
    U: Units<u32>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, u32>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u64>> for u64 where
    D: Dimension,
    D::Kind: Div,
    U: Units<u64>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, u64>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, u8>> for u8 where
    D: Dimension,
    D::Kind: Div,
    U: Units<u8>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, u8>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized> Div<Quantity<D, U, usize>> for usize where
    D: Dimension,
    D::Kind: Div,
    U: Units<usize>,
    Z0: Sub<D::L>,
    <Z0 as Sub<D::L>>::Output: Integer,
    Z0: Sub<D::M>,
    <Z0 as Sub<D::M>>::Output: Integer,
    Z0: Sub<D::T>,
    <Z0 as Sub<D::T>>::Output: Integer,
    Z0: Sub<D::I>,
    <Z0 as Sub<D::I>>::Output: Integer,
    Z0: Sub<D::Th>,
    <Z0 as Sub<D::Th>>::Output: Integer,
    Z0: Sub<D::N>,
    <Z0 as Sub<D::N>>::Output: Integer,
    Z0: Sub<D::J>,
    <Z0 as Sub<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Diff<Z0, D::L>, Diff<Z0, D::M>, Diff<Z0, D::T>, Diff<Z0, D::I>, Diff<Z0, D::Th>, Diff<Z0, D::N>, Diff<Z0, D::J>, D::Kind>, U, usize>

The resulting type after applying the / operator.

impl<Dl: ?Sized, Dr: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Div<Quantity<Dr, Ur, V>> for Quantity<Dl, Ul, V> where
    Dl: Dimension,
    Dl::L: Sub<Dr::L>,
    <Dl::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,
    Dr::Kind: Div,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + Div<V>, 
[src]

type Output = Quantity<ISQ<Diff<Dl::L, Dr::L>, Diff<Dl::M, Dr::M>, Diff<Dl::T, Dr::T>, Diff<Dl::I, Dr::I>, Diff<Dl::Th, Dr::Th>, Diff<Dl::N, Dr::N>, Diff<Dl::J, Dr::J>>, Ul, V>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized, V> Div<V> for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Div,
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

type Output = Quantity<D, U, V>

The resulting type after applying the / operator.

impl<D: ?Sized, U: ?Sized, V> DivAssign<V> for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: DivAssign,
    U: Units<V>,
    V: Num + Conversion<V> + DivAssign<V>, 
[src]

impl<D: ?Sized, U: ?Sized, V> Eq for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Eq
[src]

impl<L, M, T, I, Th, N, J, Ul: ?Sized, Ur: ?Sized, V> From<Quantity<dyn Dimension<J = J, Kind = dyn AngleKind + 'static, I = I, L = L, M = M, Th = Th, T = T, N = N> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn Kind>, Ul, V> where
    L: Integer,
    M: Integer,
    T: Integer,
    I: Integer,
    Th: Integer,
    N: Integer,
    J: Integer,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

impl<L, M, T, I, Th, N, J, Ul: ?Sized, Ur: ?Sized, V> From<Quantity<dyn Dimension<J = J, Kind = dyn ConstituentConcentrationKind + 'static, I = I, L = L, M = M, Th = Th, T = T, N = N> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn Kind>, Ul, V> where
    L: Integer,
    M: Integer,
    T: Integer,
    I: Integer,
    Th: Integer,
    N: Integer,
    J: Integer,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

impl<L, M, T, I, Th, N, J, Ul: ?Sized, Ur: ?Sized, V> From<Quantity<dyn Dimension<J = J, Kind = dyn InformationKind + 'static, I = I, L = L, M = M, Th = Th, T = T, N = N> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn Kind>, Ul, V> where
    L: Integer,
    M: Integer,
    T: Integer,
    I: Integer,
    Th: Integer,
    N: Integer,
    J: Integer,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

impl<L, M, T, I, Th, N, J, Ul: ?Sized, Ur: ?Sized, V> From<Quantity<dyn Dimension<J = J, Kind = dyn Kind + 'static, I = I, L = L, M = M, Th = Th, T = T, N = N> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn AngleKind>, Ul, V> where
    L: Integer,
    M: Integer,
    T: Integer,
    I: Integer,
    Th: Integer,
    N: Integer,
    J: Integer,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

impl<L, M, T, I, Th, N, J, Ul: ?Sized, Ur: ?Sized, V> From<Quantity<dyn Dimension<J = J, Kind = dyn Kind + 'static, I = I, L = L, M = M, Th = Th, T = T, N = N> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn SolidAngleKind>, Ul, V> where
    L: Integer,
    M: Integer,
    T: Integer,
    I: Integer,
    Th: Integer,
    N: Integer,
    J: Integer,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

impl<L, M, T, I, Th, N, J, Ul: ?Sized, Ur: ?Sized, V> From<Quantity<dyn Dimension<J = J, Kind = dyn Kind + 'static, I = I, L = L, M = M, Th = Th, T = T, N = N> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn InformationKind>, Ul, V> where
    L: Integer,
    M: Integer,
    T: Integer,
    I: Integer,
    Th: Integer,
    N: Integer,
    J: Integer,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

impl<L, M, T, I, Th, N, J, Ul: ?Sized, Ur: ?Sized, V> From<Quantity<dyn Dimension<J = J, Kind = dyn Kind + 'static, I = I, L = L, M = M, Th = Th, T = T, N = N> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn ConstituentConcentrationKind>, Ul, V> where
    L: Integer,
    M: Integer,
    T: Integer,
    I: Integer,
    Th: Integer,
    N: Integer,
    J: Integer,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

impl<L, M, T, I, Th, N, J, Ul: ?Sized, Ur: ?Sized, V> From<Quantity<dyn Dimension<J = J, Kind = dyn SolidAngleKind + 'static, I = I, L = L, M = M, Th = Th, T = T, N = N> + 'static, Ur, V>> for Quantity<dyn Dimension<L = L, M = M, T = T, I = I, Th = Th, N = N, J = J, Kind = dyn Kind>, Ul, V> where
    L: Integer,
    M: Integer,
    T: Integer,
    I: Integer,
    Th: Integer,
    N: Integer,
    J: Integer,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, BigInt>> for BigInt where
    U: Units<BigInt>,
    BigInt: Num + Conversion<BigInt>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, BigUint>> for BigUint where
    U: Units<BigUint>,
    BigUint: Num + Conversion<BigUint>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<BigInt>>> for BigRational where
    U: Units<BigRational>,
    BigRational: Num + Conversion<BigRational>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<i32>>> for Rational32 where
    U: Units<Rational32>,
    Rational32: Num + Conversion<Rational32>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<i64>>> for Rational64 where
    U: Units<Rational64>,
    Rational64: Num + Conversion<Rational64>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, Ratio<isize>>> for Rational where
    U: Units<Rational>,
    Rational: Num + Conversion<Rational>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, f32>> for f32 where
    U: Units<f32>,
    f32: Num + Conversion<f32>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, f64>> for f64 where
    U: Units<f64>,
    f64: Num + Conversion<f64>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i128>> for i128 where
    U: Units<i128>,
    i128: Num + Conversion<i128>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i16>> for i16 where
    U: Units<i16>,
    i16: Num + Conversion<i16>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i32>> for i32 where
    U: Units<i32>,
    i32: Num + Conversion<i32>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i64>> for i64 where
    U: Units<i64>,
    i64: Num + Conversion<i64>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, i8>> for i8 where
    U: Units<i8>,
    i8: Num + Conversion<i8>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, isize>> for isize where
    U: Units<isize>,
    isize: Num + Conversion<isize>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u128>> for u128 where
    U: Units<u128>,
    u128: Num + Conversion<u128>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u16>> for u16 where
    U: Units<u16>,
    u16: Num + Conversion<u16>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u32>> for u32 where
    U: Units<u32>,
    u32: Num + Conversion<u32>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u64>> for u64 where
    U: Units<u64>,
    u64: Num + Conversion<u64>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, u8>> for u8 where
    U: Units<u8>,
    u8: Num + Conversion<u8>, 
[src]

impl<U: ?Sized> From<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = Z0, N = Z0> + 'static, U, usize>> for usize where
    U: Units<usize>,
    usize: Num + Conversion<usize>, 
[src]

impl<D: ?Sized, U: ?Sized, V> Hash for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Hash
[src]

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, BigInt>> for BigInt where
    D: Dimension,
    D::Kind: Mul,
    U: Units<BigInt>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, BigInt>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, BigUint>> for BigUint where
    D: Dimension,
    D::Kind: Mul,
    U: Units<BigUint>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, BigUint>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<BigInt>>> for BigRational where
    D: Dimension,
    D::Kind: Mul,
    U: Units<BigRational>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, BigRational>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<i32>>> for Rational32 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<Rational32>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, Rational32>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<i64>>> for Rational64 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<Rational64>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, Rational64>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, Ratio<isize>>> for Rational where
    D: Dimension,
    D::Kind: Mul,
    U: Units<Rational>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, Rational>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, f32>> for f32 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<f32>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, f32>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, f64>> for f64 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<f64>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, f64>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i128>> for i128 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<i128>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, i128>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i16>> for i16 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<i16>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, i16>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i32>> for i32 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<i32>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, i32>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i64>> for i64 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<i64>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, i64>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, i8>> for i8 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<i8>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, i8>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, isize>> for isize where
    D: Dimension,
    D::Kind: Mul,
    U: Units<isize>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, isize>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u128>> for u128 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<u128>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, u128>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u16>> for u16 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<u16>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, u16>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u32>> for u32 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<u32>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, u32>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u64>> for u64 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<u64>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, u64>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, u8>> for u8 where
    D: Dimension,
    D::Kind: Mul,
    U: Units<u8>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, u8>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized> Mul<Quantity<D, U, usize>> for usize where
    D: Dimension,
    D::Kind: Mul,
    U: Units<usize>,
    Z0: Add<D::L>,
    <Z0 as Add<D::L>>::Output: Integer,
    Z0: Add<D::M>,
    <Z0 as Add<D::M>>::Output: Integer,
    Z0: Add<D::T>,
    <Z0 as Add<D::T>>::Output: Integer,
    Z0: Add<D::I>,
    <Z0 as Add<D::I>>::Output: Integer,
    Z0: Add<D::Th>,
    <Z0 as Add<D::Th>>::Output: Integer,
    Z0: Add<D::N>,
    <Z0 as Add<D::N>>::Output: Integer,
    Z0: Add<D::J>,
    <Z0 as Add<D::J>>::Output: Integer
[src]

type Output = Quantity<ISQ<Sum<Z0, D::L>, Sum<Z0, D::M>, Sum<Z0, D::T>, Sum<Z0, D::I>, Sum<Z0, D::Th>, Sum<Z0, D::N>, Sum<Z0, D::J>, D::Kind>, U, usize>

The resulting type after applying the * operator.

impl<Dl: ?Sized, Dr: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Mul<Quantity<Dr, Ur, V>> for Quantity<Dl, Ul, V> where
    Dl: Dimension,
    Dl::L: Add<Dr::L>,
    <Dl::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,
    Dr::Kind: Mul,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + Mul<V>, 
[src]

type Output = Quantity<ISQ<Sum<Dl::L, Dr::L>, Sum<Dl::M, Dr::M>, Sum<Dl::T, Dr::T>, Sum<Dl::I, Dr::I>, Sum<Dl::Th, Dr::Th>, Sum<Dl::N, Dr::N>, Sum<Dl::J, Dr::J>>, Ul, V>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized, V> Mul<V> for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Mul,
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

type Output = Quantity<D, U, V>

The resulting type after applying the * operator.

impl<D: ?Sized, U: ?Sized, V> MulAssign<V> for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: MulAssign,
    U: Units<V>,
    V: Num + Conversion<V> + MulAssign<V>, 
[src]

impl<D: ?Sized, U: ?Sized, V> Neg for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Neg,
    U: Units<V>,
    V: Signed + Conversion<V>, 
[src]

type Output = Quantity<D, U, V>

The resulting type after applying the - operator.

impl<D: ?Sized, U: ?Sized, V> Ord for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Ord
[src]

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> PartialEq<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> PartialOrd<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + PartialOrd
[src]

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Rem<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: Rem,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

type Output = Quantity<D, Ul, V>

The resulting type after applying the % operator.

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> RemAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: RemAssign,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + RemAssign
[src]

impl<D: ?Sized, U: ?Sized, V> Saturating for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Saturating,
    U: Units<V>,
    V: Num + Conversion<V> + Saturating
[src]

impl<D: ?Sized, U: ?Sized, V> Serialize for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Serialize
[src]

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> Sub<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: Sub,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

type Output = Quantity<D, Ul, V>

The resulting type after applying the - operator.

impl<Ul: ?Sized, Ur: ?Sized, V> Sub<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V>, 
[src]

type Output = ThermodynamicTemperature<Ul, V>

The resulting type after applying the - operator.

impl<D: ?Sized, Ul: ?Sized, Ur: ?Sized, V> SubAssign<Quantity<D, Ur, V>> for Quantity<D, Ul, V> where
    D: Dimension,
    D::Kind: SubAssign,
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + SubAssign<V>, 
[src]

impl<Ul: ?Sized, Ur: ?Sized, V> SubAssign<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = PInt<UInt<UTerm, B1>>, T = Z0, N = Z0> + 'static, Ur, V>> for ThermodynamicTemperature<Ul, V> where
    Ul: Units<V>,
    Ur: Units<V>,
    V: Num + Conversion<V> + SubAssign<V>, 
[src]

impl<D: ?Sized, U: ?Sized, V> Sum<Quantity<D, U, V>> for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Add,
    U: Units<V>,
    V: Num + Conversion<V> + Sum
[src]

impl<U: ?Sized, V> TryFrom<Quantity<dyn Dimension<J = Z0, Kind = dyn Kind + 'static, I = Z0, L = Z0, M = Z0, Th = Z0, T = PInt<UInt<UTerm, B1>>, N = Z0> + 'static, U, V>> for Duration where
    U: Units<V>,
    V: Num + Conversion<V> + PartialOrd + ToPrimitive,
    second: Conversion<V, T = V::T>,
    nanosecond: Conversion<V, T = V::T>, 
[src]

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.

type Error = TryFromError

The type returned in the event of a conversion error.

impl<D: ?Sized, U: ?Sized, V> Unpin for Quantity<D, U, V> where
    D: Dimension,
    U: Units<V>,
    V: Num + Conversion<V> + Unpin
[src]

impl<D: ?Sized, U: ?Sized, V> Zero for Quantity<D, U, V> where
    D: Dimension,
    D::Kind: Add,
    U: Units<V>,
    V: Num + Conversion<V>, 
[src]

Auto Trait Implementations

impl<D: ?Sized, U: ?Sized, V> RefUnwindSafe for Quantity<D, U, V> where
    D: RefUnwindSafe,
    U: RefUnwindSafe,
    V: RefUnwindSafe

impl<D: ?Sized, U: ?Sized, V> Send for Quantity<D, U, V> where
    V: Send

impl<D: ?Sized, U: ?Sized, V> Sync for Quantity<D, U, V> where
    V: Sync

impl<D: ?Sized, U: ?Sized, V> UnwindSafe for Quantity<D, U, V> where
    D: UnwindSafe,
    U: UnwindSafe,
    V: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> DeserializeOwned for T where
    T: for<'de> Deserialize<'de>, 
[src]

impl<T> From<!> for T[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, Rhs> NumAssignOps<Rhs> for T where
    T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>, 
[src]

impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
    T: Sub<Rhs, Output = Output> + Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Add<Rhs, Output = Output> + Rem<Rhs, Output = Output>, 
[src]

impl<T> Same<T> for T[src]

type Output = T

Should always be Self

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.