Struct D38 

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

Scaled fixed-point decimal with 128-bit storage.

SCALE is the base-10 exponent. A logical value v is stored as v * 10^SCALE in the underlying i128. For example, with SCALE = 12 the number 1.5 is stored as i128(1_500_000_000_000).

Precision

N/A: type definition, no arithmetic performed.

Determinism

All arithmetic is integer arithmetic on i128. The same inputs produce the same bit-pattern on every platform.

Equality and ordering

Hash, Eq, and Ord are derived from i128. Two D38<S> values are equal if and only if their underlying i128 fields are bit-equal. This works because the scale is fixed at compile time – each logical value has exactly one representation.

Const-generic scale

The const generic allows scale variants (D38<9>, D38<6>, etc.) as trivial type aliases without duplicating any method implementations. Mixed-scale arithmetic is deliberately not provided; callers convert explicitly.

Tuple Fields

0: i128

Implementations

impl<const SCALE: u32> D38<SCALE>

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

Multiply two values of the same scale, rounding the scale-narrowing divide by 10^SCALE according to mode.

The default Mul operator delegates to this with the crate-default rounding mode; call mul_with directly when you need a non-default rounding rule (e.g. HalfAwayFromZero for commercial rounding, Floor/Ceiling for one-sided bracketing).

Panics

Panics in debug builds when the rescaled quotient overflows i128. Wraps two’s-complement in release builds.

Precision

Strict: integer-only arithmetic. Within 0.5 ULP for the half-* family; directed rounding otherwise.

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

Divide two values of the same scale, rounding the final divide step according to mode.

The default Div operator delegates to this with the crate-default rounding mode.

Panics

Panics on division by zero (matching i128 /). Panics in debug builds when the quotient overflows i128; wraps in release.

Precision

Strict: integer-only arithmetic. Within 0.5 ULP for the half-* family; directed rounding otherwise.

impl<const SCALE: u32> D38<SCALE>

pub const EPSILON: Self

Smallest representable positive value: 1 LSB = 10^-SCALE.

Provided as an analogue to f64::EPSILON for generic numeric code. Note that this differs from the f64 definition (“difference between 1.0 and the next-larger f64”): for D38 the LSB is uniform across the entire representable range.

Precision

N/A: constant value, no arithmetic performed.

pub const MIN_POSITIVE: Self

Smallest positive value (equal to Self::EPSILON).

Provided as an analogue to f64::MIN_POSITIVE for generic numeric code. Unlike f64, D38 has no subnormals, so MIN_POSITIVE and EPSILON are the same value.

Precision

N/A: constant value, no arithmetic performed.

impl<const SCALE: u32> D38<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: i128) -> 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) -> i128

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() -> i128

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> D38<SCALE>

pub const 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 const fn rotate_left(self, n: u32) -> Self

Rotate the raw storage left by n bits.

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

Rotate the raw storage right by n bits.

pub const fn leading_zeros(self) -> u32

Number of leading zero bits in the raw storage.

pub const fn trailing_zeros(self) -> u32

Number of trailing zero bits in the raw storage.

pub const fn count_ones(self) -> u32

Population count of the raw storage.

pub const fn count_zeros(self) -> u32

Number of zero bits in the raw storage.

pub const fn is_power_of_two(self) -> bool

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

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

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

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 const fn is_zero(self) -> bool

true if self is the additive identity.

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

impl<const SCALE: u32> D38<SCALE>

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.

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. Available in no_std because the as f64 cast and float division are part of core.

pub fn to_f32(self) -> f32

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

impl<const SCALE: u32> D38<SCALE>

pub fn from_int(value: i64) -> 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).

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 integer part of the rounded value 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> D38<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> D38<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> D38<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> D38<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> D38<SCALE>

pub fn round(self) -> Self

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

impl<const SCALE: u32> D38<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> D38<SCALE>

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

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

use decimal_scaled::D38s9;
let a = D38s9::from_int(1_000_000);
let b = a.narrow().unwrap();
assert_eq!(b.to_bits() as i128, a.to_bits());

impl<const SCALE: u32> D38<SCALE>

pub fn from_num<T: ToPrimitive>(value: T) -> Self

Constructs a D38<SCALE> from any T: ToPrimitive, routing through num_traits::NumCast. Never panics — out-of-range inputs saturate.

Precision

Lossy: involves f32 or f64 at some point when T is a float type; result may lose precision. For integer T, the conversion is Strict (integer-only, bit-exact).

Saturation policy

• Float NaN maps to D38::ZERO.
• +Infinity maps to D38::MAX.
• -Infinity maps to D38::MIN.
• Finite out-of-range positive maps to D38::MAX.
• Finite out-of-range negative maps to D38::MIN.
• Never panics.

Examples

use decimal_scaled::D38s12;

assert_eq!(D38s12::from_num(42_i32), D38s12::from(42_i32));
assert_eq!(D38s12::from_num(f64::INFINITY), D38s12::MAX);
assert_eq!(D38s12::from_num(f64::NAN), D38s12::ZERO);

pub fn to_num<T: NumCast + Bounded>(self) -> T

Converts self to any T: NumCast + Bounded, routing through num_traits::NumCast. Never panics — out-of-range targets saturate to T::min_value() / T::max_value().

Precision

Lossy: involves f32 or f64 at some point when T is a float type; result may lose precision. For integer T, the conversion is Strict (integer-only, bit-exact).

Saturation policy

• In-range conversions return the cast value unchanged.
• Positive out-of-range maps to Bounded::max_value of T.
• Negative out-of-range maps to Bounded::min_value of T.
• Never panics.

Examples

use decimal_scaled::D38s12;

assert_eq!(D38s12::from(42_i32).to_num::<i32>(), 42_i32);
assert_eq!(D38s12::MAX.to_num::<i32>(), i32::MAX);
assert_eq!(D38s12::MIN.to_num::<i32>(), i32::MIN);

