Trait fixnum::ops::RoundingMul

source · [−]
pub trait RoundingMul<Rhs = Self> {
    type Output;
    type Error;

    fn rmul(
        self, 
        rhs: Rhs, 
        mode: RoundMode
    ) -> Result<Self::Output, Self::Error>;

    fn saturating_rmul(self, rhs: Rhs, round_mode: RoundMode) -> Self::Output
    where
        Self: PartialOrd + Zero + Sized,
        Rhs: PartialOrd + Zero,
        Self::Output: Bounded,
    { ... }
}
Expand description

Rounding multiplication.

Required Associated Types

Result of multiplication.

Usually ArithmeticError.

Required Methods

Checked rounded multiplication. Returns Err on overflow. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

use fixnum::{FixedPoint, typenum::U9, ops::{Zero, RoundingMul, RoundMode::*}};

type Amount = FixedPoint<i64, U9>;

let a: Amount = "0.000000001".parse()?;
let b: Amount = "0.000000002".parse()?;
// 1e-9 * (Ceil) 2e-9 = 1e-9
assert_eq!(a.rmul(b, Ceil)?, a);
assert_eq!(b.rmul(a, Ceil)?, a);
// 1e-9 * (Floor) 2e-9 = 0
assert_eq!(a.rmul(b, Floor)?, Amount::ZERO);
assert_eq!(b.rmul(a, Floor)?, Amount::ZERO);

Provided Methods

Saturating rounding multiplication. Computes self * rhs, saturating at the numeric bounds (MIN, MAX) instead of overflowing. Because of provided RoundMode it’s possible to perform across the FixedPoint values.

use fixnum::{FixedPoint, typenum::U9, ops::{Zero, Bounded, RoundMode::*, RoundingMul}};

type Amount = FixedPoint<i64, U9>;

let a: Amount = "0.000000001".parse()?;
let b: Amount = "0.000000002".parse()?;
// 1e-9 * (SaturatingCeil) 2e9 = 1e-9
assert_eq!(a.saturating_rmul(b, Ceil), a);
// 1e-9 * (SaturatingFloor) 2e9 = 0
assert_eq!(a.saturating_rmul(b, Floor), Amount::ZERO);

// MIN * (SaturatingFloor) MIN = MAX
assert_eq!(Amount::MIN.saturating_rmul(Amount::MIN, Floor), Amount::MAX);

let c: Amount = "-1.000000001".parse()?;
// -1.000000001 * (SaturatingCeil) MAX = MIN
assert_eq!(c.saturating_rmul(Amount::MAX, Ceil), Amount::MIN);

Implementors