Struct EngineeringQuantity

pub struct EngineeringQuantity<T: EQSupported<T>> { /* private fields */ }

Helper type for expressing numbers in engineering notation

Type parameter

The type parameter T is the underlying storage type used for the significand of the number. That is to say, an EngineeringQuantity<u32> uses a u32 to store the numeric part.

Implementations

impl<T: EQSupported<T>> EngineeringQuantity<T>

pub fn with_precision( &self, max_significant_figures: usize, ) -> DisplayAdapter<T>

Creates a standard DisplayAdapter for this object, with the given precision.

use engineering_repr::EngineeringQuantity as EQ;
let ee = EQ::<i32>::from(1234567);
assert_eq!(ee.with_precision(2).to_string(), "1.2M");

pub fn rkm_with_precision( &self, max_significant_figures: usize, ) -> DisplayAdapter<T>

Creates an RKM DisplayAdapter for this object in RKM mode, with the given precision.

use engineering_repr::EngineeringQuantity as EQ;
let ee = EQ::<i32>::from(1234567);
assert_eq!(ee.rkm_with_precision(2).to_string(), "1M2");

impl<T: EQSupported<T>> EngineeringQuantity<T>

pub fn from_raw(significand: T, exponent: i8) -> Self

Raw constructor from component parts

pub fn to_raw(self) -> (T, i8)

Raw accessor to retrieve the component parts

impl<T: EQSupported<T>> EngineeringQuantity<T>

pub fn convert<U: EQSupported<U> + From<T>>(&self) -> EngineeringQuantity<U>

Conversion to a different storage type. If you can convert from type A to type B, then you can convert from EngineeringQuantity<A> to EngineeringQuantity<B>.

use engineering_repr::EngineeringQuantity as EQ;
let q = EQ::from_raw(42u32, 0);
let q2 = q.convert::<u64>();
assert_eq!(q2.to_raw(), (42u64, 0));

pub fn try_convert<U: EQSupported<U> + TryFrom<T>>( &self, ) -> Result<EngineeringQuantity<U>, <U as TryFrom<T>>::Error>

Fallible conversion to a different storage type.

Note that conversion only fails if the significand doesn’t fit into the destination storage type, without reference to the exponent. This means that two numbers, which might be equal, may not both be convertible to the same destination type if they are not normalised. For example:

use engineering_repr::EngineeringQuantity as EQ;
let million1 = EQ::from_raw(1, 2); // 1e6
let million2 = EQ::from_raw(1_000_000, 0);
assert_eq!(million1, million2);
let r1 = million1.try_convert::<u16>().unwrap(); // OK, because stored as (1,2)
let r2 = million2.try_convert::<u16>().expect_err("overflow"); // Overflow, because 1_000_000 won't fit into a u16

impl<T: EQSupported<T>> EngineeringQuantity<T>

pub fn normalise(self) -> Self

Scales the number to remove any unnecessary groups of trailing zeroes.

Trait Implementations

impl<T: Clone + EQSupported<T>> Clone for EngineeringQuantity<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + EQSupported<T>> Debug for EngineeringQuantity<T>

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

Formats the value using the given formatter.

impl<T: Default + EQSupported<T>> Default for EngineeringQuantity<T>

fn default() -> EngineeringQuantity<T>

Returns the “default value” for a type.

impl<'de, T: EQSupported<T> + FromStr> Deserialize<'de> for EngineeringQuantity<T>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: EQSupported<T>> Display for EngineeringQuantity<T>

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

Default behaviour is to output to 3 significant figures, standard (not RKM) mode. See EngineeringQuantity::default().

Examples

use engineering_repr::EngineeringQuantity as EQ;
let ee1 = EQ::<i32>::from(1200);
assert_eq!(ee1.to_string(), "1.20k");
let ee2 = EQ::<i32>::from(123456);
assert_eq!(ee2.to_string(), "123k");

