Struct FixedPoint 

pub struct FixedPoint<I, P> { /* private fields */ }

Available on crate features i128 or i64 or i32 or i16 only.

Abstraction over fixed point numbers of arbitrary (but only compile-time specified) size and precision.

The internal representation is a fixed point decimal number, an integer value pre-multiplied by 10 ^ PRECISION, where PRECISION is a compile-time-defined decimal places count.

Maximal possible value: MAX = (2 ^ (BITS_COUNT - 1) - 1) / 10 ^ PRECISION Maximal possible calculation error: ERROR_MAX = 0.5 / (10 ^ PRECISION)

E.g. for i64 with 9 decimal places:

MAX = (2 ^ (64 - 1) - 1) / 1e9 = 9223372036.854775807 ~ 9.2e9
ERROR_MAX = 0.5 / 1e9 = 5e-10

Implementations

impl<P: Precision> FixedPoint<i16, P>

pub fn from_str_exact(str: &str) -> Result<Self, ConvertError>

Parses a string slice into a fixed point. If the value cannot be represented then this will return an error.

Use the FromStr instance to parse with rounding.

impl<P: Precision> FixedPoint<i32, P>

pub fn from_str_exact(str: &str) -> Result<Self, ConvertError>

Parses a string slice into a fixed point. If the value cannot be represented then this will return an error.

Use the FromStr instance to parse with rounding.

impl<P: Precision> FixedPoint<i64, P>

pub fn from_str_exact(str: &str) -> Result<Self, ConvertError>

Parses a string slice into a fixed point. If the value cannot be represented then this will return an error.

Use the FromStr instance to parse with rounding.

impl<P: Precision> FixedPoint<i128, P>

pub fn from_str_exact(str: &str) -> Result<Self, ConvertError>

Parses a string slice into a fixed point. If the value cannot be represented then this will return an error.

Use the FromStr instance to parse with rounding.

impl<I, P> FixedPoint<I, P>

pub const fn from_bits(raw: I) -> Self

Creates from the raw representation. 1 here is equal to 1**-P

pub const fn as_bits(&self) -> &I

Returns the raw representation.

pub fn into_bits(self) -> I

Converts to the raw representation.

impl<P: Precision> FixedPoint<i16, P>

pub const PRECISION: i32 = P::I32

Available on crate feature i16 only.

The number of digits in the fractional part.

pub const EPSILON: Self

Available on crate feature i16 only.

The difference between 0.0 and the next larger representable number.

impl<P: Precision> FixedPoint<i16, P>

pub fn signum(self) -> i16

Available on crate feature i16 only.

Returns a number representing sign of self.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

pub fn recip(self, mode: RoundMode) -> Result<Self, ArithmeticError>

Available on crate feature i16 only.

Returns 1/n.

pub fn cneg(self) -> Result<Self, ArithmeticError>

Available on crate feature i16 only.

Checked negation. Returns Err on overflow (you can’t negate MIN value).

pub fn half_sum(a: Self, b: Self, mode: RoundMode) -> Self

Available on crate feature i16 only.

Calculates (a + b) / 2.

pub fn integral(self, mode: RoundMode) -> i16

Available on crate feature i16 only.

Takes rounded integral part of the number.

use fixnum::{FixedPoint, typenum::U9, ops::RoundMode::*};

type Amount = FixedPoint<i64, U9>;

let a: Amount = "8273.519".parse()?;
assert_eq!(a.integral(Floor), 8273);
assert_eq!(a.integral(Nearest), 8274);
assert_eq!(a.integral(Ceil), 8274);

let a: Amount = "-8273.519".parse()?;
assert_eq!(a.integral(Floor), -8274);
assert_eq!(a.integral(Nearest), -8274);
assert_eq!(a.integral(Ceil), -8273);

pub fn floor(self) -> Self

Available on crate feature i16 only.

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

pub fn ceil(self) -> Self

Available on crate feature i16 only.

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

pub fn round(self) -> Self

Available on crate feature i16 only.

Returns the nearest integer to a number. Round half-way cases away from 0.0.

pub fn round_towards_zero_by(self, precision: Self) -> Self

Available on crate feature i16 only.

Rounds towards zero by the provided precision.

pub fn next_power_of_ten(self) -> Result<Self, ArithmeticError>

Available on crate feature i16 only.

Returns the next power of ten:

• For positive: the smallest greater than or equal to a number.
• For negative: the largest less than or equal to a number.

pub fn abs(self) -> Result<Self, ArithmeticError>

Available on crate feature i16 only.

Returns the absolute value of a number.

pub fn rsqrt(self, mode: RoundMode) -> Result<Self, ArithmeticError>

Available on crate feature i16 only.

Checked rounding square root. Returns Err for negative argument.

Square root of a non-negative F is a non-negative S such that:

• Floor: S ≤ sqrt(F)
• Ceil: S ≥ sqrt(F)
• Nearest: Floor or Ceil, which one is closer to sqrt(F)

use fixnum::{ArithmeticError, FixedPoint, typenum::U9};
use fixnum::ops::{Zero, RoundMode::*};

type Amount = FixedPoint<i64, U9>;

let a: Amount = "81".parse()?;
let b: Amount = "2".parse()?;
let c: Amount = "-100".parse()?;
assert_eq!(a.rsqrt(Floor)?, "9".parse()?);
assert_eq!(b.rsqrt(Floor)?, "1.414213562".parse()?);
assert_eq!(b.rsqrt(Ceil)?, "1.414213563".parse()?);
assert_eq!(c.rsqrt(Floor), Err(ArithmeticError::DomainViolation));

