Trait sp_arithmetic::fixed_point::FixedPointNumber

pub trait FixedPointNumber: Sized + Copy + Default + Debug + Saturating + Bounded + Eq + PartialEq + Ord + PartialOrd + CheckedSub + CheckedAdd + CheckedMul + CheckedDiv + Add + Sub + Div + Mul + Zero + One {
    type Inner: Debug + One + CheckedMul + CheckedDiv + FixedPointOperand;

    const DIV: Self::Inner;
    const SIGNED: bool;

    fn from_inner(int: Self::Inner) -> Self;
    fn into_inner(self) -> Self::Inner;

    fn accuracy() -> Self::Inner { ... }
    fn saturating_from_integer<N: FixedPointOperand>(int: N) -> Self { ... }
    fn checked_from_integer<N: Into<Self::Inner>>(int: N) -> Option<Self> { ... }
    fn saturating_from_rational<N: FixedPointOperand, D: FixedPointOperand>(
        n: N,
        d: D
    ) -> Self { ... }
    fn checked_from_rational<N: FixedPointOperand, D: FixedPointOperand>(
        n: N,
        d: D
    ) -> Option<Self> { ... }
    fn checked_mul_int<N: FixedPointOperand>(self, n: N) -> Option<N> { ... }
    fn saturating_mul_int<N: FixedPointOperand>(self, n: N) -> N { ... }
    fn checked_div_int<N: FixedPointOperand>(self, d: N) -> Option<N> { ... }
    fn saturating_div_int<N: FixedPointOperand>(self, d: N) -> N { ... }
    fn saturating_mul_acc_int<N: FixedPointOperand>(self, n: N) -> N { ... }
    fn saturating_abs(self) -> Self { ... }
    fn reciprocal(self) -> Option<Self> { ... }
    fn is_one(&self) -> bool { ... }
    fn is_positive(self) -> bool { ... }
    fn is_negative(self) -> bool { ... }
    fn trunc(self) -> Self { ... }
    fn frac(self) -> Self { ... }
    fn ceil(self) -> Self { ... }
    fn floor(self) -> Self { ... }
    fn round(self) -> Self { ... }
}

Something that implements a decimal fixed point number.

The precision is given by Self::DIV, i.e. 1 / DIV can be represented.

Each type can store numbers from Self::Inner::min_value() / Self::DIV to Self::Inner::max_value() / Self::DIV. This is also referred to as the accuracy of the type in the documentation.

Required Associated Types

type Inner: Debug + One + CheckedMul + CheckedDiv + FixedPointOperand

The underlying data type used for this fixed point number.

Required Associated Constants

const DIV: Self::Inner

Precision of this fixed point implementation. It should be a power of 10.

const SIGNED: bool

Indicates if this fixed point implementation is signed or not.

Required Methods

fn from_inner(int: Self::Inner) -> Self

Builds this type from an integer number.

fn into_inner(self) -> Self::Inner

Consumes self and returns the inner raw value.

Provided Methods

fn accuracy() -> Self::Inner

Precision of this fixed point implementation.

fn saturating_from_integer<N: FixedPointOperand>(int: N) -> Self

Creates self from an integer number int.

Returns Self::max or Self::min if int exceeds accuracy.

Examples found in repository

src/fixed_point.rs (line 310)

	fn round(self) -> Self {
		let n = self.frac().saturating_mul(Self::saturating_from_integer(10));
		if n < Self::saturating_from_integer(5) {
			self.trunc()
		} else if self.is_positive() {
			self.saturating_add(Self::one()).trunc()
		} else {
			self.saturating_sub(Self::one()).trunc()
		}
	}

fn checked_from_integer<N: Into<Self::Inner>>(int: N) -> Option<Self>

Creates self from an integer number int.

Returns None if int exceeds accuracy.

fn saturating_from_rational<N: FixedPointOperand, D: FixedPointOperand>(
    n: N,
    d: D
) -> Self

Creates self from a rational number. Equal to n / d.

Panics if d = 0. Returns Self::max or Self::min if n / d exceeds accuracy.

fn checked_from_rational<N: FixedPointOperand, D: FixedPointOperand>(
    n: N,
    d: D
) -> Option<Self>

Creates self from a rational number. Equal to n / d.

Returns None if d == 0 or n / d exceeds accuracy.

Examples found in repository

src/fixed_point.rs (line 136)

	fn saturating_from_rational<N: FixedPointOperand, D: FixedPointOperand>(n: N, d: D) -> Self {
		if d == D::zero() {
			panic!("attempt to divide by zero")
		}
		Self::checked_from_rational(n, d).unwrap_or_else(|| to_bound(n, d))
	}

fn checked_mul_int<N: FixedPointOperand>(self, n: N) -> Option<N>

Checked multiplication for integer type N. Equal to self * n.

Returns None if the result does not fit in N.

Examples found in repository