impl<const SCALE: u32> D38<SCALE>

pub fn ln_strict(self) -> Self

Returns the natural logarithm (base e) of self.

Algorithm

Range reduction x = 2^k * m with m ∈ [1, 2), then a Mercator reduction x = 2^k * m with m ∈ [1, 2), then the area-hyperbolic-tangent series ln(m) = 2·artanh(t), t = (m-1)/(m+1) ∈ [0, 1/3], artanh(t) = t + t³/3 + t⁵/5 + …, evaluated in a 256-bit fixed-point intermediate at SCALE + 20 working digits. The 20 guard digits bound the total accumulated rounding error far below 0.5 ULP of the output, so the result — k·ln(2) + ln(m), rounded once at the end — is correctly rounded.

Precision

Strict: integer-only, and correctly rounded — the result is within 0.5 ULP of the exact natural logarithm (IEEE-754 round-to-nearest).

Panics

Panics if self <= 0, or if the result overflows the type’s representable range (only possible for ln of a near-MAX value at SCALE >= 37).

Always available, regardless of the strict feature. When strict is enabled, the plain Self::ln delegates here.

pub fn ln(self) -> Self

Returns the natural logarithm (base e) of self.

With the strict feature enabled this is the integer-only Self::ln_strict; without it, the f64-bridge form.

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

Returns the logarithm of self in the given base, computed integer-only as ln(self) / ln(base) — both logarithms and the division are carried in the wide guard-digit intermediate, so the result is correctly rounded.

Always available, regardless of the strict feature.

Panics

Panics if self <= 0 or base <= 0, or if base == 1 (division by ln(1) = 0).

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

Returns the logarithm of self in the given base.

With the strict feature enabled this is the integer-only Self::log_strict; without it, the f64-bridge form.

pub fn log2_strict(self) -> Self

Returns the base-2 logarithm of self, computed integer-only as ln(self) / ln(2) in the wide guard-digit intermediate — the result is correctly rounded.

Always available, regardless of the strict feature.

Panics

Panics if self <= 0.

pub fn log2(self) -> Self

Returns the base-2 logarithm of self.

With the strict feature enabled this is the integer-only Self::log2_strict; without it, the f64-bridge form.

pub fn log10_strict(self) -> Self

Returns the base-10 logarithm of self, computed integer-only as ln(self) / ln(10) in the wide guard-digit intermediate — the result is correctly rounded.

Always available, regardless of the strict feature.

Panics

Panics if self <= 0.

pub fn log10(self) -> Self

Returns the base-10 logarithm of self.

With the strict feature enabled this is the integer-only Self::log10_strict; without it, the f64-bridge form.

pub fn exp_strict(self) -> Self

Returns e^self (natural exponential).

Algorithm

Range reduction x = k·ln(2) + s with k = round(x / ln 2) and |s| ≤ ln(2)/2 ≈ 0.347, then the Taylor series exp(s) = 1 + s + s²/2! + … evaluated in a 256-bit Fixed intermediate at SCALE + 30 working digits. Reassembly is exp(x) = 2^k · exp(s), applied as a shift on the working-scale value before the final rounding, so the 2^k factor never amplifies a rounding error. The result is rounded once, half-to-even, back to SCALE.

Precision

Strict: integer-only, and correctly rounded — the result is within 0.5 ULP of the exact exponential (IEEE-754 round-to-nearest).

Panics

Panics if the result overflows the type’s representable range.

pub fn exp(self) -> Self

Returns e^self (natural exponential).

With the strict feature enabled this is the integer-only Self::exp_strict; without it, the f64-bridge form.

pub fn exp2_strict(self) -> Self

Returns 2^self (base-2 exponential), computed integer-only as exp(self · ln(2)) — the self · ln(2) product is formed in the wide guard-digit intermediate (not at the type’s own scale), so the result is correctly rounded.

Always available, regardless of the strict feature.

Panics

Panics if the result overflows D38’s representable range.

pub fn exp2(self) -> Self

Returns 2^self (base-2 exponential).

With the strict feature enabled this is the integer-only Self::exp2_strict; without it, the f64-bridge form.

impl<const SCALE: u32> D38<SCALE>

pub fn ln_fast(self) -> Self

Returns the natural logarithm (base e) of self.

Precision

Lossy: converts to f64, calls f64::ln, converts back. f64::ln returns -Infinity for 0.0 (saturates to D38::MIN) and NaN for negative inputs (maps to D38::ZERO).

Examples

use decimal_scaled::D38s12;
// ln(1) == 0 (f64::ln(1.0) == 0.0 exactly).
assert_eq!(D38s12::ONE.ln(), D38s12::ZERO);

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

Returns the logarithm of self in the given base.

Implemented via a single f64::log(self_f64, base_f64) call, which avoids the extra quantisation that would come from computing ln(self) / ln(base) with two separate f64 round-trips.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// log_2(8) is approximately 3 within f64 precision.
let eight = D38s12::from_int(8);
let two = D38s12::from_int(2);
let result = eight.log(two);

pub fn log2_fast(self) -> Self

Returns the base-2 logarithm of self.

Precision

Lossy: involves f64 at some point; result may lose precision. On IEEE-754 platforms, f64::log2 is exact for integer powers of two (e.g. log2(8.0) == 3.0). Out-of-domain inputs follow the same saturation policy as Self::ln.

Examples

use decimal_scaled::D38s12;
// log2(1) == 0 (f64::log2(1.0) == 0.0 exactly).
assert_eq!(D38s12::ONE.log2(), D38s12::ZERO);

pub fn log10_fast(self) -> Self

Returns the base-10 logarithm of self.

Precision

