Struct fraction::prelude::GenericDecimal

pub struct GenericDecimal<T, P>(/* private fields */)
where
    T: Clone + Integer,
    P: Copy + Integer + Into<usize>;

Decimal type implementation

T is the type for data P is the type for precision

Uses GenericFraction internally to represent the data. Precision is being used for representation purposes only. Calculations do not use precision, but comparison does.

Examples

use fraction::GenericDecimal;

type Decimal = GenericDecimal<u64, u8>;

let d1 = Decimal::from(12);
let d2 = Decimal::from(0.5);

let mul = d1 * d2;
let div = d1 / d2;
let add = d1 + d2;

assert_eq!(mul, 6.into());
assert_eq!(div, Decimal::from("24.00"));
assert_eq!(add, Decimal::from(12.5));

Implementations

impl<T, P> GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

pub const fn sign(&self) -> Option<Sign>

where T: CheckedAdd + CheckedMul + CheckedSub,

Returns Some(Sign) of the decimal, or None if NaN is the value

pub fn set_precision(self, precision: P) -> Self

Sets representational precision for the Decimal The precision is only used for comparison and representation, not for calculations.

This is suggested method for you to utilise if you know what precision you want to work with.

Examples

use fraction::GenericDecimal;

type D = GenericDecimal<u32, u8>;

let first = D::from("0.004")  // initial precision is 4
            .set_precision(2);  // but we want to work with 2
let second = D::from("0.006").set_precision(2);

// Even though "first" and "second" both have precision 2
// the actual calculations are still performed with their
// exact initial precision
assert_eq!(first + second, D::from("0.01"));

// The comparison, on the other hand, takes the precision into account
// so the actual compared numbers will be calculated up the highest
// precision of both operands
assert_ne!(  // compares "0.010" with "0.011"
    D::from("0.01"),  // has precision 2
    D::from("0.011")  // has precision 3
);

assert_eq!(  // compares "0.01" with "0.01"
    D::from("0.01").set_precision(2),
    D::from("0.011").set_precision(2)
);

pub const fn get_precision(&self) -> P

Returns the current representational precision for the Decimal

pub fn calc_precision(self, max_precision: Option<P>) -> Self

where T: CheckedMul + DivAssign + MulAssign + SubAssign + ToPrimitive + GenericInteger, P: Bounded + CheckedAdd,

Try to recalculate the representational precision depending on the internal Fraction, which is the actual value.

Performs the actual division until the exact decimal value is calculated, the precision type (P) capacity is reached (e.g. 255 for u8) or max_precision is reached, if it is given.

WARNING

You only need this method if you want to find the max available precision for the current decimal value. However, keep in mind that irrational values (such as 1/3) do not have finite precision, so if this method returns P::MAX (or max_precision), most likely you have an irrational value. Be careful with max numbers for usize - that can take very long time to compute (more than a minute)

pub fn nan() -> Self

pub fn infinity() -> Self

pub fn neg_infinity() -> Self

pub fn neg_zero() -> Self

pub fn min_positive_value() -> Self

where T: Bounded, P: Bounded,

pub const fn is_nan(&self) -> bool

pub const fn is_infinite(&self) -> bool

pub const fn is_finite(&self) -> bool

pub fn is_normal(&self) -> bool

pub fn classify(&self) -> FpCategory

pub fn floor(&self) -> Self

pub fn ceil(&self) -> Self

pub fn round(&self) -> Self

pub fn trunc(&self) -> Self

pub fn fract(&self) -> Self

pub fn abs(&self) -> Self

pub fn signum(&self) -> Self

pub const fn is_sign_positive(&self) -> bool

pub const fn is_sign_negative(&self) -> bool

pub fn mul_add(&self, a: Self, b: Self) -> Self

pub fn recip(&self) -> Self

pub fn map( self, fun: impl FnOnce(GenericFraction<T>) -> GenericFraction<T>, ) -> Self

pub fn map_mut(&mut self, fun: impl FnOnce(&mut GenericFraction<T>))

pub fn map_ref( &self, fun: impl FnOnce(&GenericFraction<T>) -> GenericFraction<T>, ) -> Self

pub fn apply_ref<R>(&self, fun: impl FnOnce(&GenericFraction<T>, P) -> R) -> R