src/fixed_point.rs (line 185)

	fn saturating_mul_int<N: FixedPointOperand>(self, n: N) -> N {
		self.checked_mul_int(n).unwrap_or_else(|| to_bound(self.into_inner(), n))
	}

fn saturating_mul_int<N: FixedPointOperand>(self, n: N) -> N

Saturating multiplication for integer type N. Equal to self * n.

Returns N::min or N::max if the result does not fit in N.

Examples found in repository

src/fixed_point.rs (line 218)

	fn saturating_mul_acc_int<N: FixedPointOperand>(self, n: N) -> N {
		if self.is_negative() && n > N::zero() {
			n.saturating_sub(Self::zero().saturating_sub(self).saturating_mul_int(n))
		} else {
			self.saturating_mul_int(n).saturating_add(n)
		}
	}

fn checked_div_int<N: FixedPointOperand>(self, d: N) -> Option<N>

Checked division for integer type N. Equal to self / d.

Returns None if the result does not fit in N or d == 0.

Examples found in repository

src/fixed_point.rs (line 209)

	fn saturating_div_int<N: FixedPointOperand>(self, d: N) -> N {
		if d == N::zero() {
			panic!("attempt to divide by zero")
		}
		self.checked_div_int(d).unwrap_or_else(|| to_bound(self.into_inner(), d))
	}

fn saturating_div_int<N: FixedPointOperand>(self, d: N) -> N

Saturating division for integer type N. Equal to self / d.

Panics if d == 0. Returns N::min or N::max if the result does not fit in N.

fn saturating_mul_acc_int<N: FixedPointOperand>(self, n: N) -> N

Saturating multiplication for integer type N, adding the result back. Equal to self * n + n.

Returns N::min or N::max if the multiplication or final result does not fit in N.

fn saturating_abs(self) -> Self

Saturating absolute value.

Returns Self::max if self == Self::min.

Examples found in repository

src/fixed_point.rs (line 278)

	fn frac(self) -> Self {
		let integer = self.trunc();
		let fractional = self.saturating_sub(integer);
		if integer == Self::zero() {
			fractional
		} else {
			fractional.saturating_abs()
		}
	}

fn reciprocal(self) -> Option<Self>

Takes the reciprocal (inverse). Equal to 1 / self.

Returns None if self = 0.

fn is_one(&self) -> bool

Checks if the number is one.

fn is_positive(self) -> bool

Returns true if self is positive and false if the number is zero or negative.

Examples found in repository

src/fixed_point.rs (line 313)

	fn round(self) -> Self {
		let n = self.frac().saturating_mul(Self::saturating_from_integer(10));
		if n < Self::saturating_from_integer(5) {
			self.trunc()
		} else if self.is_positive() {
			self.saturating_add(Self::one()).trunc()
		} else {
			self.saturating_sub(Self::one()).trunc()
		}
	}

fn is_negative(self) -> bool

Returns true if self is negative and false if the number is zero or positive.

Examples found in repository

src/fixed_point.rs (line 217)

	fn saturating_mul_acc_int<N: FixedPointOperand>(self, n: N) -> N {
		if self.is_negative() && n > N::zero() {
			n.saturating_sub(Self::zero().saturating_sub(self).saturating_mul_int(n))
		} else {
			self.saturating_mul_int(n).saturating_add(n)
		}
	}

	/// Saturating absolute value.
	///
	/// Returns `Self::max` if `self == Self::min`.
	fn saturating_abs(self) -> Self {
		let inner = self.into_inner();
		if inner >= Self::Inner::zero() {
			self
		} else {
			Self::from_inner(inner.checked_neg().unwrap_or_else(Self::Inner::max_value))
		}
	}

	/// Takes the reciprocal (inverse). Equal to `1 / self`.
	///
	/// Returns `None` if `self = 0`.
	fn reciprocal(self) -> Option<Self> {
		Self::one().checked_div(&self)
	}

	/// Checks if the number is one.
	fn is_one(&self) -> bool {
		self.into_inner() == Self::Inner::one()
	}

	/// Returns `true` if `self` is positive and `false` if the number is zero or negative.
	fn is_positive(self) -> bool {
		self.into_inner() > Self::Inner::zero()
	}

	/// Returns `true` if `self` is negative and `false` if the number is zero or positive.
	fn is_negative(self) -> bool {
		self.into_inner() < Self::Inner::zero()
	}

	/// Returns the integer part.
	fn trunc(self) -> Self {
		self.into_inner()
			.checked_div(&Self::DIV)
			.expect("panics only if DIV is zero, DIV is not zero; qed")
			.checked_mul(&Self::DIV)
			.map(Self::from_inner)
			.expect("can not overflow since fixed number is >= integer part")
	}

	/// Returns the fractional part.
	///
	/// Note: the returned fraction will be non-negative for negative numbers,
	/// except in the case where the integer part is zero.
	fn frac(self) -> Self {
		let integer = self.trunc();
		let fractional = self.saturating_sub(integer);
		if integer == Self::zero() {
			fractional
		} else {
			fractional.saturating_abs()
		}
	}

	/// Returns the smallest integer greater than or equal to a number.
	///
	/// Saturates to `Self::max` (truncated) if the result does not fit.
	fn ceil(self) -> Self {
		if self.is_negative() {
			self.trunc()
		} else if self.frac() == Self::zero() {
			self
		} else {
			self.saturating_add(Self::one()).trunc()
		}
	}

	/// Returns the largest integer less than or equal to a number.
	///
	/// Saturates to `Self::min` (truncated) if the result does not fit.
	fn floor(self) -> Self {
		if self.is_negative() {
			self.saturating_sub(Self::one()).trunc()
		} else {
			self.trunc()
		}
	}

