Struct D96 

pub struct D96 { /* private fields */ }

96-bit fixed-point decimal with 12 decimal places of precision.

Uses 128-bit storage but only uses 96 bits of the mantissa for faster arithmetic. Range: ±39,614,081,257,132.168796771975167 Precision: 0.000000000001 (1 microGwei = 1000 wei)

Implementations

impl D96

pub const SCALE: i128 = 1_000_000_000_000i128

The scale factor: 10^12

pub const DECIMALS: u8 = 12u8

The number of decimal places

pub const MAX: Self

Maximum 96-bit value: 2^95 - 1 Range: ±39.6 trillion with 12 decimals

pub const MIN: Self

Minimum 96-bit value: -2^95

pub const ZERO: Self

Zero

pub const ONE: Self

One (1.0)

pub const TEN: Self

Ten (10.0)

pub const HUNDRED: Self

One hundred (100.0)

pub const THOUSAND: Self

One thousand (1000.0)

pub const CENT: Self

One cent (0.01) - USD, EUR, and most currency smallest unit

pub const MIL: Self

One mil (0.001) - used in some pricing contexts

pub const BASIS_POINT: Self

One basis point (0.0001) - 1 bps, common in interest rates

pub const HALF_BASIS_POINT: Self

One half basis point (0.00005)

pub const QUARTER_BASIS_POINT: Self

One quarter basis point (0.000025)

pub const THIRTY_SECOND: Self

One thirty-second (1/32 = 0.03125) - US Treasury bond price tick

pub const SIXTY_FOURTH: Self

One sixty-fourth (1/64 = 0.015625) - US Treasury bond price tick

pub const HALF_THIRTY_SECOND: Self = Self::SIXTY_FOURTH

One half of a thirty-second (1/64) - alternative name

pub const QUARTER_THIRTY_SECOND: Self

One quarter of a thirty-second (1/128 = 0.0078125)

pub const EIGHTH_THIRTY_SECOND: Self

One eighth of a thirty-second (1/256 = 0.00390625)

pub const EIGHTH: Self

One eighth (0.125) - legacy stock pricing increment

pub const SIXTEENTH: Self

One sixteenth (0.0625) - legacy stock pricing increment

pub const QUARTER: Self

One quarter (0.25)

pub const HALF: Self

One half (0.5)

pub const PERCENT: Self = Self::CENT

One percent (0.01) - same as CENT but semantic clarity

pub const TEN_BPS: Self = Self::MIL

Ten basis points (0.001) - same as MIL

pub const HUNDRED_BPS: Self = Self::PERCENT

One hundred basis points (0.01) - same as PERCENT

pub const SATOSHI: Self

One satoshi in Bitcoin terms (0.00000001) - 8 decimal places

pub const GWEI: Self

One gwei (0.000000001) - 9 decimal places, common gas unit With 12 decimals, 1 gwei = 1000 units

pub const MICRO_GWEI: Self

One microGwei (0.000000000001) - minimum representable unit Equal to 1000 wei

pub const KILO_WEI: Self

One thousand wei (0.000000000001 ETH)

impl D96

pub const fn from_raw(value: i128) -> Self

Creates a new D96 from a raw scaled value.

Panics

Panics in debug mode if value exceeds 96-bit range

pub const fn from_raw_checked(value: i128) -> Option<Self>

Creates a new D96 from a raw scaled value, checking bounds.

pub const fn to_raw(self) -> i128

Returns the raw internal value (scaled by 10^12).

pub const fn new(integer: i128, fractional: i128) -> Self

Creates a D96 from integer and fractional parts at compile time Example: new(123, 450_000_000_000) → 123.45

The fractional part should always be positive. For negative numbers, use a negative integer part: new(-123, 450_000_000_000) → -123.45

Panics

Panics if the value would overflow the 96-bit range.

pub const fn from_basis_points(bps: i128) -> Option<Self>

Create from basis points (1 bp = 0.0001) Example: from_basis_points(100) → 0.01 (1%)

pub const fn to_basis_points(self) -> i128

Convert to basis points Example: D96::from_str("0.01").unwrap().to_basis_points() → 100