Lossy: involves f64 at some point; result may lose precision. Out-of-domain inputs follow the same saturation policy as Self::ln.

Examples

use decimal_scaled::D38s12;
// log10(1) == 0 (f64::log10(1.0) == 0.0 exactly).
assert_eq!(D38s12::ONE.log10(), D38s12::ZERO);

pub fn exp_fast(self) -> Self

Returns e^self (natural exponential).

Precision

Lossy: involves f64 at some point; result may lose precision. Large positive inputs overflow f64 to +Infinity, which saturates to D38::MAX. Large negative inputs underflow to 0.0 in f64, which maps to D38::ZERO.

Examples

use decimal_scaled::D38s12;
// exp(0) == 1 (f64::exp(0.0) == 1.0 exactly).
assert_eq!(D38s12::ZERO.exp(), D38s12::ONE);

pub fn exp2_fast(self) -> Self

Returns 2^self (base-2 exponential).

Precision

Lossy: involves f64 at some point; result may lose precision. Saturation behaviour is analogous to Self::exp but at different magnitudes (inputs beyond approximately 1024 overflow to +Infinity).

Examples

use decimal_scaled::D38s12;
// exp2(0) == 1 (f64::exp2(0.0) == 1.0 exactly).
assert_eq!(D38s12::ZERO.exp2(), D38s12::ONE);

impl<const SCALE: u32> D38<SCALE>

pub const fn rescale<const TARGET_SCALE: u32>(self) -> D38<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; see that method for scale-up / scale-down semantics and the overflow policy.

pub const fn with_scale<const TARGET_SCALE: u32>(self) -> D38<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 const fn rescale_with<const TARGET_SCALE: u32>( self, mode: RoundingMode, ) -> D38<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> D38<SCALE>

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

Returns self * rhs, or None if the rescaled product does not fit in i128.

The intermediate product is computed with 256-bit arithmetic and cannot itself overflow. The only failure mode is a final i128 quotient that exceeds the storage range.

Precision

Strict: the result is truncated (not rounded) toward zero during the scale-restoring divide, identical to the default * operator.

Examples

use decimal_scaled::D38s12;

let half = D38s12::from_bits(500_000_000_000); // 0.5
assert_eq!(half.checked_mul(half), Some(D38s12::from_bits(250_000_000_000)));
assert_eq!(D38s12::MAX.checked_mul(D38s12::from_bits(2_000_000_000_000)), None);

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

Returns self * rhs with two’s-complement wrap when the rescaled product does not fit in i128.

On overflow, falls back to (a.wrapping_mul(b)).wrapping_div(multiplier()). The exact bit pattern of the wrapping result at extreme magnitudes is an implementation detail; only the no-panic contract is guaranteed.

Precision

Strict: truncates toward zero during the scale-restoring divide.

Examples

use decimal_scaled::D38s12;

let half = D38s12::from_bits(500_000_000_000); // 0.5
assert_eq!(half.wrapping_mul(half), D38s12::from_bits(250_000_000_000));
// Overflow does not panic.
let _ = D38s12::MAX.wrapping_mul(D38s12::from_bits(2_000_000_000_000));

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

Returns self * rhs, clamped to D38::MAX or D38::MIN on overflow.

The clamp direction is determined by the XOR of operand signs: same-sign operands saturate to MAX; mixed-sign operands saturate to MIN.

Precision

Strict: truncates toward zero during the scale-restoring divide.

Examples

use decimal_scaled::D38s12;

let two = D38s12::from_bits(2_000_000_000_000); // 2.0
assert_eq!(D38s12::MAX.saturating_mul(two), D38s12::MAX);
assert_eq!(D38s12::MAX.saturating_mul(-two), D38s12::MIN);

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

Returns (self * rhs, did_overflow) where the value is the wrapping result when overflow occurs.

Precision

Strict: truncates toward zero during the scale-restoring divide.

Examples

use decimal_scaled::D38s12;

let half = D38s12::from_bits(500_000_000_000); // 0.5
assert_eq!(half.overflowing_mul(half), (D38s12::from_bits(250_000_000_000), false));
let (_, ovf) = D38s12::MAX.overflowing_mul(D38s12::from_bits(2_000_000_000_000));
assert!(ovf);

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

Returns self / rhs, or None on division by zero or if the rescaled quotient does not fit in i128.

The only finite-operand overflow case is D38::MIN / NEG_ONE (storage negation of i128::MIN overflows).

Precision

Strict: the widening divide truncates toward zero, identical to the default / operator.

Examples

use decimal_scaled::D38s12;

let six = D38s12::from_bits(6_000_000_000_000); // 6.0
let two = D38s12::from_bits(2_000_000_000_000); // 2.0
assert_eq!(six.checked_div(two), Some(D38s12::from_bits(3_000_000_000_000)));
assert_eq!(D38s12::ONE.checked_div(D38s12::ZERO), None);

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

Returns self / rhs with two’s-complement wrap when the rescaled quotient does not fit in i128.

On overflow, falls back to (a.wrapping_mul(multiplier())).wrapping_div(b).

Precision

Strict: truncates toward zero.

Panics

Panics on rhs == ZERO (matches i128::wrapping_div).

Examples

use decimal_scaled::D38s12;

let six = D38s12::from_bits(6_000_000_000_000); // 6.0
let two = D38s12::from_bits(2_000_000_000_000); // 2.0
assert_eq!(six.wrapping_div(two), D38s12::from_bits(3_000_000_000_000));

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

Returns self / rhs, clamped to D38::MAX or D38::MIN on overflow.

The clamp direction is determined by the XOR of operand signs, because the scale multiplier is always positive.

Precision

Strict: truncates toward zero.

Panics

Panics on rhs == ZERO (matches i128::saturating_div).

Examples

use decimal_scaled::D38s12;

