Struct FractionExact

pub struct FractionExact(pub BigFraction);

Tuple Fields

0: BigFraction

Implementations

impl FractionExact

pub fn sqrt_abs(&self, decimal_places: u32) -> FractionExact

pub fn is_sign_negative(&self) -> bool

pub fn is_sign_positive(&self) -> bool

pub fn is_infinite(&self) -> bool

Returns true if the value is Infinity (does not matter positive or negative)

pub fn is_nan(&self) -> bool

pub fn infinity() -> Self

pub fn neg_infinity() -> Self

pub fn nan() -> Self

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

pub fn recip(&self) -> Self

1/self

pub fn one_minus(self) -> Self

pub fn two() -> FractionExact

Trait Implementations

impl Add<&FractionExact> for &FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: &FractionExact) -> Self::Output

Performs the + operation.

impl<'a> Add<i128> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: i128) -> Self::Output

Performs the + operation.

impl<'a> Add<i16> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Self::Output

Performs the + operation.

impl<'a> Add<i32> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Self::Output

Performs the + operation.

impl<'a> Add<i64> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Self::Output

Performs the + operation.

impl<'a> Add<i8> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: i8) -> Self::Output

Performs the + operation.

impl<'a> Add<u128> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: u128) -> Self::Output

Performs the + operation.

impl<'a> Add<u16> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Self::Output

Performs the + operation.

impl<'a> Add<u32> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Self::Output

Performs the + operation.

impl<'a> Add<u64> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Self::Output

Performs the + operation.

impl<'a> Add<u8> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: u8) -> Self::Output

Performs the + operation.

impl<'a> Add<usize> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the + operator.

fn add(self, rhs: usize) -> Self::Output

Performs the + operation.

impl AddAssign<&Arc<FractionExact>> for FractionExact

fn add_assign(&mut self, rhs: &Arc<FractionExact>)

Performs the += operation.

impl<T> AddAssign<T> for FractionExact

where T: Borrow<FractionExact>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl AddAssign<i128> for FractionExact

fn add_assign(&mut self, rhs: i128)

Performs the += operation.

impl AddAssign<i16> for FractionExact

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl AddAssign<i32> for FractionExact

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl AddAssign<i64> for FractionExact

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl AddAssign<i8> for FractionExact

fn add_assign(&mut self, rhs: i8)

Performs the += operation.

impl AddAssign<u128> for FractionExact

fn add_assign(&mut self, rhs: u128)

Performs the += operation.

impl AddAssign<u16> for FractionExact

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl AddAssign<u32> for FractionExact

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl AddAssign<u64> for FractionExact

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl AddAssign<u8> for FractionExact

fn add_assign(&mut self, rhs: u8)

Performs the += operation.

impl AddAssign<usize> for FractionExact

fn add_assign(&mut self, rhs: usize)

Performs the += operation.

impl ChooseRandomly for FractionExact

type Cache = FractionRandomCacheExact

fn choose_randomly(fractions: &Vec<FractionExact>) -> Result<usize>

Return a random index from 0 (inclusive) to the length of the list (exclusive). The likelihood of each index to be returned is proportional to the value of the fraction at that index.

fn choose_randomly_create_cache<'a>( fractions: impl Iterator<Item = &'a Self>, ) -> Result<FractionRandomCacheExact>

where Self: Sized + 'a,

fn choose_randomly_cached(cache: &FractionRandomCacheExact) -> usize

where Self: Sized,

impl Clone for FractionExact

fn clone(&self) -> FractionExact

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FractionExact

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

Formats the value using the given formatter.

impl Display for FractionExact

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

Formats the value using the given formatter.

impl Div<&FractionExact> for &FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: &FractionExact) -> Self::Output

Performs the / operation.

impl<'a> Div<i128> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: i128) -> Self::Output

Performs the / operation.

impl<'a> Div<i16> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Self::Output

Performs the / operation.

