# Struct sp_arithmetic::fixed_point::FixedU64

source · `pub struct FixedU64(_);`

## Expand description

A fixed point number representation in the range.
*Fixed Point 64 bits unsigned, range = [0.000000000, 18446744073.709551615]*

## Implementations

source### impl FixedU64

### impl FixedU64

source#### pub const fn from_inner(inner: u64) -> Self

#### pub const fn from_inner(inner: u64) -> Self

Create a new instance from the given `inner`

value.

`const`

version of `FixedPointNumber::from_inner`

.

source#### pub const fn into_inner(self) -> u64

#### pub const fn into_inner(self) -> u64

Return the instance’s inner value.

`const`

version of `FixedPointNumber::into_inner`

.

source#### pub const fn from_u32(n: u32) -> Self

#### pub const fn from_u32(n: u32) -> Self

Creates self from a `u32`

.

WARNING: This is a `const`

function designed for convenient use at build time and
will panic on overflow. Ensure that any inputs are sensible.

source#### pub fn from_float(x: f64) -> Self

#### pub fn from_float(x: f64) -> Self

Convert from a `float`

value.

source#### pub const fn from_perbill(n: Perbill) -> Self

#### pub const fn from_perbill(n: Perbill) -> Self

Convert from a `Perbill`

value.

source#### pub const fn into_perbill(self) -> Perbill

#### pub const fn into_perbill(self) -> Perbill

Convert into a `Perbill`

value. Will saturate if above one or below zero.

source#### pub fn try_into_perthing<P: PerThing>(self) -> Result<P, P>

#### pub fn try_into_perthing<P: PerThing>(self) -> Result<P, P>

Attempt to convert into a `PerThing`

. This will succeed iff `self`

is at least zero
and at most one. If it is out of bounds, it will result in an error returning the
clamped value.

source#### pub fn into_clamped_perthing<P: PerThing>(self) -> P

#### pub fn into_clamped_perthing<P: PerThing>(self) -> P

Attempt to convert into a `PerThing`

. This will always succeed resulting in a
clamped value if `self`

is less than zero or greater than one.

source#### pub const fn neg(self) -> Self

#### pub const fn neg(self) -> Self

Negate the value.

WARNING: This is a `const`

function designed for convenient use at build time and
will panic on overflow. Ensure that any inputs are sensible.

source#### pub const fn sqrt(self) -> Self

#### pub const fn sqrt(self) -> Self

Take the square root of a positive value.

WARNING: This is a `const`

function designed for convenient use at build time and
will panic on overflow. Ensure that any inputs are sensible.

source#### pub const fn try_sqrt(self) -> Option<Self>

#### pub const fn try_sqrt(self) -> Option<Self>

Compute the square root, rounding as desired. If it overflows or is negative, then
`None`

is returned.

source#### pub const fn add(self, rhs: Self) -> Self

#### pub const fn add(self, rhs: Self) -> Self

Add a value and return the result.

`const`

function designed for convenient use at build time and
will panic on overflow. Ensure that any inputs are sensible.

source#### pub const fn sub(self, rhs: Self) -> Self

#### pub const fn sub(self, rhs: Self) -> Self

Subtract a value and return the result.

`const`

function designed for convenient use at build time and
will panic on overflow. Ensure that any inputs are sensible.

source#### pub const fn mul(self, rhs: Self) -> Self

#### pub const fn mul(self, rhs: Self) -> Self

Multiply by a value and return the result.

Result will be rounded to the nearest representable value, rounding down if it is equidistant between two neighbours.

`const`

function designed for convenient use at build time and
will panic on overflow. Ensure that any inputs are sensible.

source#### pub const fn div(self, rhs: Self) -> Self

#### pub const fn div(self, rhs: Self) -> Self

Divide by a value and return the result.

Result will be rounded to the nearest representable value, rounding down if it is equidistant between two neighbours.

`const`

function designed for convenient use at build time and
will panic on overflow. Ensure that any inputs are sensible.

source#### pub const fn from_rational(a: u128, b: u128) -> Self

#### pub const fn from_rational(a: u128, b: u128) -> Self

