Struct D9

Source

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

Expand description

Scaled fixed-point decimal with 32-bit storage. See D38 for the shape documentation; D9 has the same surface scaled to i32 and MAX_SCALE = 9.

Tuple Fields§

§0: i32

Implementations§

Source §

impl<const SCALE: u32> D9<SCALE>

Source

pub fn from_int(value: i32) -> Self

Constructs from an integer at the widest supported source, scaling by 10^SCALE. Overflow follows Rust’s default integer arithmetic (debug panic, release wrap).

Source

pub fn from_i32(value: i32) -> Self

Constructs from an i32, scaling by 10^SCALE.

Source

pub fn to_int(self) -> i64

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

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.

Source

pub const fn to_bits(self) -> i32

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.

Source

Source §

impl<const SCALE: u32> D9<SCALE>

Source

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.

Source

pub fn signum(self) -> Self

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

Source

pub const fn is_positive(self) -> bool

Returns true if self is strictly greater than zero.

Source

pub const fn is_negative(self) -> bool

Returns true if self is strictly less than zero.

Source §

impl<const SCALE: u32> D9<SCALE>

Source

pub fn from_f64(value: f64) -> Self

Constructs from an f64 using the crate default rounding mode (HalfToEven, or whichever a rounding-* Cargo feature selects). NaN -> ZERO, +Infinity -> MAX, -Infinity -> MIN, out-of-range -> saturate by sign.

Source

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.

Source

pub fn to_f64(self) -> f64

Converts to f64 by dividing the raw storage by 10^SCALE. Available in no_std because the as f64 cast and float division are part of core.

Source

pub fn to_f32(self) -> f32

Converts to f32 via f64, then narrows. no_std-safe.

Source §

powf — feature-gated dispatcher; forwards to Self::powf_strict when the strict feature is on.

Source §

Source

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

Source

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.

Source

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

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

Source

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

Two’s-complement wrap at every multiplication step.

Source

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.

Source

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.

Source §

impl<const SCALE: u32> D9<SCALE>

Source

pub fn floor(self) -> Self

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

Source

pub fn ceil(self) -> Self

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

Source

pub fn trunc(self) -> Self

Drop the fractional part (toward zero).

The greater of self and other.

Source

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

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

Source §

impl<const SCALE: u32> D9<SCALE>

Source

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

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

Inlined rather than using i128::div_floor, which is still unstable for signed types.

Source

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

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

Source

pub const fn is_zero(self) -> bool

true if self is the additive identity.

Source

pub const 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”.

Source §

impl<const SCALE: u32> D9<SCALE>

Source

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

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

Lossless — every D9<SCALE> value fits D18<SCALE> by construction (i32::MAX < i64::MAX). Chains via further widen calls if you need to climb to D38 / D76 / etc.

use decimal_scaled::D9s6;
let a = D9s6::from_int(123);
let b = a.widen();              // D18<6>
assert_eq!(b.to_bits(), a.to_bits() as i64);

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.