let six = D38s12::from_bits(6_000_000_000_000); // 6.0
let two = D38s12::from_bits(2_000_000_000_000); // 2.0
assert_eq!(six.saturating_div(two), D38s12::from_bits(3_000_000_000_000));
// MAX / 0.5 overflows; both positive so clamp to MAX.
assert_eq!(D38s12::MAX.saturating_div(D38s12::from_bits(500_000_000_000)), D38s12::MAX);

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

Returns (self / rhs, did_overflow) where the value is the wrapping result when overflow occurs.

Precision

Strict: truncates toward zero.

Panics

Panics on rhs == ZERO (matches i128::overflowing_div).

Examples

use decimal_scaled::D38s12;

let six = D38s12::from_bits(6_000_000_000_000); // 6.0
let two = D38s12::from_bits(2_000_000_000_000); // 2.0
assert_eq!(six.overflowing_div(two), (D38s12::from_bits(3_000_000_000_000), false));
let half = D38s12::from_bits(500_000_000_000); // 0.5
let (_, ovf) = D38s12::MAX.overflowing_div(half);
assert!(ovf);

impl<const SCALE: u32> D38<SCALE>

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

Raises self to the power exp.

Uses square-and-multiply: walks the bits of exp from low to high, squaring the base each step and accumulating when the corresponding bit is set. Costs O(log exp) multiplications. Each multiplication routes through the D38 Mul operator.

exp = 0 always returns ONE, even when self is ZERO (matches i128::pow convention).

Precision

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

Panics

In debug builds, panics on i128 overflow at any multiplication step. In release builds, wraps two’s-complement. Matches i128::pow and D38::Mul semantics.

Use Self::checked_pow, Self::wrapping_pow, Self::saturating_pow, or Self::overflowing_pow for explicit overflow control.

Examples

use decimal_scaled::D38s12;
let two = D38s12::from_int(2);
assert_eq!(two.pow(10), D38s12::from_int(1024));
// exp = 0 returns ONE regardless of base.
assert_eq!(D38s12::ZERO.pow(0), D38s12::ONE);

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

Raises self to the signed integer power exp.

For non-negative exp, equivalent to self.pow(exp as u32). For negative exp, returns D38::ONE / self.pow(exp.unsigned_abs()), i.e. the reciprocal of the positive-exponent form.

Precision

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

Panics

• Overflow of i128 storage at any step in debug builds (matches Self::pow).
• Division by zero when self == ZERO and exp < 0.

Examples

use decimal_scaled::D38s12;
let two = D38s12::from_int(2);
assert_eq!(two.powi(-1), D38s12::ONE / two);
assert_eq!(two.powi(0), D38s12::ONE);
assert_eq!(two.powi(3), D38s12::from_int(8));

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

Raises self to the power exp (strict integer-only stub).

Converts both operands to f64, calls f64::powf, then converts the result back. For integer exponents, prefer Self::pow or Self::powi, which are bit-exact.

NaN results map to ZERO; infinities clamp to MAX or MIN, following the saturate-vs-error policy of Self::from_f64.

Precision

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

Examples

use decimal_scaled::D38s12;
let two = D38s12::from_int(2);
let three = D38s12::from_int(3);
// 2^3 = 8, within f64 precision.
assert!((two.powf(three).to_f64() - 8.0).abs() < 1e-9);

Raises self to the power exp, computed integer-only as exp(exp · ln(self)) — the ln, the · exp, and the exp all run in the shared wide guard-digit intermediate, so the result is correctly rounded (within 0.5 ULP).

Always available, regardless of the strict feature. When strict is enabled, the plain Self::powf delegates here.

A zero or negative base saturates to ZERO (a negative base with an arbitrary fractional exponent is not real-valued), matching the f64-bridge NaN-to-ZERO policy.

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

Raises self to the power exp.

With the strict feature enabled this is the integer-only Self::powf_strict; without it, the f64-bridge form.

pub fn sqrt_strict(self) -> Self

Returns the square root of self (strict integer-only stub).

IEEE 754 mandates that f64::sqrt is correctly-rounded (round-to-nearest, ties-to-even). Combined with the deterministic to_f64 / from_f64 round-trip, this makes D38::sqrt bit-deterministic: the same input produces the same output bit-pattern on every IEEE-754-conformant platform.

Negative inputs produce a NaN from f64::sqrt, which Self::from_f64 maps to ZERO per the saturate-vs-error policy. No panic is raised for negative inputs.

Precision

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

Examples

use decimal_scaled::D38s12;
assert_eq!(D38s12::ZERO.sqrt(), D38s12::ZERO);
// f64::sqrt(1.0) == 1.0 exactly, so the result is bit-exact.
assert_eq!(D38s12::ONE.sqrt(), D38s12::ONE);

pub fn sqrt(self) -> Self

Returns the square root of self.

With the strict feature enabled this is the integer-only, correctly-rounded Self::sqrt_strict; without it, the f64-bridge form.

pub fn cbrt(self) -> Self

Returns the cube root of self.

With the strict feature enabled this is the integer-only Self::cbrt_strict; without it, the f64-bridge form.

pub fn cbrt_strict(self) -> Self

Cube root of self. Defined for all reals — the sign of the input is preserved (cbrt(-8) = -2).

Algorithm

For a D38<SCALE> with raw storage r, the raw storage of the cube root is

round( cbrt(r / 10^SCALE) · 10^SCALE ) = round( cbrt(r · 10^(2·SCALE)) ).

r · 10^(2·SCALE) is formed exactly as a 384-bit value and its integer cube root is computed exactly, so the result is the exact cube root correctly rounded to the type’s last place (within 0.5 ULP — the IEEE-754 round-to-nearest result).

Precision

Strict: integer-only; correctly rounded.

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