pub fn with_scale(mantissa: i128, scale: u32) -> Self

Creates a D96 from a mantissa and scale (like rust_decimal).

The scale represents the number of decimal places. For example: with_scale(12345, 2) = 123.45

Panics

Panics if:

• The scale is greater than 12 (our max precision)
• The resulting value is out of bounds for D96

pub const fn try_with_scale(mantissa: i128, scale: u32) -> Option<Self>

Creates a D96 from a mantissa and scale, returning None on error.

Like with_scale but returns None instead of panicking.

pub fn with_scale_lossy(mantissa: i128, scale: u32) -> Self

Creates a D96 from a mantissa and scale, rounding if necessary.

If the scale is greater than 12, the mantissa will be divided by 10^(scale-12) to fit our precision, rounding to the nearest even number (banker’s rounding).

Panics

Panics if the resulting value (after rounding) is out of bounds for D96.

pub const fn try_with_scale_lossy(mantissa: i128, scale: u32) -> Option<Self>

Creates a D96 from a mantissa and scale, rounding if necessary, returns None on error.

Like with_scale_lossy but returns None instead of panicking on overflow.

impl D96

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

Checked addition. Returns None if overflow occurred.

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

Saturating addition. Clamps on overflow.

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

Wrapping addition. Wraps on overflow.

pub const fn try_add(self, rhs: Self) -> Result<Self>

Checked addition. Returns an error if overflow occurred.

impl D96

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

Checked subtraction. Returns None if overflow occurred.

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

Saturating subtraction. Clamps on overflow.

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

Wrapping subtraction. Wraps on overflow.

pub const fn try_sub(self, rhs: Self) -> Result<Self>

Checked subtraction. Returns an error if overflow occurred.

impl D96

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

Optimized multiplication for 96-bit values

Since we guarantee 96-bit inputs, we can use optimized 192-bit arithmetic

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

Saturating multiplication

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

Wrapping multiplication

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

Multiply by an integer (faster than general multiplication) Useful for: quantity * price, shares * rate, etc.

pub fn mul_add(self, mul: Self, add: Self) -> Option<Self>

Computes (self * mul) + add with only one rounding step More accurate and faster than separate mul + add

pub fn try_mul(self, rhs: Self) -> Result<Self>

Checked multiplication. Returns an error if overflow occurred.

pub const fn try_mul_i128(self, rhs: i128) -> Result<Self>

Multiply by an integer, returning an error on overflow

impl D96

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

Checked division. Returns None if rhs is zero or overflow occurred.

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

Wrapping division. Wraps on overflow. Returns zero if rhs is zero.

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

Saturating division. Clamps on overflow. Returns zero if rhs is zero.

pub fn try_div(self, rhs: Self) -> Result<Self>

Checked division. Returns an error if rhs is zero or overflow occurred.

impl D96

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

Checked negation. Returns None if the result would overflow.

pub const fn saturating_neg(self) -> Self

Saturating negation. Clamps on overflow.

pub const fn wrapping_neg(self) -> Self

Wrapping negation. Wraps on overflow.

pub const fn try_neg(self) -> Result<Self>

Checked negation. Returns an error if overflow occurred.

impl D96

pub const fn abs(self) -> Self

Returns the absolute value of self.

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

Checked absolute value. Returns None if the result would overflow.

pub const fn saturating_abs(self) -> Self

Saturating absolute value. Clamps on overflow.

pub const fn wrapping_abs(self) -> Self

Wrapping absolute value. Wraps on overflow.

pub const fn try_abs(self) -> Result<Self>

Checked absolute value. Returns an error if overflow occurred.

impl D96

pub const fn is_positive(self) -> bool

Returns true if self is positive.

pub const fn is_negative(self) -> bool

Returns true if self is negative.

pub const fn is_zero(self) -> bool

Returns true if self is zero.

pub const fn signum(self) -> i32

Returns the sign of self as -1, 0, or 1.

impl D96

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

Returns the minimum of two values.

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

Returns the maximum of two values.

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

Restricts a value to a certain interval.

impl D96

pub const fn floor(self) -> Self