impl<P: Precision> FixedPoint<i16, P>

pub fn from_decimal(mantissa: i16, exponent: i32) -> Result<Self, ConvertError>

Available on crate feature i16 only.

Creates a new number from separate mantissa and exponent.

pub fn to_decimal(&self, max_exponent: i32) -> (i16, i32)

Available on crate feature i16 only.

Returns a pair (mantissa, exponent) where exponent is in [-PRECISION, max_exponent].

Examples:

• fp!(5.5).to_decimal(0) // => (55, -1)
• fp!(5.5).to_decimal(-1) // => (55, -1)
• fp!(5.5).to_decimal(-2) // => (550, -2)
• fp!(50).to_decimal(0) // => (50, 0)
• fp!(50).to_decimal(i32::MAX) // => (5, 1)

Panics

If max_exponent is less than -PRECISION.

impl<P: Precision> FixedPoint<i32, P>

pub const PRECISION: i32 = P::I32

Available on crate feature i32 only.

The number of digits in the fractional part.

pub const EPSILON: Self

Available on crate feature i32 only.

The difference between 0.0 and the next larger representable number.

impl<P: Precision> FixedPoint<i32, P>

pub fn signum(self) -> i32

Available on crate feature i32 only.

Returns a number representing sign of self.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

pub fn recip(self, mode: RoundMode) -> Result<Self, ArithmeticError>

Available on crate feature i32 only.

Returns 1/n.

pub fn cneg(self) -> Result<Self, ArithmeticError>

Available on crate feature i32 only.

Checked negation. Returns Err on overflow (you can’t negate MIN value).

pub fn half_sum(a: Self, b: Self, mode: RoundMode) -> Self

Available on crate feature i32 only.

Calculates (a + b) / 2.

pub fn integral(self, mode: RoundMode) -> i32

Available on crate feature i32 only.

Takes rounded integral part of the number.

use fixnum::{FixedPoint, typenum::U9, ops::RoundMode::*};

type Amount = FixedPoint<i64, U9>;

let a: Amount = "8273.519".parse()?;
assert_eq!(a.integral(Floor), 8273);
assert_eq!(a.integral(Nearest), 8274);
assert_eq!(a.integral(Ceil), 8274);

let a: Amount = "-8273.519".parse()?;
assert_eq!(a.integral(Floor), -8274);
assert_eq!(a.integral(Nearest), -8274);
assert_eq!(a.integral(Ceil), -8273);

pub fn floor(self) -> Self

Available on crate feature i32 only.

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

pub fn ceil(self) -> Self

Available on crate feature i32 only.

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

pub fn round(self) -> Self

Available on crate feature i32 only.

Returns the nearest integer to a number. Round half-way cases away from 0.0.

pub fn round_towards_zero_by(self, precision: Self) -> Self

Available on crate feature i32 only.

Rounds towards zero by the provided precision.

pub fn next_power_of_ten(self) -> Result<Self, ArithmeticError>

Available on crate feature i32 only.

Returns the next power of ten:

• For positive: the smallest greater than or equal to a number.
• For negative: the largest less than or equal to a number.

pub fn abs(self) -> Result<Self, ArithmeticError>

Available on crate feature i32 only.

Returns the absolute value of a number.

pub fn rsqrt(self, mode: RoundMode) -> Result<Self, ArithmeticError>

Available on crate feature i32 only.

Checked rounding square root. Returns Err for negative argument.

Square root of a non-negative F is a non-negative S such that:

• Floor: S ≤ sqrt(F)
• Ceil: S ≥ sqrt(F)
• Nearest: Floor or Ceil, which one is closer to sqrt(F)

use fixnum::{ArithmeticError, FixedPoint, typenum::U9};
use fixnum::ops::{Zero, RoundMode::*};

type Amount = FixedPoint<i64, U9>;

let a: Amount = "81".parse()?;
let b: Amount = "2".parse()?;
let c: Amount = "-100".parse()?;
assert_eq!(a.rsqrt(Floor)?, "9".parse()?);
assert_eq!(b.rsqrt(Floor)?, "1.414213562".parse()?);
assert_eq!(b.rsqrt(Ceil)?, "1.414213563".parse()?);
assert_eq!(c.rsqrt(Floor), Err(ArithmeticError::DomainViolation));

impl<P: Precision> FixedPoint<i32, P>

pub fn from_decimal(mantissa: i32, exponent: i32) -> Result<Self, ConvertError>

Available on crate feature i32 only.

Creates a new number from separate mantissa and exponent.

pub fn to_decimal(&self, max_exponent: i32) -> (i32, i32)

Available on crate feature i32 only.

Returns a pair (mantissa, exponent) where exponent is in [-PRECISION, max_exponent].

Examples:

• fp!(5.5).to_decimal(0) // => (55, -1)
• fp!(5.5).to_decimal(-1) // => (55, -1)
• fp!(5.5).to_decimal(-2) // => (550, -2)
• fp!(50).to_decimal(0) // => (50, 0)
• fp!(50).to_decimal(i32::MAX) // => (5, 1)

Panics

If max_exponent is less than -PRECISION.

impl<P: Precision> FixedPoint<i64, P>

pub const PRECISION: i32 = P::I32

Available on crate feature i64 only.

The number of digits in the fractional part.

pub const EPSILON: Self

