use lexical_parse_float::float::{self, RawFloat};
use lexical_parse_float::limits::ExactFloat;
use lexical_util::num::Float;
#[test]
fn exponent_fast_path_test() {
assert_eq!(f32::min_exponent_fast_path(10), -10);
assert_eq!(f32::max_exponent_fast_path(10), 10);
assert_eq!(f32::max_exponent_disguised_fast_path(10), 17);
assert_eq!(f64::min_exponent_fast_path(10), -22);
assert_eq!(f64::max_exponent_fast_path(10), 22);
assert_eq!(f64::max_exponent_disguised_fast_path(10), 37);
}
fn slow_f32_power(exponent: usize, radix: u32) -> f32 {
let mut value: f32 = 1.0;
for _ in 0..exponent {
value *= radix as f32;
}
value
}
fn slow_f64_power(exponent: usize, radix: u32) -> f64 {
let mut value: f64 = 1.0;
for _ in 0..exponent {
value *= radix as f64;
}
value
}
fn pow_fast_path(radix: u32) {
for exponent in 0..f32::exponent_limit(radix).1 + 1 {
let exponent = exponent as usize;
let actual = f32::pow_fast_path(exponent, radix);
assert_eq!(actual, slow_f32_power(exponent, radix));
}
for exponent in 0..f64::exponent_limit(radix).1 + 1 {
let exponent = exponent as usize;
let actual = f64::pow_fast_path(exponent, radix);
assert_eq!(actual, slow_f64_power(exponent, radix));
}
}
#[test]
#[cfg_attr(miri, ignore)]
fn pow_fast_path_test() {
pow_fast_path(10);
if cfg!(feature = "power-of-two") {
pow_fast_path(2);
pow_fast_path(4);
pow_fast_path(8);
pow_fast_path(16);
pow_fast_path(32);
}
if cfg!(feature = "radix") {
pow_fast_path(3);
pow_fast_path(5);
pow_fast_path(6);
pow_fast_path(7);
pow_fast_path(9);
pow_fast_path(11);
pow_fast_path(12);
pow_fast_path(13);
pow_fast_path(14);
pow_fast_path(15);
pow_fast_path(17);
pow_fast_path(18);
pow_fast_path(19);
pow_fast_path(20);
pow_fast_path(21);
pow_fast_path(22);
pow_fast_path(23);
pow_fast_path(24);
pow_fast_path(25);
pow_fast_path(26);
pow_fast_path(27);
pow_fast_path(28);
pow_fast_path(29);
pow_fast_path(30);
pow_fast_path(31);
pow_fast_path(33);
pow_fast_path(34);
pow_fast_path(35);
pow_fast_path(36);
}
}
fn slow_int_power(exponent: usize, radix: u32) -> u64 {
let mut value: u64 = 1;
for _ in 0..exponent {
value *= radix as u64;
}
value
}
fn int_pow_fast_path(radix: u32) {
for exponent in 0..f64::mantissa_limit(radix) {
let exponent = exponent as usize;
let actual = f64::int_pow_fast_path(exponent, radix);
assert_eq!(actual, slow_int_power(exponent, radix));
}
}
#[test]
fn int_pow_fast_path_test() {
int_pow_fast_path(10);
if cfg!(feature = "power-of-two") {
int_pow_fast_path(2);
int_pow_fast_path(4);
int_pow_fast_path(8);
int_pow_fast_path(16);
int_pow_fast_path(32);
}
if cfg!(feature = "radix") {
int_pow_fast_path(3);
int_pow_fast_path(5);
int_pow_fast_path(6);
int_pow_fast_path(7);
int_pow_fast_path(9);
int_pow_fast_path(11);
int_pow_fast_path(12);
int_pow_fast_path(13);
int_pow_fast_path(14);
int_pow_fast_path(15);
int_pow_fast_path(17);
int_pow_fast_path(18);
int_pow_fast_path(19);
int_pow_fast_path(20);
int_pow_fast_path(21);
int_pow_fast_path(22);
int_pow_fast_path(23);
int_pow_fast_path(24);
int_pow_fast_path(25);
int_pow_fast_path(26);
int_pow_fast_path(27);
int_pow_fast_path(28);
int_pow_fast_path(29);
int_pow_fast_path(30);
int_pow_fast_path(31);
int_pow_fast_path(33);
int_pow_fast_path(34);
int_pow_fast_path(35);
int_pow_fast_path(36);
}
}
fn extended_to_float<F: RawFloat>(mantissa: u64, exponent: i32, expected: F) {
let fp = float::ExtendedFloat80 {
mant: mantissa,
exp: exponent,
};
assert_eq!(float::extended_to_float::<F>(fp), expected);
}
#[test]
fn extended_to_float_test() {
let max_mant = (1 << f64::MANTISSA_SIZE) - 1;
let max_exp = f64::INFINITE_POWER - 1;
extended_to_float::<f64>(0, 0, 0.0);
extended_to_float::<f64>(1, 0, 5e-324);
extended_to_float::<f64>(max_mant, max_exp, f64::MAX);
extended_to_float::<f64>(0, 1076, 9007199254740992.0);
extended_to_float::<f64>(1, 1076, 9007199254740994.0);
}
