# Struct sp_runtime::FixedI128

source · `pub struct FixedI128(_);`

## Expand description

Re-export top-level arithmetic stuff.
A fixed point number representation in the range.
*Fixed Point 128 bits signed, range = [-170141183460469231731.687303715884105728, 170141183460469231731.687303715884105727]*

## Implementations§

source§### impl FixedI128

### impl FixedI128

source#### pub const fn from_inner(inner: i128) -> FixedI128

#### pub const fn from_inner(inner: i128) -> FixedI128

Create a new instance from the given `inner`

value.

`const`

version of `FixedPointNumber::from_inner`

.

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

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

Return the instance’s inner value.

`const`

version of `FixedPointNumber::into_inner`

.

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

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

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) -> FixedI128

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

Convert from a `float`

value.

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

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

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>(self) -> Result<P, P>where
P: PerThing,

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

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>(self) -> Pwhere
P: PerThing,

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

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) -> FixedI128

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

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) -> FixedI128

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

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<FixedI128>

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

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

is returned.

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

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

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: FixedI128) -> FixedI128

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

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: FixedI128) -> FixedI128

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

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: FixedI128) -> FixedI128

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

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) -> FixedI128

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

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
) -> FixedI128

#### pub const fn from_rational_with_rounding( a: u128, b: u128, rounding: Rounding ) -> FixedI128

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: FixedI128) -> Option<FixedI128>

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

Multiply by another value, returning `None`

in the case of an error.

source#### pub const fn const_checked_mul_with_rounding(
self,
other: FixedI128,
rounding: SignedRounding
) -> Option<FixedI128>

#### pub const fn const_checked_mul_with_rounding( self, other: FixedI128, rounding: SignedRounding ) -> Option<FixedI128>

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

in the case of an
error.

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

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

Divide by another value, returning `None`

in the case of an error.

source#### pub const fn checked_rounding_div(
self,
other: FixedI128,
rounding: SignedRounding
) -> Option<FixedI128>

#### pub const fn checked_rounding_div( self, other: FixedI128, rounding: SignedRounding ) -> Option<FixedI128>

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

in the case of an
error.

## Trait Implementations§

source§### impl CheckedAdd for FixedI128

### impl CheckedAdd for FixedI128

source§### impl CheckedDiv for FixedI128

### impl CheckedDiv for FixedI128

source§### impl CheckedMul for FixedI128

### impl CheckedMul for FixedI128

source§### impl CheckedSub for FixedI128

### impl CheckedSub for FixedI128

source§### impl Decode for FixedI128

### impl Decode for FixedI128

source§#### fn decode<__CodecInputEdqy>(
__codec_input_edqy: &mut __CodecInputEdqy
) -> Result<FixedI128, Error>where
__CodecInputEdqy: Input,

#### fn decode<__CodecInputEdqy>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<FixedI128, Error>where __CodecInputEdqy: Input,

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

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

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

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

source§#### fn deserialize<D>(
deserializer: D
) -> Result<FixedI128, <D as Deserializer<'de>>::Error>where
D: Deserializer<'de>,

#### fn deserialize<D>( deserializer: D ) -> Result<FixedI128, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

source§### impl Encode for FixedI128

### impl Encode for FixedI128

source§#### fn encode_to<__CodecOutputEdqy>(
&self,
__codec_dest_edqy: &mut __CodecOutputEdqy
)where
__CodecOutputEdqy: Output + ?Sized,

#### fn encode_to<__CodecOutputEdqy>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy )where __CodecOutputEdqy: Output + ?Sized,

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

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

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

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

source§### impl FixedPointNumber for FixedI128

### impl FixedPointNumber for FixedI128

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

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

`10`

.source§#### fn from_inner(inner: <FixedI128 as FixedPointNumber>::Inner) -> FixedI128

#### fn from_inner(inner: <FixedI128 as FixedPointNumber>::Inner) -> FixedI128

source§#### fn into_inner(self) -> <FixedI128 as FixedPointNumber>::Inner

#### fn into_inner(self) -> <FixedI128 as FixedPointNumber>::Inner

`self`

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

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

`int`

