Struct fixnum::FixedPoint

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

This is supported 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<I, P> FixedPoint<I, P>

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

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

pub fn into_bits(self) -> I

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

pub const PRECISION: i32

This is supported on crate feature i16 only.

pub const EPSILON: Self

This is supported on crate feature i16 only.

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

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

This is supported on crate feature i16 only.

pub fn cneg(self) -> Result<FixedPoint<i16, P>, ArithmeticError>

This is supported on crate feature i16 only.

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

pub fn half_sum(
    a: FixedPoint<i16, P>,
    b: FixedPoint<i16, P>,
    mode: RoundMode
) -> FixedPoint<i16, P>

This is supported on crate feature i16 only.

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

This is supported 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(Ceil), 8274);

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

pub fn round_towards_zero_by(
    self,
    precision: FixedPoint<i16, P>
) -> FixedPoint<i16, P>

This is supported on crate feature i16 only.

pub fn next_power_of_ten(self) -> Result<FixedPoint<i16, P>, ArithmeticError>

This is supported on crate feature i16 only.

pub fn rounding_from_f64(
    value: f64
) -> Result<FixedPoint<i16, P>, ArithmeticError>

👎 Deprecated since 0.6.0:

Use TryFrom instead

This is supported on crate features i16 and std only.

pub fn to_f64(self) -> f64

👎 Deprecated since 0.6.0:

Use From instead

This is supported on crate feature i16 only.

pub fn rounding_to_i64(self) -> i64

This is supported on crate feature i16 only.

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

This is supported on crate feature i16 only.

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

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

This is supported on crate feature i16 only.

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

pub const PRECISION: i32

This is supported on crate feature i32 only.

pub const EPSILON: Self

This is supported on crate feature i32 only.

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

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

This is supported on crate feature i32 only.

pub fn cneg(self) -> Result<FixedPoint<i32, P>, ArithmeticError>

This is supported on crate feature i32 only.

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

pub fn half_sum(
    a: FixedPoint<i32, P>,
    b: FixedPoint<i32, P>,
    mode: RoundMode
) -> FixedPoint<i32, P>

This is supported on crate feature i32 only.

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

This is supported 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(Ceil), 8274);

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

pub fn round_towards_zero_by(
    self,
    precision: FixedPoint<i32, P>
) -> FixedPoint<i32, P>

This is supported on crate feature i32 only.

pub fn next_power_of_ten(self) -> Result<FixedPoint<i32, P>, ArithmeticError>

This is supported on crate feature i32 only.

pub fn rounding_from_f64(
    value: f64
) -> Result<FixedPoint<i32, P>, ArithmeticError>

👎 Deprecated since 0.6.0:

Use TryFrom instead

This is supported on crate features i32 and std only.

pub fn to_f64(self) -> f64

👎 Deprecated since 0.6.0:

Use From instead

This is supported on crate feature i32 only.

pub fn rounding_to_i64(self) -> i64

This is supported on crate feature i32 only.

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

This is supported on crate feature i32 only.

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

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

This is supported on crate feature i32 only.

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

pub const PRECISION: i32

This is supported on crate feature i64 only.

pub const EPSILON: Self

This is supported on crate feature i64 only.

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

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

This is supported on crate feature i64 only.

pub fn cneg(self) -> Result<FixedPoint<i64, P>, ArithmeticError>

This is supported on crate feature i64 only.

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

pub fn half_sum(
    a: FixedPoint<i64, P>,
    b: FixedPoint<i64, P>,
    mode: RoundMode
) -> FixedPoint<i64, P>

This is supported on crate feature i64 only.

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

This is supported 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(Ceil), 8274);

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

pub fn round_towards_zero_by(
    self,
    precision: FixedPoint<i64, P>
) -> FixedPoint<i64, P>

This is supported on crate feature i64 only.

pub fn next_power_of_ten(self) -> Result<FixedPoint<i64, P>, ArithmeticError>

This is supported on crate feature i64 only.

