Struct Decimal

Source

pub struct Decimal<const N: usize> { /* private fields */ }

Expand description

§Decimal

Generic signed N-bits decimal number.

Implementations§

Source §

Converts f64 to Decimal.

Source §

Converts Decimal into isize.

Source §

impl<const N: usize> Decimal<N>

Source

pub const fn to_f32(self) -> f32

Converts Decimal into f32.

Source

pub const fn to_f64(self) -> f64

Converts Decimal into f64.

Source §

The smallest positive, normalized value that this type can represent.

Source

pub const EPSILON: Self

Machine epsilon value.

This function will panic if Decimal<N> can’t be constructed from a given string.

§Examples

use fastnum::{*, decimal::*};

assert_eq!(D256::parse_str("1.2345", Context::default()), dec256!(1.2345));

use fastnum::{*, decimal::*};

let _ = D256::parse_str("Hello", Context::default());

Source

pub const fn digits(&self) -> UInt<N>

Returns the internal big integer, representing the Coefficient of a given Decimal, including significant trailing zeros.

§Examples

use fastnum::{dec256, u256};

let a = dec256!(-123.45);
assert_eq!(a.digits(), u256!(12345));

let b = dec256!(-1.0);
assert_eq!(b.digits(), u256!(10));

Returns true if the given decimal number is the result of division by zero and false otherwise.

§Examples

use fastnum::{*, decimal::*};

let ctx = Context::default().with_signal_traps(SignalsTraps::empty());
let res = dec256!(1.0).with_ctx(ctx) / dec256!(0).with_ctx(ctx);

assert!(res.is_op_div_by_zero());

Apply new Context to the given decimal number.

Returns a copy of the value with the provided context applied.

This method updates the operational context (including the rounding mode and other contextual parameters) used by subsequent operations that may round or clamp the value (e.g., add, sub, mul, div, round, rescale, quantize, etc.).

Important:

