Struct Fraction

#[repr(C)]
pub struct Fraction<I: Int> { /* private fields */ }

Represents a fractional number.

Type Contract

All combinations of numbers and signs are allowed, as long as denominator is not 0. Some operations like new will perform reduction on the value while others won’t for performance.

Reductions

Only new does full reduction, operators only do partial reduction for powers of 2. In the context of bevy_stat_query, use simple numbers like 1/3 over complicated ones like 33/100 to avoid integer overflows.

Implementations

impl Fraction<u8>

pub const fn const_new(numer: u8, denom: u8) -> Self

pub const fn const_pct(percent: u8) -> Self

pub const fn const_reduce(self) -> Self

impl Fraction<u16>

pub const fn const_new(numer: u16, denom: u16) -> Self

pub const fn const_pct(percent: u16) -> Self

pub const fn const_reduce(self) -> Self

impl Fraction<u32>

pub const fn const_new(numer: u32, denom: u32) -> Self

pub const fn const_pct(percent: u32) -> Self

pub const fn const_reduce(self) -> Self

impl Fraction<u64>

pub const fn const_new(numer: u64, denom: u64) -> Self

pub const fn const_pct(percent: u64) -> Self

pub const fn const_reduce(self) -> Self

impl Fraction<u128>

pub const fn const_new(numer: u128, denom: u128) -> Self

pub const fn const_pct(percent: u128) -> Self

pub const fn const_reduce(self) -> Self

impl Fraction<usize>

pub const fn const_new(numer: usize, denom: usize) -> Self

pub const fn const_pct(percent: usize) -> Self

pub const fn const_reduce(self) -> Self

impl Fraction<i8>

pub const fn const_new(numer: i8, denom: i8) -> Self

pub const fn const_pct(percent: i8) -> Self

pub const fn const_reduce(self) -> Self

impl Fraction<i16>

pub const fn const_new(numer: i16, denom: i16) -> Self

pub const fn const_pct(percent: i16) -> Self

pub const fn const_reduce(self) -> Self

impl Fraction<i32>

pub const fn const_new(numer: i32, denom: i32) -> Self

pub const fn const_pct(percent: i32) -> Self

pub const fn const_reduce(self) -> Self

impl Fraction<i64>

pub const fn const_new(numer: i64, denom: i64) -> Self

pub const fn const_pct(percent: i64) -> Self

pub const fn const_reduce(self) -> Self

impl Fraction<i128>

pub const fn const_new(numer: i128, denom: i128) -> Self

pub const fn const_pct(percent: i128) -> Self

pub const fn const_reduce(self) -> Self

impl Fraction<isize>

pub const fn const_new(numer: isize, denom: isize) -> Self

pub const fn const_pct(percent: isize) -> Self

pub const fn const_reduce(self) -> Self

impl<I: Int> Fraction<I>

pub fn new(numer: I, denom: I) -> Self

pub fn numer(&self) -> I

pub fn denom(&self) -> I

pub fn pct(percent: I) -> Self

pub fn reduced_pow2(self) -> Self

pub fn reduce(&mut self)

pub fn reduced(self) -> Self

pub const fn new_raw(numer: I, denom: I) -> Self

Create a unreduced fraction, does not breach the type contract as long as denom is not 0.

pub const fn from_int(value: I) -> Self

Create the fraction value / 1.

pub fn is_positive(&self) -> bool

Returns true if number is less than zero.

pub fn abs(&self) -> Self

pub fn is_zero(&self) -> bool

Returns true if number is zero.

pub fn is_negative(&self) -> bool

Returns true if number is less than zero.

pub fn floor(self) -> I

pub fn ceil(self) -> I

pub fn trunc(self) -> I

pub fn round(self) -> I

pub fn fract(self) -> Self

Returns a truncated fraction part of this value.

pub fn into_mixed_number(self) -> (I, Self)

Returns an integer and fraction part of this value.

pub fn to_mixed_number(&mut self) -> I

Truncate the integer part and return it.

Trait Implementations

impl<T: Int> Add<T> for Fraction<T>

type Output = Fraction<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Int> Add for Fraction<T>

type Output = Fraction<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: Int> AddAssign<T> for Fraction<T>

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<T: Int> AddAssign for Fraction<T>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<I: Int> Default for Fraction<I>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, I> Deserialize<'de> for Fraction<I>

where I: Deserialize<'de> + Int,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Int> Div<T> for Fraction<T>

type Output = Fraction<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Int> Div for Fraction<T>

type Output = Fraction<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Int> DivAssign<T> for Fraction<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Int> DivAssign for Fraction<T>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<I: Int + Clone> Float for Fraction<I>

fn floor(self) -> Self

fn ceil(self) -> Self

fn trunc(self) -> Self

fn round(self) -> Self

impl<T: Int> From<T> for Fraction<T>

fn from(value: T) -> Self

Converts to this type from the input type.

impl<T: Int> Mul<T> for Fraction<T>

type Output = Fraction<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Int> Mul for Fraction<T>

type Output = Fraction<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Int> MulAssign<T> for Fraction<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Int> MulAssign for Fraction<T>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<I: Int> NumCast<Fraction<I>> for I

fn cast(self) -> Fraction<I>

impl<I: Int> NumCast<I> for Fraction<I>

fn cast(self) -> I

impl<I: Int + Clone> Number for Fraction<I>

const ZERO: Self

const ONE: Self

const MIN_VALUE: Self

const MAX_VALUE: Self

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

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

impl<I: Int> Ord for Fraction<I>

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

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

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

where I: Serialize + Int,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Int> Sub<T> for Fraction<T>

type Output = Fraction<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Int> Sub for Fraction<T>

type Output = Fraction<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Int> SubAssign<T> for Fraction<T>

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<T: Int> SubAssign for Fraction<T>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<I> TypePath for Fraction<I>

where Fraction<I>: Any + Send + Sync, I: TypePath + Int,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

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

impl<I: Int> Eq for Fraction<I>