Calculate an approximation of a rational.

Result will be rounded to the nearest representable value, rounding down if it is equidistant between two neighbours.

`const`

function designed for convenient use at build time and
will panic on overflow. Ensure that any inputs are sensible.

source#### pub const fn from_rational_with_rounding(

a: u128,

b: u128,

rounding: Rounding

) -> Self

#### pub const fn from_rational_with_rounding(

a: u128,

b: u128,

rounding: Rounding

) -> Self

Calculate an approximation of a rational with custom rounding.

`const`

function designed for convenient use at build time and
will panic on overflow. Ensure that any inputs are sensible.

source#### pub const fn const_checked_mul(self, other: Self) -> Option<Self>

#### pub const fn const_checked_mul(self, other: Self) -> Option<Self>

Multiply by another value, returning `None`

in the case of an error.

source#### pub const fn const_checked_mul_with_rounding(

self,

other: Self,

rounding: SignedRounding

) -> Option<Self>

#### pub const fn const_checked_mul_with_rounding(

self,

other: Self,

rounding: SignedRounding

) -> Option<Self>

Multiply by another value with custom rounding, returning `None`

in the case of an
error.

source#### pub const fn const_checked_div(self, other: Self) -> Option<Self>

#### pub const fn const_checked_div(self, other: Self) -> Option<Self>

Divide by another value, returning `None`

in the case of an error.

source#### pub const fn checked_rounding_div(

self,

other: Self,

rounding: SignedRounding

) -> Option<Self>

#### pub const fn checked_rounding_div(

self,

other: Self,

rounding: SignedRounding

) -> Option<Self>

Divide by another value with custom rounding, returning `None`

in the case of an
error.

## Trait Implementations

source### impl CheckedAdd for FixedU64

### impl CheckedAdd for FixedU64

source#### fn checked_add(&self, rhs: &Self) -> Option<Self>

#### fn checked_add(&self, rhs: &Self) -> Option<Self>

`None`

is
returned. Read moresource### impl CheckedDiv for FixedU64

### impl CheckedDiv for FixedU64

source#### fn checked_div(&self, other: &Self) -> Option<Self>

#### fn checked_div(&self, other: &Self) -> Option<Self>

`None`

is returned. Read moresource### impl CheckedMul for FixedU64

### impl CheckedMul for FixedU64

source#### fn checked_mul(&self, other: &Self) -> Option<Self>

#### fn checked_mul(&self, other: &Self) -> Option<Self>

`None`

is returned. Read moresource### impl CheckedSub for FixedU64

### impl CheckedSub for FixedU64

source#### fn checked_sub(&self, rhs: &Self) -> Option<Self>

#### fn checked_sub(&self, rhs: &Self) -> Option<Self>

`None`

is returned. Read moresource### impl Decode for FixedU64

### impl Decode for FixedU64

source#### fn decode<__CodecInputEdqy: Input>(

__codec_input_edqy: &mut __CodecInputEdqy

) -> Result<Self, Error>

#### fn decode<__CodecInputEdqy: Input>(

__codec_input_edqy: &mut __CodecInputEdqy

) -> Result<Self, Error>

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

I: Input,

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

I: Input,

#### fn encoded_fixed_size() -> Option<usize>

#### fn encoded_fixed_size() -> Option<usize>

source### impl<'de> Deserialize<'de> for FixedU64

### impl<'de> Deserialize<'de> for FixedU64

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

D: Deserializer<'de>,

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

D: Deserializer<'de>,

source### impl Encode for FixedU64

### impl Encode for FixedU64

source#### fn encode_to<__CodecOutputEdqy: Output + ?Sized>(

&self,

__codec_dest_edqy: &mut __CodecOutputEdqy

)

#### fn encode_to<__CodecOutputEdqy: Output + ?Sized>(

&self,

__codec_dest_edqy: &mut __CodecOutputEdqy

)

source#### fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R

#### fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R

#### fn encoded_size(&self) -> usize

#### fn encoded_size(&self) -> usize

source### impl FixedPointNumber for FixedU64

### impl FixedPointNumber for FixedU64

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

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

`10`