The change is local to the returned value and does not affect other values.
If you ignore the returned value, the context update is lost.
If the value currently carries extra precision, that extra precision is reconciled immediately with the new context: it is rounded using the context’s rounding mode (and may be clamped as dictated by the context).
If the current value already has signaling flags set (e.g., INEXACT and the new context enables traps for those signals, applying this method may trigger the corresponding traps immediately, which can result in a panic (depending on the build/configuration).

§Panics:

§debug mode

This method will panic if

the current value already has some signaling flags set (e.g., INEXACT) and the new Context enables traps for those signals;
or possible extra precision rounding operation performs with some Exceptional condition and the new Context enables traps for those Exceptional condition.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Please note that this example is shared between decimal types. Which explains why D256 is used here.

use fastnum::*;

let ctx = decimal::Context::default().without_traps();
let a = dec256!(1).with_ctx(ctx);
let b = dec256!(0).with_ctx(ctx);

// No panic! We can divide by zero!
let c = a / b;
assert!(c.is_infinite());
assert!(c.is_op_div_by_zero());

See also:

Source

pub const fn with_rounding_mode(self, rm: RoundingMode) -> Self

Apply new RoundingMode to the given decimal number.

Returns a copy of the value with an updated rounding mode in its context.

This method generally does not immediately change the mathematical value; it only sets the rounding rule that will be used by subsequent operations that may round (e.g., add, sub, mul, div, round, rescale, quantize, conversions, etc.).

Important:

The change is local to the returned value and does not affect other values.
If you ignore the returned value, the rounding mode update is lost.
If the value currently carries extra precision, that extra precision is rounded using the newly provided rounding mode at the moment this method is applied. This ensures internal consistency of the stored representation with the new rounding rule.

§Panics:

§debug mode

This method will panic if possible extra precision rounding operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Please note that this example is shared between decimal types. Which explains why D256 is used here.

use fastnum::*;

let a = dec256!(1).with_rounding_mode(decimal::RoundingMode::No);
let b = dec256!(3).with_rounding_mode(decimal::RoundingMode::No);
let c = dec256!(6).with_rounding_mode(decimal::RoundingMode::No);

assert_eq!(((a / b) * c).with_rounding_mode(decimal::RoundingMode::HalfUp), dec256!(2));

See also:

More about round decimals.
RoundingMode

Source

pub const fn neg(self) -> Self

Invert the sign of the given decimal.

§Examples

use fastnum::dec256;

assert_eq!(dec256!(+1.0).neg(), dec256!(-1.0));
assert_eq!(dec256!(1.0).neg(), dec256!(-1.0));
assert_eq!(dec256!(-1.0).neg(), dec256!(1.0));

Source

pub const fn abs(self) -> Self

Get the absolute value of the decimal (non-negative sign).

§Examples

use fastnum::dec256;

assert_eq!(dec256!(1.0).abs(), dec256!(1.0));
assert_eq!(dec256!(-1.0).abs(), dec256!(1.0));

Source

pub const fn unsigned_abs(self) -> UnsignedDecimal<N>

Get the absolute value of the decimal (non-negative sign) as UnsignedDecimal.

§Examples

use fastnum::{dec256, udec256};

assert_eq!(dec256!(1.0).unsigned_abs(), udec256!(1.0));
assert_eq!(dec256!(-1.0).unsigned_abs(), udec256!(1.0));

Source

pub const fn quantum(exp: i32, ctx: Context) -> Self

The quantum of a finite number is given by: 1 × 10^exp. This is the value of a unit in the least significant position of the coefficient of a finite number.

§Examples

use fastnum::{D256, dec256, decimal::Context};

let ctx = Context::default();

assert_eq!(D256::quantum(0, ctx), dec256!(1));
assert_eq!(D256::quantum(-0, ctx), dec256!(1));
assert_eq!(D256::quantum(-3, ctx), dec256!(0.001));
assert_eq!(D256::quantum(3, ctx), dec256!(1000));

Source

pub const fn signum(&self) -> Self

Returns a number that represents the sign of self.

1.0 if the number is positive, +0.0 or INFINITY
-1.0 if the number is negative, -0.0 or NEG_INFINITY
NAN if the number is NAN

use fastnum::{D256, dec256};

let d = dec256!(3.5);

assert_eq!(d.signum(), dec256!(1.0));
assert_eq!(D256::NEG_INFINITY.signum(), dec256!(-1.0));

assert!(D256::NAN.signum().is_nan());

Source

pub const fn reduce(self) -> Self

Reduces a decimal number to its shortest (coefficient) form shifting all significant trailing zeros into the exponent.

§Examples

use fastnum::*;

let a = dec256!(-1234500);
assert_eq!(a.digits(), u256!(1234500));
assert_eq!(a.fractional_digits_count(), 0);

let b = a.reduce();
assert_eq!(b.digits(), u256!(12345));
assert_eq!(b.fractional_digits_count(), -2);

§Examples

use fastnum::dec256;

assert_eq!(dec256!(-3).clamp(dec256!(-2), dec256!(1)), dec256!(-2));
assert_eq!(dec256!(0).clamp(dec256!(-2), dec256!(1)), dec256!(0));
assert_eq!(dec256!(2).clamp(dec256!(-2), dec256!(1)), dec256!(1));

Source

pub const fn abs_sub(self, other: Self) -> Self

The positive difference of two decimal numbers.

§Examples

If self <= other: 0:0
Else: self - other

use fastnum::dec256;

assert_eq!(dec256!(1).abs_sub(dec256!(3)), dec256!(0));
assert_eq!(dec256!(3).abs_sub(dec256!(1)), dec256!(2));

Source

pub const fn lt(&self, other: &Self) -> bool

Tests signed decimal self less than other and is used by the < operator.

§Examples

use fastnum::dec256;

assert_eq!(dec256!(1.0).lt(&dec256!(1.0)), false);
assert_eq!(dec256!(1.0).lt(&dec256!(2.0)), true);
assert_eq!(dec256!(2.0).lt(&dec256!(1.0)), false);

Source

pub const fn le(&self, other: &Self) -> bool

Tests signed decimal self less than or equal to other and is used by the <= operator.

§Examples

use fastnum::dec256;

assert_eq!(dec256!(1.0).le(&dec256!(1.0)), true);
assert_eq!(dec256!(1.0).le(&dec256!(2.0)), true);
assert_eq!(dec256!(2.0).le(&dec256!(1.0)), false);

Source

pub const fn gt(&self, other: &Self) -> bool

Tests signed decimal self greater than other and is used by the > operator.

§Examples

use fastnum::dec256;

assert_eq!(dec256!(1.0).gt(&dec256!(1.0)), false);
assert_eq!(dec256!(1.0).gt(&dec256!(2.0)), false);
assert_eq!(dec256!(2.0).gt(&dec256!(1.0)), true);

Source

pub const fn ge(&self, other: &Self) -> bool

Tests signed decimal self greater than or equal to other and is used by the >= operator.

§Examples

use fastnum::dec256;

assert_eq!(dec256!(1.0).ge(&dec256!(1.0)), true);
assert_eq!(dec256!(1.0).ge(&dec256!(2.0)), false);
assert_eq!(dec256!(2.0).ge(&dec256!(1.0)), true);

Source

pub const fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

By convention, self.cmp(&other) returns the ordering matching the expression self <operator> other if true.

§Examples

use fastnum::dec256;
use std::cmp::Ordering;

assert_eq!(dec256!(5).cmp(&dec256!(10)), Ordering::Less);
assert_eq!(dec256!(10).cmp(&dec256!(5)), Ordering::Greater);
assert_eq!(dec256!(5).cmp(&dec256!(5)), Ordering::Equal);

Source

pub const fn add(self, rhs: Self) -> Self

Calculates self + rhs.

Is internally used by the + operator.

§Panics:

§debug mode

This method will panic if addition operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

let a = D256::ONE;
let b = D256::TWO;

let c = a + b;
assert_eq!(c, dec256!(3));

Panics if overflowed:

use fastnum::*;

let a = D256::MAX;
let b = D256::MAX;

let c = a + b;

See more about add and subtract.

Source

pub const fn sub(self, rhs: Self) -> Self

Calculates self – rhs.

Is internally used by the - operator.

§Panics:

§debug mode

This method will panic if subtract operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

let a = D256::ONE;
let b = D256::TWO;

let c = a - b;
assert_eq!(c, dec256!(-1));

Panics if overflowed:

use fastnum::*;

let a = D256::MAX;
let b = -D256::MAX;

let c = a - b;

See more about add and subtract.

Source

pub const fn mul(self, rhs: Self) -> Self

Calculates self × rhs.

Is internally used by the * operator.

§Panics:

§debug mode

This method will panic if multiplication operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

let a = D256::FIVE;
let b = D256::TWO;

let c = a * b;
assert_eq!(c, dec256!(10));

Panics if overflowed:

use fastnum::*;

let a = D256::MAX;
let b = D256::MAX;

let c = a * b;

See more about multiplication.

Source

pub const fn div(self, rhs: Self) -> Self

Calculates self ÷ rhs.

Is internally used by the / operator.

§Panics:

§debug mode

This method will panic if divide operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

let a = D256::FIVE;
let b = D256::TWO;

let c = -a / b;
assert_eq!(c, dec256!(-2.5));

Panics if divided by zero:

use fastnum::{dec256, D256};

let a = D256::ONE;
let b = D256::ZERO;

let c = a / b;

See more about division.

Source

pub const fn rem(self, rhs: Self) -> Self

Calculates self % rhs.

Is internally used by the % operator.

§Panics:

§debug mode

This method will panic if reminder operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

let a = D256::FIVE;
let b = D256::TWO;

let c = a % b;
assert_eq!(c, dec256!(1));

Source

pub const fn pow(self, n: Self) -> Self

Raise a decimal number to decimal power.

Using this function is generally slower than using powi for integer powers or sqrt method for 1/2 exponent.

§Precision

Since the result of power operation is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if power operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec256!(4).pow(dec256!(0.5)), dec256!(2));
assert_eq!(dec256!(8).pow(dec256!(1) / dec256!(3)), dec256!(2));

