#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum Round {
HalfEven,
HalfAwayFromZero,
Floor,
Ceiling,
TowardZero,
AwayFromZero,
}
#[inline(always)]
pub(crate) const fn round_away(
mode: Round,
negative: bool,
q_odd: bool,
r: u128,
d: u128,
) -> bool {
let other = d - r;
decide(mode, negative, q_odd, r > other, r == other, r != 0)
}
#[inline(always)]
pub(crate) const fn decide(
mode: Round,
negative: bool,
q_odd: bool,
above_half: bool,
at_half: bool,
inexact: bool,
) -> bool {
match mode {
Round::HalfEven => above_half | (at_half & q_odd),
Round::HalfAwayFromZero => above_half | at_half,
Round::Floor => negative & inexact,
Round::Ceiling => !negative & inexact,
Round::TowardZero => false,
Round::AwayFromZero => inexact,
}
}
#[cfg(test)]
mod tests {
use super::*;
const MODES: [Round; 6] = [
Round::HalfEven,
Round::HalfAwayFromZero,
Round::Floor,
Round::Ceiling,
Round::TowardZero,
Round::AwayFromZero,
];
fn oracle(n: i64, d: i64, mode: Round) -> i64 {
let down = n.div_euclid(d); let rem = n.rem_euclid(d); if rem == 0 {
return down;
}
let up = down + 1;
let positive = n > 0;
match mode {
Round::Floor => down,
Round::Ceiling => up,
Round::TowardZero => {
if positive {
down
} else {
up
}
}
Round::AwayFromZero => {
if positive {
up
} else {
down
}
}
_ if 2 * rem < d => down,
_ if 2 * rem > d => up,
Round::HalfEven => {
if down % 2 == 0 {
down
} else {
up
}
}
Round::HalfAwayFromZero => {
if positive {
up
} else {
down
}
}
}
}
#[test]
fn round_away_exhaustive_8_bit() {
let max_d: u128 = if cfg!(miri) { 12 } else { 255 };
for d in 1..=max_d {
for r in 0..d {
for q in 0..4u128 {
for negative in [false, true] {
for mode in MODES {
let magnitude = (q * d + r) as i64;
let n = if negative { -magnitude } else { magnitude };
let expected = oracle(n, d as i64, mode);
let away = round_away(mode, negative, q & 1 == 1, r, d);
let rounded = (q + away as u128) as i64;
let got = if negative { -rounded } else { rounded };
assert_eq!(got, expected, "n={n} d={d} mode={mode:?}");
}
}
}
}
}
}
}