fn trunc(self) -> Self

Returns the integer part.

Examples found in repository

src/fixed_point.rs (line 273)

	fn frac(self) -> Self {
		let integer = self.trunc();
		let fractional = self.saturating_sub(integer);
		if integer == Self::zero() {
			fractional
		} else {
			fractional.saturating_abs()
		}
	}

	/// Returns the smallest integer greater than or equal to a number.
	///
	/// Saturates to `Self::max` (truncated) if the result does not fit.
	fn ceil(self) -> Self {
		if self.is_negative() {
			self.trunc()
		} else if self.frac() == Self::zero() {
			self
		} else {
			self.saturating_add(Self::one()).trunc()
		}
	}

	/// Returns the largest integer less than or equal to a number.
	///
	/// Saturates to `Self::min` (truncated) if the result does not fit.
	fn floor(self) -> Self {
		if self.is_negative() {
			self.saturating_sub(Self::one()).trunc()
		} else {
			self.trunc()
		}
	}

	/// Returns the number rounded to the nearest integer. Rounds half-way cases away from 0.0.
	///
	/// Saturates to `Self::min` or `Self::max` (truncated) if the result does not fit.
	fn round(self) -> Self {
		let n = self.frac().saturating_mul(Self::saturating_from_integer(10));
		if n < Self::saturating_from_integer(5) {
			self.trunc()
		} else if self.is_positive() {
			self.saturating_add(Self::one()).trunc()
		} else {
			self.saturating_sub(Self::one()).trunc()
		}
	}

fn frac(self) -> Self

Returns the fractional part.

Note: the returned fraction will be non-negative for negative numbers, except in the case where the integer part is zero.

Examples found in repository

src/fixed_point.rs (line 288)

	fn ceil(self) -> Self {
		if self.is_negative() {
			self.trunc()
		} else if self.frac() == Self::zero() {
			self
		} else {
			self.saturating_add(Self::one()).trunc()
		}
	}

	/// Returns the largest integer less than or equal to a number.
	///
	/// Saturates to `Self::min` (truncated) if the result does not fit.
	fn floor(self) -> Self {
		if self.is_negative() {
			self.saturating_sub(Self::one()).trunc()
		} else {
			self.trunc()
		}
	}

	/// Returns the number rounded to the nearest integer. Rounds half-way cases away from 0.0.
	///
	/// Saturates to `Self::min` or `Self::max` (truncated) if the result does not fit.
	fn round(self) -> Self {
		let n = self.frac().saturating_mul(Self::saturating_from_integer(10));
		if n < Self::saturating_from_integer(5) {
			self.trunc()
		} else if self.is_positive() {
			self.saturating_add(Self::one()).trunc()
		} else {
			self.saturating_sub(Self::one()).trunc()
		}
	}

fn ceil(self) -> Self

Returns the smallest integer greater than or equal to a number.

Saturates to Self::max (truncated) if the result does not fit.

fn floor(self) -> Self

Returns the largest integer less than or equal to a number.

Saturates to Self::min (truncated) if the result does not fit.

fn round(self) -> Self

Returns the number rounded to the nearest integer. Rounds half-way cases away from 0.0.

Saturates to Self::min or Self::max (truncated) if the result does not fit.

Implementors

impl FixedPointNumber for FixedI64

type Inner = i64

const DIV: Self::Inner = {transmute(0x000000003b9aca00): <fixed_point::FixedI64 as fixed_point::FixedPointNumber>::Inner}

const SIGNED: bool = true

impl FixedPointNumber for FixedI128

type Inner = i128

const DIV: Self::Inner = {transmute(0x00000000000000000de0b6b3a7640000): <fixed_point::FixedI128 as fixed_point::FixedPointNumber>::Inner}

const SIGNED: bool = true

impl FixedPointNumber for FixedU64

type Inner = u64

const DIV: Self::Inner = {transmute(0x000000003b9aca00): <fixed_point::FixedU64 as fixed_point::FixedPointNumber>::Inner}

const SIGNED: bool = false

impl FixedPointNumber for FixedU128

type Inner = u128

const DIV: Self::Inner = {transmute(0x00000000000000000de0b6b3a7640000): <fixed_point::FixedU128 as fixed_point::FixedPointNumber>::Inner}

const SIGNED: bool = false