See more about the power operation.

Source

pub const fn powi(self, n: i32) -> Self

Raise a decimal number to an integer power.

Using this function is generally faster than using pow

§Panics:

§debug mode

This method will panic if power operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec256!(2).powi(3), dec256!(8));
assert_eq!(dec256!(9).powi(2), dec256!(81));
assert_eq!(dec256!(1).powi(-2), dec256!(1));
assert_eq!(dec256!(10).powi(20), dec256!(1e20));
assert_eq!(dec256!(4).powi(-2), dec256!(0.0625));

See more about the power operation.

Source

pub const fn sqrt(self) -> Self

Take the square root of the decimal number using Heron’s method, a special case of Newton’s method.

Returns NaN if self is a negative number other than -0.0.

§Precision

Since the result of square root operation is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if square root operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec128!(4).sqrt(), dec128!(2));
assert_eq!(dec128!(1).sqrt(), dec128!(1));
assert_eq!(dec128!(16).sqrt(), dec128!(4));
assert_eq!(dec128!(2).sqrt(), D128::SQRT_2);

See more about the square-root operation.

Source

pub const fn cbrt(self) -> Self

Take the cubic root of a decimal number using Newton’s method.

§Precision

Since the result of cubic root operation is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if cubic root operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec128!(8).cbrt(), dec128!(2));

See more about the N-th root operation.

Source

pub const fn nth_root(self, n: u32) -> Self

Take the N-th root of the decimal number using Newton’s method.

§Precision

Since the result of N-th root operation is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if N-th root operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec128!(16).nth_root(4), dec128!(2));

See more about the N-th root operation.

Source

pub const fn exp(self) -> Self

Returns e^self, (the exponential function).

§Precision

Since the result of exponential function is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if exponent calculation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec128!(1).exp(), D128::E);

See more about the exponential function.

Source

pub const fn exp_m1(self) -> Self

Returns e^self – 1.

§Precision

Since the result of exponential function is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if exponent calculation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::{*, decimal::RoundingMode::*};

// For exact result we need to use extra precision digits and no-rounding mode to keep precision between `.ln()` and `exp()` calls.
// Than we can use default rounding mode for round extra digits.
assert_eq!(dec128!(7.0).with_rounding_mode(No).ln().exp_m1().with_rounding_mode(HalfUp), D128::SIX);

See more about the exponential function.

Source

pub const fn exp2(self) -> Self

Returns 2^self, (the binary exponential function).

§Precision

Since the result of binary exponential function is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if binary exponential function performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec128!(0).exp2(), dec128!(1));
assert_eq!(dec128!(1).exp2(), dec128!(2));
assert_eq!(dec128!(2).exp2(), dec128!(4));
assert_eq!(dec128!(3).exp2(), dec128!(8));

See more about the binary exponential function.

Source