Available on crate feature i64 only.

The difference between 0.0 and the next larger representable number.

impl<P: Precision> FixedPoint<i64, P>

pub fn signum(self) -> i64

Available on crate feature i64 only.

Returns a number representing sign of self.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

pub fn recip(self, mode: RoundMode) -> Result<Self, ArithmeticError>

Available on crate feature i64 only.

Returns 1/n.

pub fn cneg(self) -> Result<Self, ArithmeticError>

Available on crate feature i64 only.

Checked negation. Returns Err on overflow (you can’t negate MIN value).

pub fn half_sum(a: Self, b: Self, mode: RoundMode) -> Self

Available on crate feature i64 only.

Calculates (a + b) / 2.

pub fn integral(self, mode: RoundMode) -> i64

Available on crate feature i64 only.

Takes rounded integral part of the number.

use fixnum::{FixedPoint, typenum::U9, ops::RoundMode::*};

type Amount = FixedPoint<i64, U9>;

let a: Amount = "8273.519".parse()?;
assert_eq!(a.integral(Floor), 8273);
assert_eq!(a.integral(Nearest), 8274);
assert_eq!(a.integral(Ceil), 8274);

let a: Amount = "-8273.519".parse()?;
assert_eq!(a.integral(Floor), -8274);
assert_eq!(a.integral(Nearest), -8274);
assert_eq!(a.integral(Ceil), -8273);

pub fn floor(self) -> Self

Available on crate feature i64 only.

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

pub fn ceil(self) -> Self

Available on crate feature i64 only.

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

pub fn round(self) -> Self

Available on crate feature i64 only.

Returns the nearest integer to a number. Round half-way cases away from 0.0.

pub fn round_towards_zero_by(self, precision: Self) -> Self

Available on crate feature i64 only.

Rounds towards zero by the provided precision.

pub fn next_power_of_ten(self) -> Result<Self, ArithmeticError>

Available on crate feature i64 only.

Returns the next power of ten:

• For positive: the smallest greater than or equal to a number.
• For negative: the largest less than or equal to a number.

pub fn abs(self) -> Result<Self, ArithmeticError>

Available on crate feature i64 only.

Returns the absolute value of a number.

pub fn rsqrt(self, mode: RoundMode) -> Result<Self, ArithmeticError>

Available on crate feature i64 only.

Checked rounding square root. Returns Err for negative argument.

Square root of a non-negative F is a non-negative S such that:

• Floor: S ≤ sqrt(F)
• Ceil: S ≥ sqrt(F)
• Nearest: Floor or Ceil, which one is closer to sqrt(F)

use fixnum::{ArithmeticError, FixedPoint, typenum::U9};
use fixnum::ops::{Zero, RoundMode::*};

type Amount = FixedPoint<i64, U9>;

let a: Amount = "81".parse()?;
let b: Amount = "2".parse()?;
let c: Amount = "-100".parse()?;
assert_eq!(a.rsqrt(Floor)?, "9".parse()?);
assert_eq!(b.rsqrt(Floor)?, "1.414213562".parse()?);
assert_eq!(b.rsqrt(Ceil)?, "1.414213563".parse()?);
assert_eq!(c.rsqrt(Floor), Err(ArithmeticError::DomainViolation));

impl<P: Precision> FixedPoint<i64, P>

pub fn from_decimal(mantissa: i64, exponent: i32) -> Result<Self, ConvertError>

Available on crate feature i64 only.

Creates a new number from separate mantissa and exponent.

pub fn to_decimal(&self, max_exponent: i32) -> (i64, i32)

Available on crate feature i64 only.

Returns a pair (mantissa, exponent) where exponent is in [-PRECISION, max_exponent].

Examples:

• fp!(5.5).to_decimal(0) // => (55, -1)
• fp!(5.5).to_decimal(-1) // => (55, -1)
• fp!(5.5).to_decimal(-2) // => (550, -2)
• fp!(50).to_decimal(0) // => (50, 0)
• fp!(50).to_decimal(i32::MAX) // => (5, 1)

Panics

If max_exponent is less than -PRECISION.

impl<P: Precision> FixedPoint<i128, P>

pub const PRECISION: i32 = P::I32

Available on crate feature i128 only.

The number of digits in the fractional part.

pub const EPSILON: Self

Available on crate feature i128 only.

The difference between 0.0 and the next larger representable number.

impl<P: Precision> FixedPoint<i128, P>

pub fn signum(self) -> i128

Available on crate feature i128 only.

Returns a number representing sign of self.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

pub fn recip(self, mode: RoundMode) -> Result<Self, ArithmeticError>

Available on crate feature i128 only.

Returns 1/n.

pub fn cneg(self) -> Result<Self, ArithmeticError>

Available on crate feature i128 only.

Checked negation. Returns Err on overflow (you can’t negate MIN value).

pub fn half_sum(a: Self, b: Self, mode: RoundMode) -> Self

Available on crate feature i128 only.

Calculates (a + b) / 2.

pub fn integral(self, mode: RoundMode) -> i128

Available on crate feature i128 only.

Takes rounded integral part of the number.

use fixnum::{FixedPoint, typenum::U9, ops::RoundMode::*};

type Amount = FixedPoint<i64, U9>;

let a: Amount = "8273.519".parse()?;
assert_eq!(a.integral(Floor), 8273);
assert_eq!(a.integral(Nearest), 8274);
assert_eq!(a.integral(Ceil), 8274);

