Struct cosmwasm_std::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 MAX: Self = Self(Uint256::MAX)

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

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

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

pub const fn one() -> Self

Create a 1.0 Decimal256

pub const fn zero() -> Self

Create a 0.0 Decimal256

pub fn percent(x: u64) -> Self

Convert x% into Decimal256

pub fn permille(x: u64) -> Self

Convert permille (x/1000) into Decimal256

pub fn from_atomics(
    atomics: impl Into<Uint256>,
    decimal_places: u32
) -> Result<Self, 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>
) -> Self

Returns the ratio (numerator / denominator) as a Decimal256

pub fn checked_from_ratio(
    numerator: impl Into<Uint256>,
    denominator: impl Into<Uint256>
) -> Result<Self, 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 checked_mul(self, other: Self) -> Result<Self, OverflowError>

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

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

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

pub fn sqrt(&self) -> Self

Returns the approximate square root as a Decimal256.

This should not overflow or panic.

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 Add<Decimal256> for Decimal256

type Output = Decimal256

The resulting type after applying the + operator.

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

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

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<Self, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl Display for Decimal256

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

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 Div<Decimal256> for Decimal256

type Output = Decimal256

The resulting type after applying the / operator.

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

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<Uint256> for Decimal256

type Output = Decimal256

The resulting type after applying the / operator.

fn div(self, rhs: Uint256) -> Self::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 Fraction<Uint256> for Decimal256

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

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 FromStr for Decimal256

fn from_str(input: &str) -> Result<Self, Self::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 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 Mul<Decimal256> for Decimal256

type Output = Decimal256

The resulting type after applying the * operator.

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

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 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) -> Self::Output

Performs the * operation.

impl Mul<Uint256> for Decimal256

type Output = Uint256

The resulting type after applying the * operator.

fn mul(self, rhs: Uint256) -> Self::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: Self)

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

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: &Decimal256) -> bool

This method tests for !=.

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 Serialize for Decimal256

Serializes as a decimal string

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::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 Sub<Decimal256> for Decimal256

type Output = Decimal256

The resulting type after applying the - operator.

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

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 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 Decimal256 where
    Self: Add<A, Output = Self>, 

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

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