. Read moresource§#### fn saturating_from_rational<N, D>(n: N, d: D) -> Selfwhere
N: FixedPointOperand,
D: FixedPointOperand,

#### fn saturating_from_rational<N, D>(n: N, d: D) -> Selfwhere N: FixedPointOperand, D: FixedPointOperand,

source§#### fn checked_from_rational<N, D>(n: N, d: D) -> Option<Self>where
N: FixedPointOperand,
D: FixedPointOperand,

#### fn checked_from_rational<N, D>(n: N, d: D) -> Option<Self>where N: FixedPointOperand, D: FixedPointOperand,

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

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

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

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

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

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

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

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

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

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

`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, D> From<(N, D)> for FixedI128where
N: FixedPointOperand,
D: FixedPointOperand,

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

source§### impl MaxEncodedLen for FixedI128

### impl MaxEncodedLen for FixedI128

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

#### fn max_encoded_len() -> usize

source§### impl Ord for FixedI128

### impl Ord for FixedI128

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

### impl PartialEq<FixedI128> for FixedI128

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

### impl PartialOrd<FixedI128> for FixedI128

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 FixedI128

### impl Saturating for FixedI128

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

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

`self + rhs`

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

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

`self - rhs`

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

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

`self * rhs`

, saturating at the numeric bounds instead of
overflowing.source§#### fn saturating_pow(self, exp: usize) -> FixedI128

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

`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.source§### impl Serialize for FixedI128

### impl Serialize for FixedI128

source§#### fn serialize<S>(
&self,
serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>where
S: Serializer,

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

### impl Copy for FixedI128

### impl EncodeLike<FixedI128> for FixedI128

### impl Eq for FixedI128

### impl StructuralEq for FixedI128

### impl StructuralPartialEq for FixedI128

## Auto Trait Implementations§

### impl RefUnwindSafe for FixedI128

### impl Send for FixedI128

### impl Sync for FixedI128

### impl Unpin for FixedI128

### impl UnwindSafe for FixedI128

## Blanket Implementations§

source§### impl<T> CheckedConversion for T

### impl<T> CheckedConversion for 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,

source§### impl<T> EnsureAdd for Twhere
T: EnsureAddAssign,

### impl<T> EnsureAdd for Twhere T: EnsureAddAssign,

source§#### fn ensure_add(self, v: Self) -> Result<Self, ArithmeticError>

#### fn ensure_add(self, v: Self) -> Result<Self, ArithmeticError>

source§### impl<T> EnsureAddAssign for Twhere
T: CheckedAdd + PartialOrd<T> + Zero,

### impl<T> EnsureAddAssign for Twhere T: CheckedAdd + PartialOrd<T> + Zero,

source§#### fn ensure_add_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

#### fn ensure_add_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

source§### impl<T> EnsureDiv for Twhere
T: EnsureDivAssign,

### impl<T> EnsureDiv for Twhere T: EnsureDivAssign,

source§#### fn ensure_div(self, v: Self) -> Result<Self, ArithmeticError>

#### fn ensure_div(self, v: Self) -> Result<Self, ArithmeticError>

source§### impl<T> EnsureDivAssign for Twhere
T: CheckedDiv + PartialOrd<T> + Zero,

### impl<T> EnsureDivAssign for Twhere T: CheckedDiv + PartialOrd<T> + Zero,

source§#### fn ensure_div_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

#### fn ensure_div_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

source§### impl<T> EnsureFixedPointNumber for Twhere
T: FixedPointNumber,

### impl<T> EnsureFixedPointNumber for Twhere T: FixedPointNumber,

source§#### fn ensure_from_rational<N, D>(n: N, d: D) -> Result<Self, ArithmeticError>where
N: FixedPointOperand,
D: FixedPointOperand,

#### fn ensure_from_rational<N, D>(n: N, d: D) -> Result<Self, ArithmeticError>where N: FixedPointOperand, D: FixedPointOperand,

source§#### fn ensure_mul_int<N>(self, n: N) -> Result<N, ArithmeticError>where
N: FixedPointOperand,

#### fn ensure_mul_int<N>(self, n: N) -> Result<N, ArithmeticError>where N: FixedPointOperand,