let a: Amount = "-8273.519".parse()?;
assert_eq!(a.integral(Floor), -8274);
assert_eq!(a.integral(Nearest), -8274);
assert_eq!(a.integral(Ceil), -8273);

pub fn floor(self) -> Self

Available on crate feature i128 only.

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

pub fn ceil(self) -> Self

Available on crate feature i128 only.

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

pub fn round(self) -> Self

Available on crate feature i128 only.

Returns the nearest integer to a number. Round half-way cases away from 0.0.

pub fn round_towards_zero_by(self, precision: Self) -> Self

Available on crate feature i128 only.

Rounds towards zero by the provided precision.

pub fn next_power_of_ten(self) -> Result<Self, ArithmeticError>

Available on crate feature i128 only.

Returns the next power of ten:

• For positive: the smallest greater than or equal to a number.
• For negative: the largest less than or equal to a number.

pub fn abs(self) -> Result<Self, ArithmeticError>

Available on crate feature i128 only.

Returns the absolute value of a number.

pub fn rsqrt(self, mode: RoundMode) -> Result<Self, ArithmeticError>

Available on crate feature i128 only.

Checked rounding square root. Returns Err for negative argument.

Square root of a non-negative F is a non-negative S such that:

• Floor: S ≤ sqrt(F)
• Ceil: S ≥ sqrt(F)
• Nearest: Floor or Ceil, which one is closer to sqrt(F)

use fixnum::{ArithmeticError, FixedPoint, typenum::U9};
use fixnum::ops::{Zero, RoundMode::*};

type Amount = FixedPoint<i64, U9>;

let a: Amount = "81".parse()?;
let b: Amount = "2".parse()?;
let c: Amount = "-100".parse()?;
assert_eq!(a.rsqrt(Floor)?, "9".parse()?);
assert_eq!(b.rsqrt(Floor)?, "1.414213562".parse()?);
assert_eq!(b.rsqrt(Ceil)?, "1.414213563".parse()?);
assert_eq!(c.rsqrt(Floor), Err(ArithmeticError::DomainViolation));

impl<P: Precision> FixedPoint<i128, P>

pub fn from_decimal(mantissa: i128, exponent: i32) -> Result<Self, ConvertError>

Available on crate feature i128 only.

Creates a new number from separate mantissa and exponent.

pub fn to_decimal(&self, max_exponent: i32) -> (i128, i32)

Available on crate feature i128 only.

Returns a pair (mantissa, exponent) where exponent is in [-PRECISION, max_exponent].

Examples:

• fp!(5.5).to_decimal(0) // => (55, -1)
• fp!(5.5).to_decimal(-1) // => (55, -1)
• fp!(5.5).to_decimal(-2) // => (550, -2)
• fp!(50).to_decimal(0) // => (50, 0)
• fp!(50).to_decimal(i32::MAX) // => (5, 1)

Panics

If max_exponent is less than -PRECISION.

Trait Implementations

impl<I, P> Archive for FixedPoint<I, P>

where I: Archive, PhantomData<P>: Archive,

type Archived = ArchivedFixedPoint<I, P>

The archived representation of this type.

type Resolver = FixedPointResolver<I, P>

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<P: Precision> Bounded for FixedPoint<i128, P>

Available on crate feature i128 only.

const MIN: Self

Represents MIN.

const MAX: Self

Represents MAX.

impl<P: Precision> Bounded for FixedPoint<i16, P>

Available on crate feature i16 only.

const MIN: Self

Represents MIN.

const MAX: Self

Represents MAX.

impl<P: Precision> Bounded for FixedPoint<i32, P>

Available on crate feature i32 only.

const MIN: Self

Represents MIN.

const MAX: Self

Represents MAX.

impl<P: Precision> Bounded for FixedPoint<i64, P>

Available on crate feature i64 only.

const MIN: Self

Represents MIN.

const MAX: Self

Represents MAX.

impl<P: Precision> CheckedAdd for FixedPoint<i128, P>

Available on crate feature i128 only.

type Output = FixedPoint<i128, P>

Result of addition.

type Error = ArithmeticError

Usually ArithmeticError.

fn cadd(self, rhs: Self) -> Result<Self, ArithmeticError>

Checked addition. Returns Err on overflow.

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

Saturating addition. Computes self + rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing.

impl<P: Precision> CheckedAdd for FixedPoint<i16, P>

Available on crate feature i16 only.

type Output = FixedPoint<i16, P>

Result of addition.

type Error = ArithmeticError

Usually ArithmeticError.

fn cadd(self, rhs: Self) -> Result<Self, ArithmeticError>

Checked addition. Returns Err on overflow.

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

Saturating addition. Computes self + rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing.

impl<P: Precision> CheckedAdd for FixedPoint<i32, P>

Available on crate feature i32 only.

type Output = FixedPoint<i32, P>

Result of addition.

type Error = ArithmeticError

Usually ArithmeticError.

fn cadd(self, rhs: Self) -> Result<Self, ArithmeticError>

Checked addition. Returns Err on overflow.

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

Saturating addition. Computes self + rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing.

impl<P: Precision> CheckedAdd for FixedPoint<i64, P>

Available on crate feature i64 only.

type Output = FixedPoint<i64, P>

Result of addition.

type Error = ArithmeticError

Usually ArithmeticError.

fn cadd(self, rhs: Self) -> Result<Self, ArithmeticError>

Checked addition. Returns Err on overflow.

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