impl<T: EQSupported<T>, U> From<T> for EngineeringQuantity<U>

where U: From<T> + EQSupported<U>,

fn from(value: T) -> Self

Integers can always be promoted on conversion to EngineeringQuantity. (For demotions, you have to convert the primitive yourself and handle any failures.)

let i = 42u32;
let _e = engineering_repr::EngineeringQuantity::<u64>::from(i);

impl<T: EQSupported<T> + FromStr> FromStr for EngineeringQuantity<T>

fn from_str(s: &str) -> Result<Self, Self::Err>

Example

use engineering_repr::EngineeringQuantity as EQ;
use std::str::FromStr as _;
let eq = EQ::<i64>::from_str("1.5k").unwrap();
assert_eq!(i64::try_from(eq).unwrap(), 1500);
// RKM style strings
let eq2 = EQ::<i64>::from_str("1k5").unwrap();
assert_eq!(eq, eq2);

type Err = Error

The associated error which can be returned from parsing.

impl<T: EQSupported<T> + TryFrom<EngineeringQuantity<T>>> PartialEq for EngineeringQuantity<T>

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

use engineering_repr::EngineeringQuantity as EQ;
let q1 = EQ::from_raw(42u32,0);
let q2 = EQ::from_raw(42u32,0);
assert_eq!(q1, q2);
let q3 = EQ::from_raw(42,1);
let q4 = EQ::from_raw(42000,0);
assert_eq!(q3, q4);

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<T: EQSupported<T> + TryFrom<EngineeringQuantity<T>>> PartialOrd for EngineeringQuantity<T>

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

use engineering_repr::EngineeringQuantity as EQ;
use more_asserts::assert_lt;
let q2 = EQ::from_raw(41999,0);
let q3 = EQ::from_raw(42,1);
let q4 = EQ::from_raw(42001,0);
assert_lt!(q2, q3);
assert_lt!(q3, q4);

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<T: EQSupported<T>> Serialize for EngineeringQuantity<T>

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<U: EQSupported<U>> TryFrom<EngineeringQuantity<U>> for i128

where i128: TryFrom<U>,

fn try_from(eq: EngineeringQuantity<U>) -> Result<Self, Error>

Conversion to integer is always fallible, as the exponent might cause us to under or overflow.

use engineering_repr::EngineeringQuantity;
use engineering_repr::Error as EErr;
let i = EngineeringQuantity::<u32>::from_raw(11, 1);
assert_eq!(i128::try_from(i).unwrap(), 11000);

type Error = Error

The type returned in the event of a conversion error.

impl<U: EQSupported<U>> TryFrom<EngineeringQuantity<U>> for i16

where i16: TryFrom<U>,

fn try_from(eq: EngineeringQuantity<U>) -> Result<Self, Error>

Conversion to integer is always fallible, as the exponent might cause us to under or overflow.

use engineering_repr::EngineeringQuantity;
use engineering_repr::Error as EErr;
let i = EngineeringQuantity::<u32>::from_raw(11, 1);
assert_eq!(i16::try_from(i).unwrap(), 11000);

type Error = Error

The type returned in the event of a conversion error.

impl<U: EQSupported<U>> TryFrom<EngineeringQuantity<U>> for i32

where i32: TryFrom<U>,

fn try_from(eq: EngineeringQuantity<U>) -> Result<Self, Error>

Conversion to integer is always fallible, as the exponent might cause us to under or overflow.

use engineering_repr::EngineeringQuantity;
use engineering_repr::Error as EErr;
let i = EngineeringQuantity::<u32>::from_raw(11, 1);
assert_eq!(i32::try_from(i).unwrap(), 11000);

type Error = Error

The type returned in the event of a conversion error.

impl<U: EQSupported<U>> TryFrom<EngineeringQuantity<U>> for i64

where i64: TryFrom<U>,

fn try_from(eq: EngineeringQuantity<U>) -> Result<Self, Error>