Returns sqrt(self^2 + other^2) without intermediate overflow, computed integer-only via the correctly-rounded Self::sqrt_strict. Same scale-trick algorithm as the f64-bridge Self::hypot; available in no_std.

Always available, regardless of the strict feature.

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

Returns sqrt(self^2 + other^2) without intermediate overflow.

With the strict feature enabled this is the integer-only Self::hypot_strict; without it, the f64-bridge form.

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

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

Walks the same square-and-multiply as Self::pow but uses mul_div_pow10 (which returns Option<i128>) at each step. The first None short-circuits to a None return.

Precision

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

Examples

use decimal_scaled::D38s12;
// MAX^2 overflows.
assert!(D38s12::MAX.checked_pow(2).is_none());
// Any power of ONE is ONE.
assert_eq!(D38s12::ONE.checked_pow(1_000_000), Some(D38s12::ONE));

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

Returns self^exp, wrapping two’s-complement on overflow at every multiplication step.

Follows the same square-and-multiply structure as Self::pow. When a step overflows mul_div_pow10, the fallback is wrapping_mul followed by wrapping_div of the scale multiplier. The exact wrap pattern is deterministic and reproducible but is not otherwise specified.

Precision

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

Examples

use decimal_scaled::D38s12;
// ONE^N never overflows and returns ONE.
assert_eq!(D38s12::ONE.wrapping_pow(1_000_000), D38s12::ONE);
// MAX^2 wraps to a deterministic but unspecified value.
let _ = D38s12::MAX.wrapping_pow(2);

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

Returns self^exp, clamping to D38::MAX or D38::MIN on overflow at any step.

On the first step that overflows, the result is clamped based on the sign of the mathematical result: positive overflows clamp to MAX, negative overflows clamp to MIN. The sign of the result is determined by self.signum() and whether exp is odd.

exp = 0 always returns ONE before entering the loop.

Precision

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

Examples

use decimal_scaled::D38s12;
assert_eq!(D38s12::MAX.saturating_pow(2), D38s12::MAX);
assert_eq!(D38s12::ONE.saturating_pow(1_000_000), D38s12::ONE);

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

Returns (self^exp, overflowed).

overflowed is true if any multiplication step overflowed i128. The returned value is the wrapping form (matches Self::wrapping_pow).

Precision

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

Examples

use decimal_scaled::D38s12;
let (_value, overflowed) = D38s12::MAX.overflowing_pow(2);
assert!(overflowed);
let (value, overflowed) = D38s12::ONE.overflowing_pow(5);
assert!(!overflowed);
assert_eq!(value, D38s12::ONE);

impl<const SCALE: u32> D38<SCALE>

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

Raises self to the power exp via the f64 bridge.

Converts both operands to f64, calls f64::powf, then converts the result back. For integer exponents, prefer Self::pow or Self::powi, which are bit-exact.

NaN results map to ZERO; infinities clamp to MAX or MIN, following the saturate-vs-error policy of Self::from_f64.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
let two = D38s12::from_int(2);
let three = D38s12::from_int(3);
// 2^3 = 8, within f64 precision.
assert!((two.powf(three).to_f64() - 8.0).abs() < 1e-9);

pub fn sqrt_fast(self) -> Self

Returns the square root of self via the f64 bridge.

IEEE 754 mandates that f64::sqrt is correctly-rounded (round-to-nearest, ties-to-even). Combined with the deterministic to_f64 / from_f64 round-trip, this makes D38::sqrt bit-deterministic: the same input produces the same output bit-pattern on every IEEE-754-conformant platform.

Negative inputs produce a NaN from f64::sqrt, which Self::from_f64 maps to ZERO per the saturate-vs-error policy. No panic is raised for negative inputs.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
assert_eq!(D38s12::ZERO.sqrt(), D38s12::ZERO);
// f64::sqrt(1.0) == 1.0 exactly, so the result is bit-exact.
assert_eq!(D38s12::ONE.sqrt(), D38s12::ONE);

pub fn cbrt_fast(self) -> Self

Returns the cube root of self via the f64 bridge.

f64::cbrt is defined for the entire real line, including negative inputs (cbrt(-8.0) == -2.0). The result is bit-deterministic across IEEE-754-conformant platforms because f64::cbrt is correctly-rounded.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
let neg_eight = D38s12::from_int(-8);
let result = neg_eight.cbrt();
assert!((result.to_f64() - (-2.0_f64)).abs() < 1e-9);

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

Returns sqrt(self^2 + other^2) without intermediate overflow.

The naive form (self * self + other * other).sqrt() overflows i128 once either operand approaches sqrt(D38::MAX). This method uses the scale trick to avoid that:

hypot(a, b) = max(|a|, |b|) * sqrt(1 + (min(|a|, |b|) / max(|a|, |b|))^2)

The min/max ratio is in [0, 1], so ratio^2 is also in [0, 1] and cannot overflow. The outer multiply by large only overflows when the true hypotenuse genuinely exceeds D38::MAX, which matches f64::hypot’s contract.

Both inputs are absolute-valued before processing, so hypot(-a, b) == hypot(a, b).

Edge cases: hypot(0, 0) == 0 (bit-exact via the early return); hypot(0, x) ~= |x| and hypot(x, 0) ~= |x|.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
let three = D38s12::from_int(3);
let four = D38s12::from_int(4);
// Pythagorean triple: hypot(3, 4) ~= 5.
assert!((three.hypot(four).to_f64() - 5.0).abs() < 1e-9);

impl<const SCALE: u32> D38<SCALE>

pub fn sin(self) -> Self

With strict this dispatches to Self::sin_strict; without it, the f64-bridge form is used instead.

pub fn cos(self) -> Self

With strict this dispatches to Self::cos_strict; without it, the f64-bridge form is used instead.

pub fn tan(self) -> Self

