Struct rust_decimal::Decimal

#[repr(C)]
pub struct Decimal { /* fields omitted */ }

Decimal represents a 128 bit representation of a fixed-precision decimal number. The finite set of values of type Decimal are of the form m / 10^e, where m is an integer such that -2⁹⁶ < m < 2⁹⁶, and e is an integer between 0 and 28 inclusive.

Implementations

impl Decimal

pub const MIN: Decimal

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

pub const MAX: Decimal

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

pub const ZERO: Decimal

A constant representing 0.

pub const ONE: Decimal

A constant representing 1.

pub const NEGATIVE_ONE: Decimal

A constant representing -1.

pub const TWO: Decimal

A constant representing 2.

pub const TEN: Decimal

A constant representing 10.

pub const ONE_HUNDRED: Decimal

A constant representing 100.

pub const ONE_THOUSAND: Decimal

A constant representing 1000.

pub const PI: Decimal

A constant representing π as 3.1415926535897932384626433833

pub const HALF_PI: Decimal

A constant representing π/2 as 1.5707963267948966192313216916

pub const TWO_PI: Decimal

A constant representing 2π as 6.2831853071795864769252867666

pub const E: Decimal

A constant representing Euler’s number (e) as 2.7182818284590452353602874714

pub const E_INVERSE: Decimal

A constant representing the inverse of Euler’s number (1/e) as 0.3678794411714423215955237702

pub fn new(num: i64, scale: u32) -> Decimal

Returns a Decimal with a 64 bit m representation and corresponding e scale.

Arguments

• num - An i64 that represents the m portion of the decimal number
• scale - A u32 representing the e portion of the decimal number.

Panics

This function panics if scale is > 28.

Example

use rust_decimal::Decimal;

let pi = Decimal::new(3141, 3);
assert_eq!(pi.to_string(), "3.141");

pub const fn try_new(num: i64, scale: u32) -> Result<Decimal>

Checked version of Decimal::new. Will return Err instead of panicking at run-time.

Example

use rust_decimal::Decimal;

let max = Decimal::try_new(i64::MAX, u32::MAX);
assert!(max.is_err());

pub fn from_i128_with_scale(num: i128, scale: u32) -> Decimal

Creates a Decimal using a 128 bit signed m representation and corresponding e scale.

Arguments

• num - An i128 that represents the m portion of the decimal number
• scale - A u32 representing the e portion of the decimal number.

Panics

This function panics if scale is > 28 or if num exceeds the maximum supported 96 bits.

Example

use rust_decimal::Decimal;

let pi = Decimal::from_i128_with_scale(3141i128, 3);
assert_eq!(pi.to_string(), "3.141");

pub const fn try_from_i128_with_scale(num: i128, scale: u32) -> Result<Decimal>

Checked version of Decimal::from_i128_with_scale. Will return Err instead of panicking at run-time.

Example

use rust_decimal::Decimal;

let max = Decimal::try_from_i128_with_scale(i128::MAX, u32::MAX);
assert!(max.is_err());

pub const fn from_parts(
    lo: u32,
    mid: u32,
    hi: u32,
    negative: bool,
    scale: u32
) -> Decimal

Returns a Decimal using the instances constituent parts.

Arguments

• lo - The low 32 bits of a 96-bit integer.
• mid - The middle 32 bits of a 96-bit integer.
• hi - The high 32 bits of a 96-bit integer.
• negative - true to indicate a negative number.
• scale - A power of 10 ranging from 0 to 28.

Caution: Undefined behavior

While a scale greater than 28 can be passed in, it will be automatically capped by this function at the maximum precision. The library opts towards this functionality as opposed to a panic to ensure that the function can be treated as constant. This may lead to undefined behavior in downstream applications and should be treated with caution.

Example

use rust_decimal::Decimal;

let pi = Decimal::from_parts(1102470952, 185874565, 1703060790, false, 28);
assert_eq!(pi.to_string(), "3.1415926535897932384626433832");

pub fn from_scientific(value: &str) -> Result<Decimal, Error>

