Struct Fraction 

pub struct Fraction<I> { /* private fields */ }

A fraction, usable in calculations.

A fraction is serializable as:

• A fraction string ("1/2").
• An integer (20), which represents an integer (denominator == 1).
• A floating point number (1.5), which is converted to a fraction out of 4096.
• A percentage string ("60%").
• A two-length array ([2,5]).

Implementations

impl<I> Fraction<I>

where I: FractionInteger,

pub fn new(n: I, d: I) -> Self

Creates a new fraction.

pub fn percentage(n: I) -> Self

Creates a new percentage as a fraction.

pub fn from_f64(value: f64) -> Self

Creates a new fraction from an f64.

Floating point precision is preserved by creating a fraction with a denominator of 4096.

pub fn numerator(&self) -> I

The numerator of the fraction.

pub fn denominator(&self) -> I

The denominator of the fraction.

A flat percentage is always out of 100.

pub fn is_whole(&self) -> bool

Is the fraction whole (i.e., an integer)?

pub fn simplify(&self) -> Self

Simplifies the fraction.

pub fn floor(&self) -> I

Returns the floored integer representation of the fraction.

The integer will be truncated, as if performing integer division.

pub fn ceil(&self) -> I

Returns the ceiled integer representation of the fraction.

pub fn round(&self) -> I

where I: PrimInt,

Returns the rounded integer representation of the fraction.

pub fn convert<T>(self) -> Fraction<T>

where T: FractionInteger + From<I>,

Converts the Fraction<I> to a Fraction<T>, given that T: From<I>.

pub fn try_convert<T>(self) -> Result<Fraction<T>, T::Error>

where T: FractionInteger + TryFrom<I>,

Attempts converting the Fraction<I> to a Fraction<T>, given that T: TryFrom<I>.

pub fn inverse(&self) -> Self

Returns the inverse of this fraction.

impl<I> Fraction<I>

where I: FractionInteger + Roots,

pub fn sqrt(&self) -> Self

pub fn nth_root(&self, n: u32) -> Self

pub fn pow<J>( self, rhs: Fraction<J>, ) -> Result<Self, <J as TryInto<u32>>::Error>

where I: Pow<u32, Output = I> + TryInto<J> + Zero, J: FractionInteger + TryInto<u32> + Signed,

Trait Implementations

impl<I> Add<I> for Fraction<I>

where I: FractionInteger,

type Output = Fraction<I>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<I> Add for Fraction<I>

where I: FractionInteger,

type Output = Fraction<I>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<I: Clone> Clone for Fraction<I>

fn clone(&self) -> Fraction<I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug> Debug for Fraction<I>

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

Formats the value using the given formatter.

impl<I> Default for Fraction<I>

where I: FractionInteger,

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Fraction<u16>

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

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I> Display for Fraction<I>

where I: FractionInteger + Display,

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

Formats the value using the given formatter.

impl<I> Div<I> for Fraction<I>

where I: FractionInteger,

type Output = Fraction<I>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<I> Div for Fraction<I>

where I: FractionInteger,

type Output = Fraction<I>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<I, J> From<I> for Fraction<J>

where I: FractionInteger, J: FractionInteger + From<I>,

fn from(value: I) -> Self

Converts to this type from the input type.

impl<I> FromStr for Fraction<I>

where I: FractionInteger + FromStr + Display, <I as FromStr>::Err: Display + Into<Error>,

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<I> Mul<I> for Fraction<I>

where I: FractionInteger,

type Output = Fraction<I>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I> Mul for Fraction<I>

where I: FractionInteger,

type Output = Fraction<I>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<I> Ord for Fraction<I>

where I: FractionInteger,

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<I> PartialEq<I> for Fraction<I>

where I: FractionInteger,

fn eq(&self, other: &I) -> 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<I> PartialEq for Fraction<I>

where I: FractionInteger,

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<I> PartialOrd<I> for Fraction<I>

where I: FractionInteger,

fn partial_cmp(&self, other: &I) -> 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<I> PartialOrd for Fraction<I>

where I: FractionInteger,

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<I> SaturatingAdd for Fraction<I>

where I: FractionInteger + SaturatingAdd,

fn saturating_add(&self, v: &Self) -> Self

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

impl<I> SaturatingMul for Fraction<I>

where I: FractionInteger + SaturatingMul,

fn saturating_mul(&self, v: &Self) -> Self

Saturating multiplication. Computes self * other, saturating at the relevant high or low boundary of the type.

impl<I> SaturatingSub for Fraction<I>

where I: FractionInteger + SaturatingSub,

fn saturating_sub(&self, v: &Self) -> Self

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

impl<I> Serialize for Fraction<I>

where I: FractionInteger + Into<u64> + Display,

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<I> Sub<I> for Fraction<I>

where I: FractionInteger,

type Output = Fraction<I>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<I> Sub for Fraction<I>

where I: FractionInteger,

type Output = Fraction<I>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<I> WrappingAdd for Fraction<I>

where I: FractionInteger + WrappingAdd,

fn wrapping_add(&self, v: &Self) -> Self

Wrapping (modular) addition. Computes self + other, wrapping around at the boundary of the type.

impl<I> WrappingMul for Fraction<I>

where I: FractionInteger + WrappingMul,

fn wrapping_mul(&self, v: &Self) -> Self

Wrapping (modular) multiplication. Computes self * other, wrapping around at the boundary of the type.

impl<I> WrappingSub for Fraction<I>

where I: FractionInteger + WrappingSub,

fn wrapping_sub(&self, v: &Self) -> Self

Wrapping (modular) subtraction. Computes self - other, wrapping around at the boundary of the type.

impl<I: Copy> Copy for Fraction<I>

impl<I> Eq for Fraction<I>

where I: FractionInteger,