Struct Rational 

pub struct Rational<const DENOM: i64> { /* private fields */ }

A ratonal number with a fixed denominator, therefore size_of<Rational>() == size_of<i64>().

Plus operations have more intuitive valid ranges

If you want to represent numbers in range -x to x choose DENOM as i64::MAX / x.

Rational then subdivides the whole range into i64::MAX equally-sized parts. Smaller operations are lost, going outside the range overflows.

DENOM needs to be positive or you will enter the bizarro universe.

I would strongly recommend to choose DENOM as 1 << x for x in 0..63.

The regular operations (+,-, *, /) behave just like on a regular integer, panic on overflow in debug mode, wrapping in release mode. Use the wrapping_op, checked_op or saturating_op methods to explicitly chose a behaviour.

Implementations

impl<const DENOM: i64> Rational<DENOM>

pub fn to_storage(self) -> i64

Returns the underlying integer type, for example for storing in an atomic number.

This should compile to a no-op.

pub fn from_storage(storage: i64) -> Self

Builds from the underlying integer type, for example after retrieving from an atomic number.

This should compile to a no-op.

Use from_int if you have an integer that you want to convert to a rational.

pub fn from_int(i: i64) -> Self

Converts an integer to a Rational.

pub fn aprox_float_fast(f: f64) -> Option<Self>

Since rational numbers can not represent inf, nan and other fuckery, this returns None if the input is wrong.

This will loose precision, try to only convert at the start and end of your calculation.

pub fn to_f64(self) -> f64

This will loose precision, try to only convert at the start and end of your calculation.

pub fn to_i64(self) -> i64

this will integer-round, potentially loosing a lot of precision.

pub fn clamp(self, low: Self, high: Self) -> Self

pub const fn max() -> Self

The maximum representable number.

Note that unlike floats rationals do not have pos/neg inf.

pub const fn min() -> Self

The minimum representable number.

Note that unlike floats rationals do not have pos/neg inf.

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

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

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

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

pub fn wrapping_add(self, other: Self) -> Self

pub fn wrapping_mul(self, other: i64) -> Self

pub fn wrapping_sub(self, other: Self) -> Self

pub fn wrapping_div(self, other: i64) -> Self

pub fn saturating_add(self, other: Self) -> Self

Don’t use this in parallel code if other parallel code is also subtracting, otherwise you loose determinism.

use fix_rat::Rational;
let max = Rational::<{1024}>::max();
let one = Rational::<{1024}>::from_int(1);
assert_ne!(max.saturating_add(one)-max, (max-max).saturating_add(one));

pub fn saturating_mul(self, other: i64) -> Self

pub fn saturating_sub(self, other: Self) -> Self

Trait Implementations

impl<const DENOM: i64> Add for Rational<DENOM>

type Output = Rational<DENOM>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const DENOM: i64> Clone for Rational<DENOM>

fn clone(&self) -> Rational<DENOM>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const DENOM: i64> Debug for Rational<DENOM>

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

Formats the value using the given formatter.

impl<const DENOM: i64> Default for Rational<DENOM>

fn default() -> Rational<DENOM>

Returns the “default value” for a type.

impl<'de, const DENOM: i64> Deserialize<'de> for Rational<DENOM>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const DENOM: i64> Div<i64> for Rational<DENOM>

type Output = Rational<DENOM>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const DENOM: i64> From<f64> for Rational<DENOM>

fn from(o: f64) -> Self

Converts to this type from the input type.

impl<const DENOM: i64> From<i64> for Rational<DENOM>

fn from(o: i64) -> Self

Converts to this type from the input type.

impl<const DENOMS: i64, const DENOMO: i64> Mul<Rational<DENOMO>> for Rational<DENOMS>

where [(); { _ }]:,

type Output = Rational<{ DENOMS * DENOMO }>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const DENOM: i64> Mul<i64> for Rational<DENOM>

type Output = Rational<DENOM>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const DENOM: i64> Ord for Rational<DENOM>

fn cmp(&self, other: &Rational<DENOM>) -> 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<const DENOM: i64> PartialEq for Rational<DENOM>

fn eq(&self, other: &Rational<DENOM>) -> 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<const DENOM: i64> PartialOrd for Rational<DENOM>

fn partial_cmp(&self, other: &Rational<DENOM>) -> 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<const DENOM: i64> Serialize for Rational<DENOM>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<const DENOM: i64> Sub for Rational<DENOM>

type Output = Rational<DENOM>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const DENOM: i64> Sum for Rational<DENOM>

fn sum<I>(i: I) -> Self

where I: Iterator<Item = Self>,

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

impl<const DENOM: i64> Copy for Rational<DENOM>

impl<const DENOM: i64> Eq for Rational<DENOM>

impl<const DENOM: i64> NoUninit for Rational<DENOM>

SAFETY: this is literally just an i64, transparent representation and all, this is therefore safe. can not auto-derive cause the derive macro can not very alignment in generic types.

impl<const DENOM: i64> StructuralPartialEq for Rational<DENOM>