Struct Fraction 

pub struct Fraction {
    pub numerator: i128,
    pub denominator: i128,
}

Fields

numerator: i128

denominator: i128

Implementations

impl Fraction

pub fn new(numerator: i128, denominator: i128) -> Result<Self, FuelError>

Creates a new fraction with the given numerator and denominator Panics if given a denominator of 0

pub fn reduce(&self) -> Self

Returns a new Fraction that is equal to this one, but simplified

pub fn to_decimal(&self) -> f64

Returns a decimal equivalent to this Fraction

Trait Implementations

impl<'a> Add for &'a Fraction

type Output = Fraction

The resulting type after applying the + operator.

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

Performs the + operation.

impl Clone for Fraction

fn clone(&self) -> Fraction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Fraction

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

Formats the value using the given formatter.

impl Display for Fraction

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

Formats the value using the given formatter.

impl Div<&Fraction> for &Fuel

type Output = Result<Fuel, FuelError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<&Fraction> for Fuel

type Output = Result<Fuel, FuelError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Fraction> for &Fuel

type Output = Result<Fuel, FuelError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Fraction> for Fuel

type Output = Result<Fuel, FuelError>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> Div for &'a Fraction

type Output = Fraction

The resulting type after applying the / operator.

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

Performs the / operation.

impl From<&Fuel> for Fraction

fn from(fuel: &Fuel) -> Fraction

Converts to this type from the input type.

impl Mul<&Fraction> for &Fuel

type Output = Result<Fuel, FuelError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<&Fraction> for Fuel

type Output = Result<Fuel, FuelError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Fraction> for &Fuel

type Output = Result<Fuel, FuelError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Fraction> for Fuel

Fuel * Fraction, Fuel / Fraction – always round up on loss of precision

If a Fraction’s numerator would result in an overflow of the maximum allowable Holo fuel amount, produce an Err result. Non-zero results below the minimum fractional Fuel value threshold are always rounded up.

For example, .75% of 1334 == 10.005, or 11 if rounded up. A Fraction representing .75%, Fraction::new(3, 400) multiplied by 0.001334 HoloFuel: Fuel{ units: 1334 } would result in a Some(quotient) of 1334 / 400 == 3, and then 3 * 3 == 9.

In general, any HoloFuel.units precision below the Fraction.denominator will be lost, because we perform a division by the Fraction.denominator, to avoid overflow on large values. If we had instead performed the multiplication by the numerator first, we would have have computed 1334 * 3 == 4002, and 4002 / 400 == 10; also correct, but no more useful if our intent is to “round up” since the desired result is 11 (and, it would overflow on large values). However, here we could clearly detect that 4002 % 400 == 2 remainder, indicating that we must add 1 to the result to round up.

We must find the remainder of the division by the denominator 400, after multiplying it by the numerator, see if (when rounded up by just less than the denominator), how many multiples of the denominator we missed:

// 1334 % 400 == 134, // 134 * 3 == 402 // 402 + (400 - 1) == 801 // 801 / 400 == 2. // Since all of these are small numbers, overflow is not possible (unless the Fraction is huge)

Note the checked_rem is a signed remainder, not a euclidean modulo, eg. from https://internals.rust-lang.org/t/mathematical-modulo-operator/5952:

// Remainder operator (%) // 5 % 3 // 2 // 5 % -3 // 2 // -5 % 3 // -2 // -5 % -3 // -2

// Modulo operator (%%) // 5 %% 3 // 2 // 5 %% -3 // -1 // -5 %% 3 // 1 // -5 %% -3 // -2

Therefore, when multiplying by -’ve Fuel, any checked_rem will be remain -’ve

type Output = Result<Fuel, FuelError>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul for &'a Fraction

type Output = Fraction

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<&Fraction> for FuelResult

fn mul_assign(&mut self, rhs: &Fraction)

Performs the *= operation.

impl MulAssign<Fraction> for FuelResult

fn mul_assign(&mut self, rhs: Fraction)

Performs the *= operation.

impl PartialEq for Fraction

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

fn partial_cmp(&self, other: &Fraction) -> 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> Sub for &'a Fraction

type Output = Fraction

The resulting type after applying the - operator.

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

Performs the - operation.

impl Copy for Fraction

impl Eq for Fraction