pub const fn ln(self) -> Self

Returns the natural logarithm of the decimal number.

§Precision

Since the result of natural logarithm is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if logarithm operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Please note that this example is shared between decimal types. Which explains why D256 is used here.

use fastnum::*;

assert_eq!(dec256!(2).ln(), D256::LN_2);
assert_eq!(D256::E.ln(), D256::ONE);

See also:

More about the logarithm function.

Source

pub const fn ln_1p(self) -> Self

Returns natural logarithm ln(1 + self) more accurately than if the operations were performed separately.

§Precision

Since the result of natural logarithm is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if logarithm operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Please note that this example is shared between decimal types. Which explains why D256 is used here.

use fastnum::*;

assert_eq!((D256::E - dec256!(1)).ln_1p(), dec256!(1));

See also:

More about the logarithm function.

Source

pub const fn log(self, base: Self) -> Self

Returns the logarithm of the decimal number with respect to the given arbitrary base.

§Precision

Since the result of logarithm is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if logarithm operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Please note that this example is shared between decimal types. Which explains why D256 is used here.

use fastnum::*;

assert_eq!(dec256!(64).log(dec256!(2)), dec256!(6));
assert_eq!(dec256!(27).log(dec256!(3)), dec256!(3));
assert_eq!(dec256!(15625).log(dec256!(5)), dec256!(6));

See also:

More about the logarithm function.

Source

pub const fn log2(self) -> Self

Returns the binary logarithm of the given decimal number.

§Precision

Since the result of logarithm is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if logarithm operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Please note that this example is shared between decimal types. Which explains why D256 is used here.

use fastnum::*;

assert_eq!(dec256!(64).log2(), dec256!(6));
assert_eq!(dec256!(32).log2(), dec256!(5));
assert_eq!(dec256!(1024).log2(), dec256!(10));
assert_eq!(dec256!(0.5).log2(), dec256!(-1));
assert_eq!(dec256!(0.25).log2(), dec256!(-2));
assert_eq!(dec256!(10).log2(), D256::LOG2_10);

See also:

More about the logarithm function.

Source

pub const fn log10(self) -> Self

Returns the decimal logarithm of the given decimal number.

§Precision

Since the result of logarithm is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if logarithm operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Please note that this example is shared between decimal types. Which explains why D256 is used here.

use fastnum::*;

assert_eq!(dec256!(100).log10(), dec256!(2));
assert_eq!(dec256!(1000).log10(), dec256!(3));
assert_eq!(dec256!(0.1).log10(), dec256!(-1));
assert_eq!(dec256!(0.01).log10(), dec256!(-2));
assert_eq!(dec256!(2).log10(), D256::LOG10_2);

See also:

More about the logarithm function.

Source

pub const fn hypot(self, other: Self) -> Self

Calculate the length of the hypotenuse of a right-angle triangle given legs of length x and y.

§Panics:

§debug mode

This method will panic if hypotenuse calculate operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::dec256;

let x = dec256!(2);
let y = dec256!(3);

// sqrt(x^2 + y^2)
assert_eq!(x.hypot(y), (x.powi(2) + y.powi(2)).sqrt());

Source

pub const fn mul_add(self, a: Self, b: Self) -> Self

Fused multiply-add. Computes (self * a) + b with only one rounding error, yielding a more accurate result than an unfused multiply-add.

§Panics:

§debug mode

This method will panic if multiply-add operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec128!(10.0).mul_add(dec128!(4.0), dec128!(60)), dec128!(100));

See more about the fused multiply-add function.

Source

pub const fn round(self, digits: i16) -> Self

Returns the given decimal number rounded to digits precision after the decimal point, using RoundingMode from it Context.

§Panics:

§debug mode

This method will panic if round operation (up-scale or down-scale) performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

use fastnum::{*, decimal::{*, RoundingMode::*}};

let n = dec256!(129.41675);

// Default rounding mode is `HalfUp`
assert_eq!(n.round(2),  dec256!(129.42));

assert_eq!(n.with_rounding_mode(Up).round(2), dec256!(129.42));
assert_eq!(n.with_rounding_mode(Down).round(-1), dec256!(120));
assert_eq!(n.with_rounding_mode(HalfEven).round(4), dec256!(129.4168));

See also:

More about round decimals.
RoundingMode.

Source

pub const fn trunc(self) -> Self

Truncates the decimal number to integral with no fractional portion.

This is a true truncation whereby no rounding is performed. This operation is equivalent to Self::rescale or Self::trunc_with_scale with scale set to 0.

§Performance

This operation is typically much faster than Self::rescale

§Panics:

§debug mode

This method will panic if truncate operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Please note that this example is shared between decimal types. Which explains why D256 is used here.

use fastnum::*;

assert_eq!(dec256!(3.141).trunc(), dec256!(3));
assert_eq!(dec256!(2.9).trunc(), dec256!(2));
assert_eq!(dec256!(-1.98765).trunc(), dec256!(-1));

let ctx = decimal::Context::default().without_traps();

