}

macro_rules! test_float {

($modname: ident, $fty: ty, $inf: expr, $neginf: expr, $nan: expr, $min: expr, $max: expr, $min_pos: expr) => {

($modname: ident, $fty: ty, $inf: expr, $neginf: expr, $nan: expr, $min: expr, $max: expr, $min_pos: expr, $max_exp:expr) => {

mod $modname {

#[test]

fn min() {

assert!(($nan as $fty).midpoint(1.0).is_nan());

assert!((1.0 as $fty).midpoint($nan).is_nan());

assert!(($nan as $fty).midpoint($nan).is_nan());

// test if large differences in magnitude are still correctly computed.

// NOTE: that because of how small x and y are, x + y can never overflow

// so (x + y) / 2.0 is always correct

// in particular, `2.pow(i)` will never be at the max exponent, so it could

// be safely doubled, while j is significantly smaller.

for i in $max_exp.saturating_sub(64)..$max_exp {

for j in 0..64u8 {

let large = <$fty>::from(2.0f32).powi(i);

// a much smaller number, such that there is no chance of overflow to test

// potential double rounding in midpoint's implementation.

let small = <$fty>::from(2.0f32).powi($max_exp - 1)

* <$fty>::EPSILON

* <$fty>::from(j);

let naive = (large + small) / 2.0;

let midpoint = large.midpoint(small);

assert_eq!(naive, midpoint);

}

}

}

#[test]

fn rem_euclid() {

f32::NAN,

f32::MIN,

f32::MAX,

f32::MIN_POSITIVE

f32::MIN_POSITIVE,

f32::MAX_EXP

);

test_float!(

f64,

f64::NAN,

f64::MIN,

f64::MAX,

f64::MIN_POSITIVE

f64::MIN_POSITIVE,

f64::MAX_EXP

);