Struct UnsignedDecimal

Source

pub struct UnsignedDecimal<const N: usize>(/* private fields */);

Expand description

§Unsigned Decimal

Generic unsigned N-bits decimal number.

Implementations§

Source §

Source

pub const fn to_f32(self) -> f32

Converts UnsignedDecimal into f32.

Source

pub const fn to_f64(self) -> f64

Converts UnsignedDecimal into f64.

Source §

Machine epsilon value.

The full circle constant (τ)

log₂(10).

Source §

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

§Examples

Basic usage:

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

assert_eq!(UD256::parse_str("1.2345", Context::default()), udec256!(1.2345));

Should panic:

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

let _ = UD256::parse_str("-1.2345", Context::default());

Source

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

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

§Examples

use fastnum::{udec256, u256};

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

let b = udec256!(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().without_traps();
let res = udec256!(1.0).with_ctx(ctx) / udec256!(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 UD256 is used here.

use fastnum::*;

let ctx = decimal::Context::default().without_traps();
let a = udec256!(1).with_ctx(ctx);
let b = udec256!(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 UD256 is used here.

use fastnum::*;

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

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

See also:

More about round decimals.
RoundingMode

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::{*, decimal::*};

let ctx = Context::default();

assert_eq!(UD256::quantum(0, ctx), udec256!(1));
assert_eq!(UD256::quantum(-0, ctx), udec256!(1));
assert_eq!(UD256::quantum(-3, ctx), udec256!(0.001));
assert_eq!(UD256::quantum(3, ctx), udec256!(1000));

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::{udec256, u256, decimal::Context};

let a = udec256!(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);

Source

pub const fn neg(self) -> Decimal<N>

Invert sign of the given unsigned decimal.

§Examples

use fastnum::*;

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

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::udec256;
use std::cmp::Ordering;

assert_eq!(udec256!(5).cmp(&udec256!(10)), Ordering::Less);
assert_eq!(udec256!(10).cmp(&udec256!(5)), Ordering::Greater);
assert_eq!(udec256!(5).cmp(&udec256!(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 = UD256::ONE;
let b = UD256::TWO;

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

Panics if overflowed:

use fastnum::*;

let a = UD256::MAX;
let b = UD256::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 = UD256::FIVE;
let b = UD256::TWO;

let c = a - b;
assert_eq!(c, udec256!(3));

Panics if overflowed:

use fastnum::*;

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

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 = UD256::FIVE;
let b = UD256::TWO;

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

Panics if overflowed:

use fastnum::*;

let a = UD256::MAX;
let b = UD256::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 = UD256::FIVE;
let b = UD256::TWO;

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

Panics if divided by zero:

use fastnum::*;

let a = UD256::ONE;
let b = UD256::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 = UD256::FIVE;
let b = UD256::TWO;

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

Source

pub const fn recip(self) -> Self

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

§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).

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

§Examples

use fastnum::*;

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

Source

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

Raise an unsigned decimal number to decimal power.

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

§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!(udec256!(4).pow(dec256!(0.5)), udec256!(2));
assert_eq!(udec256!(8).pow(dec256!(1) / dec256!(3)), udec256!(2));

See more about the power operation.

Source

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

Raise an unsigned 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!(udec256!(2).powi(3), udec256!(8));
assert_eq!(udec256!(9).powi(2), udec256!(81));
assert_eq!(udec256!(1).powi(-2), udec256!(1));
assert_eq!(udec256!(10).powi(20), udec256!(1e20));
assert_eq!(udec256!(4).powi(-2), udec256!(0.0625));

See more about the power operation.

Source

pub const fn sqrt(self) -> Self

Take the square root of the unsigned decimal number.

Square-root can also be calculated by using the power operation (with a second operand of 0.5). The result in that case will not be exact and may not be correctly rounded.

§Panics:

§debug mode

This method will panic if sqrt 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!(udec128!(4).sqrt(), udec128!(2));
assert_eq!(udec128!(1).sqrt(), udec128!(1));
assert_eq!(udec128!(16).sqrt(), udec128!(4));

See more about the square-root operation.

Source

pub const fn exp(self) -> Self

Returns e^self, (the exponential function).

§Panics:

§debug mode

This method will panic if exponent 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!(udec128!(1).exp(), UD128::E);

See more about the exponential function.

Source

pub const fn ln(self) -> Decimal<N>

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 UD256 is used here.

use fastnum::*;

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

See also:

More about the logarithm function.

Source

pub const fn ln_1p(self) -> Decimal<N>

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 UD256 is used here.

use fastnum::*;

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

See also:

More about the logarithm function.

Source

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

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 UD256 is used here.

use fastnum::*;

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

See also:

More about the logarithm function.

Source

pub const fn log2(self) -> Decimal<N>

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 UD256 is used here.

use fastnum::*;

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

See also:

More about the logarithm function.

Source

pub const fn log10(self) -> Decimal<N>

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 UD256 is used here.

use fastnum::*;

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

See also:

More about the logarithm function.

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!(udec128!(10.0).mul_add(udec128!(4.0), udec128!(60)), udec128!(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 = udec256!(129.41675);

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

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

See also:

More about round decimals.
RoundingMode.

Source

pub const fn floor(self) -> Self

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

§Examples

use fastnum::*;

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

Source

pub const fn ceil(self) -> Self

Finds the nearest integer greater than or equal to x.

§Examples

use fastnum::*;

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

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!(udec256!(2.17).rescale(3), udec256!(2.170));
assert_eq!(udec256!(2.17).rescale(2), udec256!(2.17));
assert_eq!(udec256!(2.17).rescale(1), udec256!(2.2));
assert_eq!(udec256!(2.17).rescale(0), udec256!(2));
assert_eq!(udec256!(2.17).rescale(-1), udec256!(0));

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

assert!(UD256::INFINITY.with_ctx(ctx).rescale(2).is_nan());
assert!(UD256::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!(udec256!(2.17).quantize(udec256!(0.001)), udec256!(2.170));
assert_eq!(udec256!(2.17).quantize(udec256!(0.01)), udec256!(2.17));
assert_eq!(udec256!(2.17).quantize(udec256!(0.1)), udec256!(2.2));
assert_eq!(udec256!(2.17).quantize(udec256!(1e+0)), udec256!(2));
assert_eq!(udec256!(2.17).quantize(udec256!(1e+1)), udec256!(0));

assert_eq!(UD256::INFINITY.quantize(UD256::INFINITY), UD256::INFINITY);

assert!(udec256!(2).with_ctx(ctx).quantize(UD256::INFINITY).is_nan());

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

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

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

See also:

More about quantize decimals.
Self::rescale.

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 UD256 is used here.

use fastnum::*;

assert_eq!(udec256!(3.141).trunc(), udec256!(3));
assert_eq!(udec256!(2.9).trunc(), udec256!(2));

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

assert!(UD256::INFINITY.with_ctx(ctx).trunc().is_nan());
assert!(UD256::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 UD256 is used here.

use fastnum::*;

assert_eq!(udec256!(3.141592).trunc_with_scale(2), udec256!(3.14));
assert_eq!(udec256!(3.141592).trunc_with_scale(3), udec256!(3.141));
assert_eq!(udec256!(3.141592).trunc_with_scale(4), udec256!(3.1415));
assert_eq!(udec256!(3.141592).trunc_with_scale(5), udec256!(3.14159));
assert_eq!(udec256!(3.141592).trunc_with_scale(6), udec256!(3.141592));

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

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

See also:

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 fn to_scientific_notation(&self) -> String

Create a string of this unsigned decimal in scientific notation.

§Examples

use fastnum::udec256;

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

Source

pub fn to_engineering_notation(&self) -> String

Create a string of this unsigned decimal in engineering notation.

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

§Examples

use fastnum::udec256;

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

Source

pub const fn to_signed(self) -> Decimal<N>

Converts the given unsigned decimal to a signed decimal number.

§Examples

use fastnum::*;

let d = udec256!(1.2345);

assert_eq!(d.to_signed(), dec256!(1.2345));

Source

pub const fn try_from_signed(d: Decimal<N>) -> Result<Self, DecimalError>

Try converts from Decimal to UnsignedDecimal.

§Examples

use fastnum::*;

assert_eq!(UD256::try_from_signed(dec256!(1.2345)), Ok(udec256!(1.2345)));
assert!(UD256::try_from_signed(dec256!(-1.2345)).is_err());

Source

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

👎Deprecated since 0.5.0

Deprecated, use resize instead.

Source

pub const fn resize<const M: usize>(self) -> UnsignedDecimal<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 UD64 is used here.

§Lossless widening:

use fastnum::*;

let x = udec64!(123.45);

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

§Narrowing with possible rounding:

use fastnum::*;

let x = udec128!(1.8446744073709551616);

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

See also:

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

Source §

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

Source §

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

Feeds this value into the given Hasher. Read more

Performs the unary - operation. Read more

Source §

impl<const N: usize> Ord for UnsignedDecimal<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 UnsignedDecimal Copy item path

§Unsigned Decimal

Implementations§

impl<const N: usize> UnsignedDecimal<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

impl<const N: usize> UnsignedDecimal<N>

pub const fn from_i8(int: i8) -> Result<Self, ParseError>

pub const fn from_i16(int: i16) -> Result<Self, ParseError>

pub const fn from_i32(int: i32) -> Result<Self, ParseError>

pub const fn from_i64(int: i64) -> Result<Self, ParseError>

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

pub const fn from_isize(int: isize) -> Result<Self, ParseError>

impl<const N: usize> UnsignedDecimal<N>

pub const fn from_f32(n: f32) -> Result<Self, ParseError>

pub const fn from_f64(n: f64) -> Result<Self, ParseError>

impl<const N: usize> UnsignedDecimal<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> UnsignedDecimal<N>

pub const fn to_f32(self) -> f32

pub const fn to_f64(self) -> f64

impl<const N: usize> UnsignedDecimal<N>

pub const NAN: Self

pub const INFINITY: Self

pub const MIN: Self = Self::ZERO

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

pub const fn from_parts(digits: UInt<N>, exp: i32, 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 UnsignedDecimal