With strict this dispatches to Self::tan_strict; without it, the f64-bridge form is used instead.

pub fn asin(self) -> Self

With strict this dispatches to Self::asin_strict; without it, the f64-bridge form is used instead.

pub fn acos(self) -> Self

With strict this dispatches to Self::acos_strict; without it, the f64-bridge form is used instead.

pub fn atan(self) -> Self

With strict this dispatches to Self::atan_strict; without it, the f64-bridge form is used instead.

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

Four-quadrant arctangent of self (y) and other (x). With strict this dispatches to Self::atan2_strict; without it, the f64-bridge form is used instead.

pub fn sinh(self) -> Self

With strict this dispatches to Self::sinh_strict; without it, the f64-bridge form is used instead.

pub fn cosh(self) -> Self

With strict this dispatches to Self::cosh_strict; without it, the f64-bridge form is used instead.

pub fn tanh(self) -> Self

With strict this dispatches to Self::tanh_strict; without it, the f64-bridge form is used instead.

pub fn asinh(self) -> Self

With strict this dispatches to Self::asinh_strict; without it, the f64-bridge form is used instead.

pub fn acosh(self) -> Self

With strict this dispatches to Self::acosh_strict; without it, the f64-bridge form is used instead.

pub fn atanh(self) -> Self

With strict this dispatches to Self::atanh_strict; without it, the f64-bridge form is used instead.

pub fn to_degrees(self) -> Self

With strict this dispatches to Self::to_degrees_strict; without it, the f64-bridge form is used instead.

pub fn to_radians(self) -> Self

With strict this dispatches to Self::to_radians_strict; without it, the f64-bridge form is used instead.

pub fn sin_strict(self) -> Self

Sine of self (radians). Strict: integer-only and correctly rounded — the result is within 0.5 ULP of the exact sine.

pub fn cos_strict(self) -> Self

Cosine of self (radians). Strict: cos(x) = sin(x + π/2), correctly rounded.

pub fn tan_strict(self) -> Self

Tangent of self (radians). Strict: tan(x) = sin(x) / cos(x), with the division carried in the wide intermediate so the result is correctly rounded.

Panics

Panics if cos(self) is zero (an odd multiple of π/2).

pub fn atan_strict(self) -> Self

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

pub fn asin_strict(self) -> Self

Arcsine of self, in radians, in [−π/2, π/2]. Strict.

asin(x) = atan(x / √(1 − x²)); the endpoints ±1 map directly to ±π/2.

Panics

Panics if |self| > 1.

pub fn acos_strict(self) -> Self

Arccosine of self, in radians, in [0, π]. Strict: acos(x) = π/2 − asin(x), correctly rounded.

Panics

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: integer-only and correctly rounded.

pub fn sinh_strict(self) -> Self

Hyperbolic sine of self. Strict: sinh(x) = (eˣ − e⁻ˣ)/2, composed in the wide intermediate from the correctly-rounded exp, so the result is itself correctly rounded.

pub fn cosh_strict(self) -> Self

Hyperbolic cosine of self. Strict: cosh(x) = (eˣ + e⁻ˣ)/2, correctly rounded.

pub fn tanh_strict(self) -> Self

Hyperbolic tangent of self. Strict: tanh(x) = sinh(x)/cosh(x) with the division in the wide intermediate. cosh ≥ 1, so the division never traps.

pub fn asinh_strict(self) -> Self

Inverse hyperbolic sine of self. Strict: asinh(x) = sign · ln(|x| + √(x² + 1)), correctly rounded. For |x| ≥ 1 the radicand is factored as |x|·(1 + √(1 + 1/x²)) to keep x² from overflowing the wide intermediate.

pub fn acosh_strict(self) -> Self

Inverse hyperbolic cosine of self. Strict: acosh(x) = ln(x + √(x² − 1)), defined for x ≥ 1, correctly rounded. For x ≥ 2 the radicand is factored as x·(1 + √(1 − 1/x²)) to keep x² in range.

Panics

Panics if self < 1.

pub fn atanh_strict(self) -> Self

Inverse hyperbolic tangent of self. Strict: atanh(x) = ln((1 + x) / (1 − x)) / 2, defined for |x| < 1, correctly rounded.

Panics

Panics if |self| >= 1.

pub fn to_degrees_strict(self) -> Self

Convert radians to degrees: self · (180 / π). Strict: the multiply and divide run in the wide intermediate, so the result is correctly rounded.

pub fn to_radians_strict(self) -> Self

Convert degrees to radians: self · (π / 180). Strict: correctly rounded.

impl<const SCALE: u32> D38<SCALE>

pub fn sin_fast(self) -> Self

Sine of self, where self is in radians.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// sin(0) == 0 (bit-exact: f64::sin(0.0) == 0.0).
assert_eq!(D38s12::ZERO.sin(), D38s12::ZERO);

pub fn cos_fast(self) -> Self

Cosine of self, where self is in radians.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// cos(0) == 1 (bit-exact: f64::cos(0.0) == 1.0).
assert_eq!(D38s12::ZERO.cos(), D38s12::ONE);

pub fn tan_fast(self) -> Self

Tangent of self, where self is in radians.

f64::tan returns very large magnitudes near odd multiples of pi/2 and infinity at the limit. Inputs that drive the f64 result outside [D38::MIN, D38::MAX] saturate per Self::from_f64.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// tan(0) == 0 (bit-exact: f64::tan(0.0) == 0.0).
assert_eq!(D38s12::ZERO.tan(), D38s12::ZERO);

pub fn asin_fast(self) -> Self

Arcsine of self. Returns radians in [-pi/2, pi/2].

f64::asin returns NaN for inputs outside [-1, 1], which Self::from_f64 maps to D38::ZERO.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// asin(0) == 0.
assert_eq!(D38s12::ZERO.asin(), D38s12::ZERO);