👎Deprecated: Use match decimal {GenericDecimal(fraction, precision) => ... }

pub fn from_fraction(fraction: GenericFraction<T>) -> Self

where T: GenericInteger + ToPrimitive, P: Bounded + CheckedAdd,

Convert from a GenericFraction

Automatically calculates precision, so for “bad” numbers may take a lot of CPU cycles, especially if precision represented by big types (e.g. usize)

Examples

use fraction::{Fraction, Decimal};

let from_fraction = Decimal::from_fraction(Fraction::new(1u64, 3u64));
let from_division = Decimal::from(1) / Decimal::from(3);

let d1 = Decimal::from(4) / from_fraction;
let d2 = Decimal::from(4) / from_division;

assert_eq!(d1, d2);
assert_eq!(d1, Decimal::from(12));

Trait Implementations

impl<'a, O, T, P> Add<O> for &'a GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, &'a T: Add<Output = T>, O: Into<GenericDecimal<T, P>>,

type Output = GenericDecimal<T, P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<O, T, P> Add<O> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, O: Into<GenericDecimal<T, P>>,

type Output = GenericDecimal<T, P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T, P> Add for &'a GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, &'a T: Add<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, T, P> AddAssign<&'a GenericDecimal<T, P>> for GenericDecimal<T, P>

where T: Clone + GenericInteger + AddAssign, P: Copy + GenericInteger + Into<usize>,

fn add_assign(&mut self, other: &'a Self)

Performs the += operation.

impl<O, T, P> AddAssign<O> for GenericDecimal<T, P>

where T: Clone + GenericInteger + AddAssign + MulAssign, P: Copy + GenericInteger + Into<usize>, O: Into<GenericDecimal<T, P>>,

fn add_assign(&mut self, other: O)

Performs the += operation.

impl<T, P> Bounded for GenericDecimal<T, P>

where T: Clone + GenericInteger + Bounded, P: Copy + GenericInteger + Into<usize> + Bounded,

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

impl<T, P> CheckedAdd for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

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

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<T, P> CheckedDiv for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

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

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl<T, P> CheckedMul for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

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

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl<T, P> CheckedSub for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

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

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl<T, P> Clone for GenericDecimal<T, P>

where T: Clone + Integer + Clone, P: Copy + Integer + Into<usize> + Clone,

fn clone(&self) -> GenericDecimal<T, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, P> Debug for GenericDecimal<T, P>

where T: Clone + GenericInteger + From<u8> + ToPrimitive + Debug, P: Copy + Integer + Into<usize>,

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

Formats the value using the given formatter.

impl<T, P> Default for GenericDecimal<T, P>

where T: Clone + Integer, P: Copy + Integer + Into<usize>,

fn default() -> Self

Returns the “default value” for a type.

impl<T, P> Display for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + Integer + Into<usize>,

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

Formats the value using the given formatter.

impl<'a, O, T, P> Div<O> for &'a GenericDecimal<T, P>

where T: Clone + GenericInteger + Div, P: Copy + GenericInteger + Into<usize>, &'a T: Div<Output = T>, O: Into<GenericDecimal<T, P>>,

type Output = GenericDecimal<T, P>

The resulting type after applying the / operator.

fn div(self, other: O) -> Self::Output

Performs the / operation.

impl<O, T, P> Div<O> for GenericDecimal<T, P>

where T: Clone + GenericInteger + Div, P: Copy + GenericInteger + Into<usize>, O: Into<Self>,

type Output = GenericDecimal<T, P>

The resulting type after applying the / operator.

fn div(self, other: O) -> Self::Output

Performs the / operation.

impl<'a, T, P> Div for &'a GenericDecimal<T, P>

where T: Clone + GenericInteger + Div, P: Copy + GenericInteger + Into<usize>, &'a T: Div<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, T, P> DivAssign<&'a GenericDecimal<T, P>> for GenericDecimal<T, P>

where T: Clone + GenericInteger + DivAssign, P: Copy + GenericInteger + Into<usize>,

fn div_assign(&mut self, other: &'a Self)

Performs the /= operation.

impl<O, T, P> DivAssign<O> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, O: Into<Self>,

fn div_assign(&mut self, other: O)

Performs the /= operation.

impl<'a, T, P> From<&'a str> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize> + From<u8>,

fn from(value: &'a str) -> Self

Converts to this type from the input type.

impl<T, P> From<BigInt> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: BigInt) -> Self

Converts to this type from the input type.

impl<T, P> From<BigUint> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: BigUint) -> Self

Converts to this type from the input type.

impl<T, P> From<f32> for GenericDecimal<T, P>

where T: Clone + GenericInteger + FromPrimitive, P: Copy + GenericInteger + Into<usize> + From<u8> + Bounded,

fn from(value: f32) -> Self

Converts to this type from the input type.

impl<T, P> From<f64> for GenericDecimal<T, P>

where T: Clone + GenericInteger + FromPrimitive, P: Copy + GenericInteger + Into<usize> + From<u8> + Bounded,

fn from(value: f64) -> Self

Converts to this type from the input type.

impl<T, P> From<i128> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: i128) -> Self

