Struct fix_rat::Rational

#[repr(transparent)]pub struct Rational<const DENOM: i64> { /* fields omitted */ }

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: Self) -> Self

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

pub fn wrapping_div(self, other: Self) -> 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: Self) -> Self

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

Trait Implementations

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

type Output = Self

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 copy of the value.

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

Performs copy-assignment from source.

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

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 = Self

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

fn from(o: f64) -> Self

Performs the conversion.

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

fn from(o: i64) -> Self

Performs the conversion.

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

type Output = Self

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.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

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

fn eq(&self, other: &Rational<DENOM>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rational<DENOM>) -> bool

This method tests for !=.

impl<const DENOM: i64> PartialOrd<Rational<DENOM>> 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: &Rational<DENOM>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rational<DENOM>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rational<DENOM>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rational<DENOM>) -> bool

This method 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> StructuralEq for Rational<DENOM>

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

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

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sum<I>(i: I) -> Self where
    I: Iterator<Item = Self>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.