Conversion to integer is always fallible, as the exponent might cause us to under or overflow.

use engineering_repr::EngineeringQuantity;
use engineering_repr::Error as EErr;
let i = EngineeringQuantity::<u32>::from_raw(11, 1);
assert_eq!(i64::try_from(i).unwrap(), 11000);

type Error = Error

The type returned in the event of a conversion error.

impl<U: EQSupported<U>> TryFrom<EngineeringQuantity<U>> for isize

where isize: TryFrom<U>,

fn try_from(eq: EngineeringQuantity<U>) -> Result<Self, Error>

Conversion to integer is always fallible, as the exponent might cause us to under or overflow.

use engineering_repr::EngineeringQuantity;
use engineering_repr::Error as EErr;
let i = EngineeringQuantity::<u32>::from_raw(11, 1);
assert_eq!(isize::try_from(i).unwrap(), 11000);

type Error = Error

The type returned in the event of a conversion error.

impl<U: EQSupported<U>> TryFrom<EngineeringQuantity<U>> for u128

where u128: TryFrom<U>,

fn try_from(eq: EngineeringQuantity<U>) -> Result<Self, Error>

Conversion to integer is always fallible, as the exponent might cause us to under or overflow.

use engineering_repr::EngineeringQuantity;
use engineering_repr::Error as EErr;
let i = EngineeringQuantity::<u32>::from_raw(11, 1);
assert_eq!(u128::try_from(i).unwrap(), 11000);

type Error = Error

The type returned in the event of a conversion error.

impl<U: EQSupported<U>> TryFrom<EngineeringQuantity<U>> for u16

where u16: TryFrom<U>,

fn try_from(eq: EngineeringQuantity<U>) -> Result<Self, Error>

Conversion to integer is always fallible, as the exponent might cause us to under or overflow.

use engineering_repr::EngineeringQuantity;
use engineering_repr::Error as EErr;
let i = EngineeringQuantity::<u32>::from_raw(11, 1);
assert_eq!(u16::try_from(i).unwrap(), 11000);

type Error = Error

The type returned in the event of a conversion error.

impl<U: EQSupported<U>> TryFrom<EngineeringQuantity<U>> for u32

where u32: TryFrom<U>,

fn try_from(eq: EngineeringQuantity<U>) -> Result<Self, Error>

Conversion to integer is always fallible, as the exponent might cause us to under or overflow.

use engineering_repr::EngineeringQuantity;
use engineering_repr::Error as EErr;
let i = EngineeringQuantity::<u32>::from_raw(11, 1);
assert_eq!(u32::try_from(i).unwrap(), 11000);

type Error = Error

The type returned in the event of a conversion error.

impl<U: EQSupported<U>> TryFrom<EngineeringQuantity<U>> for u64

where u64: TryFrom<U>,

fn try_from(eq: EngineeringQuantity<U>) -> Result<Self, Error>

Conversion to integer is always fallible, as the exponent might cause us to under or overflow.

use engineering_repr::EngineeringQuantity;
use engineering_repr::Error as EErr;
let i = EngineeringQuantity::<u32>::from_raw(11, 1);
assert_eq!(u64::try_from(i).unwrap(), 11000);

type Error = Error

The type returned in the event of a conversion error.

impl<U: EQSupported<U>> TryFrom<EngineeringQuantity<U>> for usize

where usize: TryFrom<U>,

fn try_from(eq: EngineeringQuantity<U>) -> Result<Self, Error>

Conversion to integer is always fallible, as the exponent might cause us to under or overflow.

use engineering_repr::EngineeringQuantity;
use engineering_repr::Error as EErr;
let i = EngineeringQuantity::<u32>::from_raw(11, 1);
assert_eq!(usize::try_from(i).unwrap(), 11000);

type Error = Error

The type returned in the event of a conversion error.

impl<T: Copy + EQSupported<T>> Copy for EngineeringQuantity<T>