Converts to this type from the input type.

impl<T, P> From<i16> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: i16) -> Self

Converts to this type from the input type.

impl<T, P> From<i32> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: i32) -> Self

Converts to this type from the input type.

impl<T, P> From<i64> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: i64) -> Self

Converts to this type from the input type.

impl<T, P> From<i8> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: i8) -> Self

Converts to this type from the input type.

impl<T, P> From<isize> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: isize) -> Self

Converts to this type from the input type.

impl<T, P> From<u128> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: u128) -> Self

Converts to this type from the input type.

impl<T, P> From<u16> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: u16) -> Self

Converts to this type from the input type.

impl<T, P> From<u32> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: u32) -> Self

Converts to this type from the input type.

impl<T, P> From<u64> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: u64) -> Self

Converts to this type from the input type.

impl<T, P> From<u8> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: u8) -> Self

Converts to this type from the input type.

impl<T, P> From<usize> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn from(value: usize) -> Self

Converts to this type from the input type.

impl<T, P> FromStr for GenericDecimal<T, P>

where T: Clone + GenericInteger + CheckedAdd + CheckedMul + CheckedSub, P: Copy + GenericInteger + Into<usize> + From<u8> + CheckedAdd,

type Err = ParseError

The associated error which can be returned from parsing.

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

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

impl<T, P> Hash for GenericDecimal<T, P>

where T: Clone + GenericInteger + PartialEq, P: Copy + GenericInteger + Into<usize>,

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

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<'a, O, T, P> Mul<O> for &'a GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, &'a T: Mul<Output = T>, O: Into<GenericDecimal<T, P>>,

type Output = GenericDecimal<T, P>

The resulting type after applying the * operator.

fn mul(self, other: O) -> Self::Output

Performs the * operation.

impl<O, T, P> Mul<O> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, O: Into<GenericDecimal<T, P>>,

type Output = GenericDecimal<T, P>

The resulting type after applying the * operator.

fn mul(self, other: O) -> Self::Output

Performs the * operation.

impl<'a, T, P> Mul for &'a GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, &'a T: Mul<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, T, P> MulAssign<&'a GenericDecimal<T, P>> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn mul_assign(&mut self, other: &'a Self)

Performs the *= operation.

impl<O, T, P> MulAssign<O> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, O: Into<Self>,

fn mul_assign(&mut self, other: O)

Performs the *= operation.

impl<'a, T, P> Neg for &'a GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + Integer + Into<usize>, &'a T: Neg<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, P> Neg for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + Integer + Into<usize>,

type Output = GenericDecimal<T, P>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, P> Num for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize> + From<u8>,

type FromStrRadixErr = ParseError

fn from_str_radix(value: &str, base: u32) -> Result<Self, ParseError>

Convert from a string and radix (typically 2..=36).

impl<T, P> One for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<T, P> Ord for GenericDecimal<T, P>

where T: Clone + GenericInteger + Ord, P: Copy + GenericInteger + Into<usize>,

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

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T, P> PartialEq for GenericDecimal<T, P>

where T: Clone + GenericInteger + PartialEq, P: Copy + GenericInteger + Into<usize>,

fn eq(&self, other: &Self) -> 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<T, P> PartialOrd for GenericDecimal<T, P>

where T: Clone + GenericInteger + PartialOrd, P: Copy + GenericInteger + Into<usize>,

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

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<'a, T, P> Product<&'a GenericDecimal<T, P>> for GenericDecimal<T, P>

where T: Clone + GenericInteger + PartialEq, P: Copy + GenericInteger + Into<usize>,

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<T, P> Product for GenericDecimal<T, P>

where T: Clone + GenericInteger + PartialEq, P: Copy + GenericInteger + Into<usize>,

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, O, T, P> Rem<O> for &'a GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, &'a T: Rem<Output = T>, O: Into<GenericDecimal<T, P>>,

type Output = GenericDecimal<T, P>

The resulting type after applying the % operator.

fn rem(self, other: O) -> Self::Output

Performs the % operation.

impl<O, T, P> Rem<O> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, O: Into<GenericDecimal<T, P>>,

type Output = GenericDecimal<T, P>

The resulting type after applying the % operator.

fn rem(self, other: O) -> Self::Output

Performs the % operation.

impl<'a, T, P> Rem for &'a GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, &'a T: Rem<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'a, T, P> RemAssign<&'a GenericDecimal<T, P>> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn rem_assign(&mut self, other: &'a Self)