Returns a Result which if successful contains the Decimal constitution of the scientific notation provided by value.

Arguments

• value - The scientific notation of the Decimal.

Example

use rust_decimal::Decimal;

let value = Decimal::from_scientific("9.7e-7").unwrap();
assert_eq!(value.to_string(), "0.00000097");

pub const fn scale(&self) -> u32

Returns the scale of the decimal number, otherwise known as e.

Example

use rust_decimal::Decimal;

let num = Decimal::new(1234, 3);
assert_eq!(num.scale(), 3u32);

pub const fn mantissa(&self) -> i128

Returns the mantissa of the decimal number.

Example

use rust_decimal::prelude::*;

let num = Decimal::from_str("-1.2345678").unwrap();
assert_eq!(num.mantissa(), -12345678i128);
assert_eq!(num.scale(), 7);

pub const fn is_zero(&self) -> bool

Returns true if this Decimal number is equivalent to zero.

Example

use rust_decimal::prelude::*;

let num = Decimal::ZERO;
assert!(num.is_zero());

pub fn set_sign(&mut self, positive: bool)

👎 Deprecated since 1.4.0:

please use set_sign_positive instead

An optimized method for changing the sign of a decimal number.

Arguments

• positive: true if the resulting decimal should be positive.

Example

use rust_decimal::Decimal;

let mut one = Decimal::ONE;
one.set_sign(false);
assert_eq!(one.to_string(), "-1");

pub fn set_sign_positive(&mut self, positive: bool)

An optimized method for changing the sign of a decimal number.

Arguments

• positive: true if the resulting decimal should be positive.

Example

use rust_decimal::Decimal;

let mut one = Decimal::ONE;
one.set_sign_positive(false);
assert_eq!(one.to_string(), "-1");

pub fn set_sign_negative(&mut self, negative: bool)

An optimized method for changing the sign of a decimal number.

Arguments

• negative: true if the resulting decimal should be negative.

Example

use rust_decimal::Decimal;

let mut one = Decimal::ONE;
one.set_sign_negative(true);
assert_eq!(one.to_string(), "-1");

pub fn set_scale(&mut self, scale: u32) -> Result<(), Error>

An optimized method for changing the scale of a decimal number.

Arguments

• scale: the new scale of the number

Example

use rust_decimal::Decimal;

let mut one = Decimal::ONE;
one.set_scale(5).unwrap();
assert_eq!(one.to_string(), "0.00001");

pub fn rescale(&mut self, scale: u32)

Modifies the Decimal to the given scale, attempting to do so without changing the underlying number itself.

Note that setting the scale to something less then the current Decimals scale will cause the newly created Decimal to have some rounding. Scales greater than the maximum precision supported by Decimal will be automatically rounded to Decimal::MAX_PRECISION. Rounding leverages the half up strategy.

Arguments

• scale: The scale to use for the new Decimal number.

Example

use rust_decimal::prelude::*;

// Rescaling to a higher scale preserves the value
let mut number = Decimal::from_str("1.123").unwrap();
assert_eq!(number.scale(), 3);
number.rescale(6);
assert_eq!(number.to_string(), "1.123000");
assert_eq!(number.scale(), 6);

// Rescaling to a lower scale forces the number to be rounded
let mut number = Decimal::from_str("1.45").unwrap();
assert_eq!(number.scale(), 2);
number.rescale(1);
assert_eq!(number.to_string(), "1.5");
assert_eq!(number.scale(), 1);

pub const fn serialize(&self) -> [u8; 16]

Returns a serialized version of the decimal number. The resulting byte array will have the following representation:

• Bytes 1-4: flags
• Bytes 5-8: lo portion of m
• Bytes 9-12: mid portion of m
• Bytes 13-16: high portion of m

pub const fn deserialize(bytes: [u8; 16]) -> Decimal

Deserializes the given bytes into a decimal number. The deserialized byte representation must be 16 bytes and adhere to the following convention:

• Bytes 1-4: flags
• Bytes 5-8: lo portion of m
• Bytes 9-12: mid portion of m
• Bytes 13-16: high portion of m