impl<'a> Div<i32> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Self::Output

Performs the / operation.

impl<'a> Div<i64> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Self::Output

Performs the / operation.

impl<'a> Div<i8> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: i8) -> Self::Output

Performs the / operation.

impl<'a> Div<u128> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: u128) -> Self::Output

Performs the / operation.

impl<'a> Div<u16> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Self::Output

Performs the / operation.

impl<'a> Div<u32> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Self::Output

Performs the / operation.

impl<'a> Div<u64> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Self::Output

Performs the / operation.

impl<'a> Div<u8> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: u8) -> Self::Output

Performs the / operation.

impl<'a> Div<usize> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the / operator.

fn div(self, rhs: usize) -> Self::Output

Performs the / operation.

impl<T> DivAssign<T> for FractionExact

where T: Borrow<FractionExact>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl DivAssign<i128> for FractionExact

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl DivAssign<i16> for FractionExact

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl DivAssign<i32> for FractionExact

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl DivAssign<i64> for FractionExact

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl DivAssign<i8> for FractionExact

fn div_assign(&mut self, rhs: i8)

Performs the /= operation.

impl DivAssign<u128> for FractionExact

fn div_assign(&mut self, rhs: u128)

Performs the /= operation.

impl DivAssign<u16> for FractionExact

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl DivAssign<u32> for FractionExact

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl DivAssign<u64> for FractionExact

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl DivAssign<u8> for FractionExact

fn div_assign(&mut self, rhs: u8)

Performs the /= operation.

impl DivAssign<usize> for FractionExact

fn div_assign(&mut self, rhs: usize)

Performs the /= operation.

impl From<&Arc<FractionExact>> for FractionExact

fn from(value: &Arc<FractionExact>) -> Self

Converts to this type from the input type.

impl From<&FractionExact> for FractionExact

fn from(value: &FractionExact) -> Self

Converts to this type from the input type.

impl From<(i128, i16)> for FractionExact

fn from(value: (i128, i16)) -> Self

Converts to this type from the input type.

impl From<(i128, i32)> for FractionExact

fn from(value: (i128, i32)) -> Self

Converts to this type from the input type.

impl From<(i128, i64)> for FractionExact

fn from(value: (i128, i64)) -> Self

Converts to this type from the input type.

impl From<(i128, i8)> for FractionExact

fn from(value: (i128, i8)) -> Self

Converts to this type from the input type.

impl From<(i128, u128)> for FractionExact

fn from(value: (i128, u128)) -> Self

Converts to this type from the input type.

impl From<(i128, u16)> for FractionExact

fn from(value: (i128, u16)) -> Self

Converts to this type from the input type.

impl From<(i128, u32)> for FractionExact

fn from(value: (i128, u32)) -> Self

Converts to this type from the input type.

impl From<(i128, u64)> for FractionExact

fn from(value: (i128, u64)) -> Self

Converts to this type from the input type.

impl From<(i128, u8)> for FractionExact

fn from(value: (i128, u8)) -> Self

Converts to this type from the input type.

impl From<(i128, usize)> for FractionExact

fn from(value: (i128, usize)) -> Self

Converts to this type from the input type.

impl From<(i16, i16)> for FractionExact

fn from(value: (i16, i16)) -> Self

Converts to this type from the input type.

impl From<(i16, i32)> for FractionExact

fn from(value: (i16, i32)) -> Self

Converts to this type from the input type.

impl From<(i16, i64)> for FractionExact

fn from(value: (i16, i64)) -> Self

Converts to this type from the input type.

impl From<(i16, i8)> for FractionExact

fn from(value: (i16, i8)) -> Self

Converts to this type from the input type.

impl From<(i16, u128)> for FractionExact

fn from(value: (i16, u128)) -> Self

Converts to this type from the input type.

impl From<(i16, u16)> for FractionExact

fn from(value: (i16, u16)) -> Self

Converts to this type from the input type.

