Trait Decimal 

pub trait Decimal:
    Copy
    + PartialEq
    + Eq
    + PartialOrd
    + Ord
    + Default
    + Debug
    + Display
    + Hash
    + Add<Output = Self>
    + Sub<Output = Self>
    + Mul<Output = Self>
    + Div<Output = Self>
    + Rem<Output = Self>
    + Neg<Output = Self>
    + AddAssign
    + SubAssign
    + MulAssign
    + DivAssign
    + RemAssign
    + BitAnd<Output = Self>
    + BitOr<Output = Self>
    + BitXor<Output = Self>
    + Not<Output = Self>
    + Shl<u32, Output = Self>
    + Shr<u32, Output = Self> {
    type Storage: Copy + PartialEq + Eq;

    const SCALE: u32;
    const MAX_SCALE: u32;
    const ZERO: Self;
    const ONE: Self;
    const MAX: Self;
    const MIN: Self;

    // Required methods
    fn multiplier() -> Self::Storage;
    fn from_bits(raw: Self::Storage) -> Self;
    fn to_bits(self) -> Self::Storage;
    fn scale(self) -> u32;
    fn abs(self) -> Self;
    fn signum(self) -> Self;
    fn is_positive(self) -> bool;
    fn is_negative(self) -> bool;
    fn is_nan(self) -> bool;
    fn is_infinite(self) -> bool;
    fn is_finite(self) -> bool;
    fn div_euclid(self, rhs: Self) -> Self;
    fn rem_euclid(self, rhs: Self) -> Self;
    fn div_floor(self, rhs: Self) -> Self;
    fn div_ceil(self, rhs: Self) -> Self;
    fn abs_diff(self, rhs: Self) -> Self;
    fn midpoint(self, rhs: Self) -> Self;
    fn mul_add(self, a: Self, b: Self) -> Self;
    fn pow(self, exp: u32) -> Self;
    fn powi(self, exp: i32) -> Self;
    fn checked_pow(self, exp: u32) -> Option<Self>;
    fn wrapping_pow(self, exp: u32) -> Self;
    fn saturating_pow(self, exp: u32) -> Self;
    fn overflowing_pow(self, exp: u32) -> (Self, bool);
    fn checked_add(self, rhs: Self) -> Option<Self>;
    fn checked_sub(self, rhs: Self) -> Option<Self>;
    fn checked_mul(self, rhs: Self) -> Option<Self>;
    fn checked_div(self, rhs: Self) -> Option<Self>;
    fn checked_neg(self) -> Option<Self>;
    fn checked_rem(self, rhs: Self) -> Option<Self>;
    fn wrapping_add(self, rhs: Self) -> Self;
    fn wrapping_sub(self, rhs: Self) -> Self;
    fn wrapping_mul(self, rhs: Self) -> Self;
    fn wrapping_div(self, rhs: Self) -> Self;
    fn wrapping_neg(self) -> Self;
    fn wrapping_rem(self, rhs: Self) -> Self;
    fn saturating_add(self, rhs: Self) -> Self;
    fn saturating_sub(self, rhs: Self) -> Self;
    fn saturating_mul(self, rhs: Self) -> Self;
    fn saturating_div(self, rhs: Self) -> Self;
    fn saturating_neg(self) -> Self;
    fn overflowing_add(self, rhs: Self) -> (Self, bool);
    fn overflowing_sub(self, rhs: Self) -> (Self, bool);
    fn overflowing_mul(self, rhs: Self) -> (Self, bool);
    fn overflowing_div(self, rhs: Self) -> (Self, bool);
    fn overflowing_neg(self) -> (Self, bool);
    fn overflowing_rem(self, rhs: Self) -> (Self, bool);
    fn from_i32(value: i32) -> Self;
    fn to_int(self) -> i64;
    fn to_int_with(self, mode: RoundingMode) -> i64;
    fn from_f64(value: f64) -> Self;
    fn from_f64_with(value: f64, mode: RoundingMode) -> Self;
    fn to_f64(self) -> f64;
    fn to_f32(self) -> f32;

    // Provided methods
    fn is_zero(self) -> bool { ... }
    fn is_one(self) -> bool { ... }
    fn is_normal(self) -> bool { ... }
    fn sum<I>(iter: I) -> Self
       where I: IntoIterator<Item = Self> { ... }
    fn product<I>(iter: I) -> Self
       where I: IntoIterator<Item = Self> { ... }
}

Scaled fixed-point decimal type with a compile-time SCALE and a fixed-width integer Storage.

See the module-level documentation for the full surface and what’s intentionally not on the trait.

Precision

N/A: this is a trait definition; no arithmetic is performed.

Required Associated Constants

const SCALE: u32

The decimal scale of this type, equal to the const-generic parameter. One LSB of storage represents 10^-SCALE.

const MAX_SCALE: u32