pub fn is_negative(&self) -> bool

👎 Deprecated since 0.6.3:

please use is_sign_negative instead

Returns true if the decimal is negative.

pub fn is_positive(&self) -> bool

👎 Deprecated since 0.6.3:

please use is_sign_positive instead

Returns true if the decimal is positive.

pub const fn is_sign_negative(&self) -> bool

Returns true if the sign bit of the decimal is negative.

pub const fn is_sign_positive(&self) -> bool

Returns true if the sign bit of the decimal is positive.

pub const fn min_value() -> Decimal

👎 Deprecated since 1.12.0:

Use the associated constant Decimal::MIN

Returns the minimum possible number that Decimal can represent.

pub const fn max_value() -> Decimal

👎 Deprecated since 1.12.0:

Use the associated constant Decimal::MAX

Returns the maximum possible number that Decimal can represent.

pub fn trunc(&self) -> Decimal

Returns a new Decimal integral with no fractional portion. This is a true truncation whereby no rounding is performed.

Example

use rust_decimal::Decimal;

let pi = Decimal::new(3141, 3);
let trunc = Decimal::new(3, 0);
// note that it returns a decimal
assert_eq!(pi.trunc(), trunc);

pub fn fract(&self) -> Decimal

Returns a new Decimal representing the fractional portion of the number.

Example

use rust_decimal::Decimal;

let pi = Decimal::new(3141, 3);
let fract = Decimal::new(141, 3);
// note that it returns a decimal
assert_eq!(pi.fract(), fract);

pub fn abs(&self) -> Decimal

Computes the absolute value of self.

Example

use rust_decimal::Decimal;

let num = Decimal::new(-3141, 3);
assert_eq!(num.abs().to_string(), "3.141");

pub fn floor(&self) -> Decimal

Returns the largest integer less than or equal to a number.

Example

use rust_decimal::Decimal;

let num = Decimal::new(3641, 3);
assert_eq!(num.floor().to_string(), "3");

pub fn ceil(&self) -> Decimal

Returns the smallest integer greater than or equal to a number.

Example

use rust_decimal::Decimal;

let num = Decimal::new(3141, 3);
assert_eq!(num.ceil().to_string(), "4");
let num = Decimal::new(3, 0);
assert_eq!(num.ceil().to_string(), "3");

pub fn max(self, other: Decimal) -> Decimal

Returns the maximum of the two numbers.

use rust_decimal::Decimal;

let x = Decimal::new(1, 0);
let y = Decimal::new(2, 0);
assert_eq!(y, x.max(y));

pub fn min(self, other: Decimal) -> Decimal

Returns the minimum of the two numbers.

use rust_decimal::Decimal;

let x = Decimal::new(1, 0);
let y = Decimal::new(2, 0);
assert_eq!(x, x.min(y));

pub fn normalize(&self) -> Decimal

Strips any trailing zero’s from a Decimal and converts -0 to 0.

Example

use rust_decimal::prelude::*;

let number = Decimal::from_str("3.100").unwrap();
assert_eq!(number.normalize().to_string(), "3.1");

pub fn normalize_assign(&mut self)

An in place version of normalize. Strips any trailing zero’s from a Decimal and converts -0 to 0.

Example

use rust_decimal::prelude::*;

let mut number = Decimal::from_str("3.100").unwrap();
assert_eq!(number.to_string(), "3.100");
number.normalize_assign();
assert_eq!(number.to_string(), "3.1");

pub fn round(&self) -> Decimal

Returns a new Decimal number with no fractional portion (i.e. an integer). Rounding currently follows “Bankers Rounding” rules. e.g. 6.5 -> 6, 7.5 -> 8

Example

use rust_decimal::Decimal;

// Demonstrating bankers rounding...
let number_down = Decimal::new(65, 1);
let number_up   = Decimal::new(75, 1);
assert_eq!(number_down.round().to_string(), "6");
assert_eq!(number_up.round().to_string(), "8");