impl From<(i16, u32)> for FractionExact

fn from(value: (i16, u32)) -> Self

Converts to this type from the input type.

impl From<(i16, u64)> for FractionExact

fn from(value: (i16, u64)) -> Self

Converts to this type from the input type.

impl From<(i16, u8)> for FractionExact

fn from(value: (i16, u8)) -> Self

Converts to this type from the input type.

impl From<(i16, usize)> for FractionExact

fn from(value: (i16, usize)) -> Self

Converts to this type from the input type.

impl From<(i32, i16)> for FractionExact

fn from(value: (i32, i16)) -> Self

Converts to this type from the input type.

impl From<(i32, i32)> for FractionExact

fn from(value: (i32, i32)) -> Self

Converts to this type from the input type.

impl From<(i32, i64)> for FractionExact

fn from(value: (i32, i64)) -> Self

Converts to this type from the input type.

impl From<(i32, i8)> for FractionExact

fn from(value: (i32, i8)) -> Self

Converts to this type from the input type.

impl From<(i32, u128)> for FractionExact

fn from(value: (i32, u128)) -> Self

Converts to this type from the input type.

impl From<(i32, u16)> for FractionExact

fn from(value: (i32, u16)) -> Self

Converts to this type from the input type.

impl From<(i32, u32)> for FractionExact

fn from(value: (i32, u32)) -> Self

Converts to this type from the input type.

impl From<(i32, u64)> for FractionExact

fn from(value: (i32, u64)) -> Self

Converts to this type from the input type.

impl From<(i32, u8)> for FractionExact

fn from(value: (i32, u8)) -> Self

Converts to this type from the input type.

impl From<(i32, usize)> for FractionExact

fn from(value: (i32, usize)) -> Self

Converts to this type from the input type.

impl From<(i64, i16)> for FractionExact

fn from(value: (i64, i16)) -> Self

Converts to this type from the input type.

impl From<(i64, i32)> for FractionExact

fn from(value: (i64, i32)) -> Self

Converts to this type from the input type.

impl From<(i64, i64)> for FractionExact

fn from(value: (i64, i64)) -> Self

Converts to this type from the input type.

impl From<(i64, i8)> for FractionExact

fn from(value: (i64, i8)) -> Self

Converts to this type from the input type.

impl From<(i64, u128)> for FractionExact

fn from(value: (i64, u128)) -> Self

Converts to this type from the input type.

impl From<(i64, u16)> for FractionExact

fn from(value: (i64, u16)) -> Self

Converts to this type from the input type.

impl From<(i64, u32)> for FractionExact

fn from(value: (i64, u32)) -> Self

Converts to this type from the input type.

impl From<(i64, u64)> for FractionExact

fn from(value: (i64, u64)) -> Self

Converts to this type from the input type.

impl From<(i64, u8)> for FractionExact

fn from(value: (i64, u8)) -> Self

Converts to this type from the input type.

impl From<(i64, usize)> for FractionExact

fn from(value: (i64, usize)) -> Self

Converts to this type from the input type.

impl From<(i8, i16)> for FractionExact

fn from(value: (i8, i16)) -> Self

Converts to this type from the input type.

impl From<(i8, i32)> for FractionExact

fn from(value: (i8, i32)) -> Self

Converts to this type from the input type.

impl From<(i8, i64)> for FractionExact

fn from(value: (i8, i64)) -> Self

Converts to this type from the input type.

impl From<(i8, i8)> for FractionExact

fn from(value: (i8, i8)) -> Self

Converts to this type from the input type.

impl From<(i8, u128)> for FractionExact

fn from(value: (i8, u128)) -> Self

Converts to this type from the input type.

impl From<(i8, u16)> for FractionExact

fn from(value: (i8, u16)) -> Self

Converts to this type from the input type.

impl From<(i8, u32)> for FractionExact

fn from(value: (i8, u32)) -> Self