source§#### fn ensure_div_int<D>(self, d: D) -> Result<D, ArithmeticError>where
D: FixedPointOperand,

#### fn ensure_div_int<D>(self, d: D) -> Result<D, ArithmeticError>where D: FixedPointOperand,

source§### impl<T, S> EnsureFrom<S> for Twhere
T: TryFrom<S> + PartialOrd<T> + Zero,
S: PartialOrd<S> + Zero,

### impl<T, S> EnsureFrom<S> for Twhere T: TryFrom<S> + PartialOrd<T> + Zero, S: PartialOrd<S> + Zero,

source§#### fn ensure_from(other: T) -> Result<Self, ArithmeticError>

#### fn ensure_from(other: T) -> Result<Self, ArithmeticError>

`ArithmeticError`

if fails. Read moresource§### impl<T, S> EnsureInto<S> for Twhere
T: TryInto<S> + PartialOrd<T> + Zero,
S: PartialOrd<S> + Zero,

### impl<T, S> EnsureInto<S> for Twhere T: TryInto<S> + PartialOrd<T> + Zero, S: PartialOrd<S> + Zero,

source§#### fn ensure_into(self) -> Result<T, ArithmeticError>

#### fn ensure_into(self) -> Result<T, ArithmeticError>

`ArithmeticError`

if fails. Read moresource§### impl<T> EnsureMul for Twhere
T: EnsureMulAssign,

### impl<T> EnsureMul for Twhere T: EnsureMulAssign,

source§#### fn ensure_mul(self, v: Self) -> Result<Self, ArithmeticError>

#### fn ensure_mul(self, v: Self) -> Result<Self, ArithmeticError>

source§### impl<T> EnsureMulAssign for Twhere
T: CheckedMul + PartialOrd<T> + Zero,

### impl<T> EnsureMulAssign for Twhere T: CheckedMul + PartialOrd<T> + Zero,

source§#### fn ensure_mul_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

#### fn ensure_mul_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

source§### impl<T> EnsureSub for Twhere
T: EnsureSubAssign,

### impl<T> EnsureSub for Twhere T: EnsureSubAssign,

source§#### fn ensure_sub(self, v: Self) -> Result<Self, ArithmeticError>

#### fn ensure_sub(self, v: Self) -> Result<Self, ArithmeticError>

source§### impl<T> EnsureSubAssign for Twhere
T: CheckedSub + PartialOrd<T> + Zero,

### impl<T> EnsureSubAssign for Twhere T: CheckedSub + PartialOrd<T> + Zero,

source§#### fn ensure_sub_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

#### fn ensure_sub_assign(&mut self, v: Self) -> Result<(), ArithmeticError>

source§### impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

### impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

source§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

`key`

and return `true`

if they are equal.§### impl<Q, K> Equivalent<K> for Qwhere
Q: Eq + ?Sized,
K: Borrow<Q> + ?Sized,

### impl<Q, K> Equivalent<K> for Qwhere Q: Eq + ?Sized, K: Borrow<Q> + ?Sized,

§#### fn equivalent(&self, key: &K) -> bool

#### fn equivalent(&self, key: &K) -> bool

source§### impl<T> Instrument for T

### impl<T> Instrument for T

source§#### fn instrument(self, span: Span) -> Instrumented<Self>

#### fn instrument(self, span: Span) -> Instrumented<Self>

source§#### fn in_current_span(self) -> Instrumented<Self>

#### fn in_current_span(self) -> Instrumented<Self>

source§### impl<T, Outer> IsWrappedBy<Outer> for Twhere
Outer: AsRef<T> + AsMut<T> + From<T>,
T: From<Outer>,

### impl<T, Outer> IsWrappedBy<Outer> for Twhere Outer: AsRef<T> + AsMut<T> + From<T>, T: From<Outer>,

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

§### impl<T> Pointable for T

### impl<T> Pointable for T

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<S, T> UncheckedInto<T> for Swhere
T: UncheckedFrom<S>,

### impl<S, T> UncheckedInto<T> for Swhere T: UncheckedFrom<S>,

source§#### fn unchecked_into(self) -> T

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

`unchecked_from`

.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`

.