.source#### fn from_inner(inner: Self::Inner) -> Self

#### fn from_inner(inner: Self::Inner) -> Self

source#### fn into_inner(self) -> Self::Inner

#### fn into_inner(self) -> Self::Inner

`self`

and returns the inner raw value.source#### fn saturating_from_integer<N: FixedPointOperand>(int: N) -> Self

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

`int`

. Read moresource#### fn checked_from_integer<N: Into<Self::Inner>>(int: N) -> Option<Self>

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

source#### fn saturating_from_rational<N: FixedPointOperand, D: FixedPointOperand>(

n: N,

d: D

) -> Self

#### fn saturating_from_rational<N: FixedPointOperand, D: FixedPointOperand>(

n: N,

d: D

) -> Self

source#### fn checked_from_rational<N: FixedPointOperand, D: FixedPointOperand>(

n: N,

d: D

) -> Option<Self>

#### fn checked_from_rational<N: FixedPointOperand, D: FixedPointOperand>(

n: N,

d: D

) -> Option<Self>

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

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

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

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

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

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

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

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

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

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

`N`

, adding the result back.
Equal to `self * n + n`

. Read moresource#### fn saturating_abs(self) -> Self

#### fn saturating_abs(self) -> Self

source#### fn reciprocal(self) -> Option<Self>

#### fn reciprocal(self) -> Option<Self>

`1 / self`

. Read moresource#### fn is_positive(self) -> bool

#### fn is_positive(self) -> bool

`true`

if `self`

is positive and `false`

if the number is zero or negative.source#### fn is_negative(self) -> bool

#### fn is_negative(self) -> bool

`true`

if `self`

is negative and `false`

if the number is zero or positive.source### impl<N: FixedPointOperand, D: FixedPointOperand> From<(N, D)> for FixedU64

### impl<N: FixedPointOperand, D: FixedPointOperand> From<(N, D)> for FixedU64

source### impl MaxEncodedLen for FixedU64

### impl MaxEncodedLen for FixedU64

source#### fn max_encoded_len() -> usize

#### fn max_encoded_len() -> usize

source### impl Ord for FixedU64

### impl Ord for FixedU64

1.21.0 · source#### fn max(self, other: Self) -> Selfwhere

Self: Sized,

#### fn max(self, other: Self) -> Selfwhere

Self: Sized,

1.21.0 · source#### fn min(self, other: Self) -> Selfwhere

Self: Sized,

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

Self: Sized,

1.50.0 · source#### fn clamp(self, min: Self, max: Self) -> Selfwhere

Self: Sized + PartialOrd<Self>,

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

Self: Sized + PartialOrd<Self>,

source### impl PartialOrd<FixedU64> for FixedU64

### impl PartialOrd<FixedU64> for FixedU64

source#### fn partial_cmp(&self, other: &FixedU64) -> Option<Ordering>

#### fn partial_cmp(&self, other: &FixedU64) -> Option<Ordering>

1.0.0 · source#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource### impl Saturating for FixedU64

### impl Saturating for FixedU64

source#### fn saturating_add(self, rhs: Self) -> Self

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

`self + rhs`

, saturating at the numeric bounds instead of
overflowing. Read moresource#### fn saturating_sub(self, rhs: Self) -> Self

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

`self - rhs`

, saturating at the numeric bounds instead of
overflowing. Read moresource#### fn saturating_mul(self, rhs: Self) -> Self

#### fn saturating_mul(self, rhs: Self) -> Self

`self * rhs`

, saturating at the numeric bounds instead of
overflowing. Read moresource#### fn saturating_pow(self, exp: usize) -> Self

#### fn saturating_pow(self, exp: usize) -> Self

`self.pow(exp)`

, saturating at the numeric bounds
instead of overflowing. Read moresource#### fn saturating_inc(&mut self)where

Self: One,

#### fn saturating_inc(&mut self)where

Self: One,

source#### fn saturating_dec(&mut self)where

Self: One,

#### fn saturating_dec(&mut self)where

Self: One,

source#### fn saturating_accrue(&mut self, amount: Self)where

Self: One,

#### fn saturating_accrue(&mut self, amount: Self)where

