Struct fadroma::prelude::Decimal256

pub struct Decimal256(_);

A fixed-point decimal value with 18 fractional digits, i.e. Decimal256(1_000_000_000_000_000_000) == 1.0

The greatest possible value that can be represented is 115792089237316195423570985008687907853269984665640564039457.584007913129639935 (which is (2^256 - 1) / 10^18)

Implementations

impl Decimal256

pub const DECIMAL_PLACES: u32 = 18u32

The number of decimal places. Since decimal types are fixed-point rather than floating-point, this is a constant.

pub const MAX: Decimal256 = Self(Uint256::MAX)

The largest value that can be represented by this decimal type.

pub const MIN: Decimal256 = Self(Uint256::MIN)

The smallest value that can be represented by this decimal type.

pub const fn new(value: Uint256) -> Decimal256

Creates a Decimal256 from Uint256 This is equivalent to Decimal256::from_atomics(value, 18) but usable in a const context.

pub const fn raw(value: u128) -> Decimal256

Creates a Decimal256 from u128 This is equivalent to Decimal256::from_atomics(value, 18) but usable in a const context.

pub const fn one() -> Decimal256

Create a 1.0 Decimal256

pub const fn zero() -> Decimal256

Create a 0.0 Decimal256

pub fn percent(x: u64) -> Decimal256

Convert x% into Decimal256

pub fn permille(x: u64) -> Decimal256

Convert permille (x/1000) into Decimal256

pub fn from_atomics( atomics: impl Into<Uint256>, decimal_places: u32 ) -> Result<Decimal256, Decimal256RangeExceeded>

Creates a decimal from a number of atomic units and the number of decimal places. The inputs will be converted internally to form a decimal with 18 decimal places. So the input 123 and 2 will create the decimal 1.23.

Using 18 decimal places is slightly more efficient than other values as no internal conversion is necessary.

Examples

let a = Decimal256::from_atomics(1234u64, 3).unwrap();
assert_eq!(a.to_string(), "1.234");

let a = Decimal256::from_atomics(1234u128, 0).unwrap();
assert_eq!(a.to_string(), "1234");

let a = Decimal256::from_atomics(1u64, 18).unwrap();
assert_eq!(a.to_string(), "0.000000000000000001");

let a = Decimal256::from_atomics(Uint256::MAX, 18).unwrap();
assert_eq!(a, Decimal256::MAX);

pub fn from_ratio( numerator: impl Into<Uint256>, denominator: impl Into<Uint256> ) -> Decimal256

Returns the ratio (numerator / denominator) as a Decimal256

pub fn checked_from_ratio( numerator: impl Into<Uint256>, denominator: impl Into<Uint256> ) -> Result<Decimal256, CheckedFromRatioError>

Returns the ratio (numerator / denominator) as a Decimal256

pub const fn is_zero(&self) -> bool

pub const fn atomics(&self) -> Uint256

A decimal is an integer of atomic units plus a number that specifies the position of the decimal dot. So any decimal can be expressed as two numbers.

Examples

// Value with whole and fractional part
let a = Decimal256::from_str("1.234").unwrap();
assert_eq!(a.decimal_places(), 18);
assert_eq!(a.atomics(), Uint256::from(1234000000000000000u128));

// Smallest possible value
let b = Decimal256::from_str("0.000000000000000001").unwrap();
assert_eq!(b.decimal_places(), 18);
assert_eq!(b.atomics(), Uint256::from(1u128));

pub const fn decimal_places(&self) -> u32

The number of decimal places. This is a constant value for now but this could potentially change as the type evolves.

See also Decimal256::atomics().

pub fn floor(&self) -> Decimal256

Rounds value down after decimal places.

pub fn ceil(&self) -> Decimal256

Rounds value up after decimal places. Panics on overflow.

pub fn checked_ceil(&self) -> Result<Decimal256, RoundUpOverflowError>

Rounds value up after decimal places. Returns OverflowError on overflow.

