Struct fix::Fix

pub struct Fix<Bits, Base, Exp> {
    pub bits: Bits,
    /* private fields */
}

Fixed-point number representing Bits × Base ^Exp.

• Bits is an integer primitive type, or any type which can be created from a type-level integer and exponentiated.
• Base is an Unsigned type-level integer.
• Exp is a signed type-level Integer.

Summary of operations

Lower case variables represent values of Bits. Upper case B and E represent type-level integers Base and Exp, respectively.

• −(x B^E) = (−x) B^E
• (x B^E) + (y B^E) = (x + y) B^E
• (x B^E) − (y B^E) = (x − y) B^E
• (x B^E_x) × (y B^E_y) = (x × y) B^{E_x + E_y}
• (x B^E_x) ÷ (y B^E_y) = (x ÷ y) B^{E_x − E_y}
• (x B^E_x) % (y B^E_y) = (x % y) B^E_x
• (x B^E) × y = (x × y) B^E
• (x B^E) ÷ y = (x ÷ y) B^E
• (x B^E) % y = (x % y) B^E

Fields

bits: Bits

The underlying integer.

Implementations

impl<Bits, Base, Exp> Fix<Bits, Base, Exp>

pub fn new(bits: Bits) -> Self

Creates a number.

Examples

use fix::aliases::si::{Kilo, Milli};
Milli::new(25); // 0.025
Kilo::new(25); // 25 000

pub fn convert<ToExp>(self) -> Fix<Bits, Base, ToExp>

where Bits: FromUnsigned + Pow + Mul<Output = Bits> + Div<Output = Bits>, Base: Unsigned, Exp: Sub<ToExp>, Diff<Exp, ToExp>: Abs + IsLess<Z0>, AbsVal<Diff<Exp, ToExp>>: Integer,

Converts to another Exp.

Examples

use fix::aliases::si::{Kilo, Milli};
let kilo = Kilo::new(5);
let milli = Milli::new(5_000_000);
assert_eq!(kilo, milli.convert());
assert_eq!(milli, kilo.convert());

pub fn widen<ToBits>(self) -> Fix<ToBits, Base, Exp>

where ToBits: From<Bits>,

Converts the underlying bits to a wider type.

Examples

use fix::aliases::si::Milli;
let one = Milli::new(16899u64);
let mapped = one.widen::<u128>();
assert_eq!(mapped, Milli::new(16899u128));

pub fn narrow<ToBits>(self) -> Option<Fix<ToBits, Base, Exp>>

where ToBits: TryFrom<Bits>,

Attempts to converts underlying bits to a narrower type. Returns None if conversion fails.

Examples

use fix::aliases::si::Milli;
let one = Milli::new(16899u128);
let mapped = one.narrow::<u64>();
assert_eq!(mapped, Some(Milli::new(16899u64)));

impl<Bits, Base, Exp> Fix<Bits, Base, Exp>

where Self: CheckedSub, Bits: Copy,

pub fn abs_diff(&self, v: &Self) -> Fix<Bits, Base, Exp>

Trait Implementations

impl<Bits, Base, Exp> Add for Fix<Bits, Base, Exp>

where Bits: Add<Output = Bits>,

type Output = Fix<Bits, Base, Exp>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Bits, Base, Exp> AddAssign for Fix<Bits, Base, Exp>

where Bits: AddAssign,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<Bits, Base, Exp> CheckedAdd for Fix<Bits, Base, Exp>

where Bits: CheckedAdd,

fn checked_add(&self, v: &Self) -> Option<Self>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl<Bits, Base, LExp, RExp> CheckedDivFix<Fix<Bits, Base, RExp>> for Fix<Bits, Base, LExp>

where Bits: CheckedDiv, LExp: Sub<RExp>,

type Output = Fix<Bits, Base, <LExp as Sub<RExp>>::Output>

fn checked_div(&self, v: &Fix<Bits, Base, RExp>) -> Option<Self::Output>

impl<Bits, Base, LExp, RExp> CheckedMulFix<Fix<Bits, Base, RExp>> for Fix<Bits, Base, LExp>

where Bits: CheckedMul, LExp: Add<RExp>,

type Output = Fix<Bits, Base, <LExp as Add<RExp>>::Output>

fn checked_mul(&self, v: &Fix<Bits, Base, RExp>) -> Option<Self::Output>

impl<Bits, Base, Exp> CheckedSub for Fix<Bits, Base, Exp>

where Bits: CheckedSub,

fn checked_sub(&self, v: &Self) -> Option<Self>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl<Bits, Base, Exp> Clone for Fix<Bits, Base, Exp>

where Bits: Clone,

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Bits, Base, Exp> Debug for Fix<Bits, Base, Exp>

where Bits: Debug, Base: Unsigned, Exp: Integer,

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

Formats the value using the given formatter.

impl<Bits, Base, Exp> Default for Fix<Bits, Base, Exp>

where Bits: Default,

fn default() -> Self

Returns the “default value” for a type.

impl<Bits, Base, Exp> Div<Bits> for Fix<Bits, Base, Exp>

where Bits: Div<Output = Bits>,