Self: One,

`amount`

, saturating.source#### fn saturating_reduce(&mut self, amount: Self)where

Self: One,

#### fn saturating_reduce(&mut self, amount: Self)where

Self: One,

`amount`

, saturating at zero.### impl Copy for FixedU64

### impl EncodeLike<FixedU64> for FixedU64

### impl Eq for FixedU64

### impl StructuralEq for FixedU64

### impl StructuralPartialEq for FixedU64

## Auto Trait Implementations

### impl RefUnwindSafe for FixedU64

### impl Send for FixedU64

### impl Sync for FixedU64

### impl Unpin for FixedU64

### impl UnwindSafe for FixedU64

## Blanket Implementations

source### impl<T> BorrowMut<T> for Twhere

T: ?Sized,

### impl<T> BorrowMut<T> for Twhere

T: ?Sized,

const: unstable · source#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

### impl<T> DecodeAll for Twhere

T: Decode,

### impl<T> DecodeAll for Twhere

T: Decode,

#### fn decode_all(input: &mut &[u8]) -> Result<T, Error>

#### fn decode_all(input: &mut &[u8]) -> Result<T, Error>

`Self`

and consume all of the given input data. Read more### impl<T> DecodeLimit for Twhere

T: Decode,

### impl<T> DecodeLimit for Twhere

T: Decode,

#### fn decode_all_with_depth_limit(limit: u32, input: &mut &[u8]) -> Result<T, Error>

#### fn decode_all_with_depth_limit(limit: u32, input: &mut &[u8]) -> Result<T, Error>

`Self`

and consume all of the given input data. Read more#### fn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>where

I: Input,

#### fn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>where

I: Input,

`Self`

with the given maximum recursion depth and advance `input`

by the number of
bytes consumed. Read more### impl<T> HasCompact for Twhere

T: 'static,

Compact<T>: for<'a> EncodeAsRef<'a, T> + Decode + From<T> + Into<T>,

### impl<T> HasCompact for Twhere

T: 'static,

Compact<T>: for<'a> EncodeAsRef<'a, T> + Decode + From<T> + Into<T>,

#### type Type = Compact<T>

#### type Type = Compact<T>

### impl<T> KeyedVec for Twhere

T: Codec,

### impl<T> KeyedVec for Twhere

T: Codec,

#### fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8, Global>

#### fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8, Global>

`Self`

prepended by given slice.source### impl<T> LowerBounded for Twhere

T: Bounded,

### impl<T> LowerBounded for Twhere

T: Bounded,

source### impl<T> SaturatedConversion for T

### impl<T> SaturatedConversion for T

source#### fn saturated_from<T>(t: T) -> Selfwhere

Self: UniqueSaturatedFrom<T>,

#### fn saturated_from<T>(t: T) -> Selfwhere

Self: UniqueSaturatedFrom<T>,

source#### fn saturated_into<T>(self) -> Twhere

Self: UniqueSaturatedInto<T>,

#### fn saturated_into<T>(self) -> Twhere

Self: UniqueSaturatedInto<T>,

`T`

. Read moresource### impl<T> ThresholdOrd<T> for Twhere

T: Ord + PartialOrd<T> + Copy + Clone + Zero + Saturating,

### impl<T> ThresholdOrd<T> for Twhere

T: Ord + PartialOrd<T> + Copy + Clone + Zero + Saturating,

source### impl<T, S> UniqueSaturatedFrom<T> for Swhere

S: TryFrom<T> + Bounded,

### impl<T, S> UniqueSaturatedFrom<T> for Swhere

S: TryFrom<T> + Bounded,

source#### fn unique_saturated_from(t: T) -> S

#### fn unique_saturated_from(t: T) -> S

`T`

into an equivalent instance of `Self`

.source### impl<T, S> UniqueSaturatedInto<T> for Swhere

T: Bounded,

S: TryInto<T>,

### impl<T, S> UniqueSaturatedInto<T> for Swhere

T: Bounded,

S: TryInto<T>,

source#### fn unique_saturated_into(self) -> T

#### fn unique_saturated_into(self) -> T

`T`

.