The maximum legal SCALE for this width. Equal to the largest k such that 10^k fits in Self::Storage. For example, 38 for D38, 76 for D76.

const ZERO: Self

The additive identity (logical value 0).

const ONE: Self

The multiplicative identity (logical value 1).

const MAX: Self

The largest representable value (storage equal to Self::Storage::MAX).

const MIN: Self

The smallest representable value (storage equal to Self::Storage::MIN).

Required Associated Types

type Storage: Copy + PartialEq + Eq

Underlying integer storage type (e.g. i128 for D38<SCALE>).

Required Methods

fn multiplier() -> Self::Storage

Returns 10^SCALE, the factor that converts a logical integer to its storage representation.

fn from_bits(raw: Self::Storage) -> Self

Constructs from a raw storage value.

fn to_bits(self) -> Self::Storage

Returns the raw storage value.

fn scale(self) -> u32

Returns the decimal scale of this value (equal to Self::SCALE; provided for ergonomic method-call syntax).

fn abs(self) -> Self

Absolute value. Self::MIN.abs() panics in debug, wraps to Self::MIN in release (mirroring the storage type).

fn signum(self) -> Self

+ONE, ZERO, or -ONE according to the sign of self.

fn is_positive(self) -> bool

true when self > ZERO.

fn is_negative(self) -> bool

true when self < ZERO.

fn is_nan(self) -> bool

Always false — fixed-point decimals cannot represent NaN.

fn is_infinite(self) -> bool

Always false — fixed-point decimals cannot represent infinity.

fn is_finite(self) -> bool

Always true — every fixed-point decimal value is finite.

fn div_euclid(self, rhs: Self) -> Self

Euclidean division: integer quotient (rounded so the remainder is non-negative) scaled back into Self. Panics on rhs == ZERO.

fn rem_euclid(self, rhs: Self) -> Self

Euclidean remainder, non-negative when rhs != ZERO. Panics on rhs == ZERO.

fn div_floor(self, rhs: Self) -> Self

Floor-rounded division (toward -∞). Panics on rhs == ZERO.

fn div_ceil(self, rhs: Self) -> Self

Ceil-rounded division (toward +∞). Panics on rhs == ZERO.

fn abs_diff(self, rhs: Self) -> Self

|self - rhs|, computed without intermediate overflow.

fn midpoint(self, rhs: Self) -> Self

Midpoint of self and rhs (rounding toward -∞), computed without intermediate overflow.

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

self * a + b — mirrors the f64::mul_add call shape so f64-generic numeric code can monomorphise to a decimal type.

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

self^exp via square-and-multiply. Overflow follows Mul (debug panic, release wrap).

fn powi(self, exp: i32) -> Self

Signed integer exponent. Negative exp produces ONE / self.pow(|exp|); the divide truncates at the type’s scale.

fn checked_pow(self, exp: u32) -> Option<Self>

Some(self^exp), or None if any intermediate step overflows.

fn wrapping_pow(self, exp: u32) -> Self

Wrapping pow. Each multiplication step wraps in the storage type.

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

Saturating pow — clamps to MAX / MIN on overflow, with the sign matching the mathematical result.

fn overflowing_pow(self, exp: u32) -> (Self, bool)

(self^exp, overflowed) — the wrapping result paired with a boolean.

fn checked_add(self, rhs: Self) -> Option<Self>

Some(self + rhs), or None if the sum overflows.

fn checked_sub(self, rhs: Self) -> Option<Self>

Some(self - rhs), or None if the difference overflows.

fn checked_mul(self, rhs: Self) -> Option<Self>

Some(self * rhs), or None if the scaled product overflows.

fn checked_div(self, rhs: Self) -> Option<Self>

Some(self / rhs), or None if rhs == ZERO or the quotient overflows the storage.

fn checked_neg(self) -> Option<Self>

Some(-self), or None when self == MIN.

fn checked_rem(self, rhs: Self) -> Option<Self>

Some(self % rhs), or None on divide-by-zero / MIN % -ONE.

fn wrapping_add(self, rhs: Self) -> Self

Two’s-complement wrapping +.

fn wrapping_sub(self, rhs: Self) -> Self

Two’s-complement wrapping -.

fn wrapping_mul(self, rhs: Self) -> Self

Wrapping * — intermediate widens for overflow detection, the final narrowing wraps.

fn wrapping_div(self, rhs: Self) -> Self

Wrapping / — panics on rhs == ZERO, matching i128::wrapping_div.

fn wrapping_neg(self) -> Self

Wrapping -self; MIN.wrapping_neg() == MIN.

fn wrapping_rem(self, rhs: Self) -> Self

Wrapping % — panics on rhs == ZERO.

fn saturating_add(self, rhs: Self) -> Self

Saturating +.

fn saturating_sub(self, rhs: Self) -> Self

Saturating -.

fn saturating_mul(self, rhs: Self) -> Self

