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 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: Self = _

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

pub const MIN: Self = _

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

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 floor(&self) -> Self

Rounds value down after decimal places.

pub fn ceil(&self) -> Self

Rounds value up after decimal places. Panics on overflow.

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

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

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

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

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

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

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

Raises a value to the power of exp, panics 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 checked_div(self, other: Self) -> Result<Self, CheckedFromRatioError>

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

pub fn sqrt(&self) -> Self

Returns the approximate square root as a Decimal256.

This should not overflow or panic.

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

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

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

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

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

pub fn to_uint_floor(self) -> Uint256

Converts this decimal to an unsigned integer by truncating the fractional part, e.g. 22.5 becomes 22.

Examples

use std::str::FromStr;
use cosmwasm_std::{Decimal256, Uint256};

let d = Decimal256::from_str("12.345").unwrap();
assert_eq!(d.to_uint_floor(), Uint256::from(12u64));

let d = Decimal256::from_str("12.999").unwrap();
assert_eq!(d.to_uint_floor(), Uint256::from(12u64));

let d = Decimal256::from_str("75.0").unwrap();
assert_eq!(d.to_uint_floor(), Uint256::from(75u64));

pub fn to_uint_ceil(self) -> Uint256

Converts this decimal to an unsigned integer by rounting up to the next integer, e.g. 22.3 becomes 23.

Examples

use std::str::FromStr;
use cosmwasm_std::{Decimal256, Uint256};

let d = Decimal256::from_str("12.345").unwrap();
assert_eq!(d.to_uint_ceil(), Uint256::from(13u64));

let d = Decimal256::from_str("12.999").unwrap();
assert_eq!(d.to_uint_ceil(), Uint256::from(13u64));

let d = Decimal256::from_str("75.0").unwrap();
assert_eq!(d.to_uint_ceil(), Uint256::from(75u64));

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

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

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 From<Decimal> for Decimal256

fn from(input: Decimal) -> Self

Converts to this type from the input type.

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

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) -> 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<'a> PartialEq<Decimal256> for &'a 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: Self) -> Self

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

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