Saturating addition. Computes self + rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing.

impl<P: Precision> CheckedMul<FixedPoint<i128, P>> for i128

Available on crate feature i128 only.

type Output = FixedPoint<i128, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn cmul( self, rhs: FixedPoint<i128, P>, ) -> Result<FixedPoint<i128, P>, ArithmeticError>

Checked multiplication. Returns Err on overflow. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

fn saturating_mul(self, rhs: FixedPoint<i128, P>) -> Self::Output

Saturating multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

impl<P: Precision> CheckedMul<FixedPoint<i16, P>> for i16

Available on crate feature i16 only.

type Output = FixedPoint<i16, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn cmul( self, rhs: FixedPoint<i16, P>, ) -> Result<FixedPoint<i16, P>, ArithmeticError>

Checked multiplication. Returns Err on overflow. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

fn saturating_mul(self, rhs: FixedPoint<i16, P>) -> Self::Output

Saturating multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

impl<P: Precision> CheckedMul<FixedPoint<i32, P>> for i32

Available on crate feature i32 only.

type Output = FixedPoint<i32, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn cmul( self, rhs: FixedPoint<i32, P>, ) -> Result<FixedPoint<i32, P>, ArithmeticError>

Checked multiplication. Returns Err on overflow. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

fn saturating_mul(self, rhs: FixedPoint<i32, P>) -> Self::Output

Saturating multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

impl<P: Precision> CheckedMul<FixedPoint<i64, P>> for i64

Available on crate feature i64 only.

type Output = FixedPoint<i64, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn cmul( self, rhs: FixedPoint<i64, P>, ) -> Result<FixedPoint<i64, P>, ArithmeticError>

Checked multiplication. Returns Err on overflow. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

fn saturating_mul(self, rhs: FixedPoint<i64, P>) -> Self::Output

Saturating multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

impl<P: Precision> CheckedMul<i128> for FixedPoint<i128, P>

Available on crate feature i128 only.

type Output = FixedPoint<i128, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn cmul(self, rhs: i128) -> Result<Self, ArithmeticError>

Checked multiplication. Returns Err on overflow. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

fn saturating_mul(self, rhs: i128) -> Self::Output

Saturating multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

impl<P: Precision> CheckedMul<i16> for FixedPoint<i16, P>

Available on crate feature i16 only.

type Output = FixedPoint<i16, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn cmul(self, rhs: i16) -> Result<Self, ArithmeticError>

Checked multiplication. Returns Err on overflow. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

fn saturating_mul(self, rhs: i16) -> Self::Output

Saturating multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

impl<P: Precision> CheckedMul<i32> for FixedPoint<i32, P>

Available on crate feature i32 only.

type Output = FixedPoint<i32, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn cmul(self, rhs: i32) -> Result<Self, ArithmeticError>

Checked multiplication. Returns Err on overflow. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

fn saturating_mul(self, rhs: i32) -> Self::Output

Saturating multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

impl<P: Precision> CheckedMul<i64> for FixedPoint<i64, P>

Available on crate feature i64 only.

type Output = FixedPoint<i64, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn cmul(self, rhs: i64) -> Result<Self, ArithmeticError>

Checked multiplication. Returns Err on overflow. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

fn saturating_mul(self, rhs: i64) -> Self::Output

Saturating multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. This is multiplication without rounding, hence it’s available only when at least one operand is integer.

impl<P: Precision> CheckedSub for FixedPoint<i128, P>

Available on crate feature i128 only.

type Output = FixedPoint<i128, P>

Result of subtraction.

type Error = ArithmeticError

Usually ArithmeticError.

fn csub(self, rhs: Self) -> Result<Self, ArithmeticError>

Checked subtraction. Returns Err on overflow.

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

Saturating subtraction. Computes self - rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing.

impl<P: Precision> CheckedSub for FixedPoint<i16, P>

Available on crate feature i16 only.

type Output = FixedPoint<i16, P>

Result of subtraction.

type Error = ArithmeticError

Usually ArithmeticError.

fn csub(self, rhs: Self) -> Result<Self, ArithmeticError>

Checked subtraction. Returns Err on overflow.

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

Saturating subtraction. Computes self - rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing.

impl<P: Precision> CheckedSub for FixedPoint<i32, P>

Available on crate feature i32 only.

type Output = FixedPoint<i32, P>

Result of subtraction.

type Error = ArithmeticError

Usually ArithmeticError.

fn csub(self, rhs: Self) -> Result<Self, ArithmeticError>

Checked subtraction. Returns Err on overflow.

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

Saturating subtraction. Computes self - rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing.

impl<P: Precision> CheckedSub for FixedPoint<i64, P>

Available on crate feature i64 only.

type Output = FixedPoint<i64, P>

Result of subtraction.

type Error = ArithmeticError

Usually ArithmeticError.

fn csub(self, rhs: Self) -> Result<Self, ArithmeticError>

Checked subtraction. Returns Err on overflow.

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

Saturating subtraction. Computes self - rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing.

impl<I: Clone, P: Clone> Clone for FixedPoint<I, P>

fn clone(&self) -> FixedPoint<I, P>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<P> CompactAs for FixedPoint<i128, P>

Available on crate features parity and i128 only.

type As = u128

A compact-encodable type that should be used as the encoding.

fn encode_as(&self) -> &Self::As

Returns the compact-encodable type.

fn decode_from(value: Self::As) -> Result<Self, Error>

