Struct D76 

#[repr(transparent)]
pub struct D76<const SCALE: u32>(pub Int256);

Scaled fixed-point decimal with 256-bit storage. See D38 for the shape documentation; D76 has the same surface scaled to a 256-bit signed integer and MAX_SCALE = 76.

Gated behind the d76 (or umbrella wide) Cargo feature. The storage backend is Int256; this is the interim backend per research/multi_width_decimals.md §3.

Tuple Fields

0: Int256

Implementations

impl<const SCALE: u32> D76<SCALE>

pub const SCALE: u32 = SCALE

The decimal scale of this type, equal to the SCALE const-generic parameter. One LSB of storage represents 10^-SCALE. Use in type-level / const contexts; prefer Self::scale when an instance is in hand.

pub const ZERO: Self

The additive identity. Stored as zero bits.

Precision

N/A: constant value, no arithmetic performed.

pub const ONE: Self

The multiplicative identity. Stored as 10^SCALE bits.

Precision

N/A: constant value, no arithmetic performed.

pub const MAX: Self

The largest representable value: the storage type’s MAX.

Arithmetic that overflows this bound panics in debug builds and wraps in release builds.

pub const MIN: Self

The smallest representable value: the storage type’s MIN.

Mirror of Self::MAX. Note that -MIN panics in debug builds because two’s-complement MIN has no positive counterpart.

pub const fn from_bits(raw: Int256) -> Self

Constructs from a raw storage bit pattern.

The integer is interpreted directly as the internal storage: raw represents the logical value raw * 10^(-SCALE). This is the inverse of Self::to_bits.

Precision

Strict: all arithmetic is integer-only; result is bit-exact.

pub const fn to_bits(self) -> Int256

Returns the raw storage value.

The returned integer encodes the logical value self * 10^SCALE. This is the inverse of Self::from_bits.

Precision

Strict: all arithmetic is integer-only; result is bit-exact.

pub const fn multiplier() -> Int256

Returns 10^SCALE, the factor that converts a logical integer value to its storage representation. Equals the bit pattern of Self::ONE.

Precision

Strict: all arithmetic is integer-only; result is bit-exact.

Overflow

10^SCALE overflows the storage type at SCALE > MAX_SCALE. Calling with an overflowing scale panics at compile time when the const item is evaluated.

pub const fn scale(self) -> u32

Returns the decimal scale of this value, equal to the SCALE const-generic parameter. The value is determined entirely by the type; the method exists for ergonomic method-call syntax.

impl<const SCALE: u32> D76<SCALE>

pub fn mul_with(self, rhs: Self, mode: RoundingMode) -> Self

Multiply two values of the same scale, rounding the scale-narrowing step according to mode. Result is within 0.5 ULP for the half-* family and bounded by the directed-rounding rule otherwise.

For SCALE ≤ 38 the divide-by-10^SCALE step routes through the Möller-Granlund magic-divide kernel shared with D38 — avoiding the generic schoolbook divide for the common case. Larger scales fall through to the slower n / (10^SCALE) path.

pub fn div_with(self, rhs: Self, mode: RoundingMode) -> Self

Divide two values of the same scale, rounding the scale-narrowing step according to mode. Within 0.5 ULP for the half-* family.

The divisor here is the runtime operand rhs.0, not 10^SCALE, so the MG magic-divide doesn’t apply; the final step uses the wide integer’s schoolbook limbs_divmod (which has its own hardware fast paths for sub-word divisors). Scaling the numerator uses the type’s multiplier() const (already evaluated at the $Storage width) widened to $Wider, avoiding the per-call pow(SCALE) on the wider type.

impl<const SCALE: u32> D76<SCALE>

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

Checked addition. Some(self + rhs), or None if the sum would overflow Self.

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

Wrapping addition. self + rhs modulo the storage type’s MAX − MIN range.

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

Saturating addition. Clamps to Self::MIN / Self::MAX on overflow.

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

Overflowing addition. Returns (self.wrapping_add(rhs), overflowed).

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

Checked subtraction. Some(self - rhs), or None if the difference would overflow Self.

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

Wrapping subtraction.

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

Saturating subtraction. Clamps to Self::MIN / Self::MAX on overflow.

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

Overflowing subtraction. Returns (self.wrapping_sub(rhs), overflowed).

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

Checked negation. Some(-self), or None when self == Self::MIN (whose negation is unrepresentable in two’s-complement).

pub const fn wrapping_neg(self) -> Self

Wrapping negation. Self::MIN.wrapping_neg() == Self::MIN (same as i128::wrapping_neg).

pub const fn saturating_neg(self) -> Self