pub fn checked_add(self, other: Decimal256) -> Result<Decimal256, OverflowError>

pub fn checked_sub(self, other: Decimal256) -> Result<Decimal256, OverflowError>

pub fn checked_mul(self, other: Decimal256) -> Result<Decimal256, OverflowError>

Multiplies one Decimal256 by another, returning an OverflowError if an overflow occurred.

pub fn pow(self, exp: u32) -> Decimal256

Raises a value to the power of exp, panics if an overflow occurred.

pub fn checked_pow(self, exp: u32) -> Result<Decimal256, OverflowError>

Raises a value to the power of exp, returning an OverflowError if an overflow occurred.

pub fn checked_div( self, other: Decimal256 ) -> Result<Decimal256, CheckedFromRatioError>

pub fn checked_rem( self, other: Decimal256 ) -> Result<Decimal256, DivideByZeroError>

pub fn sqrt(&self) -> Decimal256

Returns the approximate square root as a Decimal256.

This should not overflow or panic.

pub fn abs_diff(self, other: Decimal256) -> Decimal256

pub fn saturating_add(self, other: Decimal256) -> Decimal256

pub fn saturating_sub(self, other: Decimal256) -> Decimal256

pub fn saturating_mul(self, other: Decimal256) -> Decimal256

pub fn saturating_pow(self, exp: u32) -> Decimal256

Trait Implementations

impl Add<&Decimal256> for &Decimal256

type Output = <Decimal256 as Add<Decimal256>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Decimal256) -> <Decimal256 as Add<Decimal256>>::Output

Performs the + operation.

impl Add<&Decimal256> for Decimal256

type Output = <Decimal256 as Add<Decimal256>>::Output

The resulting type after applying the + operator.

fn add(self, other: &Decimal256) -> <Decimal256 as Add<Decimal256>>::Output

Performs the + operation.

impl<'a> Add<Decimal256> for &'a Decimal256

type Output = <Decimal256 as Add<Decimal256>>::Output

The resulting type after applying the + operator.

fn add(self, other: Decimal256) -> <Decimal256 as Add<Decimal256>>::Output

Performs the + operation.

impl Add<Decimal256> for Decimal256

type Output = Decimal256

The resulting type after applying the + operator.

fn add(self, other: Decimal256) -> Decimal256

Performs the + operation.

impl AddAssign<&Decimal256> for Decimal256

fn add_assign(&mut self, other: &Decimal256)

Performs the += operation.

impl AddAssign<Decimal256> for Decimal256

fn add_assign(&mut self, rhs: Decimal256)

Performs the += operation.

impl Canonize for Decimal256

type Output = Decimal256

fn canonize(self, _api: &dyn Api) -> StdResult<Self::Output>

impl Clone for Decimal256

fn clone(&self) -> Decimal256

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Decimal256

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

Formats the value using the given formatter.

impl Default for Decimal256

fn default() -> Decimal256

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Decimal256

Deserializes as a base64 string

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

Deserialize this value from the given Serde deserializer.

impl Display for Decimal256

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

Formats the value using the given formatter.

impl Div<&Decimal256> for &Decimal256

type Output = <Decimal256 as Div<Decimal256>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Decimal256) -> <Decimal256 as Div<Decimal256>>::Output

Performs the / operation.

impl Div<&Decimal256> for Decimal256

type Output = <Decimal256 as Div<Decimal256>>::Output

The resulting type after applying the / operator.

fn div(self, other: &Decimal256) -> <Decimal256 as Div<Decimal256>>::Output

Performs the / operation.

impl<'a> Div<Decimal256> for &'a Decimal256

type Output = <Decimal256 as Div<Decimal256>>::Output

The resulting type after applying the / operator.

fn div(self, other: Decimal256) -> <Decimal256 as Div<Decimal256>>::Output

Performs the / operation.

impl Div<Decimal256> for Decimal256

type Output = Decimal256

