Trait sp_runtime::PerThing
source · pub trait PerThing: Sized + Saturating + Copy + Default + Eq + PartialEq<Self> + Ord + PartialOrd<Self> + Bounded + Debug + Div<Self, Output = Self> + Mul<Self, Output = Self> + Pow<usize, Output = Self> {
type Inner: BaseArithmetic + Unsigned + Copy + Into<u128> + Debug;
type Upper: BaseArithmetic + Copy + From<Self::Inner> + TryInto<Self::Inner> + UniqueSaturatedInto<Self::Inner> + Unsigned + Debug;
const ACCURACY: Self::Inner;
Show 23 methods
// Required methods
fn deconstruct(self) -> Self::Inner;
fn from_parts(parts: Self::Inner) -> Self;
fn from_float(x: f64) -> Self;
fn from_rational_with_rounding<N>(
p: N,
q: N,
rounding: Rounding
) -> Result<Self, ()>
where N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>,
Self::Inner: Into<N>;
// Provided methods
fn zero() -> Self { ... }
fn is_zero(&self) -> bool { ... }
fn one() -> Self { ... }
fn is_one(&self) -> bool { ... }
fn less_epsilon(self) -> Self { ... }
fn try_less_epsilon(self) -> Result<Self, Self> { ... }
fn plus_epsilon(self) -> Self { ... }
fn try_plus_epsilon(self) -> Result<Self, Self> { ... }
fn from_percent(x: Self::Inner) -> Self { ... }
fn square(self) -> Self { ... }
fn left_from_one(self) -> Self { ... }
fn mul_floor<N>(self, b: N) -> N
where N: MultiplyArg + UniqueSaturatedInto<Self::Inner>,
Self::Inner: Into<N> { ... }
fn mul_ceil<N>(self, b: N) -> N
where N: MultiplyArg + UniqueSaturatedInto<Self::Inner>,
Self::Inner: Into<N> { ... }
fn saturating_reciprocal_mul<N>(self, b: N) -> N
where N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>,
Self::Inner: Into<N> { ... }
fn saturating_reciprocal_mul_floor<N>(self, b: N) -> N
where N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>,
Self::Inner: Into<N> { ... }
fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> N
where N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>,
Self::Inner: Into<N> { ... }
fn from_fraction(x: f64) -> Self { ... }
fn from_rational<N>(p: N, q: N) -> Self
where N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>,
Self::Inner: Into<N> { ... }
fn from_rational_approximation<N>(p: N, q: N) -> Self
where N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>,
Self::Inner: Into<N> { ... }
}
Expand description
Re-export top-level arithmetic stuff.
Something that implements a fixed point ration with an arbitrary granularity X
, as parts per
X
.
Required Associated Types§
Required Associated Constants§
Required Methods§
sourcefn deconstruct(self) -> Self::Inner
fn deconstruct(self) -> Self::Inner
Consume self and return the number of parts per thing.
sourcefn from_parts(parts: Self::Inner) -> Self
fn from_parts(parts: Self::Inner) -> Self
Build this type from a number of parts per thing.
sourcefn from_float(x: f64) -> Self
fn from_float(x: f64) -> Self
Converts a fraction into Self
.
sourcefn from_rational_with_rounding<N>(
p: N,
q: N,
rounding: Rounding
) -> Result<Self, ()>where
N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>,
Self::Inner: Into<N>,
fn from_rational_with_rounding<N>( p: N, q: N, rounding: Rounding ) -> Result<Self, ()>where N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>, Self::Inner: Into<N>,
Approximate the fraction p/q
into a per-thing fraction.
The computation of this approximation is performed in the generic type N
. Given
M
as the data type that can hold the maximum value of this per-thing (e.g. u32
for
Perbill
), this can only work if N == M
or N: From<M> + TryInto<M>
.
In the case of an overflow (or divide by zero), an Err
is returned.
Rounding is determined by the parameter rounding
, i.e.
// 989/100 is technically closer to 99%.
assert_eq!(
Percent::from_rational_with_rounding(989u64, 1000, Down).unwrap(),
Percent::from_parts(98),
);
assert_eq!(
Percent::from_rational_with_rounding(984u64, 1000, NearestPrefUp).unwrap(),
Percent::from_parts(98),
);
assert_eq!(
Percent::from_rational_with_rounding(985u64, 1000, NearestPrefDown).unwrap(),
Percent::from_parts(98),
);
assert_eq!(
Percent::from_rational_with_rounding(985u64, 1000, NearestPrefUp).unwrap(),
Percent::from_parts(99),
);
assert_eq!(
Percent::from_rational_with_rounding(986u64, 1000, NearestPrefDown).unwrap(),
Percent::from_parts(99),
);
assert_eq!(
Percent::from_rational_with_rounding(981u64, 1000, Up).unwrap(),
Percent::from_parts(99),
);
assert_eq!(
Percent::from_rational_with_rounding(1001u64, 1000, Up),
Err(()),
);
assert_eq!(
Percent::from_rational_with_rounding(981u64, 1000, Up).unwrap(),
Percent::from_parts(99),
);
Provided Methods§
sourcefn less_epsilon(self) -> Self
fn less_epsilon(self) -> Self
Return the next lower value to self
or self
if it is already zero.
sourcefn try_less_epsilon(self) -> Result<Self, Self>
fn try_less_epsilon(self) -> Result<Self, Self>
Return the next lower value to self
or an error with the same value if self
is already
zero.
sourcefn plus_epsilon(self) -> Self
fn plus_epsilon(self) -> Self
Return the next higher value to self
or self
if it is already one.
sourcefn try_plus_epsilon(self) -> Result<Self, Self>
fn try_plus_epsilon(self) -> Result<Self, Self>
Return the next higher value to self
or an error with the same value if self
is already
one.
sourcefn from_percent(x: Self::Inner) -> Self
fn from_percent(x: Self::Inner) -> Self
Build this type from a percent. Equivalent to Self::from_parts(x * Self::ACCURACY / 100)
but more accurate and can cope with potential type overflows.
sourcefn left_from_one(self) -> Self
fn left_from_one(self) -> Self
Return the part left when self
is saturating-subtracted from Self::one()
.
sourcefn mul_floor<N>(self, b: N) -> Nwhere
N: MultiplyArg + UniqueSaturatedInto<Self::Inner>,
Self::Inner: Into<N>,
fn mul_floor<N>(self, b: N) -> Nwhere N: MultiplyArg + UniqueSaturatedInto<Self::Inner>, Self::Inner: Into<N>,
Multiplication that always rounds down to a whole number. The standard Mul
rounds to the
nearest whole number.
// round to nearest
assert_eq!(Percent::from_percent(34) * 10u64, 3);
assert_eq!(Percent::from_percent(36) * 10u64, 4);
// round down
assert_eq!(Percent::from_percent(34).mul_floor(10u64), 3);
assert_eq!(Percent::from_percent(36).mul_floor(10u64), 3);
sourcefn mul_ceil<N>(self, b: N) -> Nwhere
N: MultiplyArg + UniqueSaturatedInto<Self::Inner>,
Self::Inner: Into<N>,
fn mul_ceil<N>(self, b: N) -> Nwhere N: MultiplyArg + UniqueSaturatedInto<Self::Inner>, Self::Inner: Into<N>,
Multiplication that always rounds the result up to a whole number. The standard Mul
rounds to the nearest whole number.
// round to nearest
assert_eq!(Percent::from_percent(34) * 10u64, 3);
assert_eq!(Percent::from_percent(36) * 10u64, 4);
// round up
assert_eq!(Percent::from_percent(34).mul_ceil(10u64), 4);
assert_eq!(Percent::from_percent(36).mul_ceil(10u64), 4);
sourcefn saturating_reciprocal_mul<N>(self, b: N) -> Nwhere
N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>,
Self::Inner: Into<N>,
fn saturating_reciprocal_mul<N>(self, b: N) -> Nwhere N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>, Self::Inner: Into<N>,
Saturating multiplication by the reciprocal of self
. The result is rounded to the
nearest whole number and saturates at the numeric bounds instead of overflowing.
assert_eq!(Percent::from_percent(50).saturating_reciprocal_mul(10u64), 20);
sourcefn saturating_reciprocal_mul_floor<N>(self, b: N) -> Nwhere
N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>,
Self::Inner: Into<N>,
fn saturating_reciprocal_mul_floor<N>(self, b: N) -> Nwhere N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>, Self::Inner: Into<N>,
Saturating multiplication by the reciprocal of self
. The result is rounded down to the
nearest whole number and saturates at the numeric bounds instead of overflowing.
// round to nearest
assert_eq!(Percent::from_percent(60).saturating_reciprocal_mul(10u64), 17);
// round down
assert_eq!(Percent::from_percent(60).saturating_reciprocal_mul_floor(10u64), 16);
sourcefn saturating_reciprocal_mul_ceil<N>(self, b: N) -> Nwhere
N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>,
Self::Inner: Into<N>,
fn saturating_reciprocal_mul_ceil<N>(self, b: N) -> Nwhere N: ReciprocalArg + UniqueSaturatedInto<Self::Inner>, Self::Inner: Into<N>,
Saturating multiplication by the reciprocal of self
. The result is rounded up to the
nearest whole number and saturates at the numeric bounds instead of overflowing.
// round to nearest
assert_eq!(Percent::from_percent(61).saturating_reciprocal_mul(10u64), 16);
// round up
assert_eq!(Percent::from_percent(61).saturating_reciprocal_mul_ceil(10u64), 17);
sourcefn from_rational<N>(p: N, q: N) -> Selfwhere
N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>,
Self::Inner: Into<N>,
fn from_rational<N>(p: N, q: N) -> Selfwhere N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>, Self::Inner: Into<N>,
Approximate the fraction p/q
into a per-thing fraction. This will never overflow.
The computation of this approximation is performed in the generic type N
. Given
M
as the data type that can hold the maximum value of this per-thing (e.g. u32 for
perbill), this can only work if N == M
or N: From<M> + TryInto<M>
.
Note that this always rounds down, i.e.
// 989/1000 is technically closer to 99%.
assert_eq!(
Percent::from_rational(989u64, 1000),
Percent::from_parts(98),
);
sourcefn from_rational_approximation<N>(p: N, q: N) -> Selfwhere
N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>,
Self::Inner: Into<N>,
fn from_rational_approximation<N>(p: N, q: N) -> Selfwhere N: RationalArg + TryInto<Self::Inner> + TryInto<Self::Upper>, Self::Inner: Into<N>,
Same as Self::from_rational
.