Saturating negation. Self::MIN.saturating_neg() == Self::MAX.

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

Overflowing negation. Returns (self.wrapping_neg(), overflowed); overflowed is true only when self == Self::MIN.

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

Checked remainder. Some(self % rhs), or None if rhs == 0 or the operation would overflow (the pathological case Self::MIN % -ONE).

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

Wrapping remainder. Panics on divide-by-zero (matches i128::wrapping_rem).

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

Overflowing remainder. Returns (self.wrapping_rem(rhs), overflowed); overflowed is true only at the Self::MIN % -ONE boundary.

impl<const SCALE: u32> D76<SCALE>

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

Checked multiplication. Computes self * rhs rounded toward zero, returning None if the result doesn’t fit in Self. The intermediate product is computed in $Wider so widening overflow is detected before the final narrowing.

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

Wrapping multiplication. Computes self * rhs modulo the storage type’s MAX − MIN range. The intermediate product still widens to $Wider; only the narrowing step wraps.

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

Saturating multiplication. Computes self * rhs, clamping to Self::MIN / Self::MAX on overflow. Sign of the saturated bound matches the sign of the exact mathematical product.

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

Overflowing multiplication. Returns the wrapped result together with a boolean flag — true if the mathematical product was out of range.

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

Checked division. Returns None if rhs is zero or the result would overflow Self. Rounded toward zero. The numerator is pre-multiplied by 10^SCALE in $Wider so the intermediate carries the scale-up step without losing precision.

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

Wrapping division. Computes self / rhs with the scale-up step done modulo $Wider’s range and the final narrowing wrapping. Panics on divide-by-zero (matches i128::wrapping_div semantics).

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

Saturating division. Computes self / rhs, clamping to Self::MIN / Self::MAX on overflow. Divide-by-zero saturates to the appropriate-sign bound.

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

Overflowing division. Returns the wrapped result together with a boolean flag — true if the exact quotient was out of range or rhs was zero.

impl<const SCALE: u32> D76<SCALE>

pub const fn abs(self) -> Self

Returns the absolute value of self.

Note: abs(MIN) overflows (because |MIN| has no positive counterpart in two’s complement). Debug builds panic; release builds wrap.

pub fn signum(self) -> Self

Returns the sign of self encoded as a scaled Self: -ONE, ZERO, or +ONE.

pub const fn is_positive(self) -> bool

Returns true if self is strictly greater than zero.

pub const fn is_negative(self) -> bool

Returns true if self is strictly less than zero.

impl<const SCALE: u32> D76<SCALE>

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

The lesser of self and other.

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

The greater of self and other.

pub fn clamp(self, lo: Self, hi: Self) -> Self

Restrict self to the closed interval [lo, hi]. Panics if lo > hi.

pub fn recip(self) -> Self

Multiplicative inverse: ONE / self. Panics on self == ZERO.

impl<const SCALE: u32> D76<SCALE>

pub fn copysign(self, sign: Self) -> Self

Magnitude of self with the sign of sign. Zero sign is treated as positive (the storage type has no negative zero).

impl<const SCALE: u32> D76<SCALE>

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

Logical (zero-fill) right shift of the raw storage by n bits. Unlike the arithmetic Shr operator, the vacated high bits are always zero regardless of sign.

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

Rotate the raw storage left by n bits.

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

Rotate the raw storage right by n bits.

pub fn leading_zeros(self) -> u32

Number of leading zero bits in the raw storage.

pub fn trailing_zeros(self) -> u32

Number of trailing zero bits in the raw storage.

pub fn count_ones(self) -> u32

Population count of the raw storage.

pub fn count_zeros(self) -> u32

Number of zero bits in the raw storage.

pub fn is_power_of_two(self) -> bool

true if the raw storage, viewed as unsigned, is a power of two.

pub fn next_power_of_two(self) -> Self

Smallest power of two >= the raw storage viewed as unsigned. Panics in debug builds on overflow.

impl<const SCALE: u32> D76<SCALE>

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

Euclidean division: the quotient as an integer multiple of ONE, chosen so the remainder is non-negative. Panics on rhs == ZERO.

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

Euclidean remainder: self - rhs * self.div_euclid(rhs), always non-negative when rhs != ZERO. Both operands share the scale, so no rescaling is needed. Panics on rhs == ZERO.

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

Absolute difference |self - rhs|. Computed as max - min so the subtraction is always non-negative.

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

Midpoint of self and rhs without intermediate overflow, rounding toward negative infinity. Uses the branch-free (a & b) + ((a ^ b) >> 1) identity, which is overflow-free and storage-agnostic.

pub const fn is_nan(self) -> bool

Always false — a fixed-point decimal has no NaN.