pub fn acos_fast(self) -> Self

Arccosine of self. Returns radians in [0, pi].

f64::acos returns NaN for inputs outside [-1, 1], which Self::from_f64 maps to D38::ZERO.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::{D38s12, DecimalConsts};
// acos(1) == 0.
assert_eq!(D38s12::ONE.acos(), D38s12::ZERO);

pub fn atan_fast(self) -> Self

Arctangent of self. Returns radians in (-pi/2, pi/2).

Defined for the entire real line.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// atan(0) == 0.
assert_eq!(D38s12::ZERO.atan(), D38s12::ZERO);

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

Four-quadrant arctangent of self (y) over other (x). Returns radians in (-pi, pi].

Signature matches f64::atan2(self, other): the receiver is y and the argument is x.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::{D38s12, DecimalConsts};
// atan2(1, 1) ~= pi/4 (45 degrees, first quadrant).
let one = D38s12::ONE;
let result = one.atan2(one); // approximately D38s12::quarter_pi()

pub fn sinh_fast(self) -> Self

Hyperbolic sine of self.

Defined for the entire real line. Saturates at large magnitudes per Self::from_f64.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// sinh(0) == 0.
assert_eq!(D38s12::ZERO.sinh(), D38s12::ZERO);

pub fn cosh_fast(self) -> Self

Hyperbolic cosine of self.

Defined for the entire real line; result is always >= 1. Saturates at large magnitudes per Self::from_f64.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// cosh(0) == 1.
assert_eq!(D38s12::ZERO.cosh(), D38s12::ONE);

pub fn tanh_fast(self) -> Self

Hyperbolic tangent of self.

Defined for the entire real line; range is (-1, 1).

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// tanh(0) == 0.
assert_eq!(D38s12::ZERO.tanh(), D38s12::ZERO);

pub fn asinh_fast(self) -> Self

Inverse hyperbolic sine of self.

Defined for the entire real line.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// asinh(0) == 0.
assert_eq!(D38s12::ZERO.asinh(), D38s12::ZERO);

pub fn acosh_fast(self) -> Self

Inverse hyperbolic cosine of self.

f64::acosh returns NaN for inputs less than 1, which Self::from_f64 maps to D38::ZERO.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// acosh(1) == 0.
assert_eq!(D38s12::ONE.acosh(), D38s12::ZERO);

pub fn atanh_fast(self) -> Self

Inverse hyperbolic tangent of self.

f64::atanh returns NaN for inputs outside (-1, 1), which Self::from_f64 maps to D38::ZERO.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// atanh(0) == 0.
assert_eq!(D38s12::ZERO.atanh(), D38s12::ZERO);

pub fn to_degrees_fast(self) -> Self

Convert radians to degrees: self * (180 / pi).

Routed through f64::to_degrees so results match the de facto reference produced by the rest of the Rust ecosystem. Multiplying by a precomputed D38 factor derived from D38::pi() would diverge from f64 by a 1-LSB rescale rounding without any practical determinism gain, since the f64 bridge is already the precision floor.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// to_degrees(0) == 0.
assert_eq!(D38s12::ZERO.to_degrees(), D38s12::ZERO);

pub fn to_radians_fast(self) -> Self

Convert degrees to radians: self * (pi / 180).

Routed through f64::to_radians. See Self::to_degrees for the rationale.

Precision

Lossy: involves f64 at some point; result may lose precision.

Examples

use decimal_scaled::D38s12;
// to_radians(0) == 0.
assert_eq!(D38s12::ZERO.to_radians(), D38s12::ZERO);

Trait Implementations

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

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

Add two values of the same scale.

type Output = D38<SCALE>

The resulting type after applying the + operator.

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

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

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

Formats the value using the given formatter.

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

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

Bitwise AND of the raw storage values.

type Output = D38<SCALE>

The resulting type after applying the & operator.

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

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

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

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

Bitwise OR of the raw storage values.

type Output = D38<SCALE>

The resulting type after applying the | operator.

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

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

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

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

Bitwise XOR of the raw storage values.

type Output = D38<SCALE>

The resulting type after applying the ^ operator.

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

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl<const SCALE: u32> Bounded for D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<SCALE>

fn clone(&self) -> D38<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 D38<SCALE>

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

Formats the value using the given formatter.

impl<const SCALE: u32> Decimal for D38<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 = 38

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

The additive identity (logical value 0).

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

The multiplicative identity (logical value 1).

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

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

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

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

type Storage = i128

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

fn multiplier() -> i128

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

fn from_bits(raw: i128) -> Self

Constructs from a raw storage value.

fn to_bits(self) -> i128

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 D38<SCALE>

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 D38<SCALE>

Default returns ZERO, matching i128::default() == 0.

This lets #[derive(Default)] work correctly on structs that contain D38<S> fields.

fn default() -> Self

Returns the “default value” for a type.

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

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

Deserialise from a base-10 integer string (human-readable formats), 16 little-endian bytes (binary formats), or a native integer (self-describing binary formats such as CBOR).

Human-readable formats route via deserialize_any so a JSON string, JSON number, or TOML integer all reach the correct visitor branch. Binary formats that are not self-describing (postcard, bincode) route via deserialize_bytes directly.

Precision

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

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

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

Formats the value using the given formatter.

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

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

Divide self by rhs, rescaling the numerator to keep the result in value * 10^S form.

The numerator self.0 is widened to 256 bits and multiplied by 10^SCALE before dividing by rhs.0. This avoids the intermediate overflow that would occur with a naive (self.0 * 10^S) / rhs.0 approach at large dividend magnitudes.

Panics

Panics on division by zero (matching i128 /). Also panics in debug builds when the final quotient overflows i128; wraps in release builds.