assert!(D256::INFINITY.with_ctx(ctx).trunc().is_nan());
assert!(D256::NEG_INFINITY.with_ctx(ctx).trunc().is_nan());
assert!(D256::NAN.with_ctx(ctx).trunc().is_nan());

See also:

Source

pub const fn trunc_with_scale(self, scale: i16) -> Self

Truncates the decimal number to the given number of digits after the decimal point.

This is a true truncation whereby no rounding is performed. This operation is equivalent to Self::rescale.

§Performance

This operation is typically much faster than Self::rescale

§Panics:

§debug mode

This method will panic if truncate operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Please note that this example is shared between decimal types. Which explains why D256 is used here.

use fastnum::*;

assert_eq!(dec256!(3.141592).trunc_with_scale(2), dec256!(3.14));
assert_eq!(dec256!(3.141592).trunc_with_scale(3), dec256!(3.141));
assert_eq!(dec256!(3.141592).trunc_with_scale(4), dec256!(3.1415));
assert_eq!(dec256!(3.141592).trunc_with_scale(5), dec256!(3.14159));
assert_eq!(dec256!(3.141592).trunc_with_scale(6), dec256!(3.141592));
assert_eq!(dec256!(-1.98765).trunc_with_scale(1), dec256!(-1.9));

let ctx = decimal::Context::default().without_traps();

assert!(D256::INFINITY.with_ctx(ctx).trunc_with_scale(1).is_nan());
assert!(D256::NEG_INFINITY.with_ctx(ctx).trunc_with_scale(1).is_nan());
assert!(D256::NAN.with_ctx(ctx).trunc_with_scale(1).is_nan());

See also:

Source

pub const fn floor(self) -> Self

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

§Examples

use fastnum::*;

assert_eq!(dec256!(3.99).floor(), dec256!(3));
assert_eq!(dec256!(3.0).floor(), dec256!(3));
assert_eq!(dec256!(3.01).floor(), dec256!(3));
assert_eq!(dec256!(3.5).floor(), dec256!(3));
assert_eq!(dec256!(4.0).floor(), dec256!(4));

assert_eq!(dec256!(-3.01).floor(), dec256!(-4));
assert_eq!(dec256!(-3.1).floor(), dec256!(-4));
assert_eq!(dec256!(-3.5).floor(), dec256!(-4));
assert_eq!(dec256!(-4.0).floor(), dec256!(-4));

Source

pub const fn ceil(self) -> Self

Finds the nearest integer greater than or equal to x.

§Examples

use fastnum::*;

assert_eq!(dec256!(3.01).ceil(), dec256!(4));
assert_eq!(dec256!(3.99).ceil(), dec256!(4));
assert_eq!(dec256!(4.0).ceil(), dec256!(4));
assert_eq!(dec256!(1.0001).ceil(), dec256!(2));
assert_eq!(dec256!(1.00001).ceil(), dec256!(2));
assert_eq!(dec256!(1.000001).ceil(), dec256!(2));
assert_eq!(dec256!(1.00000000000001).ceil(), dec256!(2));

assert_eq!(dec256!(-3.01).ceil(), dec256!(-3));
assert_eq!(dec256!(-3.5).ceil(), dec256!(-3));
assert_eq!(dec256!(-4.0).ceil(), dec256!(-4));

Source

pub const fn rescale(self, new_scale: i16) -> Self

Returns the given decimal number re-scaled to digits precision after the decimal point.

§Panics:

§debug mode

This method will panic if rescale operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

use fastnum::{*, decimal::*};

assert_eq!(dec256!(2.17).rescale(3), dec256!(2.170));
assert_eq!(dec256!(2.17).rescale(2), dec256!(2.17));
assert_eq!(dec256!(2.17).rescale(1), dec256!(2.2));
assert_eq!(dec256!(2.17).rescale(0), dec256!(2));
assert_eq!(dec256!(2.17).rescale(-1), dec256!(0));

let ctx = Context::default().without_traps();

assert!(D256::INFINITY.with_ctx(ctx).rescale(2).is_nan());
assert!(D256::NEG_INFINITY.with_ctx(ctx).rescale(2).is_nan());
assert!(D256::NAN.with_ctx(ctx).rescale(1).is_nan());

See also:

More about rescale decimals.
Self::quantize.

Source

pub const fn quantize(self, other: Self) -> Self

Returns a value equal to self (rounded), having the exponent of other.

§Panics:

§debug mode

This method will panic if quantize operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

use fastnum::{*, decimal::*};

let ctx = Context::default().without_traps();

assert_eq!(dec256!(2.17).quantize(dec256!(0.001)), dec256!(2.170));
assert_eq!(dec256!(2.17).quantize(dec256!(0.01)), dec256!(2.17));
assert_eq!(dec256!(2.17).quantize(dec256!(0.1)), dec256!(2.2));
assert_eq!(dec256!(2.17).quantize(dec256!(1e+0)), dec256!(2));
assert_eq!(dec256!(2.17).quantize(dec256!(1e+1)), dec256!(0));

