Struct const_units::DynQuantity

pub struct DynQuantity<V>(pub V, pub SI);

A value with dimensionality, checked at runtime

Tuple Fields

0: V

1: SI

Implementations

impl<V> DynQuantity<V>

pub fn powi(self, exp: i32) -> DynQuantity<V::Output>

where V: Pow<i32>,

Take the power to an integer

assert_eq!(DynQuantity(2., meter).powi(2), DynQuantity(4., meter.powi(2)));

pub fn powf(self, exp: (i32, u32)) -> DynQuantity<V::Output>

where V: Pow<f64>,

Take the power to a fraction

assert_eq!(DynQuantity(4., meter).powf((1, 2)), DynQuantity(2., meter.powf((1, 2))));

pub fn convert_to( self, new_units: SI ) -> Result<DynQuantity<V>, InconsistentUnits>

where V: Mul<V, Output = V> + Div<V, Output = V> + NumCast,

Convert a DynQuantity to a different set of units

Okay

// Converting minutes to seconds
assert_eq!(DynQuantity(1., minute).convert_to(second), Ok(DynQuantity(60., second)));
// Can't convert meters to seconds
assert!(DynQuantity(1., meter).convert_to(second).is_err())

pub fn checked_add<R>( self, rhs: DynQuantity<R> ) -> Result<DynQuantity<<V as Add<R>>::Output>, InconsistentUnits>

where V: Add<R>,

Add two DynQuantitys. Will return an error if they have different units.

pub fn checked_sub<R>( self, rhs: DynQuantity<R> ) -> Result<DynQuantity<<V as Sub<R>>::Output>, InconsistentUnits>

where V: Sub<R>,

Subtract two DynQuantitys. Will return an error if they have different units.

impl<V: Display> DynQuantity<V>

pub fn write_as( &self, units: &'static str, f: &mut Formatter<'_> ) -> Result<(), Error>

Write the quantity to a formatter using the given units. Must be parseable by crate::si. Will return core::fmt::Error if units couldn’t be parsed or if they aren’t equal to the DynQuantity’s units.

For copy/paste purposes: ⋅

pub fn format_as( &self, units: &'static str ) -> Result<String, FormatAsError<'_>>

Format the quantity using the given units. Must be parseable by crate::si.

Multiplication symbol for copy/paste purposes: ⋅

Okay:

assert_eq!(DynQuantity(1., newton).format_as("N"), Ok("1 N".to_owned()));
assert!(DynQuantity(1., newton).format_as("K").is_err());

Trait Implementations

impl<R, T: Add<R>> Add<DynQuantity<R>> for DynQuantity<T>

type Output = DynQuantity<<T as Add<R>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: DynQuantity<R>) -> Self::Output

Performs the + operation.

impl<R, T: AddAssign<R>> AddAssign<DynQuantity<R>> for DynQuantity<T>

Units must be the same for addition

fn add_assign(&mut self, rhs: DynQuantity<R>)

Performs the += operation.

impl<V: Clone> Clone for DynQuantity<V>

fn clone(&self) -> DynQuantity<V>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V: Debug> Debug for DynQuantity<V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<V: Display> Display for DynQuantity<V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<R, T: Div<R>> Div<DynQuantity<R>> for DynQuantity<T>

type Output = DynQuantity<<T as Div<R>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: DynQuantity<R>) -> Self::Output

Performs the / operation.

impl<R, T: DivAssign<R>> DivAssign<DynQuantity<R>> for DynQuantity<T>

fn div_assign(&mut self, rhs: DynQuantity<R>)

Performs the /= operation.

impl<V, const UNITS: SI> From<Quantity<V, UNITS>> for DynQuantity<V>

fn from(value: Quantity<V, UNITS>) -> Self

Converts to this type from the input type.

impl<R, T: Mul<R>> Mul<DynQuantity<R>> for DynQuantity<T>

type Output = DynQuantity<<T as Mul<R>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: DynQuantity<R>) -> Self::Output

Performs the * operation.

impl<R, T: MulAssign<R>> MulAssign<DynQuantity<R>> for DynQuantity<T>

fn mul_assign(&mut self, rhs: DynQuantity<R>)

Performs the *= operation.

impl<V: PartialEq> PartialEq for DynQuantity<V>

fn eq(&self, other: &DynQuantity<V>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V: PartialOrd> PartialOrd for DynQuantity<V>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<R, T: Sub<R>> Sub<DynQuantity<R>> for DynQuantity<T>

Units must be the same for addition

type Output = DynQuantity<<T as Sub<R>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: DynQuantity<R>) -> Self::Output

Performs the - operation.

impl<R, T: SubAssign<R>> SubAssign<DynQuantity<R>> for DynQuantity<T>

Units must be the same for addition

fn sub_assign(&mut self, rhs: DynQuantity<R>)

Performs the -= operation.

impl<V, const UNITS: SI> TryFrom<DynQuantity<V>> for Quantity<V, UNITS>

type Error = InconsistentUnits

The type returned in the event of a conversion error.

fn try_from(value: DynQuantity<V>) -> Result<Self, Self::Error>

Performs the conversion.

impl<V: Copy> Copy for DynQuantity<V>

impl<V: Eq> Eq for DynQuantity<V>

impl<V> StructuralEq for DynQuantity<V>

impl<V> StructuralPartialEq for DynQuantity<V>