pub fn rounding_from_f64(
    value: f64
) -> Result<FixedPoint<i64, P>, ArithmeticError>

👎 Deprecated since 0.6.0:

Use TryFrom instead

This is supported on crate features i64 and std only.

pub fn to_f64(self) -> f64

👎 Deprecated since 0.6.0:

Use From instead

This is supported on crate feature i64 only.

pub fn rounding_to_i64(self) -> i64

This is supported on crate feature i64 only.

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

This is supported on crate feature i64 only.

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

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

This is supported on crate feature i64 only.

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

pub const PRECISION: i32

This is supported on crate feature i128 only.

pub const EPSILON: Self

This is supported on crate feature i128 only.

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

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

This is supported on crate feature i128 only.

pub fn cneg(self) -> Result<FixedPoint<i128, P>, ArithmeticError>

This is supported on crate feature i128 only.

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

pub fn half_sum(
    a: FixedPoint<i128, P>,
    b: FixedPoint<i128, P>,
    mode: RoundMode
) -> FixedPoint<i128, P>

This is supported on crate feature i128 only.

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

This is supported 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(Ceil), 8274);

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

pub fn round_towards_zero_by(
    self,
    precision: FixedPoint<i128, P>
) -> FixedPoint<i128, P>

This is supported on crate feature i128 only.

pub fn next_power_of_ten(self) -> Result<FixedPoint<i128, P>, ArithmeticError>

This is supported on crate feature i128 only.

pub fn rounding_from_f64(
    value: f64
) -> Result<FixedPoint<i128, P>, ArithmeticError>

👎 Deprecated since 0.6.0:

Use TryFrom instead

This is supported on crate features i128 and std only.

pub fn to_f64(self) -> f64

👎 Deprecated since 0.6.0:

Use From instead

This is supported on crate feature i128 only.

pub fn rounding_to_i64(self) -> i64

This is supported on crate feature i128 only.

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

This is supported on crate feature i128 only.

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

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

This is supported on crate feature i128 only.

Trait Implementations

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

This is supported on crate feature i16 only.

const MIN: Self

const MAX: Self

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

This is supported on crate feature i32 only.

const MIN: Self

const MAX: Self

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

This is supported on crate feature i64 only.

const MIN: Self

const MAX: Self

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

This is supported on crate feature i128 only.

const MIN: Self

const MAX: Self

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

This is supported on crate feature i128 only.

type Output = FixedPoint<i128, P>

type Error = ArithmeticError

fn cadd(
    self,
    rhs: FixedPoint<i128, P>
) -> Result<FixedPoint<i128, P>, 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<FixedPoint<i16, P>> for FixedPoint<i16, P>

This is supported on crate feature i16 only.

type Output = FixedPoint<i16, P>

type Error = ArithmeticError

fn cadd(
    self,
    rhs: FixedPoint<i16, P>
) -> Result<FixedPoint<i16, P>, 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<FixedPoint<i32, P>> for FixedPoint<i32, P>

This is supported on crate feature i32 only.

type Output = FixedPoint<i32, P>

type Error = ArithmeticError

fn cadd(
    self,
    rhs: FixedPoint<i32, P>
) -> Result<FixedPoint<i32, P>, 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<FixedPoint<i64, P>> for FixedPoint<i64, P>

This is supported on crate feature i64 only.

type Output = FixedPoint<i64, P>

type Error = ArithmeticError

fn cadd(
    self,
    rhs: FixedPoint<i64, P>
) -> Result<FixedPoint<i64, P>, 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

This is supported on crate feature i128 only.

type Output = FixedPoint<i128, P>

type Error = 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

This is supported on crate feature i16 only.

type Output = FixedPoint<i16, P>

type Error = 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

This is supported on crate feature i32 only.

type Output = FixedPoint<i32, P>

type Error = 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

This is supported on crate feature i64 only.

type Output = FixedPoint<i64, P>

type Error = 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>

This is supported on crate feature i128 only.

type Output = FixedPoint<i128, P>

type Error = ArithmeticError