assert_eq!(D256::NEG_INFINITY.quantize(D256::INFINITY), D256::NEG_INFINITY);

assert!(dec256!(2).with_ctx(ctx).quantize(D256::INFINITY).is_nan());

assert_eq!(dec256!(-0.1).quantize(dec256!(1)), dec256!(-0));
assert_eq!(dec256!(-0).quantize(dec256!(1e+5)), dec256!(-0E+5));

assert!(dec128!(0.34028).with_ctx(ctx).quantize(dec128!(1e-32765)).is_nan());
assert!(dec128!(-0.34028).with_ctx(ctx).quantize(dec128!(1e-32765)).is_nan());

assert_eq!(dec256!(217).quantize(dec256!(1e-1)), dec256!(217.0));
assert_eq!(dec256!(217).quantize(dec256!(1e+0)), dec256!(217));
assert_eq!(dec256!(217).quantize(dec256!(1e+1)), dec256!(2.2E+2));
assert_eq!(dec256!(217).quantize(dec256!(1e+2)), dec256!(2E+2));

See also:

More about quantize decimals.
Self::rescale.

Source

pub const fn is_ok(&self) -> bool

Returns:

true if no Exceptional condition Signals flag has been trapped by Context trap-enabler, and
false otherwise.

Source

pub const fn ok(self) -> Option<Self>

Returns:

Some(Self) if no Exceptional condition Signals flag has been trapped by Context trap-enabler, and
None otherwise.

Source

pub const fn recip(self) -> Self

Takes the reciprocal (inverse) of a number, 1/x.

§Precision

Since the result of reciprocal is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if reciprocal operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

use fastnum::*;

assert_eq!(dec256!(2).recip(), dec256!(0.5));

Source

pub const fn to_degrees(self) -> Self

Converts radians to degrees.

§Panics:

§debug mode

This method will panic if conversion performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

use fastnum::*;

assert_eq!(D128::PI.to_degrees(), dec128!(180));
assert_eq!(D128::TAU.to_degrees(), dec128!(360));

Source

pub const fn to_radians(self) -> Self

Converts degrees to radians.

§Panics:

§debug mode

This method will panic if conversion performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

use fastnum::*;

assert_eq!(dec128!(180).to_radians(), D128::PI);
assert_eq!(dec128!(360).to_radians(), D128::TAU);

Source

pub fn to_scientific_notation(&self) -> String

Create a string of this decimal in scientific notation.

§Examples

use fastnum::dec256;

let n = dec256!(-12345678);
assert_eq!(&n.to_scientific_notation(), "-1.2345678e7");

Source

pub fn to_engineering_notation(&self) -> String

Create a string of this decimal in engineering notation.

Engineering notation is scientific notation with the exponent coerced to a multiple of three

§Examples

use fastnum::dec256;

let n = dec256!(-12345678);
assert_eq!(&n.to_engineering_notation(), "-12.345678e6");

Source

pub const fn transmute<const M: usize>(self) -> Decimal<M>

👎Deprecated since 0.5.0

Deprecated, use resize instead.

Source

pub const fn resize<const M: usize>(self) -> Decimal<M>

Safety resizes the underlying decimal to use M limbs while preserving the numeric value when possible.

This operation can either widen or narrow the internal representation:

Widening (M >= N) is lossless: the value is preserved.
Narrowing (M < N) may reduce available capacity. In this case the value is rounded according to the current Context and corresponding status flags are set.

Behavior details:

Rounding: extra precision is rounded using the active RoundingMode from the current context.
Signals: status flags such as Inexact, Rounded, Clamped, Overflow, or Underflow may be raised depending on the operation outcome and context limits.

Note: lossless, no-rounding conversions.

If you need to change width without any rounding:

Use crate::Cast for guaranteed-lossless widening (value-preserving by definition).
Use crate::TryCast for potential narrowing without rounding; it returns an error if the value does not fit into the target width, thus guaranteeing no silent rounding or truncation.

§Performance

This operation is typically much slower than crate::Cast and crate::TryCast transformations.

§Panics:

§debug mode

This method will panic if resize operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Please note that this example is shared between decimal types. Which explains why D64 is used here.

§Lossless widening:

use fastnum::*;

let x = dec64!(123.45);

// Increase internal width from 2 to 4 limbs — value is preserved.
let y: D128 = x.resize();
assert_eq!(y, dec128!(123.45));
assert!(y.is_op_ok());

§Narrowing with possible rounding:

use fastnum::*;

let x = dec128!(1.8446744073709551616);

// Reduce width; value may be rounded according to context.
let y: D64 = x.resize();
// Rounding/precision-loss indicators may be set, depending on capacity and context:
assert_eq!(y, dec64!(1.844674407370955162));
assert!(y.is_op_inexact() && y.is_op_rounded());

Since the result of trigonometric sine is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if trigonometric sine operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(D128::FRAC_PI_2.sin(), dec128!(1));

See more about the trigonometric functions.

Source