Decode Self from the compact-decoded type.

impl<P> CompactAs for FixedPoint<i16, P>

Available on crate features parity and i16 only.

type As = u16

A compact-encodable type that should be used as the encoding.

fn encode_as(&self) -> &Self::As

Returns the compact-encodable type.

fn decode_from(value: Self::As) -> Result<Self, Error>

Decode Self from the compact-decoded type.

impl<P> CompactAs for FixedPoint<i32, P>

Available on crate features parity and i32 only.

type As = u32

A compact-encodable type that should be used as the encoding.

fn encode_as(&self) -> &Self::As

Returns the compact-encodable type.

fn decode_from(value: Self::As) -> Result<Self, Error>

Decode Self from the compact-decoded type.

impl<P> CompactAs for FixedPoint<i64, P>

Available on crate features parity and i64 only.

type As = u64

A compact-encodable type that should be used as the encoding.

fn encode_as(&self) -> &Self::As

Returns the compact-encodable type.

fn decode_from(value: Self::As) -> Result<Self, Error>

Decode Self from the compact-decoded type.

impl<P: Precision> Debug for FixedPoint<i128, P>

Available on crate feature i128 only.

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

Formats the value using the given formatter.

impl<P: Precision> Debug for FixedPoint<i16, P>

Available on crate feature i16 only.

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

Formats the value using the given formatter.

impl<P: Precision> Debug for FixedPoint<i32, P>

Available on crate feature i32 only.

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

Formats the value using the given formatter.

impl<P: Precision> Debug for FixedPoint<i64, P>

Available on crate feature i64 only.

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

Formats the value using the given formatter.

impl<P> Decode for FixedPoint<i128, P>

Available on crate features parity and i128 only.

fn decode<In: Input>(input: &mut In) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<P> Decode for FixedPoint<i16, P>

Available on crate features parity and i16 only.

fn decode<In: Input>(input: &mut In) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<P> Decode for FixedPoint<i32, P>

Available on crate features parity and i32 only.

fn decode<In: Input>(input: &mut In) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<P> Decode for FixedPoint<i64, P>

Available on crate features parity and i64 only.

fn decode<In: Input>(input: &mut In) -> Result<Self, Error>

Attempt to deserialise the value from input.

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self>, ) -> Result<DecodeFinished, Error>

where I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory.

fn skip<I>(input: &mut I) -> Result<(), Error>

where I: Input,

Attempt to skip the encoded value from input.

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type.

impl<I: Default, P: Default> Default for FixedPoint<I, P>

fn default() -> FixedPoint<I, P>

Returns the “default value” for a type.

impl<'de, I, P> Deserialize<'de> for FixedPoint<I, P>

where I: Deserialize<'de>, Self: FromStr + TryFrom<f64> + TryFrom<u64> + TryFrom<i64> + TryFrom<i128> + TryFrom<u128>,

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<__D: Fallible + ?Sized, I, P> Deserialize<FixedPoint<I, P>, __D> for Archived<FixedPoint<I, P>>

where I: Archive, <I as Archive>::Archived: Deserialize<I, __D>, PhantomData<P>: Archive, <PhantomData<P> as Archive>::Archived: Deserialize<PhantomData<P>, __D>,

fn deserialize( &self, deserializer: &mut __D, ) -> Result<FixedPoint<I, P>, <__D as Fallible>::Error>

Deserializes using the given deserializer

impl<P: Precision> Display for FixedPoint<i128, P>

Available on crate feature i128 only.

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

Formats the value using the given formatter.

impl<P: Precision> Display for FixedPoint<i16, P>

Available on crate feature i16 only.

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

Formats the value using the given formatter.

impl<P: Precision> Display for FixedPoint<i32, P>

Available on crate feature i32 only.

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

Formats the value using the given formatter.

impl<P: Precision> Display for FixedPoint<i64, P>

Available on crate feature i64 only.

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

Formats the value using the given formatter.

impl<P> Encode for FixedPoint<i128, P>

Available on crate features parity and i128 only.

fn encode_to<O: Output + ?Sized>(&self, destination: &mut O)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<P> Encode for FixedPoint<i16, P>

Available on crate features parity and i16 only.

fn encode_to<O: Output + ?Sized>(&self, destination: &mut O)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<P> Encode for FixedPoint<i32, P>

Available on crate features parity and i32 only.

fn encode_to<O: Output + ?Sized>(&self, destination: &mut O)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<P> Encode for FixedPoint<i64, P>

Available on crate features parity and i64 only.

fn encode_to<O: Output + ?Sized>(&self, destination: &mut O)

Convert self to a slice and append it to the destination.

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding.

fn encode(&self) -> Vec<u8>

Convert self to an owned vector.

fn using_encoded<R, F>(&self, f: F) -> R

where F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.

fn encoded_size(&self) -> usize

Calculates the encoded size.

impl<I, P> From<Compact<FixedPoint<I, P>>> for FixedPoint<I, P>

Available on crate feature parity only.

fn from(value: Compact<Self>) -> Self

Converts to this type from the input type.

impl<P: Precision> From<FixedPoint<i128, P>> for f64

fn from(value: FixedPoint<i128, P>) -> Self

Converts to this type from the input type.

impl<P: Precision> From<FixedPoint<i16, P>> for f64

fn from(value: FixedPoint<i16, P>) -> Self

Converts to this type from the input type.

impl<P: Precision> From<FixedPoint<i32, P>> for f64

