use super::super::expansion::{expansion_sign, expansion_sum, negate, scale_expansion};
use super::super::sign::Sign;
pub(super) fn next_up(x: f64) -> f64 {
if x == 0.0 {
return f64::from_bits(1); }
let bits = x.to_bits();
f64::from_bits(if x > 0.0 { bits + 1 } else { bits - 1 })
}
pub(super) fn next_down(x: f64) -> f64 {
-next_up(-x)
}
pub(super) fn correctly_rounded_divide(num: &[f64], denom: &[f64]) -> f64 {
let denom_sign = expansion_sign(denom);
let mut q: f64 = num.iter().sum::<f64>() / denom.iter().sum::<f64>();
for iter in 0..8u32 {
let r = expansion_sum(num, &negate(&scale_expansion(denom, q)));
let r_sign = expansion_sign(&r);
if r_sign == Sign::Zero {
record_iters(iter);
return q;
}
let quotient_positive = r_sign == denom_sign;
let neighbor = if quotient_positive {
next_up(q)
} else {
next_down(q)
};
let half_ulp = 0.5 * (neighbor - q).abs();
let r_abs = if r_sign == Sign::Positive {
r
} else {
negate(&r)
};
let denom_abs = if denom_sign == Sign::Positive {
denom.to_vec()
} else {
negate(denom)
};
let threshold = scale_expansion(&denom_abs, half_ulp);
match expansion_sign(&expansion_sum(&r_abs, &negate(&threshold))) {
Sign::Negative => {
record_iters(iter);
return q;
}
Sign::Positive => q = neighbor,
Sign::Zero => {
record_iters(iter);
let q_is_even = (q.to_bits() & 1) == 0;
return if q_is_even { q } else { neighbor };
}
}
}
record_iters(8);
q
}
#[cfg(test)]
pub(super) fn record_iters(n: u32) {
MAX_DIVIDE_ITERS.with(|c| c.set(c.get().max(n)));
}
#[cfg(not(test))]
#[inline(always)]
fn record_iters(_n: u32) {}
#[cfg(test)]
thread_local! {
pub(super) static MAX_DIVIDE_ITERS: std::cell::Cell<u32> = const { std::cell::Cell::new(0) };
}
#[cfg(test)]
mod tests {
use super::super::super::expansion::two_sum;
use super::*;
#[test]
fn next_up_down_basic() {
assert!(next_up(1.0) > 1.0);
assert_eq!(next_down(next_up(1.0)), 1.0);
assert_eq!(next_up(0.0), f64::from_bits(1));
assert_eq!(next_up(-0.0), f64::from_bits(1));
assert_eq!(next_down(0.0), -f64::from_bits(1));
assert!(next_up(-1.0) > -1.0);
assert_eq!(next_down(next_up(-1.0)), -1.0);
}
fn assert_exact_tie_rounds_to_even(q0: f64) {
for neighbor in [next_up(q0), next_down(q0)] {
let (hi, lo) = two_sum(q0, neighbor);
let midpoint = scale_expansion(&[lo, hi], 0.5);
let got = correctly_rounded_divide(&midpoint, &[1.0]);
let expected = if (q0.to_bits() & 1) == 0 {
q0
} else {
neighbor
};
assert_eq!(
got, expected,
"tie between {q0} and {neighbor} should round to the even one"
);
}
}
#[test]
fn exact_tie_rounds_to_even_normal_range() {
assert_exact_tie_rounds_to_even(3.0);
}
#[test]
fn exact_tie_rounds_to_even_at_power_of_two_boundary() {
assert_exact_tie_rounds_to_even(4.0);
}
}