Struct Unit 

#[repr(C)]
pub struct Unit {
    pub second: i32,
    pub meter: i32,
    pub kilogram: i32,
    pub ampere: i32,
    pub kelvin: i32,
    pub mol: i32,
    pub candela: i32,
}

Struct representing a unit of measurement in the SI system via the exponents of the base units. The unit is purely defined by the values of its fields, meaning that it can change at runtime. The struct implements basic arithmetic functions such as multiplication and division (via the Mul, MulAssign, Div, DivAssign traits), exponentiation (Unit::powi) and a fallible version of root calculation (Unit::try_nthroot).

Serialization and deserialization

If the serde feature is enabled, this struct can be serialized and deserialized. Serialization creates the “standard” serde representation one would expect from the Serialize macro.

An Unit can be deserialized from both its “standard” serialized representation and from a PredefUnit variant:

use dyn_quantity::Unit;

// Direct deserialization
let str = "---\nsecond: -3\nmeter: 2\nkilogram: 1\nampere: -1\nkelvin: 0\nmol: 0\ncandela: 0";
let unit_direct: Unit = serde_yaml::from_str(str).unwrap();

// Deserialization from PredefUnit
let str = "ElectricVoltage";
let unit_predef: Unit = serde_yaml::from_str(str).unwrap();
assert_eq!(unit_predef, unit_direct);

Fields

second: i32

Exponent for the SI base unit of time.

meter: i32

Exponent for the SI base unit of length.

kilogram: i32

Exponent for the SI base unit of mass.

ampere: i32

Exponent for the SI base unit of electrical current.

kelvin: i32

Exponent for the SI base unit of temperature.

mol: i32

Exponent for the SI base unit of amount of substance.

candela: i32

Exponent for the SI base unit of luminous intensity

Implementations

impl Unit

pub fn powi(self, n: i32) -> Unit

Raises self to an integer power.

Examples

use dyn_quantity::Unit;

let exponents = Unit::from([0, 1, 0, 2, 0, -2, 0]);
let array: [i32; 7] = exponents.powi(2).into();
assert_eq!(array, [0, 2, 0, 4, 0, -4, 0]);

pub fn try_nthroot(self, n: i32) -> Result<Unit, RootError>

Tries to calculate the nth root of self. This operation fails if any of the exponents is not divisible by n.

Examples

use dyn_quantity::Unit;

let unit = Unit::from([0, 2, 0, 2, 0, -4, 0]);

// It is possible to calculate the square root:
let array: [i32; 7] = unit.clone().try_nthroot(2).unwrap().into();
assert_eq!(array, [0, 1, 0, 1, 0, -2, 0]);

// But not the cubic root (not all exponents are divisible by 3):
assert!(unit.try_nthroot(3).is_err());

pub fn is_dimensionless(&self) -> bool

Returns whether Unit is dimensionless (all exponents are zero) or not.

Trait Implementations

impl Clone for Unit

fn clone(&self) -> Unit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Unit

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

Formats the value using the given formatter.

impl Default for Unit

fn default() -> Unit

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Unit

fn deserialize<D>( deserializer: D, ) -> Result<Unit, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Unit

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

Formats the value using the given formatter.

impl Div for Unit

type Output = Unit

The resulting type after applying the / operator.

fn div(self, rhs: Unit) -> <Unit as Div>::Output

Performs the / operation.

impl DivAssign for Unit

fn div_assign(&mut self, rhs: Unit)

Performs the /= operation.

impl From<[i32; 7]> for Unit

fn from(array: [i32; 7]) -> Unit

Converts an array of seven i32 values into Unit.

The individual array elements are interpreted as follows:

• array[0]: Exponent of second
• array[1]: Exponent of meter
• array[2]: Exponent of kilogram
• array[3]: Exponent of ampere
• array[4]: Exponent of kelvin
• array[5]: Exponent of mol
• array[6]: Exponent of candela

impl From<PredefUnit> for Unit

fn from(value: PredefUnit) -> Unit

Converts to this type from the input type.

impl From<Unit> for [i32; 7]

fn from(value: Unit) -> [i32; 7]

Converts an Unit into an array of seven i32.

The exponents are put into the array in the following order:

• array[0]: Exponent of second
• array[1]: Exponent of meter
• array[2]: Exponent of kilogram
• array[3]: Exponent of ampere
• array[4]: Exponent of kelvin
• array[5]: Exponent of mol
• array[6]: Exponent of candela

impl Hash for Unit

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul for Unit

type Output = Unit

The resulting type after applying the * operator.

fn mul(self, rhs: Unit) -> <Unit as Mul>::Output

Performs the * operation.

impl MulAssign for Unit

fn mul_assign(&mut self, rhs: Unit)

Performs the *= operation.

impl PartialEq for Unit

fn eq(&self, other: &Unit) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Unit

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for Unit

impl Eq for Unit

impl StructuralPartialEq for Unit