Converts to this type from the input type.

impl From<(i8, u64)> for FractionExact

fn from(value: (i8, u64)) -> Self

Converts to this type from the input type.

impl From<(i8, u8)> for FractionExact

fn from(value: (i8, u8)) -> Self

Converts to this type from the input type.

impl From<(i8, usize)> for FractionExact

fn from(value: (i8, usize)) -> Self

Converts to this type from the input type.

impl From<(u128, i128)> for FractionExact

fn from(value: (u128, i128)) -> Self

Converts to this type from the input type.

impl From<(u128, i16)> for FractionExact

fn from(value: (u128, i16)) -> Self

Converts to this type from the input type.

impl From<(u128, i32)> for FractionExact

fn from(value: (u128, i32)) -> Self

Converts to this type from the input type.

impl From<(u128, i64)> for FractionExact

fn from(value: (u128, i64)) -> Self

Converts to this type from the input type.

impl From<(u128, i8)> for FractionExact

fn from(value: (u128, i8)) -> Self

Converts to this type from the input type.

impl From<(u128, u128)> for FractionExact

fn from(value: (u128, u128)) -> Self

Converts to this type from the input type.

impl From<(u128, u16)> for FractionExact

fn from(value: (u128, u16)) -> Self

Converts to this type from the input type.

impl From<(u128, u32)> for FractionExact

fn from(value: (u128, u32)) -> Self

Converts to this type from the input type.

impl From<(u128, u64)> for FractionExact

fn from(value: (u128, u64)) -> Self

Converts to this type from the input type.

impl From<(u128, u8)> for FractionExact

fn from(value: (u128, u8)) -> Self

Converts to this type from the input type.

impl From<(u128, usize)> for FractionExact

fn from(value: (u128, usize)) -> Self

Converts to this type from the input type.

impl From<(u16, i128)> for FractionExact

fn from(value: (u16, i128)) -> Self

Converts to this type from the input type.

impl From<(u16, i16)> for FractionExact

fn from(value: (u16, i16)) -> Self

Converts to this type from the input type.

impl From<(u16, i32)> for FractionExact

fn from(value: (u16, i32)) -> Self

Converts to this type from the input type.

impl From<(u16, i64)> for FractionExact

fn from(value: (u16, i64)) -> Self

Converts to this type from the input type.

impl From<(u16, i8)> for FractionExact

fn from(value: (u16, i8)) -> Self

Converts to this type from the input type.

impl From<(u16, u128)> for FractionExact

fn from(value: (u16, u128)) -> Self

Converts to this type from the input type.

impl From<(u16, u16)> for FractionExact

fn from(value: (u16, u16)) -> Self

Converts to this type from the input type.

impl From<(u16, u32)> for FractionExact

fn from(value: (u16, u32)) -> Self

Converts to this type from the input type.

impl From<(u16, u64)> for FractionExact

fn from(value: (u16, u64)) -> Self

Converts to this type from the input type.

impl From<(u16, u8)> for FractionExact

fn from(value: (u16, u8)) -> Self

Converts to this type from the input type.

impl From<(u16, usize)> for FractionExact

fn from(value: (u16, usize)) -> Self

Converts to this type from the input type.

impl From<(u32, i128)> for FractionExact

fn from(value: (u32, i128)) -> Self

Converts to this type from the input type.

impl From<(u32, i16)> for FractionExact

fn from(value: (u32, i16)) -> Self

Converts to this type from the input type.

impl From<(u32, i32)> for FractionExact

fn from(value: (u32, i32)) -> Self

Converts to this type from the input type.

impl From<(u32, i64)> for FractionExact

fn from(value: (u32, i64)) -> Self

Converts to this type from the input type.

impl From<(u32, i8)> for FractionExact

fn from(value: (u32, i8)) -> Self

Converts to this type from the input type.

impl From<(u32, u128)> for FractionExact

fn from(value: (u32, u128)) -> Self