pub fn round_dp_with_strategy(
    &self,
    dp: u32,
    strategy: RoundingStrategy
) -> Decimal

Returns a new Decimal number with the specified number of decimal points for fractional portion. Rounding is performed using the provided RoundingStrategy

Arguments

• dp: the number of decimal points to round to.
• strategy: the RoundingStrategy to use.

Example

use rust_decimal::{Decimal, RoundingStrategy};
use core::str::FromStr;

let tax = Decimal::from_str("3.4395").unwrap();
assert_eq!(tax.round_dp_with_strategy(2, RoundingStrategy::MidpointAwayFromZero).to_string(), "3.44");

pub fn round_dp(&self, dp: u32) -> Decimal

Returns a new Decimal number with the specified number of decimal points for fractional portion. Rounding currently follows “Bankers Rounding” rules. e.g. 6.5 -> 6, 7.5 -> 8

Arguments

• dp: the number of decimal points to round to.

Example

use rust_decimal::Decimal;
use core::str::FromStr;

let pi = Decimal::from_str("3.1415926535897932384626433832").unwrap();
assert_eq!(pi.round_dp(2).to_string(), "3.14");

pub const fn unpack(&self) -> UnpackedDecimal

Convert Decimal to an internal representation of the underlying struct. This is useful for debugging the internal state of the object.

Important Disclaimer

This is primarily intended for library maintainers. The internal representation of a Decimal is considered “unstable” for public use.

Example

use rust_decimal::Decimal;
use core::str::FromStr;

let pi = Decimal::from_str("3.1415926535897932384626433832").unwrap();
assert_eq!(format!("{:?}", pi), "3.1415926535897932384626433832");
assert_eq!(format!("{:?}", pi.unpack()), "UnpackedDecimal { \
    negative: false, scale: 28, hi: 1703060790, mid: 185874565, lo: 1102470952 \
}");

pub fn checked_add(self, other: Decimal) -> Option<Decimal>

Checked addition. Computes self + other, returning None if overflow occurred.

pub fn checked_sub(self, other: Decimal) -> Option<Decimal>

Checked subtraction. Computes self - other, returning None if overflow occurred.

pub fn checked_mul(self, other: Decimal) -> Option<Decimal>

Checked multiplication. Computes self * other, returning None if overflow occurred.

pub fn checked_div(self, other: Decimal) -> Option<Decimal>

Checked division. Computes self / other, returning None if other == 0.0 or the division results in overflow.

pub fn checked_rem(self, other: Decimal) -> Option<Decimal>

Checked remainder. Computes self % other, returning None if other == 0.0.

pub fn from_str_radix(str: &str, radix: u32) -> Result<Self, Error>

Trait Implementations

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

type Output = Decimal

The resulting type after applying the + operator.

fn add(self, other: &Decimal) -> Decimal

Performs the + operation.

impl<'a, 'b> Add<&'b Decimal> for &'a Decimal

type Output = Decimal

The resulting type after applying the + operator.

fn add(self, other: &Decimal) -> Decimal

Performs the + operation.

impl Add<Decimal> for Decimal

type Output = Decimal

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Decimal

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> AddAssign<&'a Decimal> for Decimal

