Struct 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 const fn constant(bits: Bits) -> Self

Like Self::new, but creates numbers in the constant context.

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 duplicate 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, Exp> FixExt for Fix<Bits, U10, NInt<Exp>>

where Exp: Unsigned + NonZero + IsLess<U20>, Bits: From<u64>,

fn one() -> Fix<Bits, U10, NInt<Exp>>

This precision’s equivalent of 1.

fn zero() -> Self

impl<Bits, Exp> From<Fix<Bits, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, Exp>> for IFixValue128

where Bits: Into<i128>, Exp: Integer,

fn from(fix: Fix<Bits, U10, Exp>) -> Self

Converts to this type from the input type.

impl<Bits, Exp> From<Fix<Bits, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, Exp>> for IFixValue16

where Bits: Into<i16>, Exp: Integer,

fn from(fix: Fix<Bits, U10, Exp>) -> Self

Converts to this type from the input type.

impl<Bits, Exp> From<Fix<Bits, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, Exp>> for IFixValue32

where Bits: Into<i32>, Exp: Integer,

fn from(fix: Fix<Bits, U10, Exp>) -> Self

Converts to this type from the input type.

impl<Bits, Exp> From<Fix<Bits, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, Exp>> for IFixValue64

where Bits: Into<i64>, Exp: Integer,

fn from(fix: Fix<Bits, U10, Exp>) -> Self

Converts to this type from the input type.

impl<Bits, Exp> From<Fix<Bits, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, Exp>> for IFixValue8

where Bits: Into<i8>, Exp: Integer,

fn from(fix: Fix<Bits, U10, Exp>) -> Self

Converts to this type from the input type.

impl<Bits, Exp> From<Fix<Bits, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, Exp>> for UFixValue128

where Bits: Into<u128>, Exp: Integer,

fn from(fix: Fix<Bits, U10, Exp>) -> Self

Converts to this type from the input type.

impl<Bits, Exp> From<Fix<Bits, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, Exp>> for UFixValue16

where Bits: Into<u16>, Exp: Integer,

fn from(fix: Fix<Bits, U10, Exp>) -> Self

Converts to this type from the input type.

impl<Bits, Exp> From<Fix<Bits, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, Exp>> for UFixValue32

where Bits: Into<u32>, Exp: Integer,

fn from(fix: Fix<Bits, U10, Exp>) -> Self

Converts to this type from the input type.

impl<Bits, Exp> From<Fix<Bits, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, Exp>> for UFixValue64

where Bits: Into<u64>, Exp: Integer,

fn from(fix: Fix<Bits, U10, Exp>) -> Self

Converts to this type from the input type.

impl<Bits, Exp> From<Fix<Bits, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, Exp>> for UFixValue8

where Bits: Into<u8>, Exp: Integer,

fn from(fix: Fix<Bits, U10, Exp>) -> Self

Converts to this type from the input type.

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,

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

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

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<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> SaturatingAdd for Fix<Bits, Base, Exp>

where Bits: SaturatingAdd,

fn saturating_add(&self, v: &Self) -> Self

Saturating addition. Computes self + other, saturating at the relevant high or low boundary of the type.

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

where Bits: SaturatingSub,

fn saturating_sub(&self, v: &Self) -> Self

Saturating subtraction. Computes self - other, saturating at the relevant high or low boundary of the type.

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, Exp> TryFrom<IFixValue128> for Fix<Bits, U10, Exp>

where Bits: From<i128>, Exp: Integer,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: IFixValue128) -> Result<Fix<Bits, U10, Exp>>

Performs the conversion.

impl<Bits, Exp> TryFrom<IFixValue16> for Fix<Bits, U10, Exp>

where Bits: From<i16>, Exp: Integer,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: IFixValue16) -> Result<Fix<Bits, U10, Exp>>

Performs the conversion.

impl<Bits, Exp> TryFrom<IFixValue32> for Fix<Bits, U10, Exp>

where Bits: From<i32>, Exp: Integer,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: IFixValue32) -> Result<Fix<Bits, U10, Exp>>

Performs the conversion.

impl<Bits, Exp> TryFrom<IFixValue64> for Fix<Bits, U10, Exp>

where Bits: From<i64>, Exp: Integer,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: IFixValue64) -> Result<Fix<Bits, U10, Exp>>

Performs the conversion.

impl<Bits, Exp> TryFrom<IFixValue8> for Fix<Bits, U10, Exp>

where Bits: From<i8>, Exp: Integer,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: IFixValue8) -> Result<Fix<Bits, U10, Exp>>

Performs the conversion.

impl<Bits, Exp> TryFrom<UFixValue128> for Fix<Bits, U10, Exp>

where Bits: From<u128>, Exp: Integer,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: UFixValue128) -> Result<Fix<Bits, U10, Exp>>

Performs the conversion.

impl<Bits, Exp> TryFrom<UFixValue16> for Fix<Bits, U10, Exp>

where Bits: From<u16>, Exp: Integer,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: UFixValue16) -> Result<Fix<Bits, U10, Exp>>

Performs the conversion.

impl<Bits, Exp> TryFrom<UFixValue32> for Fix<Bits, U10, Exp>

where Bits: From<u32>, Exp: Integer,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: UFixValue32) -> Result<Fix<Bits, U10, Exp>>

Performs the conversion.

impl<Bits, Exp> TryFrom<UFixValue64> for Fix<Bits, U10, Exp>

where Bits: From<u64>, Exp: Integer,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: UFixValue64) -> Result<Fix<Bits, U10, Exp>>

Performs the conversion.

impl<Bits, Exp> TryFrom<UFixValue8> for Fix<Bits, U10, Exp>

where Bits: From<u8>, Exp: Integer,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: UFixValue8) -> Result<Fix<Bits, U10, Exp>>

Performs the conversion.

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,