Converts to this type from the input type.

impl From<(u32, u16)> for FractionExact

fn from(value: (u32, u16)) -> Self

Converts to this type from the input type.

impl From<(u32, u32)> for FractionExact

fn from(value: (u32, u32)) -> Self

Converts to this type from the input type.

impl From<(u32, u64)> for FractionExact

fn from(value: (u32, u64)) -> Self

Converts to this type from the input type.

impl From<(u32, u8)> for FractionExact

fn from(value: (u32, u8)) -> Self

Converts to this type from the input type.

impl From<(u32, usize)> for FractionExact

fn from(value: (u32, usize)) -> Self

Converts to this type from the input type.

impl From<(u64, i128)> for FractionExact

fn from(value: (u64, i128)) -> Self

Converts to this type from the input type.

impl From<(u64, i16)> for FractionExact

fn from(value: (u64, i16)) -> Self

Converts to this type from the input type.

impl From<(u64, i32)> for FractionExact

fn from(value: (u64, i32)) -> Self

Converts to this type from the input type.

impl From<(u64, i64)> for FractionExact

fn from(value: (u64, i64)) -> Self

Converts to this type from the input type.

impl From<(u64, i8)> for FractionExact

fn from(value: (u64, i8)) -> Self

Converts to this type from the input type.

impl From<(u64, u128)> for FractionExact

fn from(value: (u64, u128)) -> Self

Converts to this type from the input type.

impl From<(u64, u16)> for FractionExact

fn from(value: (u64, u16)) -> Self

Converts to this type from the input type.

impl From<(u64, u32)> for FractionExact

fn from(value: (u64, u32)) -> Self

Converts to this type from the input type.

impl From<(u64, u64)> for FractionExact

fn from(value: (u64, u64)) -> Self

Converts to this type from the input type.

impl From<(u64, u8)> for FractionExact

fn from(value: (u64, u8)) -> Self

Converts to this type from the input type.

impl From<(u64, usize)> for FractionExact

fn from(value: (u64, usize)) -> Self

Converts to this type from the input type.

impl From<(u8, i128)> for FractionExact

fn from(value: (u8, i128)) -> Self

Converts to this type from the input type.

impl From<(u8, i16)> for FractionExact

fn from(value: (u8, i16)) -> Self

Converts to this type from the input type.

impl From<(u8, i32)> for FractionExact

fn from(value: (u8, i32)) -> Self

Converts to this type from the input type.

impl From<(u8, i64)> for FractionExact

fn from(value: (u8, i64)) -> Self

Converts to this type from the input type.

impl From<(u8, i8)> for FractionExact

fn from(value: (u8, i8)) -> Self

Converts to this type from the input type.

impl From<(u8, u128)> for FractionExact

fn from(value: (u8, u128)) -> Self

Converts to this type from the input type.

impl From<(u8, u16)> for FractionExact

fn from(value: (u8, u16)) -> Self

Converts to this type from the input type.

impl From<(u8, u32)> for FractionExact

fn from(value: (u8, u32)) -> Self

Converts to this type from the input type.

impl From<(u8, u64)> for FractionExact

fn from(value: (u8, u64)) -> Self

Converts to this type from the input type.

impl From<(u8, u8)> for FractionExact

fn from(value: (u8, u8)) -> Self

Converts to this type from the input type.

impl From<(u8, usize)> for FractionExact

fn from(value: (u8, usize)) -> Self

Converts to this type from the input type.

impl From<(usize, i128)> for FractionExact

fn from(value: (usize, i128)) -> Self

Converts to this type from the input type.

impl From<(usize, i16)> for FractionExact

fn from(value: (usize, i16)) -> Self

Converts to this type from the input type.

impl From<(usize, i32)> for FractionExact

fn from(value: (usize, i32)) -> Self

Converts to this type from the input type.

impl From<(usize, i64)> for FractionExact

fn from(value: (usize, i64)) -> Self

