# Struct sp_arithmetic::fixed_point::FixedU128

source · `pub struct FixedU128(_);`

## Expand description

A fixed point number representation in the range.
*Fixed Point 128 bits unsigned, range = [0.000000000000000000, 340282366920938463463.374607431768211455]*

## Implementations§

source§### impl FixedU128

### impl FixedU128

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

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

Create a new instance from the given `inner`

value.

`const`

version of `FixedPointNumber::from_inner`

.

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

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

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 FixedU128

### impl CheckedAdd for FixedU128

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

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

`None`

is
returned.source§### impl CheckedDiv for FixedU128

### impl CheckedDiv for FixedU128

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

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

`None`

is returned.source§### impl CheckedMul for FixedU128

### impl CheckedMul for FixedU128

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

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

`None`

is returned.source§### impl CheckedSub for FixedU128

### impl CheckedSub for FixedU128

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

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

`None`

is returned.source§### impl Decode for FixedU128

### impl Decode for FixedU128

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 FixedU128

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

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 FixedU128

### impl Encode for FixedU128

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 FixedU128

### impl FixedPointNumber for FixedU128

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

#### const DIV: Self::Inner = {transmute(0x00000000000000000de0b6b3a7640000): <fixed_point::FixedU128 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 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 FixedU128

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

source§### impl MaxEncodedLen for FixedU128

### impl MaxEncodedLen for FixedU128

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

#### fn max_encoded_len() -> usize

source§### impl Ord for FixedU128

### impl Ord for FixedU128

source§### impl PartialEq<FixedU128> for FixedU128

### impl PartialEq<FixedU128> for FixedU128

source§### impl PartialOrd<FixedU128> for FixedU128

### impl PartialOrd<FixedU128> for FixedU128

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 FixedU128

### impl Saturating for FixedU128

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.source§#### fn saturating_sub(self, rhs: Self) -> Self

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

`self - rhs`

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

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

`self * rhs`

, saturating at the numeric bounds instead of
overflowing.source§#### 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.source§#### fn saturating_less_one(self) -> Selfwhere
Self: One,

#### fn saturating_less_one(self) -> Selfwhere Self: One,

source§#### fn saturating_plus_one(self) -> Selfwhere
Self: One,

#### fn saturating_plus_one(self) -> Selfwhere Self: One,

source§#### 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 FixedU128

### impl EncodeLike<FixedU128> for FixedU128

### impl Eq for FixedU128

### impl StructuralEq for FixedU128

### impl StructuralPartialEq for FixedU128

## Auto Trait Implementations§

### impl RefUnwindSafe for FixedU128

### impl Send for FixedU128

### impl Sync for FixedU128

### impl Unpin for FixedU128

### impl UnwindSafe for FixedU128

## Blanket Implementations§

§### 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,

§### 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>,

§### impl<T> KeyedVec for Twhere
T: Codec,

### impl<T> KeyedVec for Twhere T: Codec,

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`

.