The resulting type after applying the / operator.

fn div(self, other: Decimal256) -> Decimal256

Performs the / operation.

impl Div<Uint256> for Decimal256

type Output = Decimal256

The resulting type after applying the / operator.

fn div(self, rhs: Uint256) -> <Decimal256 as Div<Uint256>>::Output

Performs the / operation.

impl DivAssign<&Decimal256> for Decimal256

fn div_assign(&mut self, other: &Decimal256)

Performs the /= operation.

impl DivAssign<Decimal256> for Decimal256

fn div_assign(&mut self, rhs: Decimal256)

Performs the /= operation.

impl DivAssign<Uint256> for Decimal256

fn div_assign(&mut self, rhs: Uint256)

Performs the /= operation.

impl FadromaDeserialize for Decimal256

fn from_bytes<'a>(de: &mut Deserializer<'a>) -> Result<Self>

Deserialize into a new instance by reading bytes from the provided Deserializer.

impl FadromaSerialize for Decimal256

fn size_hint(&self) -> usize

The size in bytes of the particular instance when converted to its byte respresentation. While it’s preferred that this method returns an exact size (or at least a bigger estimation) it’s not an error to return an incorrect number. The penalty for doing so is potentially incurring unnecessary re-allocations.

fn to_bytes(&self, ser: &mut Serializer) -> Result<()>

Serialize the instance into bytes by writing to the provided Serializer.

impl Fraction<Uint256> for Decimal256

fn inv(&self) -> Option<Decimal256>

Returns the multiplicative inverse 1/d for decimal d.

If d is zero, none is returned.

fn numerator(&self) -> Uint256

Returns the numerator p

fn denominator(&self) -> Uint256

Returns the denominator q

impl From<Decimal> for Decimal256

fn from(input: Decimal) -> Decimal256

Converts to this type from the input type.

impl FromStr for Decimal256

fn from_str(input: &str) -> Result<Decimal256, <Decimal256 as FromStr>::Err>

Converts the decimal string to a Decimal256 Possible inputs: “1.23”, “1”, “000012”, “1.123000000” Disallowed: “”, “.23”

This never performs any kind of rounding. More than DECIMAL_PLACES fractional digits, even zeros, result in an error.

type Err = StdError

The associated error which can be returned from parsing.

impl Humanize for Decimal256

type Output = Decimal256

fn humanize(self, _api: &dyn Api) -> StdResult<Self::Output>

impl JsonSchema for Decimal256

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl Mul<&Decimal256> for &Decimal256

type Output = <Decimal256 as Mul<Decimal256>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Decimal256) -> <Decimal256 as Mul<Decimal256>>::Output

Performs the * operation.

impl Mul<&Decimal256> for Decimal256

type Output = <Decimal256 as Mul<Decimal256>>::Output

The resulting type after applying the * operator.

fn mul(self, other: &Decimal256) -> <Decimal256 as Mul<Decimal256>>::Output

Performs the * operation.

impl<'a> Mul<Decimal256> for &'a Decimal256

type Output = <Decimal256 as Mul<Decimal256>>::Output

The resulting type after applying the * operator.

fn mul(self, other: Decimal256) -> <Decimal256 as Mul<Decimal256>>::Output

Performs the * operation.

impl Mul<Decimal256> for Decimal256

type Output = Decimal256

The resulting type after applying the * operator.

fn mul(self, other: Decimal256) -> Decimal256

Performs the * operation.

impl Mul<Decimal256> for Uint256

Both du and ud with d: Decimal256 and u: Uint256 returns an Uint256. There is no specific reason for this decision other than the initial use cases we have. If you need a Decimal256 result for the same calculation, use Decimal256(du) or Decimal256(ud).

type Output = Uint256

The resulting type after applying the * operator.

fn mul(self, rhs: Decimal256) -> <Uint256 as Mul<Decimal256>>::Output

Performs the * operation.

impl Mul<Uint256> for Decimal256

