Struct const_units::Quantity

pub struct Quantity<V, const UNITS: SI>(pub V);

A value with dimensionality

Tuple Fields

0: V

Implementations

impl<V, const UNITS: SI> Quantity<V, UNITS>

pub fn powi<const EXP: i32>(self) -> Quantity<V::Output, { _ }>

where V: Pow<i32>,

Take the power to an integer

assert_eq!(Quantity::<f64, { meter }>(2.).powi::<2>(), Quantity::<f64, { meter.powi(2) }>(4.));

pub fn powf<const EXP: (i32, u32)>(self) -> Quantity<V::Output, { _ }>

where V: Pow<f64>,

Take the power to a fraction

assert_eq!(Quantity::<f64, { meter }>(4.).powf::<{(1, 2)}>(), Quantity::<f64, { meter.powf((1, 2)) }>(2.));

pub fn convert_to<const NEW_UNITS: SI>(self) -> Quantity<V, NEW_UNITS>

where Bool<{ _ }>: True, V: Mul<V, Output = V> + Div<V, Output = V> + NumCast,

Convert a Quantity to a different set of units

Okay

// Converting minutes to seconds
assert_eq!(Quantity::<f64, { minute }>(1.).convert_to::<{ second }>(), Quantity::<f64, { second }>(60.))

Broken

// Can't convert meters to seconds
assert_eq!(Quantity::<f64, { meter }>(1.).convert_to::<{ second }>(), Quantity::<f64, { second }>(1.))

impl<V: Display, const UNITS: SI> Quantity<V, UNITS>

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

where Bool<{ _ }>: True,

Write the quantity to a formatter using the given units. Must be parseable by crate::si.

For copy/paste purposes: ⋅

pub fn format_as<const AS: &'static str>(&self) -> String

where Bool<{ _ }>: True,

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

Multiplication symbol for copy/paste purposes: ⋅

Okay:

assert_eq!(Quantity::<f64, newton>(1.).format_as::<"N">(), "1 N");

Broken:

assert_eq!(Quantity::<f64, newton>(1.).format_as::<"K">(), "1 K");

Trait Implementations

impl<R, O, T: Add<R, Output = O>, const UNITS: SI> Add<Quantity<R, UNITS>> for Quantity<T, UNITS>

Units must be the same for addition

type Output = Quantity<O, UNITS>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<R, T: AddAssign<R>, const UNITS: SI> AddAssign<Quantity<R, UNITS>> for Quantity<T, UNITS>

Units must be the same for addition

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

Performs the += operation.

impl<V: Clone, const UNITS: SI> Clone for Quantity<V, UNITS>

fn clone(&self) -> Quantity<V, UNITS>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V: Debug, const UNITS: SI> Debug for Quantity<V, UNITS>

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

Formats the value using the given formatter.

impl<V> Deref for Quantity<V, DIMENSIONLESS>

Arbitrary math operations are only reasonable on dimensionless values

type Target = V

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<V> DerefMut for Quantity<V, DIMENSIONLESS>

Arbitrary math operations are only reasonable on dimensionless values

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<V: Display, const UNITS: SI> Display for Quantity<V, UNITS>

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

Formats the value using the given formatter.

impl<R, O, T: Div<R, Output = O>, const LHS_UNITS: SI, const RHS_UNITS: SI> Div<Quantity<R, RHS_UNITS>> for Quantity<T, LHS_UNITS>

where Quantity<O, { _ }>: Sized,

Division divides the units

type Output = Quantity<O, { SI::div(LHS_UNITS, RHS_UNITS) }>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<R, T: DivAssign<R>, const UNITS: SI> DivAssign<Quantity<R, DIMENSIONLESS>> for Quantity<T, UNITS>

Scaling by a dimensionless value is OK

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

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, O, T: Mul<R, Output = O>, const LHS_UNITS: SI, const RHS_UNITS: SI> Mul<Quantity<R, RHS_UNITS>> for Quantity<T, LHS_UNITS>

where Quantity<O, { _ }>: Sized,

Multiplications multiplies the units

type Output = Quantity<O, { SI::mul(LHS_UNITS, RHS_UNITS) }>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<R, T: MulAssign<R>, const UNITS: SI> MulAssign<Quantity<R, DIMENSIONLESS>> for Quantity<T, UNITS>

Scaling by a dimensionless value is OK

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

Performs the *= operation.

impl<V: Ord, const UNITS: SI> Ord for Quantity<V, UNITS>

fn cmp(&self, other: &Quantity<V, UNITS>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<V: PartialEq, const UNITS: SI> PartialEq for Quantity<V, UNITS>

fn eq(&self, other: &Quantity<V, UNITS>) -> 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, const UNITS: SI> PartialOrd for Quantity<V, UNITS>

fn partial_cmp(&self, other: &Quantity<V, UNITS>) -> 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, O, T: Sub<R, Output = O>, const UNITS: SI> Sub<Quantity<R, UNITS>> for Quantity<T, UNITS>

Units must be the same for addition

type Output = Quantity<O, UNITS>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<R, T: SubAssign<R>, const UNITS: SI> SubAssign<Quantity<R, UNITS>> for Quantity<T, UNITS>

Units must be the same for addition

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

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, const UNITS: SI> Copy for Quantity<V, UNITS>

impl<V: Eq, const UNITS: SI> Eq for Quantity<V, UNITS>

impl<V, const UNITS: SI> StructuralEq for Quantity<V, UNITS>

impl<V, const UNITS: SI> StructuralPartialEq for Quantity<V, UNITS>