Returns the largest integer less than or equal to self.

pub const fn ceil(self) -> Self

Returns the smallest integer greater than or equal to self.

pub const fn trunc(self) -> Self

Returns the integer part of self, truncating any fractional part.

pub const fn fract(self) -> Self

Returns the fractional part of self.

pub const fn round(self) -> Self

Rounds to the nearest integer, using banker’s rounding (round half to even).

pub const fn round_dp(self, decimal_places: u8) -> Self

Rounds to the specified number of decimal places.

impl D96

pub fn recip(self) -> Option<Self>

Returns the reciprocal (multiplicative inverse) of self.

pub fn try_recip(self) -> Result<Self>

Checked reciprocal. Returns an error if self is zero.

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

Raises self to an integer power.

pub fn try_powi(self, exp: i32) -> Result<Self>

Checked integer power. Returns an error if overflow occurred.

pub fn sqrt(self) -> Option<Self>

Returns the square root of self using Newton’s method.

pub fn try_sqrt(self) -> Result<Self>

Checked square root. Returns an error if self is negative.

impl D96

pub const fn from_i128(value: i128) -> Option<Self>

Creates a D96 from an i128 integer.

pub const fn from_i64(value: i64) -> Self

Creates a D96 from an i64 integer (always succeeds for reasonable values).

pub const fn from_i32(value: i32) -> Self

Creates a D96 from an i32 integer (always succeeds).

pub const fn from_u32(value: u32) -> Self

Creates a D96 from a u32 integer (always succeeds).

pub const fn from_u64(value: u64) -> Self

Creates a D96 from a u64 integer (always succeeds for reasonable values).

pub const fn from_u128(value: u128) -> Option<Self>

Creates a D96 from a u128 integer.

pub const fn to_i128(self) -> i128

Converts to i128, truncating any fractional part.

pub const fn to_i64(self) -> Option<i64>

Converts to i64, truncating any fractional part. Returns None if the value doesn’t fit in i64.

pub const fn to_i128_round(self) -> i128

Converts to i128, rounding to nearest (banker’s rounding on ties).

pub const fn try_from_i128(value: i128) -> Result<Self>

Creates a D96 from an i128, returning an error on overflow.

pub const fn try_from_u128(value: u128) -> Result<Self>

Creates a D96 from a u128, returning an error on overflow.

impl D96

pub fn from_f64(value: f64) -> Option<Self>

Creates a D96 from an f64.

Returns None if the value is NaN, infinite, or out of range.

pub fn to_f64(self) -> f64

Converts to f64.

Note: May lose precision for very large values.

pub fn from_f32(value: f32) -> Option<Self>

Creates a D96 from an f32.

pub fn to_f32(self) -> f32

Converts to f32.

Note: May lose precision.

pub fn try_from_f64(value: f64) -> Result<Self>

Creates a D96 from an f64, returning an error if invalid.

impl D96

pub fn percent_of(self, percent: Self) -> Option<Self>

Calculate percentage: self * (percent / 100)

pub fn add_percent(self, percent: Self) -> Option<Self>

Add percentage: self * (1 + percent/100)

impl D96

pub fn from_str_exact(s: &str) -> Result<Self>

Parses a decimal string into a D96.

Supports formats like: “123”, “123.45”, “-123.45”, “0.000000000001” Fast parsing using SWAR (SIMD Within A Register) for both integer and fractional parts

pub fn from_str_lossy(s: &str) -> Result<Self>

Parse a string, rounding to 12 decimal places if necessary

Unlike from_str_exact, this will succeed even if the input has more than 12 decimal places, rounding the excess digits using banker’s rounding.

pub fn from_fixed_point_str(s: &str, decimals: u8) -> Result<Self>

Parse from fixed-point string (no decimal point)

impl D96

pub const BYTES: usize = 16usize

The size of this type in bytes.

pub fn from_utf8_bytes(bytes: &[u8]) -> Result<Self>

Parse from byte slice

pub const fn from_le_bytes(bytes: [u8; 16]) -> Self

Read D96 from little-endian bytes

pub const fn from_be_bytes(bytes: [u8; 16]) -> Self