pub const fn is_infinite(self) -> bool

Always false — a fixed-point decimal has no infinity.

pub const fn is_finite(self) -> bool

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

pub 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; there is no hardware FMA — the multiply uses the type’s Mul and the add uses its Add.

impl<const SCALE: u32> D76<SCALE>

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

Floor-rounded division: floor(self / rhs) as an integer multiple of ONE. Panics on rhs == ZERO.

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

Ceil-rounded division: ceil(self / rhs) as an integer multiple of ONE. Panics on rhs == ZERO.

pub fn is_zero(self) -> bool

true if self is the additive identity.

pub fn is_normal(self) -> bool

Returns true for any non-zero value. A fixed-point decimal has no subnormals, so zero is the only value that is not “normal”.

impl<const SCALE: u32> D76<SCALE>

pub fn sqrt_strict(self) -> Self

Correctly-rounded square root.

Negative inputs saturate to Self::ZERO, matching the f64-bridge saturate-not-panic policy of the narrow tiers.

Precision

Strict: integer-only; the result is the exact square root correctly rounded to the type’s last place (within 0.5 ULP).

pub fn cbrt_strict(self) -> Self

Correctly-rounded cube root.

Defined for the whole real line: cbrt(-x) == -cbrt(x).

Precision

Strict: integer-only; the result is the exact cube root correctly rounded to the type’s last place (within 0.5 ULP).

pub fn sqrt(self) -> Self

Square root. With strict enabled this is the integer-only, correctly-rounded Self::sqrt_strict.

pub fn cbrt(self) -> Self

Cube root. With strict enabled this is the integer-only, correctly-rounded Self::cbrt_strict.

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

sqrt(self² + other²) without intermediate overflow, computed integer-only via the correctly-rounded Self::sqrt_strict. Uses the scale-trick algorithm:

hypot(a, b) = max(|a|,|b|) · sqrt(1 + (min(|a|,|b|)/max(|a|,|b|))²)

The min/max ratio lies in [0, 1], so ratio² + 1 is always in [1, 2] — the inner sqrt never overflows. The outer multiply by large only overflows when the true hypotenuse genuinely exceeds the type’s range.

hypot(0, 0) = 0 (bit-exact); hypot(0, x) = |x|.

impl<const SCALE: u32> D76<SCALE>

pub fn ln_strict(self) -> Self

Natural logarithm (base e). Strict: integer-only and correctly rounded. Panics if self <= 0.

pub fn ln_strict_agm(self) -> Self

Natural logarithm via the Brent–Salamin AGM (1976). Strict and correctly rounded. Same contract as Self::ln_strict; the implementation path differs. AGM converges quadratically and scales better than the artanh-series path at very high working scales.

Currently an alternate; the canonical ln_strict stays on the artanh path until a bench at the relevant working scale shows AGM winning by the OVERRIDE_POLICY.md margin.

pub fn exp_strict_agm(self) -> Self

e^self via Newton’s iteration on ln_fixed_agm. Strict and correctly rounded. Same contract as Self::exp_strict; the implementation path differs. Quadratic convergence makes this asymptotically faster than the Taylor exp_strict at very high working scales.

pub fn log_strict(self, base: Self) -> Self

Logarithm of self in the given base, as ln(self) / ln(base). Strict and correctly rounded. Panics if self <= 0, base <= 0, or base == 1.

pub fn log2_strict(self) -> Self

Base-2 logarithm. Strict and correctly rounded. Panics if self <= 0.

pub fn log10_strict(self) -> Self

Base-10 logarithm. Strict and correctly rounded. Panics if self <= 0.

pub fn exp_strict(self) -> Self

e^self. Strict and correctly rounded. Panics if the result overflows the representable range.

pub fn exp2_strict(self) -> Self

2^self, as exp(self · ln 2). Strict and correctly rounded. Panics if the result overflows.

pub fn powf_strict(self, exp: Self) -> Self

self raised to the power exp, as exp(exp · ln self). Strict and correctly rounded. A zero or negative base saturates to ZERO (a negative base with a fractional exponent is not real-valued).

pub fn sin_strict(self) -> Self

Sine of self (radians). Strict and correctly rounded.

pub fn cos_strict(self) -> Self

Cosine of self (radians), as sin(self + π/2). Strict and correctly rounded.

pub fn tan_strict(self) -> Self

Tangent of self (radians), as sin / cos. Strict and correctly rounded. Panics at odd multiples of π/2.

pub fn atan_strict(self) -> Self

Arctangent of self, in radians, in (−π/2, π/2). Strict and correctly rounded.

pub fn asin_strict(self) -> Self