Precision

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

Examples

use decimal_scaled::D38s12;

let a = D38s12::from_bits(3_000_000_000_000); // 3.0
let b = D38s12::from_bits(2_000_000_000_000); // 2.0
assert_eq!((a / b).to_bits(), 1_500_000_000_000); // 1.5

type Output = D38<SCALE>

The resulting type after applying the / operator.

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

fn div_assign(&mut self, rhs: Self)

Divide self by rhs in place.

Precision

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

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

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

Widens a narrower decimal type to this wider one. The scale is unchanged and the storage is widened by an as cast (lossless because the source storage type is strictly narrower than the destination).

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

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

Widens a narrower decimal type to this wider one. The scale is unchanged and the storage is widened by an as cast (lossless because the source storage type is strictly narrower than the destination).

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

fn from(value: i16) -> Self

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

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

fn from(value: i32) -> Self

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

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

fn from(value: i64) -> Self

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

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

fn from(value: i8) -> Self

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

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

fn from(value: u16) -> Self

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

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

fn from(value: u32) -> Self

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

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

fn from(value: u64) -> Self

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

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

fn from(value: u8) -> Self

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

impl<const SCALE: u32> FromPrimitive for D38<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 D38<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 D38<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> LowerExp for D38<SCALE>

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

Formats the value in scientific notation with a lowercase e.

Trailing zeros in the mantissa are stripped, so 1.500000000000 formats as 1.5e0. Zero formats as 0e0.

Precision

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

Examples

use decimal_scaled::D38s12;

let v = D38s12::from_bits(1_500_000_000_000);
assert_eq!(format!("{v:e}"), "1.5e0");

let sub = D38s12::from_bits(1_500_000_000);
assert_eq!(format!("{sub:e}"), "1.5e-3");

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

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

Formats the value using the given formatter.

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

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

Multiply two values, rescaling the result back to value * 10^S form.

The raw product a.0 * b.0 has units 10^(2S), so it must be divided by 10^S to restore the canonical scale. This is done via a 256-bit widening intermediate and a Moller-Granlund magic-number divide (see the mg_divide module), which avoids the intermediate overflow that would occur with a naive i128 multiply at large operand magnitudes.

Panics

Panics in debug builds when the final rescaled quotient overflows i128::MAX. In release builds the result wraps two’s-complement.

Precision

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

Examples

use decimal_scaled::D38s12;

let a = D38s12::from_bits(1_500_000_000_000); // 1.5
let b = D38s12::from_bits(2_000_000_000_000); // 2.0
assert_eq!((a * b).to_bits(), 3_000_000_000_000); // 3.0

type Output = D38<SCALE>

The resulting type after applying the * operator.

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

fn mul_assign(&mut self, rhs: Self)

Multiply self by rhs in place.

Precision

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

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

type Output = D38<SCALE>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

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

fn not(self) -> Self

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

type Output = D38<SCALE>

The resulting type after applying the ! operator.

impl<const SCALE: u32> Num for D38<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 D38<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 D38<SCALE>

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

Formats the value using the given formatter.

impl<const SCALE: u32> One for D38<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 D38<SCALE>

fn cmp(&self, other: &D38<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<D38<SCALE>> for f32

fn eq(&self, other: &D38<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<D38<SCALE>> for f64

fn eq(&self, other: &D38<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<D38<SCALE>> for i128

fn eq(&self, other: &D38<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<D38<SCALE>> for i16

fn eq(&self, other: &D38<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<D38<SCALE>> for i32

fn eq(&self, other: &D38<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<D38<SCALE>> for i64

fn eq(&self, other: &D38<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<D38<SCALE>> for i8

fn eq(&self, other: &D38<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<D38<SCALE>> for isize

fn eq(&self, other: &D38<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<D38<SCALE>> for u128

fn eq(&self, other: &D38<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<D38<SCALE>> for u16

fn eq(&self, other: &D38<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<D38<SCALE>> for u32

fn eq(&self, other: &D38<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<D38<SCALE>> for u64

fn eq(&self, other: &D38<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<D38<SCALE>> for u8

fn eq(&self, other: &D38<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<D38<SCALE>> for usize

fn eq(&self, other: &D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<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 D38<SCALE>

fn eq(&self, other: &D38<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 D38<SCALE>

fn partial_cmp(&self, other: &D38<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 D38<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 = D38<SCALE>

The resulting type after applying the % operator.

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

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

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

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

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

Precision

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

impl<const SCALE: u32> Shl<u32> for D38<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 = D38<SCALE>

The resulting type after applying the << operator.

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

fn shl_assign(&mut self, n: u32)

Performs the <<= operation.

impl<const SCALE: u32> Shr<u32> for D38<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 = D38<SCALE>

The resulting type after applying the >> operator.

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

fn shr_assign(&mut self, n: u32)

Performs the >>= operation.

impl<const SCALE: u32> Signed for D38<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 D38<SCALE>

type Output = D38<SCALE>

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const SCALE: u32> ToPrimitive for D38<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<D38<SCALE>> for D18<SCALE>

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

Attempts to narrow a wider decimal type to this narrower one. Fails with OutOfRange 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<D38<SCALE>> for D9<SCALE>

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

Attempts to narrow a wider decimal type to this narrower one. Fails with OutOfRange 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 D38<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 D38<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 D38<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 D38<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> UpperExp for D38<SCALE>

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

Formats the value in scientific notation with an uppercase E.

Identical to fmt::LowerExp except the exponent separator is E.

Precision

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

Examples

use decimal_scaled::D38s12;

let v = D38s12::from_bits(1_500_000_000_000);
assert_eq!(format!("{v:E}"), "1.5E0");

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

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

Formats the value using the given formatter.

impl<const SCALE: u32> Zero for D38<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 D38<SCALE>

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

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