Performs the %= operation.

impl<O, T, P> RemAssign<O> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, O: Into<Self>,

fn rem_assign(&mut self, other: O)

Performs the %= operation.

impl<T, P> Signed for GenericDecimal<T, P>

where T: Clone + GenericInteger + Neg, P: Copy + GenericInteger + Into<usize> + From<u8>,

fn abs(&self) -> Self

Computes the absolute value.

fn abs_sub(&self, other: &Self) -> Self

The positive difference of two numbers.

fn signum(&self) -> Self

Returns the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

impl<'a, O, T, P> Sub<O> for &'a GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, &'a T: Sub<Output = T>, O: Into<GenericDecimal<T, P>>,

type Output = GenericDecimal<T, P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<O, T, P> Sub<O> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, O: Into<GenericDecimal<T, P>>,

type Output = GenericDecimal<T, P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T, P> Sub for &'a GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, &'a T: Sub<Output = T>,

type Output = GenericDecimal<T, P>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, T, P> SubAssign<&'a GenericDecimal<T, P>> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

fn sub_assign(&mut self, other: &'a Self)

Performs the -= operation.

impl<O, T, P> SubAssign<O> for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>, O: Into<Self>,

fn sub_assign(&mut self, other: O)

Performs the -= operation.

impl<'a, T, P> Sum<&'a GenericDecimal<T, P>> for GenericDecimal<T, P>

where T: Clone + GenericInteger + PartialEq, P: Copy + GenericInteger + Into<usize>,

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, P> Sum for GenericDecimal<T, P>

where T: Clone + GenericInteger + PartialEq, P: Copy + GenericInteger + Into<usize>,

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, P> ToPrimitive for GenericDecimal<T, P>

where T: Clone + GenericInteger + ToPrimitive, P: Copy + GenericInteger + Into<usize>,

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

impl<T, P> TryFrom<GenericDecimal<T, P>> for BigInt

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for BigUint

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize>,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for f32

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for f64

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for i128

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for i16

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for i32

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for i64

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for i8

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for isize

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for u128

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for u16

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for u32

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for u64

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for u8

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, P> TryFrom<GenericDecimal<T, P>> for usize

where T: Clone + ToPrimitive + GenericInteger, P: Copy + Into<usize> + GenericInteger,

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: GenericDecimal<T, P>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T, F, P1, P2> TryToConvertFrom<GenericDecimal<F, P1>> for GenericDecimal<T, P2>

where T: Copy + Integer + TryToConvertFrom<F>, F: Copy + Integer, P2: Copy + Integer + Into<usize> + TryToConvertFrom<P1>, P1: Copy + Integer + Into<usize>,

fn try_to_convert_from(src: GenericDecimal<F, P1>) -> Option<Self>

impl<T, P> Zero for GenericDecimal<T, P>

where T: Clone + GenericInteger, P: Copy + GenericInteger + Into<usize> + Zero,

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T, P> Copy for GenericDecimal<T, P>

where T: Copy + Integer, P: Copy + Integer + Into<usize>,

impl<T, P> Eq for GenericDecimal<T, P>

where T: Clone + GenericInteger + Eq, P: Copy + GenericInteger + Into<usize>,