type Output = Uint256

The resulting type after applying the * operator.

fn mul(self, rhs: Uint256) -> <Decimal256 as Mul<Uint256>>::Output

Performs the * operation.

impl MulAssign<&Decimal256> for Decimal256

fn mul_assign(&mut self, other: &Decimal256)

Performs the *= operation.

impl MulAssign<Decimal256> for Decimal256

fn mul_assign(&mut self, rhs: Decimal256)

Performs the *= operation.

impl Ord for Decimal256

fn cmp(&self, other: &Decimal256) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<&Decimal256> for Decimal256

fn eq(&self, rhs: &&Decimal256) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Decimal256> for &Decimal256

fn eq(&self, rhs: &Decimal256) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Decimal256> for Decimal256

fn eq(&self, other: &Decimal256) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Decimal256> for Decimal256

fn partial_cmp(&self, other: &Decimal256) -> 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 Rem<&Decimal256> for &Decimal256

type Output = <Decimal256 as Rem<Decimal256>>::Output

The resulting type after applying the % operator.

fn rem(self, other: &Decimal256) -> <Decimal256 as Rem<Decimal256>>::Output

Performs the % operation.

impl Rem<&Decimal256> for Decimal256

type Output = <Decimal256 as Rem<Decimal256>>::Output

The resulting type after applying the % operator.

fn rem(self, other: &Decimal256) -> <Decimal256 as Rem<Decimal256>>::Output

Performs the % operation.

impl<'a> Rem<Decimal256> for &'a Decimal256

type Output = <Decimal256 as Rem<Decimal256>>::Output

The resulting type after applying the % operator.

fn rem(self, other: Decimal256) -> <Decimal256 as Rem<Decimal256>>::Output

Performs the % operation.

impl Rem<Decimal256> for Decimal256

fn rem(self, rhs: Decimal256) -> Decimal256

Panics

This operation will panic if rhs is zero

type Output = Decimal256

The resulting type after applying the % operator.

impl RemAssign<&Decimal256> for Decimal256

fn rem_assign(&mut self, other: &Decimal256)

Performs the %= operation.

impl RemAssign<Decimal256> for Decimal256

fn rem_assign(&mut self, rhs: Decimal256)

Performs the %= operation.

impl Serialize for Decimal256

Serializes as a decimal string

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

Serialize this value into the given Serde serializer.

impl Sub<&Decimal256> for &Decimal256

type Output = <Decimal256 as Sub<Decimal256>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Decimal256) -> <Decimal256 as Sub<Decimal256>>::Output

Performs the - operation.

impl Sub<&Decimal256> for Decimal256

type Output = <Decimal256 as Sub<Decimal256>>::Output

The resulting type after applying the - operator.

fn sub(self, other: &Decimal256) -> <Decimal256 as Sub<Decimal256>>::Output

Performs the - operation.

impl<'a> Sub<Decimal256> for &'a Decimal256

type Output = <Decimal256 as Sub<Decimal256>>::Output

The resulting type after applying the - operator.

fn sub(self, other: Decimal256) -> <Decimal256 as Sub<Decimal256>>::Output

Performs the - operation.

impl Sub<Decimal256> for Decimal256

type Output = Decimal256

The resulting type after applying the - operator.

fn sub(self, other: Decimal256) -> Decimal256

Performs the - operation.

impl SubAssign<&Decimal256> for Decimal256

fn sub_assign(&mut self, other: &Decimal256)

Performs the -= operation.

impl SubAssign<Decimal256> for Decimal256

fn sub_assign(&mut self, rhs: Decimal256)

Performs the -= operation.

impl<A> Sum<A> for Decimal256where Decimal256: Add<A, Output = Decimal256>,

fn sum<I>(iter: I) -> Decimal256where I: Iterator<Item = A>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl Copy for Decimal256

impl Eq for Decimal256

impl StructuralEq for Decimal256

impl StructuralPartialEq for Decimal256