Struct Divisor 

pub struct Divisor<I: Int, S: Scale> { /* private fields */ }

A divisor prepared once, for dividing many values by it.

A book’s notionals by one price, or amounts by one rate: div_round and checked_div_round take it where they take a decimal, and divide by two multiplications and a comparison, where by a decimal they take a division. Preparing it takes a division, so it pays where one divisor divides many values: on values of random lengths by one divisor, a D64<8> quotient rounded half to even takes 3.00 ns prepared and 5.97 by the decimal, and a D128<18> one 12.40 and 15.95, on a Graviton4 (bench/results/2026-10-14T06-08Z-pr18-baseline-graviton4).

Examples

use ddust::round::HalfEven;
use ddust::{D64, Divisor, dec};

let price: D64<2> = dec!(64_250.50);
let by_price = Divisor::new(price).expect("not zero");
let notional: D64<8> = dec!(1_000_000);
assert_eq!(notional.div_round(by_price, HalfEven), dec!(15.56408121), "units of it");
assert_eq!(notional.div_round(by_price, HalfEven), notional.div_round(price, HalfEven));
assert!(Divisor::new(D64::<2>::ZERO).is_none(), "never zero");

Implementations

impl<I: Int, S: Scale> Divisor<I, S>

pub const fn new(value: Decimal<I, S>) -> Option<Self>

where I: Int, S: Scale,

value prepared as a divisor, or None for zero.

Examples

use ddust::{D64, Divisor, dec};

let rate: D64<4> = dec!(1.0825);
assert_eq!(Divisor::new(rate).map(Divisor::get), Some(rate), "prepared");
assert!(Divisor::new(D64::<4>::ZERO).is_none(), "never zero");

pub const fn get(self) -> Decimal<I, S>

The value it divides by.

Trait Implementations

impl<I: Clone + Int, S: Clone + Scale> Clone for Divisor<I, S>

where I::Prepared: Clone,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Copy + Int, S: Copy + Scale> Copy for Divisor<I, S>

where I::Prepared: Copy,

impl<I: Debug + Int, S: Debug + Scale> Debug for Divisor<I, S>

where I::Prepared: Debug,

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

Formats the value using the given formatter.

impl<I: Int, T: Scale> DivisorOf<I> for Divisor<I, T>

impl<I: Int, S: Scale> Eq for Divisor<I, S>

impl<I: Int, S: Scale> Hash for Divisor<I, S>

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<I: Int, S: Scale> PartialEq for Divisor<I, S>

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

Equality operator ==.

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

Inequality operator !=.