fn from(value: FixedPoint<i32, P>) -> Self

Converts to this type from the input type.

impl<P: Precision> From<FixedPoint<i64, P>> for f64

fn from(value: FixedPoint<i64, P>) -> Self

Converts to this type from the input type.

impl<P: Precision> FromStr for FixedPoint<i128, P>

fn from_str(str: &str) -> Result<Self, Self::Err>

Parses a string slice into a fixed point. If the value cannot be represented, it will be rounded to the nearest value.

Use from_str_exact to parse without rounding.

type Err = ConvertError

The associated error which can be returned from parsing.

impl<P: Precision> FromStr for FixedPoint<i16, P>

fn from_str(str: &str) -> Result<Self, Self::Err>

Parses a string slice into a fixed point. If the value cannot be represented, it will be rounded to the nearest value.

Use from_str_exact to parse without rounding.

type Err = ConvertError

The associated error which can be returned from parsing.

impl<P: Precision> FromStr for FixedPoint<i32, P>

fn from_str(str: &str) -> Result<Self, Self::Err>

Parses a string slice into a fixed point. If the value cannot be represented, it will be rounded to the nearest value.

Use from_str_exact to parse without rounding.

type Err = ConvertError

The associated error which can be returned from parsing.

impl<P: Precision> FromStr for FixedPoint<i64, P>

fn from_str(str: &str) -> Result<Self, Self::Err>

Parses a string slice into a fixed point. If the value cannot be represented, it will be rounded to the nearest value.

Use from_str_exact to parse without rounding.

type Err = ConvertError

The associated error which can be returned from parsing.

impl<I: Hash, P: Hash> Hash for FixedPoint<I, P>

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

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<I, P> JsonSchema for FixedPoint<I, P>