Saturating * — sign of the saturated bound matches the mathematical product.

fn saturating_div(self, rhs: Self) -> Self

Saturating / — divide-by-zero saturates to MAX / MIN according to the sign of self.

fn saturating_neg(self) -> Self

Saturating -self — MIN.saturating_neg() == MAX.

fn overflowing_add(self, rhs: Self) -> (Self, bool)

Overflowing +.

fn overflowing_sub(self, rhs: Self) -> (Self, bool)

Overflowing -.

fn overflowing_mul(self, rhs: Self) -> (Self, bool)

Overflowing *.

fn overflowing_div(self, rhs: Self) -> (Self, bool)

Overflowing / — overflowed is true on out-of-range or divide-by-zero.

fn overflowing_neg(self) -> (Self, bool)

Overflowing -self — overflowed is true iff self == MIN.

fn overflowing_rem(self, rhs: Self) -> (Self, bool)

Overflowing %.

fn from_i32(value: i32) -> Self

Construct from an i32, scaling by 10^SCALE. Width-generic integer constructor; for wider source integers use the concrete type’s from_int (whose IntSrc parameter varies per width).

fn to_int(self) -> i64

Convert to i64 using the crate-default rounding mode, with saturating overflow on out-of-range integer parts.

fn to_int_with(self, mode: RoundingMode) -> i64

Convert to i64 using the supplied rounding mode for the fractional discard step. Saturating overflow on out-of-range integer parts.

fn from_f64(value: f64) -> Self

Construct from f64 using the crate-default rounding mode. NaN saturates to ZERO; ±∞ saturates to MAX / MIN.

fn from_f64_with(value: f64, mode: RoundingMode) -> Self

Construct from f64 using the supplied rounding mode.

fn to_f64(self) -> f64

Convert to f64. Lossy when the storage magnitude exceeds f64’s ~15-digit exact range.

fn to_f32(self) -> f32

Convert to f32. Lossy.

Provided Methods

fn is_zero(self) -> bool

true if this value is the additive identity.

fn is_one(self) -> bool

true if this value is the multiplicative identity.

fn is_normal(self) -> bool

true for every non-zero value (a fixed-point decimal has no subnormals).

fn sum<I>(iter: I) -> Self

where I: IntoIterator<Item = Self>,

Sums an iterator of decimals of this width, starting from ZERO. Width-generic convenience for iter.fold(ZERO, +).

fn product<I>(iter: I) -> Self

where I: IntoIterator<Item = Self>,

Multiplies an iterator of decimals of this width, starting from ONE. Width-generic convenience for iter.fold(ONE, *).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<const SCALE: u32> Decimal for D9<SCALE>

const SCALE: u32 = SCALE

const MAX_SCALE: u32 = 9

const ZERO: Self = D9<SCALE>::ZERO

const ONE: Self = D9<SCALE>::ONE

const MAX: Self = D9<SCALE>::MAX

const MIN: Self = D9<SCALE>::MIN

type Storage = i32

impl<const SCALE: u32> Decimal for D18<SCALE>

const SCALE: u32 = SCALE

const MAX_SCALE: u32 = 18

const ZERO: Self = D18<SCALE>::ZERO

const ONE: Self = D18<SCALE>::ONE

const MAX: Self = D18<SCALE>::MAX

const MIN: Self = D18<SCALE>::MIN

type Storage = i64

impl<const SCALE: u32> Decimal for D38<SCALE>

const SCALE: u32 = SCALE

const MAX_SCALE: u32 = 38

const ZERO: Self = D38<SCALE>::ZERO

const ONE: Self = D38<SCALE>::ONE

const MAX: Self = D38<SCALE>::MAX

const MIN: Self = D38<SCALE>::MIN

type Storage = i128

impl<const SCALE: u32> Decimal for D76<SCALE>

const SCALE: u32 = SCALE

const MAX_SCALE: u32 = 76

const ZERO: Self = D76<SCALE>::ZERO

const ONE: Self = D76<SCALE>::ONE

const MAX: Self = D76<SCALE>::MAX

const MIN: Self = D76<SCALE>::MIN

type Storage = Int256

impl<const SCALE: u32> Decimal for D153<SCALE>

const SCALE: u32 = SCALE

const MAX_SCALE: u32 = 153

const ZERO: Self = D153<SCALE>::ZERO

const ONE: Self = D153<SCALE>::ONE

const MAX: Self = D153<SCALE>::MAX

const MIN: Self = D153<SCALE>::MIN

type Storage = Int512

impl<const SCALE: u32> Decimal for D307<SCALE>

const SCALE: u32 = SCALE

const MAX_SCALE: u32 = 307

const ZERO: Self = D307<SCALE>::ZERO

const ONE: Self = D307<SCALE>::ONE

const MAX: Self = D307<SCALE>::MAX

const MIN: Self = D307<SCALE>::MIN

type Storage = Int1024