pub const fn cos(self) -> Self

Computes cos(self) (trigonometric cosine of decimal number in radians).

§Precision

Since the result of trigonometric cosine is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if trigonometric cosine operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(D128::TAU.cos(), dec128!(1));

See more about the trigonometric functions.

Source

pub const fn tan(self) -> Self

Computes tan(self) (trigonometric tangent of decimal number in radians).

§Precision

Since the result of trigonometric tangent is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if trigonometric tangent operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(D128::FRAC_PI_4.tan(), dec128!(1));

See more about the trigonometric functions.

Source

pub const fn asin(self) -> Self

Computes arcsin(self) (trigonometric arcsine of decimal number).

Return value is in radians in the range [-π/2, π/2] or NaN if the number is outside the range [-1, 1].

§Precision

Since the result of trigonometric arcsine is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if trigonometric arcsine operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(D128::FRAC_PI_2.sin().asin(), D128::FRAC_PI_2);

See more about the trigonometric functions.

Source

pub const fn acos(self) -> Self

Computes arccos(self) (trigonometric arccosine of decimal number).

Return value is in radians in the range [0, π] or NaN if the number is outside the range [-1, 1].

§Precision

Since the result of trigonometric arccosine is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if trigonometric arccosine operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec256!(1).acos(), dec256!(0));

See more about the trigonometric functions.

Source

pub const fn atan(self) -> Self

Computes arctan(self) (trigonometric arctangent of decimal number).

Return value is in radians in the range [-π/2, π/2].

§Precision

Since the result of trigonometric arctangent is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if trigonometric arctangent operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(D128::ZERO.atan(), D128::ZERO);
assert_eq!(D128::ONE.atan(), D128::FRAC_PI_4);
assert_eq!(D128::ONE.neg().atan(), D128::FRAC_PI_4.neg());

See more about the trigonometric functions.

Source

pub const fn atan2(self, other: Self) -> Self

Computes the four quadrant arctangent of self (y) and other (x).

x = 0, y = 0: 0
x >= 0: arctan(y/x) -> [-π/2, π/2]
y >= 0: arctan(y/x) + π -> (pi/2, π]
y < 0: arctan(y/x) - π -> (-π, -π/2)

§Precision

Since the result of trigonometric 2-argument arctangent is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if trigonometric 2-argument arctangent operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec128!(-3.0).atan2(dec128!(3.0)), D128::FRAC_PI_4.neg());
assert_eq!(dec128!(3.0).atan2(dec128!(-3.0)), D128::FRAC_PI_4 * D128::THREE);

See more about the trigonometric functions.

Source

pub const fn sin_cos(self) -> (Self, Self)

Simultaneously computes the sine and cosine of the number, x. Returns (sin(x), cos(x)).

§Precision

Since the result of trigonometric sine and cosine function is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if trigonometric sine and cosine computation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(D128::FRAC_PI_2.sin_cos(), (dec128!(1), dec128!(0)));

See more about the trigonometric functions.

Source

pub const fn sinh(self) -> Self

Computes sinh(self) (hyperbolic sine of decimal number).

§Precision

Since the result of hyperbolic sine is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if hyperbolic sine operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec128!(1).sinh(), (D128::E * D128::E - dec128!(1.0)) / (dec128!(2.0) * D128::E));

See more about the trigonometric functions.

Source

pub const fn cosh(self) -> Self

Computes cosh(self) (hyperbolic cosine of decimal number).

§Precision

Since the result of hyperbolic cosine is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if hyperbolic cosine operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec256!(1).cosh(), (D256::E * D256::E + dec256!(1.0)) / (dec256!(2.0) * D256::E));

See more about the trigonometric functions.

Source

pub const fn tanh(self) -> Self

Computes tanh(self) (hyperbolic tangent of decimal number).

§Precision

Since the result of hyperbolic tangent is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if hyperbolic tangent operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

let e2 = D128::E * D128::E;
assert_eq!(dec128!(1).tanh(), (e2 - dec128!(1.0)) / (e2 + dec128!(1.0)));

See more about the trigonometric functions.

Source

pub const fn asinh(self) -> Self

Computes arsinh(self) (inverse hyperbolic sine of decimal number).

§Precision

Since the result of inverse hyperbolic sine is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if inverse hyperbolic sine operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec128!(1).sinh().asinh(), dec128!(1));

See more about the trigonometric functions.

Source

pub const fn acosh(self) -> Self

Computes arcosh(self) (inverse hyperbolic cosine of decimal number).

§Precision

Since the result of inverse hyperbolic cosine is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if inverse hyperbolic cosine operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(dec128!(1).cosh().acosh(), dec128!(1));

See more about the trigonometric functions.

Source

pub const fn atanh(self) -> Self

Computes artanh(self) (inverse hyperbolic tangent of decimal number).

§Precision

Since the result of inverse hyperbolic tangent is irrational number, it can usually only be computed to some finite precision from a series of increasingly accurate approximations.

The result of this operation is mostly inexact and raises OP_INEXACT signal.