Read D96 from big-endian bytes

pub const fn from_ne_bytes(bytes: [u8; 16]) -> Self

Read D96 from native-endian bytes

pub const fn read_le_bytes(bytes: &[u8]) -> Self

Read D96 from a byte slice (little-endian)

pub const fn read_be_bytes(bytes: &[u8]) -> Self

Read D96 from a byte slice (big-endian)

pub const fn read_ne_bytes(bytes: &[u8]) -> Self

Read D96 from a byte slice (native-endian)

pub const fn try_read_le_bytes(bytes: &[u8]) -> Option<Self>

Try to read D96 from a byte slice (little-endian), checking bounds

pub const fn try_read_be_bytes(bytes: &[u8]) -> Option<Self>

Try to read D96 from a byte slice (big-endian), checking bounds

pub const fn try_read_ne_bytes(bytes: &[u8]) -> Option<Self>

Try to read D96 from a byte slice (native-endian), checking bounds

pub const fn to_be_bytes(self) -> [u8; 16]

Returns the memory representation as a byte array in big-endian byte order.

pub const fn to_le_bytes(self) -> [u8; 16]

Returns the memory representation as a byte array in little-endian byte order.

pub const fn to_ne_bytes(self) -> [u8; 16]

Returns the memory representation as a byte array in native byte order.

pub fn write_le_bytes(&self, buf: &mut [u8])

Writes the decimal as bytes in little-endian order.

pub fn write_be_bytes(&self, buf: &mut [u8])

Writes the decimal as bytes in big-endian order.

pub fn write_ne_bytes(&self, buf: &mut [u8])

Writes the decimal as bytes in native-endian order.

pub fn try_write_le_bytes(&self, buf: &mut [u8]) -> Option<()>

Tries to write the decimal as bytes in little-endian order.

pub fn try_write_be_bytes(&self, buf: &mut [u8]) -> Option<()>

Tries to write the decimal as bytes in big-endian order.

pub fn try_write_ne_bytes(&self, buf: &mut [u8]) -> Option<()>

Tries to write the decimal as bytes in native-endian order.

Trait Implementations

impl Add for D96

type Output = D96

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for D96

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for D96

fn clone(&self) -> D96

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for D96

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

Formats the value using the given formatter.

impl Default for D96

fn default() -> Self

Returns the “default value” for a type.

impl Display for D96

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

Formats the value using the given formatter.

impl Div for D96

type Output = D96

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign for D96

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl From<i16> for D96

fn from(value: i16) -> Self

Converts to this type from the input type.

impl From<i32> for D96

fn from(value: i32) -> Self

Converts to this type from the input type.

impl From<i64> for D96

fn from(value: i64) -> Self

Converts to this type from the input type.

impl From<i8> for D96

fn from(value: i8) -> Self

Converts to this type from the input type.

impl From<u16> for D96

fn from(value: u16) -> Self

Converts to this type from the input type.

impl From<u32> for D96

fn from(value: u32) -> Self

Converts to this type from the input type.

impl From<u64> for D96

fn from(value: u64) -> Self

Converts to this type from the input type.

impl From<u8> for D96

fn from(value: u8) -> Self

Converts to this type from the input type.

impl FromStr for D96

type Err = DecimalError

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 Hash for D96

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 Mul for D96

type Output = D96

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for D96

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for D96

type Output = D96

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for D96

fn cmp(&self, other: &D96) -> 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 PartialEq for D96

fn eq(&self, other: &D96) -> 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 PartialOrd for D96

fn partial_cmp(&self, other: &D96) -> 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<'a> Product<&'a D96> for D96

fn product<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl Product for D96

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl Sub for D96

type Output = D96

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for D96

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<'a> Sum<&'a D96> for D96

fn sum<I: Iterator<Item = &'a Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Sum for D96

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl TryFrom<f32> for D96

type Error = DecimalError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<f64> for D96

type Error = DecimalError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<i128> for D96

type Error = DecimalError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl TryFrom<u128> for D96

type Error = DecimalError

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Copy for D96

impl Eq for D96

impl StructuralPartialEq for D96