type Output = Fix<Bits, Base, Exp>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Bits, Base, LExp, RExp> Div<Fix<Bits, Base, RExp>> for Fix<Bits, Base, LExp>

where Bits: Div<Output = Bits>, LExp: Sub<RExp>,

type Output = Fix<Bits, Base, <LExp as Sub<RExp>>::Output>

The resulting type after applying the / operator.

fn div(self, rhs: Fix<Bits, Base, RExp>) -> Self::Output

Performs the / operation.

impl<Bits, Base, Exp> DivAssign<Bits> for Fix<Bits, Base, Exp>

where Bits: DivAssign,

fn div_assign(&mut self, rhs: Bits)

Performs the /= operation.

impl<Bits, Base, Exp> Hash for Fix<Bits, Base, Exp>

where Bits: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Bits, Base, Exp> Mul<Bits> for Fix<Bits, Base, Exp>

where Bits: Mul<Output = Bits>,

type Output = Fix<Bits, Base, Exp>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Bits, Base, LExp, RExp> Mul<Fix<Bits, Base, RExp>> for Fix<Bits, Base, LExp>

where Bits: Mul<Output = Bits>, LExp: Add<RExp>,

type Output = Fix<Bits, Base, <LExp as Add<RExp>>::Output>

The resulting type after applying the * operator.

fn mul(self, rhs: Fix<Bits, Base, RExp>) -> Self::Output

Performs the * operation.

impl<Bits, Base, Exp> MulAssign<Bits> for Fix<Bits, Base, Exp>

where Bits: MulAssign,

fn mul_assign(&mut self, rhs: Bits)

Performs the *= operation.

impl<Bits, Base, LExp, RExp> MulDiv<Fix<Bits, Base, RExp>> for Fix<Bits, Base, LExp>

where Bits: MulDiv,

type Output = Fix<<Bits as MulDiv>::Output, Base, LExp>

Output type for the methods of this trait.

fn mul_div_ceil( self, num: Fix<Bits, Base, RExp>, denom: Fix<Bits, Base, RExp> ) -> Option<Self::Output>

Calculates ceil(val * num / denom), i.e. the the smallest integer greater than or equal to the result of the division.

fn mul_div_floor( self, num: Fix<Bits, Base, RExp>, denom: Fix<Bits, Base, RExp> ) -> Option<Self::Output>

Calculates floor(val * num / denom), i.e. the largest integer less than or equal to the result of the division.

fn mul_div_round( self, num: Fix<Bits, Base, RExp>, denom: Fix<Bits, Base, RExp> ) -> Option<Self::Output>

Calculates round(val * num / denom), i.e. the closest integer to the result of the division. If both surrounding integers are the same distance (x.5), the one with the bigger absolute value is returned (round away from 0.0).

impl<Bits, Base, Exp> Neg for Fix<Bits, Base, Exp>

where Bits: Neg<Output = Bits>,

type Output = Fix<Bits, Base, Exp>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<Bits, Base, Exp> Ord for Fix<Bits, Base, Exp>

where Bits: Ord,

fn cmp(&self, rhs: &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 + PartialOrd,

Restrict a value to a certain interval.

impl<Bits, Base, Exp> PartialEq for Fix<Bits, Base, Exp>

where Bits: PartialEq,

fn eq(&self, rhs: &Self) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Bits, Base, Exp> PartialOrd for Fix<Bits, Base, Exp>

where Bits: PartialOrd,

fn partial_cmp(&self, rhs: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

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

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

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

fn ge(&self, other: &Rhs) -> bool

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

impl<Bits, Base, Exp> Rem<Bits> for Fix<Bits, Base, Exp>

where Bits: Rem<Output = Bits>,

type Output = Fix<Bits, Base, Exp>

The resulting type after applying the % operator.

fn rem(self, rhs: Bits) -> Self

Performs the % operation.

impl<Bits, Base, Exp> Rem for Fix<Bits, Base, Exp>

where Bits: Rem<Output = Bits>,

type Output = Fix<Bits, Base, Exp>

The resulting type after applying the % operator.

fn rem(self, rhs: Self) -> Self

Performs the % operation.

impl<Bits, Base, Exp> RemAssign<Bits> for Fix<Bits, Base, Exp>

where Bits: RemAssign,

fn rem_assign(&mut self, rhs: Bits)

Performs the %= operation.

impl<Bits, Base, LExp, RExp> RemAssign<Fix<Bits, Base, RExp>> for Fix<Bits, Base, LExp>

where Bits: RemAssign,

fn rem_assign(&mut self, rhs: Fix<Bits, Base, RExp>)

Performs the %= operation.

impl<Bits, Base, Exp> Sub for Fix<Bits, Base, Exp>

where Bits: Sub<Output = Bits>,

type Output = Fix<Bits, Base, Exp>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Bits, Base, Exp> SubAssign for Fix<Bits, Base, Exp>

where Bits: SubAssign,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<Bits, Base, Exp> Copy for Fix<Bits, Base, Exp>

where Bits: Copy,

impl<Bits, Base, Exp> Eq for Fix<Bits, Base, Exp>

where Bits: Eq,