fn cmul(self, rhs: i128) -> 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: 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>

This is supported on crate feature i16 only.

type Output = FixedPoint<i16, P>

type Error = ArithmeticError

fn cmul(self, rhs: i16) -> 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: 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>

This is supported on crate feature i32 only.

type Output = FixedPoint<i32, P>

type Error = ArithmeticError

fn cmul(self, rhs: i32) -> 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: 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>

This is supported on crate feature i64 only.

type Output = FixedPoint<i64, P>

type Error = ArithmeticError

fn cmul(self, rhs: i64) -> 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: 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<FixedPoint<i128, P>> for FixedPoint<i128, P>

This is supported on crate feature i128 only.

type Output = FixedPoint<i128, P>

type Error = ArithmeticError

fn csub(
    self,
    rhs: FixedPoint<i128, P>
) -> Result<FixedPoint<i128, P>, 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<FixedPoint<i16, P>> for FixedPoint<i16, P>

This is supported on crate feature i16 only.

type Output = FixedPoint<i16, P>

type Error = ArithmeticError

fn csub(
    self,
    rhs: FixedPoint<i16, P>
) -> Result<FixedPoint<i16, P>, 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<FixedPoint<i32, P>> for FixedPoint<i32, P>

This is supported on crate feature i32 only.

type Output = FixedPoint<i32, P>

type Error = ArithmeticError

fn csub(
    self,
    rhs: FixedPoint<i32, P>
) -> Result<FixedPoint<i32, P>, 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<FixedPoint<i64, P>> for FixedPoint<i64, P>

This is supported on crate feature i64 only.

type Output = FixedPoint<i64, P>

type Error = ArithmeticError

fn csub(
    self,
    rhs: FixedPoint<i64, P>
) -> Result<FixedPoint<i64, P>, 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 copy of the value.

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

Performs copy-assignment from source.

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

This is supported 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>

This is supported 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>

This is supported 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> CompactAs for FixedPoint<i128, P>

This is supported 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: Precision> Debug for FixedPoint<i16, P>

This is supported 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>

This is supported 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>

This is supported on crate feature i64 only.

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

Formats the value using the given formatter.

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

This is supported on crate feature i128 only.

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

Formats the value using the given formatter.

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

This is supported 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 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>

This is supported 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 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>

This is supported 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 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<i128, P>

This is supported 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 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, 

This is supported 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<P: Precision> Display for FixedPoint<i16, P>

This is supported 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>

This is supported 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>

This is supported on crate feature i64 only.

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

Formats the value using the given formatter.

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

This is supported on crate feature i128 only.

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

Formats the value using the given formatter.

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

This is supported 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, Global>

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>

This is supported 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, Global>

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>

This is supported 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, Global>

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<i128, P>

This is supported 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, Global>

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>

This is supported on crate feature parity only.

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

This is supported on crate feature i16 only.

type Err = ConvertError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

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

This is supported on crate feature i32 only.

type Err = ConvertError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

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

This is supported on crate feature i64 only.

type Err = ConvertError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

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

This is supported on crate feature i128 only.

type Err = ConvertError

The associated error which can be returned from parsing.

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

Parses a string s to return a value of this type.

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, 

Feeds a slice of this type into the given Hasher.

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

This is supported on crate feature i16 only.

const ONE: Self

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

This is supported on crate feature i32 only.

const ONE: Self

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

This is supported on crate feature i64 only.

const ONE: Self

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

This is supported on crate feature i128 only.

const ONE: Self

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

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

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

fn eq(&self, other: &FixedPoint<I, P>) -> bool

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

fn ne(&self, other: &FixedPoint<I, P>) -> bool

This method tests for !=.

impl<I: PartialOrd, P: PartialOrd> PartialOrd<FixedPoint<I, P>> 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

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

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

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

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

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

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

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

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

This is supported on crate feature i128 only.

type Output = FixedPoint<i128, P>

type Error = 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<FixedPoint<i128, P>> for i128

This is supported on crate feature i128 only.