Converts to this type from the input type.

impl From<(usize, i8)> for FractionExact

fn from(value: (usize, i8)) -> Self

Converts to this type from the input type.

impl From<(usize, u128)> for FractionExact

fn from(value: (usize, u128)) -> Self

Converts to this type from the input type.

impl From<(usize, u16)> for FractionExact

fn from(value: (usize, u16)) -> Self

Converts to this type from the input type.

impl From<(usize, u32)> for FractionExact

fn from(value: (usize, u32)) -> Self

Converts to this type from the input type.

impl From<(usize, u64)> for FractionExact

fn from(value: (usize, u64)) -> Self

Converts to this type from the input type.

impl From<(usize, u8)> for FractionExact

fn from(value: (usize, u8)) -> Self

Converts to this type from the input type.

impl From<(usize, usize)> for FractionExact

fn from(value: (usize, usize)) -> Self

Converts to this type from the input type.

impl From<Arc<FractionExact>> for FractionExact

fn from(value: Arc<FractionExact>) -> Self

Converts to this type from the input type.

impl From<i128> for FractionExact

fn from(value: i128) -> Self

Converts to this type from the input type.

impl From<i16> for FractionExact

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i32> for FractionExact

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for FractionExact

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<i8> for FractionExact

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<u128> for FractionExact

fn from(value: u128) -> Self

Converts to this type from the input type.

impl From<u16> for FractionExact

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for FractionExact

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for FractionExact

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u8> for FractionExact

fn from(value: u8) -> Self

Converts to this type from the input type.

impl From<usize> for FractionExact

fn from(value: usize) -> Self

Converts to this type from the input type.

impl FromStr for FractionExact

type Err = Error

The associated error which can be returned from parsing.

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

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

impl Hash for FractionExact

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

For good reasons, Rust does not support hashing of doubles. However, we need it to store distributions in a hashmap. Approximate arithmetic is discouraged

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 MaybeExact for FractionExact

fn extract_exact(&self) -> Result<&GenericFraction<BigUint>>

This is a low-level function to extract an f64. Only use if you are sure that the fraction is exact. May not be available in all compilation modes.

type Approximate = f64

type Exact = GenericFraction<BigUint>

fn is_exact(&self) -> bool

fn extract_approx(&self) -> Result<f64>

This is a low-level function to extract an f64. Will only succeed if the fraction is approximate.

impl Mul<&FractionExact> for &FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: &FractionExact) -> Self::Output

Performs the * operation.

impl<'a> Mul<i128> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: i128) -> Self::Output

Performs the * operation.

impl<'a> Mul<i16> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Self::Output

Performs the * operation.

impl<'a> Mul<i32> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Self::Output

Performs the * operation.

impl<'a> Mul<i64> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Self::Output

Performs the * operation.

impl<'a> Mul<i8> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: i8) -> Self::Output

Performs the * operation.

impl<'a> Mul<u128> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: u128) -> Self::Output

Performs the * operation.

impl<'a> Mul<u16> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Self::Output

Performs the * operation.

impl<'a> Mul<u32> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Self::Output

Performs the * operation.

impl<'a> Mul<u64> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Self::Output

Performs the * operation.

impl<'a> Mul<u8> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: u8) -> Self::Output

Performs the * operation.

impl<'a> Mul<usize> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the * operator.

fn mul(self, rhs: usize) -> Self::Output

Performs the * operation.

impl<T> MulAssign<T> for FractionExact

where T: Borrow<FractionExact>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl MulAssign<i128> for FractionExact

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl MulAssign<i16> for FractionExact

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl MulAssign<i32> for FractionExact

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign<i64> for FractionExact

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl MulAssign<i8> for FractionExact

fn mul_assign(&mut self, rhs: i8)

Performs the *= operation.

impl MulAssign<u128> for FractionExact

fn mul_assign(&mut self, rhs: u128)

