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

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

    // Provided methods
    fn accuracy() -> Self::Inner { ... }
    fn saturating_from_integer<N>(int: N) -> Self
       where N: FixedPointOperand { ... }
    fn checked_from_integer<N>(int: N) -> Option<Self>
       where N: Into<Self::Inner> { ... }
    fn saturating_from_rational<N, D>(n: N, d: D) -> Self
       where N: FixedPointOperand,
             D: FixedPointOperand { ... }
    fn checked_from_rational<N, D>(n: N, d: D) -> Option<Self>
       where N: FixedPointOperand,
             D: FixedPointOperand { ... }
    fn checked_mul_int<N>(self, n: N) -> Option<N>
       where N: FixedPointOperand { ... }
    fn saturating_mul_int<N>(self, n: N) -> N
       where N: FixedPointOperand { ... }
    fn checked_div_int<N>(self, d: N) -> Option<N>
       where N: FixedPointOperand { ... }
    fn saturating_div_int<N>(self, d: N) -> N
       where N: FixedPointOperand { ... }
    fn saturating_mul_acc_int<N>(self, n: N) -> N
       where N: FixedPointOperand { ... }
    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 { ... }
}

Re-export top-level arithmetic stuff. 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 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 Associated Types

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

The underlying data type used for this fixed point number.

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>(int: N) -> Self

where N: FixedPointOperand,

Creates self from an integer number int.

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

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

where N: Into<Self::Inner>,

Creates self from an integer number int.

Returns None if int exceeds accuracy.

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

where N: FixedPointOperand, D: FixedPointOperand,

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, D>(n: N, d: D) -> Option<Self>

where N: FixedPointOperand, D: FixedPointOperand,

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

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

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

where N: FixedPointOperand,

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

Returns None if the result does not fit in N.

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

where N: FixedPointOperand,

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

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

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

where N: FixedPointOperand,

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

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

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

where N: FixedPointOperand,

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>(self, n: N) -> N

where N: FixedPointOperand,

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.

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.

fn is_negative(self) -> bool

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

fn trunc(self) -> Self

Returns the integer part.

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.

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.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl FixedPointNumber for FixedI64

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

const SIGNED: bool = true

type Inner = i64

impl FixedPointNumber for FixedI128

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

const SIGNED: bool = true

type Inner = i128

impl FixedPointNumber for FixedU64

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

const SIGNED: bool = false

type Inner = u64

impl FixedPointNumber for FixedU128

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

const SIGNED: bool = false

type Inner = u128