type Output = FixedPoint<i128, P>

type Error = 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 FixedPoint<i16, P>

This is supported on crate feature i16 only.

type Output = FixedPoint<i16, P>

type Error = 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<FixedPoint<i16, P>> for i16

This is supported on crate feature i16 only.

type Output = FixedPoint<i16, P>

type Error = 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 FixedPoint<i32, P>

This is supported on crate feature i32 only.

type Output = FixedPoint<i32, P>

type Error = 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<FixedPoint<i32, P>> for i32

This is supported on crate feature i32 only.

type Output = FixedPoint<i32, P>

type Error = 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 FixedPoint<i64, P>

This is supported on crate feature i64 only.

type Output = FixedPoint<i64, P>

type Error = 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<FixedPoint<i64, P>> for i64

This is supported on crate feature i64 only.

type Output = FixedPoint<i64, P>

type Error = 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>

This is supported on crate feature i128 only.

type Output = FixedPoint<i128, P>

type Error = ArithmeticError

fn rdiv(
    self,
    rhs: i128,
    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<i16> for FixedPoint<i16, P>

This is supported on crate feature i16 only.

type Output = FixedPoint<i16, P>

type Error = ArithmeticError

fn rdiv(
    self,
    rhs: i16,
    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<i32> for FixedPoint<i32, P>

This is supported on crate feature i32 only.

type Output = FixedPoint<i32, P>

type Error = ArithmeticError

fn rdiv(
    self,
    rhs: i32,
    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<i64> for FixedPoint<i64, P>

This is supported on crate feature i64 only.

type Output = FixedPoint<i64, P>

type Error = ArithmeticError

fn rdiv(
    self,
    rhs: i64,
    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> RoundingMul<FixedPoint<i128, P>> for FixedPoint<i128, P>

This is supported on crate feature i128 only.

type Output = FixedPoint<i128, P>

type Error = 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<FixedPoint<i16, P>> for FixedPoint<i16, P>

This is supported on crate feature i16 only.

type Output = FixedPoint<i16, P>

type Error = 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<FixedPoint<i32, P>> for FixedPoint<i32, P>

This is supported on crate feature i32 only.

type Output = FixedPoint<i32, P>

type Error = 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<FixedPoint<i64, P>> for FixedPoint<i64, P>

This is supported on crate feature i64 only.

type Output = FixedPoint<i64, P>

type Error = 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> RoundingSqrt for FixedPoint<i16, P>

This is supported on crate feature i16 only.

type Error = ArithmeticError

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

Checked rounding square root. Returns Err for negative argument.

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

This is supported on crate feature i32 only.

type Error = ArithmeticError

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

Checked rounding square root. Returns Err for negative argument.

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

This is supported on crate feature i64 only.

type Error = ArithmeticError

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

Checked rounding square root. Returns Err for negative argument.

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

This is supported on crate feature i128 only.

type Error = ArithmeticError

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

Checked rounding square root. Returns Err for negative argument.

impl<I, P> Serialize for FixedPoint<I, P> where
    I: Serialize,
    Self: Display, 

This is supported 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<i16, P>

type Error = ConvertError

The type returned in the event of a conversion error.

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

Performs the conversion.

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

type Error = ConvertError

The type returned in the event of a conversion error.

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

Performs the conversion.

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

type Error = ConvertError

The type returned in the event of a conversion error.

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

Performs the conversion.

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

type Error = ConvertError

The type returned in the event of a conversion error.

fn try_from(value: f64) -> 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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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> 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> Zero for FixedPoint<i16, P>

This is supported on crate feature i16 only.

const ZERO: Self

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

This is supported on crate feature i32 only.

const ZERO: Self

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

This is supported on crate feature i64 only.

const ZERO: Self

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

This is supported on crate feature i128 only.

const ZERO: Self

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

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

This is supported on crate features parity and i128 only.

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

This is supported on crate features parity and i16 only.

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

This is supported on crate features parity and i32 only.

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

This is supported on crate features parity and i64 only.

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

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

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