Struct const_units::SI

pub struct SI {
    pub scale: (i128, u128),
    pub s: (i32, u32),
    pub m: (i32, u32),
    pub kg: (i32, u32),
    pub A: (i32, u32),
    pub K: (i32, u32),
    pub mol: (i32, u32),
    pub cd: (i32, u32),
}

Represents SI units

Each field contains the exponent of the corresponding dimension. Exponents are fractions where the first element of the tuple is the numerator and the second is the denominator. Ensure the fractions are fully simplified if you’re creating an instance directly.

Fields

scale: (i128, u128)

A scale factor - used for units that are constant multiples of other units; ie. minutes or kilometers

s: (i32, u32)

Seconds

m: (i32, u32)

Meters

kg: (i32, u32)

Kilograms

A: (i32, u32)

Amperes

K: (i32, u32)

Kelvin

mol: (i32, u32)

Moles

cd: (i32, u32)

Candelas

Implementations

impl SI

pub const fn scale_by(self, scale: (i128, u128)) -> Self

Multiply the scale factor by a given constant

assert_eq!(second.scale_by((60, 1)), minute)

pub const fn mul(self, rhs: Self) -> Self

Multiply SI units

assert_eq!(newton.mul(meter), joule)

pub const fn div(self, rhs: Self) -> Self

Divide SI units

assert_eq!(joule.div(second), watt);

pub const fn powi(self, v: i32) -> Self

Raise SI units to an integer power

assert_eq!(second.powi(-1), hertz);

pub const fn powf(self, v: (i32, u32)) -> Self

Raise SI units to a fractional power

assert_eq!(meter.powi(2).powf((1, 2)), meter);

Panics

Panics if scale can’t be raised to the given power without losing precision

meter.scale_by((2, 1)).powf((1, 2)); // `2` isn't a square number

pub const fn checked_powf(self, v: (i32, u32)) -> Option<Self>

A checked version of pow

assert_eq!(meter.powi(2).checked_powf((1, 2)), Some(meter));
assert_eq!(meter.scale_by((2, 1)).checked_powf((1, 2)), None);

pub const fn const_eq(self, other: SI) -> bool

Compare units in constant functions

pub const fn same_dimension(self, other: SI) -> bool

Determine whether two units measure the same dimension

use const_units::si;
assert!(si("min").same_dimension(si("s")));
assert!(!si("cd").same_dimension(si("s")));

Trait Implementations

impl Clone for SI

fn clone(&self) -> SI

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SI

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

Formats the value using the given formatter.

impl Display for SI

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

Formats the value using the given formatter.

impl PartialEq for SI

fn eq(&self, other: &SI) -> 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 ConstParamTy for SI

impl Copy for SI

impl Eq for SI

impl StructuralEq for SI

impl StructuralPartialEq for SI