fn add_assign(&mut self, other: &'a Decimal)

Performs the += operation.

impl<'a> AddAssign<&'a Decimal> for &'a mut Decimal

fn add_assign(&mut self, other: &'a Decimal)

Performs the += operation.

impl AddAssign<Decimal> for Decimal

fn add_assign(&mut self, other: Decimal)

Performs the += operation.

impl<'a> AddAssign<Decimal> for &'a mut Decimal

fn add_assign(&mut self, other: Decimal)

Performs the += operation.

impl Arbitrary<'_> for Decimal

fn arbitrary(u: &mut Unstructured<'_>) -> ArbitraryResult<Self>

Generate an arbitrary value of Self from the given unstructured data.

fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self, Error>

Generate an arbitrary value of Self from the entirety of the given unstructured data.

fn size_hint(depth: usize) -> (usize, Option<usize>)

Get a size hint for how many bytes out of an Unstructured this type needs to construct itself.

impl<'expr> AsExpression<Nullable<Numeric>> for &'expr Decimal

type Expression = Bound<Nullable<Numeric>, Self>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl AsExpression<Nullable<Numeric>> for Decimal

type Expression = Bound<Nullable<Numeric>, Self>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl<'expr> AsExpression<Numeric> for &'expr Decimal

type Expression = Bound<Numeric, Self>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl AsExpression<Numeric> for Decimal

type Expression = Bound<Numeric, Self>

The expression being returned

fn as_expression(self) -> Self::Expression

Perform the conversion

impl CheckedAdd for Decimal

fn checked_add(&self, v: &Decimal) -> Option<Decimal>

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl CheckedDiv for Decimal

fn checked_div(&self, v: &Decimal) -> Option<Decimal>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl CheckedMul for Decimal

fn checked_mul(&self, v: &Decimal) -> Option<Decimal>

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl CheckedRem for Decimal

fn checked_rem(&self, v: &Decimal) -> Option<Decimal>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl CheckedSub for Decimal

fn checked_sub(&self, v: &Decimal) -> Option<Decimal>

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl Clone for Decimal

fn clone(&self) -> Decimal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Decimal

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

Formats the value using the given formatter.

impl Default for Decimal

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Decimal

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

Deserialize this value from the given Serde deserializer.

impl Display for Decimal

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

Formats the value using the given formatter.

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

type Output = Decimal

The resulting type after applying the / operator.

fn div(self, other: &Decimal) -> Decimal

Performs the / operation.

impl<'a, 'b> Div<&'b Decimal> for &'a Decimal

type Output = Decimal

The resulting type after applying the / operator.

fn div(self, other: &Decimal) -> Decimal

Performs the / operation.

impl Div<Decimal> for Decimal

type Output = Decimal

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Decimal

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> DivAssign<&'a Decimal> for Decimal

fn div_assign(&mut self, other: &'a Decimal)

Performs the /= operation.

impl<'a> DivAssign<&'a Decimal> for &'a mut Decimal

fn div_assign(&mut self, other: &'a Decimal)

Performs the /= operation.

impl DivAssign<Decimal> for Decimal

fn div_assign(&mut self, other: Decimal)

Performs the /= operation.

impl<'a> DivAssign<Decimal> for &'a mut Decimal

fn div_assign(&mut self, other: Decimal)

Performs the /= operation.

impl<'a> From<&'a Decimal> for PgNumeric

fn from(decimal: &'a Decimal) -> Self

Performs the conversion.

impl From<Decimal> for PgNumeric

fn from(bigdecimal: Decimal) -> Self

Performs the conversion.

impl From<i128> for Decimal

fn from(t: i128) -> Self

Performs the conversion.

impl From<i16> for Decimal

fn from(t: i16) -> Self

Performs the conversion.

impl From<i32> for Decimal

fn from(t: i32) -> Self

Performs the conversion.

impl From<i64> for Decimal

fn from(t: i64) -> Self

Performs the conversion.

impl From<i8> for Decimal

fn from(t: i8) -> Self

Performs the conversion.

impl From<isize> for Decimal

fn from(t: isize) -> Self

Performs the conversion.

impl From<u128> for Decimal

fn from(t: u128) -> Self

Performs the conversion.

impl From<u16> for Decimal

fn from(t: u16) -> Self

Performs the conversion.

impl From<u32> for Decimal

fn from(t: u32) -> Self

Performs the conversion.

impl From<u64> for Decimal

fn from(t: u64) -> Self

Performs the conversion.

impl From<u8> for Decimal

fn from(t: u8) -> Self

Performs the conversion.

impl From<usize> for Decimal

fn from(t: usize) -> Self

Performs the conversion.

impl FromPrimitive for Decimal

fn from_i32(n: i32) -> Option<Decimal>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i64(n: i64) -> Option<Decimal>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Decimal>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Decimal>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Decimal>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Decimal>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f32(n: f32) -> Option<Decimal>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_f64(n: f64) -> Option<Decimal>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl<'a> FromSql<'a> for Decimal

fn from_sql(
    _: &Type,
    raw: &[u8]
) -> Result<Decimal, Box<dyn Error + Sync + Send + 'static>>

Creates a new value of this type from a buffer of data of the specified Postgres Type in its binary format.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be created from the specified Postgres Type.

fn from_sql_null(
    ty: &Type
) -> Result<Self, Box<dyn Error + Send + Sync + 'static, Global>>

Creates a new value of this type from a NULL SQL value.

fn from_sql_nullable(
    ty: &Type,
    raw: Option<&'a [u8]>
) -> Result<Self, Box<dyn Error + Send + Sync + 'static, Global>>

A convenience function that delegates to from_sql and from_sql_null depending on the value of raw.

impl FromSql<Numeric, Pg> for Decimal

fn from_sql(numeric: Option<&[u8]>) -> Result<Self>

See the trait documentation.

impl<__ST, __DB> FromSqlRow<__ST, __DB> for Decimal where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

fn build_from_row<R: Row<__DB>>(row: &mut R) -> Result<Self>

See the trait documentation.

const FIELDS_NEEDED: usize

The number of fields that this type will consume. Must be equal to the number of times you would call row.take() in build_from_row

impl FromStr for Decimal

type Err = Error

The associated error which can be returned from parsing.

fn from_str(value: &str) -> Result<Decimal, Self::Err>

Parses a string s to return a value of this type.

impl Hash for Decimal

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl LowerExp for Decimal

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

Formats the value using the given formatter.

impl MathematicalOps for Decimal

fn exp(&self) -> Decimal

The estimated exponential function, e^x. Stops calculating when it is within tolerance of roughly 0.0000002.

fn checked_exp(&self) -> Option<Decimal>

The estimated exponential function, e^x. Stops calculating when it is within tolerance of roughly 0.0000002. Returns None on overflow.

fn exp_with_tolerance(&self, tolerance: Decimal) -> Decimal

The estimated exponential function, e^x using the tolerance provided as a hint as to when to stop calculating. A larger tolerance will cause the number to stop calculating sooner at the potential cost of a slightly less accurate result.

fn checked_exp_with_tolerance(&self, tolerance: Decimal) -> Option<Decimal>

The estimated exponential function, e^x using the tolerance provided as a hint as to when to stop calculating. A larger tolerance will cause the number to stop calculating sooner at the potential cost of a slightly less accurate result. Returns None on overflow.

fn powi(&self, exp: i64) -> Decimal

Raise self to the given integer exponent: x^y

fn checked_powi(&self, exp: i64) -> Option<Decimal>

Raise self to the given integer exponent x^y returning None on overflow.

fn powu(&self, exp: u64) -> Decimal

Raise self to the given unsigned integer exponent: x^y

fn checked_powu(&self, exp: u64) -> Option<Decimal>

Raise self to the given unsigned integer exponent x^y returning None on overflow.

fn powf(&self, exp: f64) -> Decimal

Raise self to the given floating point exponent: x^y

fn checked_powf(&self, exp: f64) -> Option<Decimal>

Raise self to the given floating point exponent x^y returning None on overflow.

fn powd(&self, exp: Decimal) -> Decimal

Raise self to the given Decimal exponent: x^y. If exp is not whole then the approximation e^y*ln(x) is used.

fn checked_powd(&self, exp: Decimal) -> Option<Decimal>

Raise self to the given Decimal exponent x^y returning None on overflow. If exp is not whole then the approximation e^y*ln(x) is used.

fn sqrt(&self) -> Option<Decimal>

The square root of a Decimal. Uses a standard Babylonian method.

fn ln(&self) -> Decimal

Calculates the natural logarithm for a Decimal calculated using Taylor’s series.

fn checked_ln(&self) -> Option<Decimal>

Calculates the checked natural logarithm for a Decimal calculated using Taylor’s series. Returns None for negative numbers or zero.

fn log10(&self) -> Decimal

Calculates the base 10 logarithm of a specified Decimal number.

fn checked_log10(&self) -> Option<Decimal>

Calculates the checked base 10 logarithm of a specified Decimal number. Returns None for negative numbers or zero.

fn erf(&self) -> Decimal

Abramowitz Approximation of Error Function from wikipedia

fn norm_cdf(&self) -> Decimal

The Cumulative distribution function for a Normal distribution

fn norm_pdf(&self) -> Decimal

The Probability density function for a Normal distribution.

fn checked_norm_pdf(&self) -> Option<Decimal>

The Probability density function for a Normal distribution returning None on overflow.

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

type Output = Decimal

The resulting type after applying the * operator.

fn mul(self, other: &Decimal) -> Decimal

Performs the * operation.

impl<'a, 'b> Mul<&'b Decimal> for &'a Decimal

type Output = Decimal

The resulting type after applying the * operator.

fn mul(self, other: &Decimal) -> Decimal

Performs the * operation.

impl Mul<Decimal> for Decimal

type Output = Decimal

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Decimal

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> MulAssign<&'a Decimal> for Decimal

fn mul_assign(&mut self, other: &'a Decimal)

Performs the *= operation.

impl<'a> MulAssign<&'a Decimal> for &'a mut Decimal

fn mul_assign(&mut self, other: &'a Decimal)

Performs the *= operation.

impl MulAssign<Decimal> for Decimal

fn mul_assign(&mut self, other: Decimal)

Performs the *= operation.

impl<'a> MulAssign<Decimal> for &'a mut Decimal

fn mul_assign(&mut self, other: Decimal)

Performs the *= operation.

impl Neg for Decimal

type Output = Decimal

The resulting type after applying the - operator.

fn neg(self) -> Decimal

Performs the unary - operation.

impl<'a> Neg for &'a Decimal

type Output = Decimal

The resulting type after applying the - operator.

fn neg(self) -> Decimal

Performs the unary - operation.

impl Num for Decimal

type FromStrRadixErr = Error

fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl One for Decimal

fn one() -> Decimal

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool where
    Self: PartialEq<Self>, 

Returns true if self is equal to the multiplicative identity.

impl Ord for Decimal

fn cmp(&self, other: &Decimal) -> 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<Decimal> for Decimal

fn eq(&self, other: &Decimal) -> 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 !=.

impl PartialOrd<Decimal> for Decimal

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

type Output = Decimal

The result after applying the operator.

fn pow(self, rhs: Decimal) -> Self::Output

Returns self to the power rhs.

impl Pow<f64> for Decimal

type Output = Decimal

The result after applying the operator.

fn pow(self, rhs: f64) -> Self::Output

Returns self to the power rhs.

impl Pow<i64> for Decimal

type Output = Decimal

The result after applying the operator.

fn pow(self, rhs: i64) -> Self::Output

Returns self to the power rhs.

impl Pow<u64> for Decimal

type Output = Decimal

The result after applying the operator.

fn pow(self, rhs: u64) -> Self::Output

Returns self to the power rhs.

impl<__ST, __DB> Queryable<__ST, __DB> for Decimal where
    __DB: Backend,
    Self: FromSql<__ST, __DB>, 

type Row = Self

The Rust type you’d like to map from.

fn build(row: Self::Row) -> Self

Construct an instance of this type

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

type Output = Decimal

The resulting type after applying the % operator.

fn rem(self, other: &Decimal) -> Decimal

Performs the % operation.

impl<'a, 'b> Rem<&'b Decimal> for &'a Decimal

type Output = Decimal

The resulting type after applying the % operator.

fn rem(self, other: &Decimal) -> Decimal

Performs the % operation.

impl Rem<Decimal> for Decimal

type Output = Decimal

The resulting type after applying the % operator.

fn rem(self, other: Decimal) -> Decimal

Performs the % operation.

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

type Output = Decimal

The resulting type after applying the % operator.

fn rem(self, other: Decimal) -> Decimal

Performs the % operation.

impl<'a> RemAssign<&'a Decimal> for Decimal

fn rem_assign(&mut self, other: &'a Decimal)

Performs the %= operation.

impl<'a> RemAssign<&'a Decimal> for &'a mut Decimal

fn rem_assign(&mut self, other: &'a Decimal)

Performs the %= operation.

impl RemAssign<Decimal> for Decimal

fn rem_assign(&mut self, other: Decimal)

Performs the %= operation.

impl<'a> RemAssign<Decimal> for &'a mut Decimal

fn rem_assign(&mut self, other: Decimal)

Performs the %= operation.

impl Serialize for Decimal

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

Serialize this value into the given Serde serializer.

impl Signed for Decimal

fn abs(&self) -> Self

Computes the absolute value.

fn abs_sub(&self, other: &Self) -> Self

The positive difference of two numbers.

fn signum(&self) -> Self

Returns the sign of the number.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

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

type Output = Decimal

The resulting type after applying the - operator.

fn sub(self, other: &Decimal) -> Decimal

Performs the - operation.

impl<'a, 'b> Sub<&'b Decimal> for &'a Decimal

type Output = Decimal

The resulting type after applying the - operator.

fn sub(self, other: &Decimal) -> Decimal

Performs the - operation.

impl Sub<Decimal> for Decimal

type Output = Decimal

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Decimal

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> SubAssign<&'a Decimal> for Decimal

fn sub_assign(&mut self, other: &'a Decimal)

Performs the -= operation.

impl<'a> SubAssign<&'a Decimal> for &'a mut Decimal

fn sub_assign(&mut self, other: &'a Decimal)

Performs the -= operation.

impl SubAssign<Decimal> for Decimal

fn sub_assign(&mut self, other: Decimal)

Performs the -= operation.

impl<'a> SubAssign<Decimal> for &'a mut Decimal

fn sub_assign(&mut self, other: Decimal)

Performs the -= operation.

impl<'a> Sum<&'a Decimal> for Decimal

fn sum<I: Iterator<Item = &'a Decimal>>(iter: I) -> Self

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

impl Sum<Decimal> for Decimal

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

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

impl ToPrimitive for Decimal

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

impl ToSql for Decimal

fn to_sql(
    &self,
    _: &Type,
    out: &mut BytesMut
) -> Result<IsNull, Box<dyn Error + Sync + Send + 'static>>

Converts the value of self into the binary format of the specified Postgres Type, appending it to out.

fn accepts(ty: &Type) -> bool

Determines if a value of this type can be converted to the specified Postgres Type.

fn to_sql_checked(
    &self,
    ty: &Type,
    out: &mut BytesMut
) -> Result<IsNull, Box<dyn Error + Sync + Send>>

An adaptor method used internally by Rust-Postgres.

impl<__DB> ToSql<Nullable<Numeric>, __DB> for Decimal where
    __DB: Backend,
    Self: ToSql<Numeric, __DB>, 

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, __DB>) -> Result

See the trait documentation.

impl ToSql<Numeric, Pg> for Decimal

fn to_sql<W: Write>(&self, out: &mut Output<'_, W, Pg>) -> Result

See the trait documentation.

impl<'a> TryFrom<&'a PgNumeric> for Decimal

type Error = Box<dyn Error + Send + Sync>

The type returned in the event of a conversion error.

fn try_from(numeric: &'a PgNumeric) -> Result<Self>

Performs the conversion.

impl TryFrom<Decimal> for f32

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Decimal) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Decimal> for f64

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: Decimal) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<PgNumeric> for Decimal

type Error = Box<dyn Error + Send + Sync>

The type returned in the event of a conversion error.

fn try_from(numeric: PgNumeric) -> Result<Self>

Performs the conversion.

impl TryFrom<f32> for Decimal

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: f32) -> Result<Self, Error>

Performs the conversion.

impl TryFrom<f64> for Decimal

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: f64) -> Result<Self, Error>

Performs the conversion.

impl UpperExp for Decimal

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

Formats the value using the given formatter.

impl Zero for Decimal

fn zero() -> Decimal

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl Copy for Decimal

impl Eq for Decimal