Struct xenon::Xe

pub struct Xe<T, B = U10, V = u64>(_, _, _);

Implementations

impl<T, B> Xe<T, B>

pub fn from_parts(n: u64, t: T) -> Selfwhere
    B: Default,

pub fn from_str_at_precision(s: &str, t: T) -> Result<Self, ()>where
    B: Default,
    isize: From<T>,
    T: Copy,

pub fn from_quanta(n: u64) -> Selfwhere
    T: Default,
    B: Default,

pub fn from_u64(n: u64) -> Option<Self>where
    T: Default,
    B: Default + Pow<T>,
    <B as Pow<T>>::Output: Unsigned,

pub fn from_f64(f: f64) -> Option<Self>where
    T: Default,
    B: Default + Pow<T>,
    <B as Pow<T>>::Output: Unsigned,

pub fn truncated_div<T1, T2>(self, other: Xe<T1, B>) -> Xe<T2, B>where
    T1: Add<T2>,
    T2: Default,
    Sum<T1, T2>: Sub<T>,
    Diff<Sum<T1, T2>, T>: Unsigned,
    B: Unsigned,

pub fn truncated_mul<T1, T2>(self, other: Xe<T1, B>) -> Xe<T2, B>where
    T: Add<T1>,
    T2: Default,
    Sum<T, T1>: Sub<T2>,
    Diff<Sum<T, T1>, T2>: Unsigned,
    B: Unsigned,

The output type must be no greater in precision than the type that would accomodate the result of the multiplication without truncation (statically checked).

pub fn is_zero(self) -> boolwhere
    T: Add<T>,
    T: PartialEq<<T as Add<T>>::Output>,

Return whether the value is the additive identity for its types.

Trait Implementations

impl<T, B> Add<Xe<T, B, u64>> for Xe<T, B>

type Output = Xe<T, B, u64>

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl<T: Clone, B: Clone, V: Clone> Clone for Xe<T, B, V>

fn clone(&self) -> Xe<T, B, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, B> Debug for Xe<T, B>where
    T: Debug,
    B: Debug,
    Xe<T, B>: Display,

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

Formats the value using the given formatter.

impl<T: Default, B: Default, V: Default> Default for Xe<T, B, V>

fn default() -> Xe<T, B, V>

Returns the “default value” for a type.

impl<T, U10> Display for Xe<T, U10>where
    T: ToIsize,

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

Formats the value using the given formatter.

impl<T> FromStr for Xe<T, U10>where
    T: Default + Unsigned,

type Err = ()

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

impl<T0, T1, B> Mul<Xe<T1, B, u64>> for Xe<T0, B>where
    T0: Add<T1>,

type Output = Xe<<T0 as Add<T1>>::Output, B, u64>

The resulting type after applying the * operator.

fn mul(self, other: Xe<T1, B>) -> Self::Output

Performs the * operation.

impl<T, B> Ord for Xe<T, B>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<T, B> PartialEq<Xe<T, B, u64>> for Xe<T, B>

fn eq(&self, other: &Self) -> 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, B> PartialEq<f64> for Xe<T, B>where
    T: Default,
    B: Default + Pow<T>,
    <B as Pow<T>>::Output: Unsigned,

fn eq(&self, other: &f64) -> 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, B> PartialOrd<Xe<T, B, u64>> for Xe<T, B>

fn partial_cmp(&self, other: &Self) -> 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<T, B> Sub<Xe<T, B, u64>> for Xe<T, B>

type Output = Xe<T, B, u64>

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl<T: Copy, B: Copy, V: Copy> Copy for Xe<T, B, V>

impl<T, B> Eq for Xe<T, B>