Arcsine of self, in radians, in [−π/2, π/2], as atan(x / √(1 − x²)). Strict. Panics if |self| > 1.

pub fn acos_strict(self) -> Self

Arccosine of self, in radians, in [0, π], as π/2 − asin(self). Strict. Panics if |self| > 1.

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

Four-quadrant arctangent of self (y) and other (x), in radians, in (−π, π]. Strict and correctly rounded.

pub fn sinh_strict(self) -> Self

Hyperbolic sine, as (eˣ − e⁻ˣ)/2. Strict and correctly rounded.

pub fn cosh_strict(self) -> Self

Hyperbolic cosine, as (eˣ + e⁻ˣ)/2. Strict and correctly rounded.

pub fn tanh_strict(self) -> Self

Hyperbolic tangent, as sinh / cosh. Strict and correctly rounded.

pub fn asinh_strict(self) -> Self

Inverse hyperbolic sine, as sign · ln(|x| + √(x² + 1)). Strict and correctly rounded. For |x| ≥ 1 the radicand is factored to keep x² inside the working width.

pub fn acosh_strict(self) -> Self

Inverse hyperbolic cosine, as ln(x + √(x² − 1)), defined for x ≥ 1. Strict and correctly rounded. For x ≥ 2 the radicand is factored to keep x² in range.

pub fn atanh_strict(self) -> Self

Inverse hyperbolic tangent, as ln((1+x)/(1−x)) / 2, defined for |x| < 1. Strict and correctly rounded. Panics if |self| >= 1.

pub fn to_degrees_strict(self) -> Self

Convert radians to degrees: self · (180 / π). Strict and correctly rounded. Panics if |self| · 180 overflows the working integer.

pub fn to_radians_strict(self) -> Self

Convert degrees to radians: self · (π / 180). Strict and correctly rounded. mul is the scale-aware (a * b) / 10^w, so the working-width budget is the same as any other binary op in the core — no separate overflow check needed.

pub fn ln_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::ln_strict.

pub fn ln_strict_agm_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::ln_strict_agm.

pub fn exp_strict_agm_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::exp_strict_agm.