Performs the *= operation.

impl MulAssign<u16> for FractionExact

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl MulAssign<u32> for FractionExact

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl MulAssign<u64> for FractionExact

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl MulAssign<u8> for FractionExact

fn mul_assign(&mut self, rhs: u8)

Performs the *= operation.

impl MulAssign<usize> for FractionExact

fn mul_assign(&mut self, rhs: usize)

Performs the *= operation.

impl<'a> Neg for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Neg for FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl One for FractionExact

fn one() -> Self

fn is_one(&self) -> bool

fn set_one(&mut self)

impl Ord for FractionExact

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,

Restrict a value to a certain interval.

impl PartialEq for FractionExact

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 PartialOrd for FractionExact

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

Note that exact and approximate should not be compared.

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 Signed for FractionExact

fn abs(&self) -> Self

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.

fn is_not_negative(&self) -> bool

For exact arithmetic: Returns true if the number is positive or zero. For approximate arithmetic: returns true if the number is larger than -epsilon

fn is_not_positive(&self) -> bool

For exact arithmetic: Returns true if the number is negative or zero. For approximate arithmetic: returns true if the number is smaller than epsilon

impl Sub<&FractionExact> for &FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: &FractionExact) -> Self::Output

Performs the - operation.

impl<'a> Sub<i128> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: i128) -> Self::Output

Performs the - operation.

impl<'a> Sub<i16> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Self::Output

Performs the - operation.

impl<'a> Sub<i32> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Self::Output

Performs the - operation.

impl<'a> Sub<i64> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Self::Output

Performs the - operation.

impl<'a> Sub<i8> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: i8) -> Self::Output

Performs the - operation.

impl<'a> Sub<u128> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: u128) -> Self::Output

Performs the - operation.

impl<'a> Sub<u16> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Self::Output

Performs the - operation.

impl<'a> Sub<u32> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Self::Output

Performs the - operation.

impl<'a> Sub<u64> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Self::Output

Performs the - operation.

impl<'a> Sub<u8> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: u8) -> Self::Output

Performs the - operation.

impl<'a> Sub<usize> for &'a FractionExact

type Output = FractionExact

The resulting type after applying the - operator.

fn sub(self, rhs: usize) -> Self::Output

Performs the - operation.

impl<T> SubAssign<T> for FractionExact

where T: Borrow<FractionExact>,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl SubAssign<i128> for FractionExact

fn sub_assign(&mut self, rhs: i128)

Performs the -= operation.

impl SubAssign<i16> for FractionExact

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl SubAssign<i32> for FractionExact

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign<i64> for FractionExact

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl SubAssign<i8> for FractionExact

fn sub_assign(&mut self, rhs: i8)

Performs the -= operation.

impl SubAssign<u128> for FractionExact

fn sub_assign(&mut self, rhs: u128)

Performs the -= operation.

impl SubAssign<u16> for FractionExact

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl SubAssign<u32> for FractionExact

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl SubAssign<u64> for FractionExact

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl SubAssign<u8> for FractionExact

fn sub_assign(&mut self, rhs: u8)

Performs the -= operation.

impl SubAssign<usize> for FractionExact

fn sub_assign(&mut self, rhs: usize)

Performs the -= operation.

impl<'a> Sum<&'a FractionExact> for FractionExact

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

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

impl Sum for FractionExact

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

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

impl TryFrom<&BigUint> for FractionExact

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &BigUint) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<&FractionNotParsedYet> for FractionExact

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &FractionNotParsedYet) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<(BigUint, BigUint)> for FractionExact

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: (BigUint, BigUint)) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BigInt> for FractionExact

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: BigInt) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<BigUint> for FractionExact

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: BigUint) -> Result<Self, Self::Error>

Performs the conversion.

impl Zero for FractionExact

fn zero() -> Self

fn is_zero(&self) -> bool

fn set_zero(&mut self)

impl Eq for FractionExact