§Panics:

§debug mode

This method will panic if inverse hyperbolic tangent operation performs with some Exceptional condition and corresponding Signals in the Context is trapped by trap-enabler.

§release mode

In release mode panic will not occur and result can be one of Special values(NaN or ±Infinity).

§Examples

Basic usage:

use fastnum::*;

assert_eq!(D256::ZERO.tanh().atanh(), D256::ZERO);

See more about the trigonometric functions.

Source

pub const fn from_unsigned(ud: UnsignedDecimal<N>) -> Self

Converts from UnsignedDecimal to a signed Decimal number.

§Examples

use fastnum::*;

let d = udec256!(1.2345);

assert_eq!(D256::from_unsigned(d), dec256!(1.2345));

Source

pub const fn try_to_unsigned(self) -> Result<UnsignedDecimal<N>, DecimalError>

Try converts from Decimal to UnsignedDecimal.

§Examples

use fastnum::*;

assert_eq!(dec256!(1.2345).try_to_unsigned(), Ok(udec256!(1.2345)));
assert!(dec256!(-1.2345).try_to_unsigned().is_err());

impl<const N: usize> Hash for Decimal<N>

Source §

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

Feeds this value into the given Hasher. Read more

1.3.0 · Source§

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

Feeds a slice of this type into the given Hasher. Read more

Source §

impl<const N: usize> Ord for Decimal<N>

Source §

fn cmp(&self, rhs: &Self) -> Ordering

This method returns an Ordering between self and other. Read more

1.21.0 (const: unstable) · Source§

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

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

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Struct Decimal Copy item path

§Decimal

Implementations§

impl<const N: usize> Decimal<N>

pub const fn from_u8(n: u8) -> Self

pub const fn from_u16(n: u16) -> Self

pub const fn from_u32(n: u32) -> Self

pub const fn from_u64(n: u64) -> Self

pub const fn from_u128(n: u128) -> Result<Self, ParseError>

pub const fn from_usize(n: usize) -> Self

pub const fn from_i8(n: i8) -> Self

pub const fn from_i16(n: i16) -> Self

pub const fn from_i32(n: i32) -> Self

pub const fn from_i64(n: i64) -> Self

pub const fn from_i128(n: i128) -> Result<Self, ParseError>

pub const fn from_isize(n: isize) -> Self

pub const fn from_f32(n: f32) -> Self

pub const fn from_f64(n: f64) -> Self

impl<const N: usize> Decimal<N>

pub const fn to_u8(self) -> Result<u8, ParseError>

pub const fn to_u16(self) -> Result<u16, ParseError>

pub const fn to_u32(self) -> Result<u32, ParseError>

pub const fn to_u64(self) -> Result<u64, ParseError>

pub const fn to_u128(self) -> Result<u128, ParseError>

pub const fn to_usize(self) -> Result<usize, ParseError>

pub const fn to_i8(self) -> Result<i8, ParseError>

pub const fn to_i16(self) -> Result<i16, ParseError>

pub const fn to_i32(self) -> Result<i32, ParseError>

pub const fn to_i64(self) -> Result<i64, ParseError>

pub const fn to_i128(self) -> Result<i128, ParseError>

pub const fn to_isize(self) -> Result<isize, ParseError>

impl<const N: usize> Decimal<N>

pub const fn to_f32(self) -> f32

pub const fn to_f64(self) -> f64

impl<const N: usize> Decimal<N>

pub const NAN: Self

pub const INFINITY: Self

pub const NEG_INFINITY: Self

pub const MIN: Self

pub const MAX: Self

pub const MIN_POSITIVE: Self

pub const EPSILON: Self

pub const ZERO: Self

pub const ONE: Self

pub const TWO: Self

pub const THREE: Self

pub const FOUR: Self

pub const FIVE: Self

pub const SIX: Self

pub const SEVEN: Self

pub const EIGHT: Self

pub const NINE: Self

pub const TEN: Self

pub const HALF: Self

pub const E: Self

pub const PI: Self

pub const TAU: Self

pub const FRAC_1_PI: Self

pub const FRAC_2_PI: Self

pub const FRAC_PI_2: Self

pub const FRAC_PI_3: Self

pub const FRAC_PI_4: Self

pub const FRAC_PI_6: Self

pub const FRAC_PI_8: Self

pub const FRAC_2_SQRT_PI: Self

pub const LN_2: Self

pub const LN_10: Self

pub const LOG2_E: Self

pub const LOG10_E: Self

pub const SQRT_2: Self

pub const FRAC_1_SQRT_2: Self

pub const LOG10_2: Self

pub const LOG2_10: Self

impl<const N: usize> Decimal<N>

pub const fn from_parts( digits: UInt<N>, exp: i32, sign: Sign, ctx: Context, ) -> Self

§Examples

pub const fn from_str(s: &str, ctx: Context) -> Result<Self, ParseError>

§Examples

pub const fn parse_str(s: &str, ctx: Context) -> Self

§Panics

Struct Decimal