Enum lib_rapid::math::unit_conversion::SIPrefix

pub enum SIPrefix<T> {
    Yocto(T),
    Zepto(T),
    Atto(T),
    Femto(T),
    Pico(T),
    Nano(T),
    Micro(T),
    Milli(T),
    Centi(T),
    Deci(T),
    Unity(T),
    Deca(T),
    Hecto(T),
    Kilo(T),
    Mega(T),
    Giga(T),
    Tera(T),
    Peta(T),
    Exa(T),
    Zetta(T),
    Yotta(T),
}

SI-Prefixes as used in several fields.

Variants

Yocto(T)

x · 10⁻²⁴.

Zepto(T)

x · 10⁻²¹.

Atto(T)

x · 10⁻¹⁸.

Femto(T)

x · 10⁻¹⁵.

Pico(T)

x · 10⁻¹².

Nano(T)

x · 10⁻⁹.

Micro(T)

x · 10⁻⁶.

Milli(T)

x · 10⁻³.

Centi(T)

x · 10⁻².

Deci(T)

x · 10⁻¹.

Unity(T)

x · 10⁰.

Deca(T)

x · 10¹.

Hecto(T)

x · 10².

Kilo(T)

x · 10³.

Mega(T)

x · 10⁶.

Giga(T)

x · 10⁹.

Tera(T)

x · 10¹².

Peta(T)

x · 10¹⁵.

Exa(T)

x · 10¹⁸.

Zetta(T)

x · 10²¹.

Yotta(T)

x · 10²⁴.

Implementations

impl<T: Into<f64> + Copy> SIPrefix<T>

pub fn to_decimal_f32(&self) -> f32

Converts a SI-Prefix value into a regular f32.

Returns

A f32.

Examples

use lib_rapid::math::unit_conversion::SIPrefix;
assert_eq!(0.000_000_000_000_000_000_000_005, SIPrefix::Yocto(5.0).to_decimal_f32());
assert_eq!(0.5, SIPrefix::Deci(5.0).to_decimal_f32());
assert_eq!(5000.0, SIPrefix::Kilo(5.0).to_decimal_f32());

impl<T: Into<f64> + Copy> SIPrefix<T>

pub fn to_decimal_f64(&self) -> f64

Converts a SI-Prefix value into a regular f64.

Returns

A f64.

Examples

use lib_rapid::math::unit_conversion::SIPrefix;
assert_eq!(0.000_000_000_000_000_000_000_005, SIPrefix::Yocto(5.0).to_decimal_f64());
assert_eq!(0.5, SIPrefix::Deci(5.0).to_decimal_f64());
assert_eq!(5000.0, SIPrefix::Kilo(5.0).to_decimal_f64());

Trait Implementations

impl<T: Clone> Clone for SIPrefix<T>

fn clone(&self) -> SIPrefix<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Into<f64> + Copy> Into<f32> for SIPrefix<T>

fn into(self) -> f32

Converts this type into the (usually inferred) input type.

impl<T: Into<f64> + Copy> Into<f64> for SIPrefix<T>

fn into(self) -> f64

Converts this type into the (usually inferred) input type.

impl<T: PartialEq> PartialEq for SIPrefix<T>

fn eq(&self, other: &SIPrefix<T>) -> 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<T: Copy> Copy for SIPrefix<T>

impl<T> StructuralPartialEq for SIPrefix<T>