Available on crate feature schemars only.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(_: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

impl<P: Precision> One for FixedPoint<i128, P>

Available on crate feature i128 only.

const ONE: Self

Represents 1.

impl<P: Precision> One for FixedPoint<i16, P>

Available on crate feature i16 only.

const ONE: Self

Represents 1.

impl<P: Precision> One for FixedPoint<i32, P>

Available on crate feature i32 only.

const ONE: Self

Represents 1.

impl<P: Precision> One for FixedPoint<i64, P>

Available on crate feature i64 only.

const ONE: Self

Represents 1.

impl<I: Ord, P: Ord> Ord for FixedPoint<I, P>

fn cmp(&self, other: &FixedPoint<I, P>) -> 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: PartialEq, P: PartialEq> PartialEq for FixedPoint<I, P>

fn eq(&self, other: &FixedPoint<I, P>) -> 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: PartialOrd, P: PartialOrd> PartialOrd for FixedPoint<I, P>

fn partial_cmp(&self, other: &FixedPoint<I, P>) -> 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<P: Precision> RoundingDiv<FixedPoint<i128, P>> for i128

Available on crate feature i128 only.

type Output = FixedPoint<i128, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv( self, rhs: FixedPoint<i128, P>, mode: RoundMode, ) -> Result<FixedPoint<i128, P>, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingDiv<FixedPoint<i16, P>> for i16

Available on crate feature i16 only.

type Output = FixedPoint<i16, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv( self, rhs: FixedPoint<i16, P>, mode: RoundMode, ) -> Result<FixedPoint<i16, P>, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingDiv<FixedPoint<i32, P>> for i32

Available on crate feature i32 only.

type Output = FixedPoint<i32, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv( self, rhs: FixedPoint<i32, P>, mode: RoundMode, ) -> Result<FixedPoint<i32, P>, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingDiv<FixedPoint<i64, P>> for i64

Available on crate feature i64 only.

type Output = FixedPoint<i64, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv( self, rhs: FixedPoint<i64, P>, mode: RoundMode, ) -> Result<FixedPoint<i64, P>, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingDiv<i128> for FixedPoint<i128, P>

Available on crate feature i128 only.

type Output = FixedPoint<i128, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv(self, rhs: i128, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingDiv<i16> for FixedPoint<i16, P>

Available on crate feature i16 only.

type Output = FixedPoint<i16, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv(self, rhs: i16, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingDiv<i32> for FixedPoint<i32, P>

Available on crate feature i32 only.

type Output = FixedPoint<i32, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv(self, rhs: i32, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingDiv<i64> for FixedPoint<i64, P>

Available on crate feature i64 only.

type Output = FixedPoint<i64, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv(self, rhs: i64, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingDiv for FixedPoint<i128, P>

Available on crate feature i128 only.

type Output = FixedPoint<i128, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv(self, rhs: Self, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingDiv for FixedPoint<i16, P>

Available on crate feature i16 only.

type Output = FixedPoint<i16, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv(self, rhs: Self, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingDiv for FixedPoint<i32, P>

Available on crate feature i32 only.

type Output = FixedPoint<i32, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv(self, rhs: Self, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingDiv for FixedPoint<i64, P>

Available on crate feature i64 only.

type Output = FixedPoint<i64, P>

Result of division.

type Error = ArithmeticError

Usually ArithmeticError.

fn rdiv(self, rhs: Self, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded division. Returns Err on overflow or attempt to divide by zero. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingMul for FixedPoint<i128, P>

Available on crate feature i128 only.

type Output = FixedPoint<i128, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn rmul(self, rhs: Self, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded multiplication. Returns Err on overflow. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

fn saturating_rmul(self, rhs: Rhs, round_mode: RoundMode) -> Self::Output

where Self: PartialOrd + Zero + Sized, Rhs: PartialOrd + Zero, Self::Output: Bounded,

Saturating rounding multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingMul for FixedPoint<i16, P>

Available on crate feature i16 only.

type Output = FixedPoint<i16, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn rmul(self, rhs: Self, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded multiplication. Returns Err on overflow. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

fn saturating_rmul(self, rhs: Rhs, round_mode: RoundMode) -> Self::Output

where Self: PartialOrd + Zero + Sized, Rhs: PartialOrd + Zero, Self::Output: Bounded,

Saturating rounding multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingMul for FixedPoint<i32, P>

Available on crate feature i32 only.

type Output = FixedPoint<i32, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn rmul(self, rhs: Self, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded multiplication. Returns Err on overflow. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

fn saturating_rmul(self, rhs: Rhs, round_mode: RoundMode) -> Self::Output

where Self: PartialOrd + Zero + Sized, Rhs: PartialOrd + Zero, Self::Output: Bounded,

Saturating rounding multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<P: Precision> RoundingMul for FixedPoint<i64, P>

Available on crate feature i64 only.

type Output = FixedPoint<i64, P>

Result of multiplication.

type Error = ArithmeticError

Usually ArithmeticError.

fn rmul(self, rhs: Self, mode: RoundMode) -> Result<Self, ArithmeticError>

Checked rounded multiplication. Returns Err on overflow. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

fn saturating_rmul(self, rhs: Rhs, round_mode: RoundMode) -> Self::Output

where Self: PartialOrd + Zero + Sized, Rhs: PartialOrd + Zero, Self::Output: Bounded,

Saturating rounding multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

impl<__S: Fallible + ?Sized, I, P> Serialize<__S> for FixedPoint<I, P>

where I: Serialize<__S>, PhantomData<P>: Serialize<__S>,

fn serialize( &self, serializer: &mut __S, ) -> Result<<Self as Archive>::Resolver, <__S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<I, P> Serialize for FixedPoint<I, P>

where I: Serialize, Self: Stringify + Clone,

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<P: Precision> TryFrom<f64> for FixedPoint<i128, P>

fn try_from(value: f64) -> Result<Self, Self::Error>

Implementation courtesy of rust_decimal crate

type Error = ConvertError

The type returned in the event of a conversion error.

impl<P: Precision> TryFrom<f64> for FixedPoint<i16, P>

fn try_from(value: f64) -> Result<Self, Self::Error>

Implementation courtesy of rust_decimal crate

type Error = ConvertError

The type returned in the event of a conversion error.

impl<P: Precision> TryFrom<f64> for FixedPoint<i32, P>

fn try_from(value: f64) -> Result<Self, Self::Error>

Implementation courtesy of rust_decimal crate

type Error = ConvertError

The type returned in the event of a conversion error.

impl<P: Precision> TryFrom<f64> for FixedPoint<i64, P>

fn try_from(value: f64) -> Result<Self, Self::Error>

Implementation courtesy of rust_decimal crate

type Error = ConvertError

The type returned in the event of a conversion error.

impl<P: Precision> TryFrom<i128> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i128) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i128> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i128) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i128> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i128) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i128> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i128) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i16> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i16) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i16> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i16) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i16> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i16) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i16> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i16) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i32> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i32> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i32> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i32> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i64> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i64) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i64> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i64) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i64> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i64) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i64> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i64) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i8> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i8) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i8> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i8) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i8> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i8) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<i8> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: i8) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<isize> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: isize) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<isize> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: isize) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<isize> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: isize) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<isize> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: isize) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u128> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u128) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u128> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u128) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u128> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u128) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u128> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u128) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u16> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u16) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u16> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u16) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u16> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u16) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u16> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u16) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u32> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u32> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u32> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u32> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u32) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u64> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u64) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u64> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u64) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u64> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u64) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u64> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u64) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u8> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u8> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u8> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<u8> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: u8) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<usize> for FixedPoint<i128, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: usize) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<usize> for FixedPoint<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: usize) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<usize> for FixedPoint<i32, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: usize) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> TryFrom<usize> for FixedPoint<i64, P>

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: usize) -> Result<Self, Self::Error>

Performs the conversion.

impl<P: Precision> Zero for FixedPoint<i128, P>

Available on crate feature i128 only.

const ZERO: Self

Represents 0.

impl<P: Precision> Zero for FixedPoint<i16, P>

Available on crate feature i16 only.

const ZERO: Self

Represents 0.

impl<P: Precision> Zero for FixedPoint<i32, P>

Available on crate feature i32 only.

const ZERO: Self

Represents 0.

impl<P: Precision> Zero for FixedPoint<i64, P>

Available on crate feature i64 only.

const ZERO: Self

Represents 0.

impl<I: Copy, P: Copy> Copy for FixedPoint<I, P>

impl<P> EncodeLike for FixedPoint<i128, P>

Available on crate features parity and i128 only.

impl<P> EncodeLike for FixedPoint<i16, P>

Available on crate features parity and i16 only.

impl<P> EncodeLike for FixedPoint<i32, P>

Available on crate features parity and i32 only.

impl<P> EncodeLike for FixedPoint<i64, P>

Available on crate features parity and i64 only.

impl<I: Eq, P: Eq> Eq for FixedPoint<I, P>

impl<I, P> StructuralPartialEq for FixedPoint<I, P>