pub fn log_strict_with(self, base: Self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::log_strict.

pub fn log2_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::log2_strict.

pub fn log10_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::log10_strict.

pub fn exp_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::exp_strict.

pub fn exp2_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::exp2_strict.

pub fn powf_strict_with(self, exp: Self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::powf_strict.

pub fn sin_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::sin_strict.

pub fn cos_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::cos_strict.

pub fn tan_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::tan_strict.

pub fn atan_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::atan_strict.

pub fn asin_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::asin_strict.

pub fn acos_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::acos_strict.

pub fn atan2_strict_with(self, other: Self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::atan2_strict.

pub fn sinh_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::sinh_strict.

pub fn cosh_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::cosh_strict.

pub fn tanh_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::tanh_strict.

pub fn asinh_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::asinh_strict.

pub fn acosh_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::acosh_strict.

pub fn atanh_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::atanh_strict.

pub fn to_degrees_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::to_degrees_strict.

pub fn to_radians_strict_with(self, mode: RoundingMode) -> Self

Mode-aware sibling of Self::to_radians_strict.

impl<const SCALE: u32> D76<SCALE>

pub fn ln(self) -> Self

With strict, dispatches to Self::ln_strict.

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

With strict, dispatches to Self::log_strict.

pub fn log2(self) -> Self

With strict, dispatches to Self::log2_strict.

pub fn log10(self) -> Self

With strict, dispatches to Self::log10_strict.

pub fn exp(self) -> Self

With strict, dispatches to Self::exp_strict.

pub fn exp2(self) -> Self

With strict, dispatches to Self::exp2_strict.

pub fn powf(self, exp: Self) -> Self

With strict, dispatches to Self::powf_strict.

pub fn sin(self) -> Self

With strict, dispatches to Self::sin_strict.

pub fn cos(self) -> Self

With strict, dispatches to Self::cos_strict.

pub fn tan(self) -> Self

With strict, dispatches to Self::tan_strict.

pub fn asin(self) -> Self

With strict, dispatches to Self::asin_strict.

pub fn acos(self) -> Self

With strict, dispatches to Self::acos_strict.

pub fn atan(self) -> Self

With strict, dispatches to Self::atan_strict.

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

With strict, dispatches to Self::atan2_strict.

pub fn sinh(self) -> Self

With strict, dispatches to Self::sinh_strict.

pub fn cosh(self) -> Self

With strict, dispatches to Self::cosh_strict.

pub fn tanh(self) -> Self

With strict, dispatches to Self::tanh_strict.

pub fn asinh(self) -> Self

With strict, dispatches to Self::asinh_strict.

pub fn acosh(self) -> Self

With strict, dispatches to Self::acosh_strict.

pub fn atanh(self) -> Self

With strict, dispatches to Self::atanh_strict.

pub fn to_degrees(self) -> Self

With strict, dispatches to Self::to_degrees_strict.

pub fn to_radians(self) -> Self

With strict, dispatches to Self::to_radians_strict.

impl<const SCALE: u32> D76<SCALE>

pub fn ln_fast(self) -> Self

Natural logarithm via the f64 bridge.

pub fn log_fast(self, base: Self) -> Self

Logarithm in the given base via the f64 bridge.

pub fn log2_fast(self) -> Self

Base-2 logarithm via the f64 bridge.

pub fn log10_fast(self) -> Self

Base-10 logarithm via the f64 bridge.

pub fn exp_fast(self) -> Self

e^self via the f64 bridge.

pub fn exp2_fast(self) -> Self

2^self via the f64 bridge.

pub fn sqrt_fast(self) -> Self

Square root via the f64 bridge.

pub fn cbrt_fast(self) -> Self

Cube root via the f64 bridge.

pub fn powf_fast(self, exp: Self) -> Self

self ^ exp via the f64 bridge.

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

sqrt(self^2 + other^2) via the f64 bridge.

pub fn sin_fast(self) -> Self

Sine (radians) via the f64 bridge.

pub fn cos_fast(self) -> Self

Cosine (radians) via the f64 bridge.

pub fn tan_fast(self) -> Self

Tangent (radians) via the f64 bridge.

pub fn asin_fast(self) -> Self

Arcsine via the f64 bridge.

pub fn acos_fast(self) -> Self

Arccosine via the f64 bridge.

pub fn atan_fast(self) -> Self

Arctangent via the f64 bridge.

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

Four-quadrant arctangent via the f64 bridge.

pub fn sinh_fast(self) -> Self

Hyperbolic sine via the f64 bridge.

pub fn cosh_fast(self) -> Self

Hyperbolic cosine via the f64 bridge.

pub fn tanh_fast(self) -> Self

Hyperbolic tangent via the f64 bridge.

pub fn asinh_fast(self) -> Self

Inverse hyperbolic sine via the f64 bridge.

pub fn acosh_fast(self) -> Self

Inverse hyperbolic cosine via the f64 bridge.

pub fn atanh_fast(self) -> Self

Inverse hyperbolic tangent via the f64 bridge.

pub fn to_degrees_fast(self) -> Self

Radians → degrees via the f64 bridge.

pub fn to_radians_fast(self) -> Self

Degrees → radians via the f64 bridge.

impl<const SCALE: u32> D76<SCALE>

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

Raises self to the power exp via square-and-multiply. exp = 0 always returns ONE. Overflow at any multiplication step follows the Mul operator’s semantics (debug-panic, release-wrap).

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

Signed integer exponent. For non-negative exp this is self.pow(exp as u32); for negative exp it is Self::ONE / self.pow(exp.unsigned_abs()).

i32::unsigned_abs handles i32::MIN without the signed-negation overflow that (-i32::MIN) as u32 would cause.

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

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

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

Two’s-complement wrap at every multiplication step.

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

Saturates to Self::MAX or Self::MIN on overflow, based on the sign the mathematical result would have.

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

(self^exp, overflowed). overflowed is true if any multiplication step overflowed; the value is the wrapping form.

impl<const SCALE: u32> D76<SCALE>

pub fn from_int(value: i128) -> Self

Constructs from an integer source, scaling by 10^SCALE. Overflow follows the wide integer’s default arithmetic semantics.

pub fn from_i32(value: i32) -> Self

Constructs from an i32, scaling by 10^SCALE.

pub fn to_int(self) -> i64

Converts to i64 using the crate default rounding mode. Saturates to i64::MAX / i64::MIN when the rounded integer part falls outside i64’s range.

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

Converts to i64 using the supplied rounding mode for the fractional discard step. Saturates to i64::MAX / i64::MIN when the rounded integer is out of i64 range.

impl<const SCALE: u32> D76<SCALE>

pub fn from_f64(value: f64) -> Self

Constructs from an f64 using the crate default rounding mode. NaN -> ZERO, +Infinity -> MAX, -Infinity -> MIN, out-of-range -> saturate by sign.

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

Constructs from an f64 using the supplied rounding mode. Saturation policy as in Self::from_f64.

pub fn to_f64(self) -> f64

Converts to f64 by dividing the raw storage by 10^SCALE. Lossy: an f64 mantissa cannot hold the full wide-storage precision.

pub fn to_f32(self) -> f32

Converts to f32 via f64, then narrows.

impl<const SCALE: u32> D76<SCALE>

pub fn rescale<const TARGET_SCALE: u32>(self) -> D76<TARGET_SCALE>

Rescales to TARGET_SCALE using the crate’s default rounding mode (HalfToEven, or whatever a rounding-* Cargo feature selects). Delegates to Self::rescale_with.

pub fn with_scale<const TARGET_SCALE: u32>(self) -> D76<TARGET_SCALE>

Builder-style alias for Self::rescale.

Returns a new value at TARGET_SCALE using the crate’s default rounding mode. Use Self::rescale_with when you need to pass an explicit RoundingMode.

pub fn rescale_with<const TARGET_SCALE: u32>( self, mode: RoundingMode, ) -> D76<TARGET_SCALE>

Rescales to TARGET_SCALE using the supplied rounding mode.

• TARGET_SCALE == SCALE: bit-identity.
• TARGET_SCALE > SCALE: scale-up multiplies by 10^(TARGET - SCALE); lossless; panics on overflow.
• TARGET_SCALE < SCALE: scale-down divides by 10^(SCALE - TARGET) with the requested rounding rule.

impl<const SCALE: u32> D76<SCALE>

pub fn floor(self) -> Self

Largest integer multiple of ONE less than or equal to self (toward negative infinity).

pub fn ceil(self) -> Self

Smallest integer multiple of ONE greater than or equal to self (toward positive infinity).

pub fn trunc(self) -> Self

Drop the fractional part (toward zero).

pub fn fract(self) -> Self

Return only the fractional part: self - self.trunc().

impl<const SCALE: u32> D76<SCALE>

pub fn round(self) -> Self

Round to the nearest integer (half-away-from-zero).

impl<const SCALE: u32> D76<SCALE>

pub fn narrow(self) -> Result<D38<SCALE>, ConvertError>

Demote to the previous storage tier (D38) at the same SCALE. Returns Err(ConvertError::OutOfRange) if the value doesn’t fit i128’s range at the given scale.

impl<const SCALE: u32> D76<SCALE>

pub fn widen(self) -> D153<SCALE>

Promote to the next storage tier (D153) at the same SCALE. Lossless.

Trait Implementations

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

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

Add two values of the same scale.

type Output = D76<SCALE>

The resulting type after applying the + operator.

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

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

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

Formats the value using the given formatter.

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

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

Bitwise AND of the raw storage values.

type Output = D76<SCALE>

The resulting type after applying the & operator.

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

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

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

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

Bitwise OR of the raw storage values.

type Output = D76<SCALE>

The resulting type after applying the | operator.

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

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

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

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

Bitwise XOR of the raw storage values.

type Output = D76<SCALE>

The resulting type after applying the ^ operator.

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

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

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

fn min_value() -> Self

Returns the smallest finite number this type can represent

fn max_value() -> Self

Returns the largest finite number this type can represent

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

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

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

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

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

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

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

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

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

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

fn checked_neg(&self) -> Option<Self>

Negates a number, returning None for results that can’t be represented, like signed MIN values that can’t be positive, or non-zero unsigned values that can’t be negative.

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

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

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

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

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

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

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

fn clone(&self) -> D76<SCALE>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

const SCALE: u32 = SCALE

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

const MAX_SCALE: u32 = 76

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 = D76<SCALE>::ZERO

The additive identity (logical value 0).

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

The multiplicative identity (logical value 1).

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

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

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

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

type Storage = Int256

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

fn multiplier() -> Int256

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

fn from_bits(raw: Int256) -> Self

Constructs from a raw storage value.

fn to_bits(self) -> Int256

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.

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, *).

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

Available on crate features d76 or wide only.

fn pi() -> Self

Pi (~3.14159265…). One half-turn in radians.

fn tau() -> Self

Tau (~6.28318530…). One full turn in radians.

fn half_pi() -> Self

Half-pi (~1.57079632…). One quarter-turn in radians.

fn quarter_pi() -> Self

Quarter-pi (~0.78539816…). One eighth-turn in radians.

fn golden() -> Self

The golden ratio (~1.61803398…). Dimensionless.

fn e() -> Self

Euler’s number (~2.71828182…). Dimensionless.

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

Available on crate features d76 or wide only.

fn default() -> Self

Returns the “default value” for a type.

impl<'de, const SCALE: u32> Deserialize<'de> for D76<SCALE>

fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

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

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

Formats the value using the given formatter.

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

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

Divide two values of the same scale using the crate-default RoundingMode (within 0.5 ULP). Numerator is widened to $Wider, multiplied by 10^SCALE, then divided by b preserving the value · 10^SCALE form. See Self::div_with for a non-default rounding mode.

type Output = D76<SCALE>

The resulting type after applying the / operator.

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

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const SCALE: u32> From<D18<SCALE>> for D76<SCALE>

fn from(value: D18<SCALE>) -> Self

Widens a narrower decimal type to this wider one. The scale is unchanged; the storage is widened via the WideInt cast (lossless because the source domain is a subset of the destination).

impl<const SCALE: u32> From<D38<SCALE>> for D76<SCALE>

fn from(value: D38<SCALE>) -> Self

Widens a narrower decimal type to this wider one. The scale is unchanged; the storage is widened via the WideInt cast (lossless because the source domain is a subset of the destination).

impl<const SCALE: u32> From<D76<SCALE>> for D153<SCALE>

fn from(value: D76<SCALE>) -> Self

Widens a narrower decimal type to this wider one. The scale is unchanged; the storage is widened via the WideInt cast (lossless because the source domain is a subset of the destination).

impl<const SCALE: u32> From<D76<SCALE>> for D307<SCALE>

fn from(value: D76<SCALE>) -> Self

Widens a narrower decimal type to this wider one. The scale is unchanged; the storage is widened via the WideInt cast (lossless because the source domain is a subset of the destination).

impl<const SCALE: u32> From<D9<SCALE>> for D76<SCALE>

fn from(value: D9<SCALE>) -> Self

Widens a narrower decimal type to this wider one. The scale is unchanged; the storage is widened via the WideInt cast (lossless because the source domain is a subset of the destination).

impl<const SCALE: u32> From<i16> for D76<SCALE>

fn from(value: i16) -> Self

Constructs from an integer by scaling to value * 10^SCALE. Overflows follow the wide integer’s default arithmetic semantics (debug-mode panic, release-mode wrap).

impl<const SCALE: u32> From<i32> for D76<SCALE>

fn from(value: i32) -> Self

Constructs from an integer by scaling to value * 10^SCALE. Overflows follow the wide integer’s default arithmetic semantics (debug-mode panic, release-mode wrap).

impl<const SCALE: u32> From<i64> for D76<SCALE>

fn from(value: i64) -> Self

Constructs from an integer by scaling to value * 10^SCALE. Overflows follow the wide integer’s default arithmetic semantics (debug-mode panic, release-mode wrap).

impl<const SCALE: u32> From<i8> for D76<SCALE>

fn from(value: i8) -> Self

Constructs from an integer by scaling to value * 10^SCALE. Overflows follow the wide integer’s default arithmetic semantics (debug-mode panic, release-mode wrap).

impl<const SCALE: u32> From<u16> for D76<SCALE>

fn from(value: u16) -> Self

Constructs from an integer by scaling to value * 10^SCALE. Overflows follow the wide integer’s default arithmetic semantics (debug-mode panic, release-mode wrap).

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

fn from(value: u32) -> Self

Constructs from an integer by scaling to value * 10^SCALE. Overflows follow the wide integer’s default arithmetic semantics (debug-mode panic, release-mode wrap).

impl<const SCALE: u32> From<u64> for D76<SCALE>

fn from(value: u64) -> Self

Constructs from an integer by scaling to value * 10^SCALE. Overflows follow the wide integer’s default arithmetic semantics (debug-mode panic, release-mode wrap).

impl<const SCALE: u32> From<u8> for D76<SCALE>

fn from(value: u8) -> Self

Constructs from an integer by scaling to value * 10^SCALE. Overflows follow the wide integer’s default arithmetic semantics (debug-mode panic, release-mode wrap).

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Err = ParseError

The associated error which can be returned from parsing.

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

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

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

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

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

Formats the value using the given formatter.

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

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

Multiply two values of the same scale. Widens to $Wider to hold a · b exactly, divides by 10^SCALE using the crate-default RoundingMode (IEEE-754 round-to-nearest; within 0.5 ULP), and narrows back to $Storage. See Self::mul_with to choose a non-default rounding mode.

type Output = D76<SCALE>

The resulting type after applying the * operator.

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

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

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

type Output = D76<SCALE>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

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

fn not(self) -> Self

Bitwise complement of the raw storage (flip every bit).

type Output = D76<SCALE>

The resulting type after applying the ! operator.

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

type FromStrRadixErr = ParseError

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

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

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

fn from<T: ToPrimitive>(n: T) -> Option<Self>

Creates a number from another value that can be converted into a primitive via the ToPrimitive trait. If the source value cannot be represented by the target type, then None is returned.

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

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

Formats the value using the given formatter.

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

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

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

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

fn cmp(&self, other: &D76<SCALE>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for f32

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for f64

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for i128

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for i16

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for i32

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for i64

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for i8

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for isize

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for u128

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for u16

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for u64

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for u8

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<D76<SCALE>> for usize

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<f32> for D76<SCALE>

fn eq(&self, other: &f32) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<f64> for D76<SCALE>

fn eq(&self, other: &f64) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<i128> for D76<SCALE>

fn eq(&self, other: &i128) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<i16> for D76<SCALE>

fn eq(&self, other: &i16) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<i32> for D76<SCALE>

fn eq(&self, other: &i32) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<i64> for D76<SCALE>

fn eq(&self, other: &i64) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<i8> for D76<SCALE>

fn eq(&self, other: &i8) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<isize> for D76<SCALE>

fn eq(&self, other: &isize) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<u128> for D76<SCALE>

fn eq(&self, other: &u128) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<u16> for D76<SCALE>

fn eq(&self, other: &u16) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

fn eq(&self, other: &u32) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<u64> for D76<SCALE>

fn eq(&self, other: &u64) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<u8> for D76<SCALE>

fn eq(&self, other: &u8) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const SCALE: u32> PartialEq<usize> for D76<SCALE>

fn eq(&self, other: &usize) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

fn eq(&self, other: &D76<SCALE>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

fn partial_cmp(&self, other: &D76<SCALE>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

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

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

Remainder of two values at the same scale. Because both operands share the scale factor, the storage-level remainder is the answer with no rescaling.

type Output = D76<SCALE>

The resulting type after applying the % operator.

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

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

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

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

Serialise as a base-10 integer string for human- readable formats, or as $bytes_len little-endian bytes for binary formats.

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

fn shl(self, n: u32) -> Self

Left-shift the raw storage by n bits. Debug-panics when n exceeds the storage width; wraps in release.

type Output = D76<SCALE>

The resulting type after applying the << operator.

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

fn shl_assign(&mut self, n: u32)

Performs the <<= operation.

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

fn shr(self, n: u32) -> Self

Arithmetic (sign-extending) right-shift of the raw storage by n bits. Use Self::unsigned_shr for the logical (zero-fill) shift.

type Output = D76<SCALE>

The resulting type after applying the >> operator.

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

fn shr_assign(&mut self, n: u32)

Performs the >>= operation.

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

fn abs(&self) -> Self

Computes the absolute value.

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

The positive difference of two numbers.

fn signum(&self) -> Self

Returns the sign of the number.

fn is_positive(&self) -> bool

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

fn is_negative(&self) -> bool

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

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

type Output = D76<SCALE>

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<const SCALE: u32> TryFrom<D153<SCALE>> for D76<SCALE>

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

Attempts to narrow a wider decimal type to this narrower one. Fails with Overflow when the source value exceeds the destination’s MIN..=MAX. The scale is unchanged.

type Error = ConvertError

The type returned in the event of a conversion error.

impl<const SCALE: u32> TryFrom<D307<SCALE>> for D76<SCALE>

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

Attempts to narrow a wider decimal type to this narrower one. Fails with Overflow when the source value exceeds the destination’s MIN..=MAX. The scale is unchanged.

type Error = ConvertError

The type returned in the event of a conversion error.

impl<const SCALE: u32> TryFrom<D76<SCALE>> for D18<SCALE>

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

Attempts to narrow a wider decimal type to this narrower one. Fails with Overflow when the source value exceeds the destination’s MIN..=MAX. The scale is unchanged.

type Error = ConvertError

The type returned in the event of a conversion error.

impl<const SCALE: u32> TryFrom<D76<SCALE>> for D38<SCALE>

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

Attempts to narrow a wider decimal type to this narrower one. Fails with Overflow when the source value exceeds the destination’s MIN..=MAX. The scale is unchanged.

type Error = ConvertError

The type returned in the event of a conversion error.

impl<const SCALE: u32> TryFrom<D76<SCALE>> for D9<SCALE>

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

Attempts to narrow a wider decimal type to this narrower one. Fails with Overflow when the source value exceeds the destination’s MIN..=MAX. The scale is unchanged.

type Error = ConvertError

The type returned in the event of a conversion error.

impl<const SCALE: u32> TryFrom<f32> for D76<SCALE>

type Error = ConvertError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<const SCALE: u32> TryFrom<f64> for D76<SCALE>

type Error = ConvertError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<const SCALE: u32> TryFrom<i128> for D76<SCALE>

type Error = ConvertError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl<const SCALE: u32> TryFrom<u128> for D76<SCALE>

type Error = ConvertError

The type returned in the event of a conversion error.

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

Performs the conversion.

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

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

Formats the value using the given formatter.

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

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

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

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

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

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