742 lines
23 KiB
Rust
742 lines
23 KiB
Rust
// NOTE we intentionally avoid using the `quote` crate here because it doesn't work with the
|
|
// `x86_64-unknown-linux-musl` target.
|
|
|
|
// NOTE usually the only thing you need to do to test a new math function is to add it to one of the
|
|
// macro invocations found in the bottom of this file.
|
|
|
|
extern crate rand;
|
|
|
|
use std::error::Error;
|
|
use std::fmt::Write as _0;
|
|
use std::fs::{self, File};
|
|
use std::io::Write as _1;
|
|
use std::{i16, u16, u32, u64, u8};
|
|
|
|
use rand::{Rng, SeedableRng, XorShiftRng};
|
|
|
|
// Number of test cases to generate
|
|
const NTESTS: usize = 10_000;
|
|
|
|
// TODO tweak these functions to generate edge cases (zero, infinity, NaN) more often
|
|
fn f32(rng: &mut XorShiftRng) -> f32 {
|
|
let sign = if rng.gen_bool(0.5) { 1 << 31 } else { 0 };
|
|
let exponent = (rng.gen_range(0, u8::MAX) as u32) << 23;
|
|
let mantissa = rng.gen_range(0, u32::MAX) & ((1 << 23) - 1);
|
|
|
|
f32::from_bits(sign + exponent + mantissa)
|
|
}
|
|
|
|
fn f64(rng: &mut XorShiftRng) -> f64 {
|
|
let sign = if rng.gen_bool(0.5) { 1 << 63 } else { 0 };
|
|
let exponent = (rng.gen_range(0, u16::MAX) as u64 & ((1 << 11) - 1)) << 52;
|
|
let mantissa = rng.gen_range(0, u64::MAX) & ((1 << 52) - 1);
|
|
|
|
f64::from_bits(sign + exponent + mantissa)
|
|
}
|
|
|
|
// fn(f32) -> f32
|
|
macro_rules! f32_f32 {
|
|
($($intr:ident,)*) => {
|
|
fn f32_f32(rng: &mut XorShiftRng) -> Result<(), Box<Error>> {
|
|
// MUSL C implementation of the function to test
|
|
extern "C" {
|
|
$(fn $intr(_: f32) -> f32;)*
|
|
}
|
|
|
|
$(
|
|
let mut cases = String::new();
|
|
for _ in 0..NTESTS {
|
|
let inp = f32(rng);
|
|
let out = unsafe { $intr(inp) };
|
|
|
|
let inp = inp.to_bits();
|
|
let out = out.to_bits();
|
|
|
|
write!(cases, "({}, {})", inp, out).unwrap();
|
|
cases.push(',');
|
|
}
|
|
|
|
let mut f = File::create(concat!("tests/", stringify!($intr), ".rs"))?;
|
|
write!(f, "
|
|
#![deny(warnings)]
|
|
|
|
extern crate libm;
|
|
|
|
use std::panic;
|
|
|
|
#[test]
|
|
fn {0}() {{
|
|
const CASES: &[(u32, u32)] = &[
|
|
{1}
|
|
];
|
|
|
|
for case in CASES {{
|
|
let (inp, expected) = *case;
|
|
|
|
if let Ok(outf) =
|
|
panic::catch_unwind(|| libm::{0}(f32::from_bits(inp)))
|
|
{{
|
|
let outi = outf.to_bits();
|
|
|
|
if !((outf.is_nan() && f32::from_bits(expected).is_nan())
|
|
|| libm::_eqf(outi, expected))
|
|
{{
|
|
panic!(
|
|
\"input: {{}}, output: {{}}, expected: {{}}\",
|
|
inp, outi, expected,
|
|
);
|
|
}}
|
|
}} else {{
|
|
panic!(
|
|
\"input: {{}}, output: PANIC, expected: {{}}\",
|
|
inp, expected,
|
|
);
|
|
}}
|
|
}}
|
|
}}
|
|
",
|
|
stringify!($intr),
|
|
cases)?;
|
|
)*
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|
|
|
|
// fn(f32, f32) -> f32
|
|
macro_rules! f32f32_f32 {
|
|
($($intr:ident,)*) => {
|
|
fn f32f32_f32(rng: &mut XorShiftRng) -> Result<(), Box<Error>> {
|
|
extern "C" {
|
|
$(fn $intr(_: f32, _: f32) -> f32;)*
|
|
}
|
|
|
|
$(
|
|
let mut cases = String::new();
|
|
for _ in 0..NTESTS {
|
|
let i1 = f32(rng);
|
|
let i2 = f32(rng);
|
|
let out = unsafe { $intr(i1, i2) };
|
|
|
|
let i1 = i1.to_bits();
|
|
let i2 = i2.to_bits();
|
|
let out = out.to_bits();
|
|
|
|
write!(cases, "(({}, {}), {})", i1, i2, out).unwrap();
|
|
cases.push(',');
|
|
}
|
|
|
|
let mut f = File::create(concat!("tests/", stringify!($intr), ".rs"))?;
|
|
write!(f, "
|
|
#![deny(warnings)]
|
|
|
|
extern crate libm;
|
|
|
|
use std::panic;
|
|
|
|
#[test]
|
|
fn {0}() {{
|
|
const CASES: &[((u32, u32), u32)] = &[
|
|
{1}
|
|
];
|
|
|
|
for case in CASES {{
|
|
let ((i1, i2), expected) = *case;
|
|
|
|
if let Ok(outf) = panic::catch_unwind(|| {{
|
|
libm::{0}(f32::from_bits(i1), f32::from_bits(i2))
|
|
}}) {{
|
|
let outi = outf.to_bits();
|
|
|
|
if !((outf.is_nan() && f32::from_bits(expected).is_nan())
|
|
|| libm::_eqf(outi, expected))
|
|
{{
|
|
panic!(
|
|
\"input: {{:?}}, output: {{}}, expected: {{}}\",
|
|
(i1, i2),
|
|
outi,
|
|
expected,
|
|
);
|
|
}}
|
|
}} else {{
|
|
panic!(
|
|
\"input: {{:?}}, output: PANIC, expected: {{}}\",
|
|
(i1, i2),
|
|
expected,
|
|
);
|
|
}}
|
|
}}
|
|
}}
|
|
",
|
|
stringify!($intr),
|
|
cases)?;
|
|
)*
|
|
|
|
Ok(())
|
|
}
|
|
};
|
|
}
|
|
|
|
// fn(f32, f32, f32) -> f32
|
|
macro_rules! f32f32f32_f32 {
|
|
($($intr:ident,)*) => {
|
|
fn f32f32f32_f32(rng: &mut XorShiftRng) -> Result<(), Box<Error>> {
|
|
extern "C" {
|
|
$(fn $intr(_: f32, _: f32, _: f32) -> f32;)*
|
|
}
|
|
|
|
$(
|
|
let mut cases = String::new();
|
|
for _ in 0..NTESTS {
|
|
let i1 = f32(rng);
|
|
let i2 = f32(rng);
|
|
let i3 = f32(rng);
|
|
let out = unsafe { $intr(i1, i2, i3) };
|
|
|
|
let i1 = i1.to_bits();
|
|
let i2 = i2.to_bits();
|
|
let i3 = i3.to_bits();
|
|
let out = out.to_bits();
|
|
|
|
write!(cases, "(({}, {}, {}), {})", i1, i2, i3, out).unwrap();
|
|
cases.push(',');
|
|
}
|
|
|
|
let mut f = File::create(concat!("tests/", stringify!($intr), ".rs"))?;
|
|
write!(f, "
|
|
#![deny(warnings)]
|
|
|
|
extern crate libm;
|
|
|
|
use std::panic;
|
|
|
|
#[test]
|
|
fn {0}() {{
|
|
const CASES: &[((u32, u32, u32), u32)] = &[
|
|
{1}
|
|
];
|
|
|
|
for case in CASES {{
|
|
let ((i1, i2, i3), expected) = *case;
|
|
|
|
if let Ok(outf) = panic::catch_unwind(|| {{
|
|
libm::{0}(
|
|
f32::from_bits(i1),
|
|
f32::from_bits(i2),
|
|
f32::from_bits(i3),
|
|
)
|
|
}}) {{
|
|
let outi = outf.to_bits();
|
|
|
|
if !((outf.is_nan() && f32::from_bits(expected).is_nan())
|
|
|| libm::_eqf(outi, expected))
|
|
{{
|
|
panic!(
|
|
\"input: {{:?}}, output: {{}}, expected: {{}}\",
|
|
(i1, i2, i3),
|
|
outi,
|
|
expected,
|
|
);
|
|
}}
|
|
}} else {{
|
|
panic!(
|
|
\"input: {{:?}}, output: PANIC, expected: {{}}\",
|
|
(i1, i2, i3),
|
|
expected,
|
|
);
|
|
}}
|
|
}}
|
|
}}
|
|
",
|
|
stringify!($intr),
|
|
cases)?;
|
|
)*
|
|
|
|
Ok(())
|
|
}
|
|
};
|
|
}
|
|
|
|
// fn(f32, i32) -> f32
|
|
macro_rules! f32i32_f32 {
|
|
($($intr:ident,)*) => {
|
|
fn f32i32_f32(rng: &mut XorShiftRng) -> Result<(), Box<Error>> {
|
|
extern "C" {
|
|
$(fn $intr(_: f32, _: i32) -> f32;)*
|
|
}
|
|
|
|
$(
|
|
let mut cases = String::new();
|
|
for _ in 0..NTESTS {
|
|
let i1 = f32(rng);
|
|
let i2 = rng.gen_range(i16::MIN, i16::MAX);
|
|
let out = unsafe { $intr(i1, i2 as i32) };
|
|
|
|
let i1 = i1.to_bits();
|
|
let out = out.to_bits();
|
|
|
|
write!(cases, "(({}, {}), {})", i1, i2, out).unwrap();
|
|
cases.push(',');
|
|
}
|
|
|
|
let mut f = File::create(concat!("tests/", stringify!($intr), ".rs"))?;
|
|
write!(f, "
|
|
#![deny(warnings)]
|
|
|
|
extern crate libm;
|
|
|
|
use std::panic;
|
|
|
|
#[test]
|
|
fn {0}() {{
|
|
const CASES: &[((u32, i16), u32)] = &[
|
|
{1}
|
|
];
|
|
|
|
for case in CASES {{
|
|
let ((i1, i2), expected) = *case;
|
|
|
|
if let Ok(outf) = panic::catch_unwind(|| {{
|
|
libm::{0}(f32::from_bits(i1), i2 as i32)
|
|
}}) {{
|
|
let outi = outf.to_bits();
|
|
|
|
if !((outf.is_nan() && f32::from_bits(expected).is_nan())
|
|
|| libm::_eqf(outi, expected))
|
|
{{
|
|
panic!(
|
|
\"input: {{:?}}, output: {{}}, expected: {{}}\",
|
|
(i1, i2),
|
|
outi,
|
|
expected,
|
|
);
|
|
}}
|
|
}} else {{
|
|
panic!(
|
|
\"input: {{:?}}, output: PANIC, expected: {{}}\",
|
|
(i1, i2),
|
|
expected,
|
|
);
|
|
}}
|
|
}}
|
|
}}
|
|
",
|
|
stringify!($intr),
|
|
cases)?;
|
|
)*
|
|
|
|
Ok(())
|
|
}
|
|
};
|
|
}
|
|
|
|
// fn(f64) -> f64
|
|
macro_rules! f64_f64 {
|
|
($($intr:ident,)*) => {
|
|
fn f64_f64(rng: &mut XorShiftRng) -> Result<(), Box<Error>> {
|
|
// MUSL C implementation of the function to test
|
|
extern "C" {
|
|
$(fn $intr(_: f64) -> f64;)*
|
|
}
|
|
|
|
$(
|
|
let mut cases = String::new();
|
|
for _ in 0..NTESTS {
|
|
let inp = f64(rng);
|
|
let out = unsafe { $intr(inp) };
|
|
|
|
let inp = inp.to_bits();
|
|
let out = out.to_bits();
|
|
|
|
write!(cases, "({}, {})", inp, out).unwrap();
|
|
cases.push(',');
|
|
}
|
|
|
|
let mut f = File::create(concat!("tests/", stringify!($intr), ".rs"))?;
|
|
write!(f, "
|
|
#![deny(warnings)]
|
|
|
|
extern crate libm;
|
|
|
|
use std::panic;
|
|
|
|
#[test]
|
|
fn {0}() {{
|
|
const CASES: &[(u64, u64)] = &[
|
|
{1}
|
|
];
|
|
|
|
for case in CASES {{
|
|
let (inp, expected) = *case;
|
|
|
|
if let Ok(outf) = panic::catch_unwind(|| {{
|
|
libm::{0}(f64::from_bits(inp))
|
|
}}) {{
|
|
let outi = outf.to_bits();
|
|
|
|
if !((outf.is_nan() && f64::from_bits(expected).is_nan())
|
|
|| libm::_eq(outi, expected))
|
|
{{
|
|
panic!(
|
|
\"input: {{}}, output: {{}}, expected: {{}}\",
|
|
inp,
|
|
outi,
|
|
expected,
|
|
);
|
|
}}
|
|
}} else {{
|
|
panic!(
|
|
\"input: {{}}, output: PANIC, expected: {{}}\",
|
|
inp,
|
|
expected,
|
|
);
|
|
}}
|
|
}}
|
|
}}
|
|
",
|
|
stringify!($intr),
|
|
cases)?;
|
|
)*
|
|
|
|
Ok(())
|
|
}
|
|
}
|
|
}
|
|
|
|
// fn(f64, f64) -> f64
|
|
macro_rules! f64f64_f64 {
|
|
($($intr:ident,)*) => {
|
|
fn f64f64_f64(rng: &mut XorShiftRng) -> Result<(), Box<Error>> {
|
|
extern "C" {
|
|
$(fn $intr(_: f64, _: f64) -> f64;)*
|
|
}
|
|
|
|
$(
|
|
let mut cases = String::new();
|
|
for _ in 0..NTESTS {
|
|
let i1 = f64(rng);
|
|
let i2 = f64(rng);
|
|
let out = unsafe { $intr(i1, i2) };
|
|
|
|
let i1 = i1.to_bits();
|
|
let i2 = i2.to_bits();
|
|
let out = out.to_bits();
|
|
|
|
write!(cases, "(({}, {}), {})", i1, i2, out).unwrap();
|
|
cases.push(',');
|
|
}
|
|
|
|
let mut f = File::create(concat!("tests/", stringify!($intr), ".rs"))?;
|
|
write!(f, "
|
|
#![deny(warnings)]
|
|
|
|
extern crate libm;
|
|
|
|
use std::panic;
|
|
|
|
#[test]
|
|
fn {0}() {{
|
|
const CASES: &[((u64, u64), u64)] = &[
|
|
{1}
|
|
];
|
|
|
|
for case in CASES {{
|
|
let ((i1, i2), expected) = *case;
|
|
|
|
if let Ok(outf) = panic::catch_unwind(|| {{
|
|
libm::{0}(f64::from_bits(i1), f64::from_bits(i2))
|
|
}}) {{
|
|
let outi = outf.to_bits();
|
|
|
|
if !((outf.is_nan() && f64::from_bits(expected).is_nan()) ||
|
|
libm::_eq(outi, expected)) {{
|
|
panic!(
|
|
\"input: {{:?}}, output: {{}}, expected: {{}}\",
|
|
(i1, i2),
|
|
outi,
|
|
expected,
|
|
);
|
|
}}
|
|
}} else {{
|
|
panic!(
|
|
\"input: {{:?}}, output: PANIC, expected: {{}}\",
|
|
(i1, i2),
|
|
expected,
|
|
);
|
|
}}
|
|
}}
|
|
}}
|
|
",
|
|
stringify!($intr),
|
|
cases)?;
|
|
)*
|
|
|
|
Ok(())
|
|
}
|
|
};
|
|
}
|
|
|
|
// fn(f64, f64, f64) -> f64
|
|
macro_rules! f64f64f64_f64 {
|
|
($($intr:ident,)*) => {
|
|
fn f64f64f64_f64(rng: &mut XorShiftRng) -> Result<(), Box<Error>> {
|
|
extern "C" {
|
|
$(fn $intr(_: f64, _: f64, _: f64) -> f64;)*
|
|
}
|
|
|
|
$(
|
|
let mut cases = String::new();
|
|
for _ in 0..NTESTS {
|
|
let i1 = f64(rng);
|
|
let i2 = f64(rng);
|
|
let i3 = f64(rng);
|
|
let out = unsafe { $intr(i1, i2, i3) };
|
|
|
|
let i1 = i1.to_bits();
|
|
let i2 = i2.to_bits();
|
|
let i3 = i3.to_bits();
|
|
let out = out.to_bits();
|
|
|
|
write!(cases, "(({}, {}, {}), {})", i1, i2, i3, out).unwrap();
|
|
cases.push(',');
|
|
}
|
|
|
|
let mut f = File::create(concat!("tests/", stringify!($intr), ".rs"))?;
|
|
write!(f, "
|
|
#![deny(warnings)]
|
|
|
|
extern crate libm;
|
|
|
|
use std::panic;
|
|
|
|
#[test]
|
|
fn {0}() {{
|
|
const CASES: &[((u64, u64, u64), u64)] = &[
|
|
{1}
|
|
];
|
|
|
|
for case in CASES {{
|
|
let ((i1, i2, i3), expected) = *case;
|
|
|
|
if let Ok(outf) = panic::catch_unwind(|| {{
|
|
libm::{0}(
|
|
f64::from_bits(i1),
|
|
f64::from_bits(i2),
|
|
f64::from_bits(i3),
|
|
)
|
|
}}) {{
|
|
let outi = outf.to_bits();
|
|
|
|
if !((outf.is_nan() && f64::from_bits(expected).is_nan())
|
|
|| libm::_eq(outi, expected))
|
|
{{
|
|
panic!(
|
|
\"input: {{:?}}, output: {{}}, expected: {{}}\",
|
|
(i1, i2, i3),
|
|
outi,
|
|
expected,
|
|
);
|
|
}}
|
|
}} else {{
|
|
panic!(
|
|
\"input: {{:?}}, output: PANIC, expected: {{}}\",
|
|
(i1, i2, i3),
|
|
expected,
|
|
);
|
|
}}
|
|
}}
|
|
}}
|
|
",
|
|
stringify!($intr),
|
|
cases)?;
|
|
)*
|
|
|
|
Ok(())
|
|
}
|
|
};
|
|
}
|
|
|
|
// fn(f64, i32) -> f64
|
|
macro_rules! f64i32_f64 {
|
|
($($intr:ident,)*) => {
|
|
fn f64i32_f64(rng: &mut XorShiftRng) -> Result<(), Box<Error>> {
|
|
extern "C" {
|
|
$(fn $intr(_: f64, _: i32) -> f64;)*
|
|
}
|
|
|
|
$(
|
|
let mut cases = String::new();
|
|
for _ in 0..NTESTS {
|
|
let i1 = f64(rng);
|
|
let i2 = rng.gen_range(i16::MIN, i16::MAX);
|
|
let out = unsafe { $intr(i1, i2 as i32) };
|
|
|
|
let i1 = i1.to_bits();
|
|
let out = out.to_bits();
|
|
|
|
write!(cases, "(({}, {}), {})", i1, i2, out).unwrap();
|
|
cases.push(',');
|
|
}
|
|
|
|
let mut f = File::create(concat!("tests/", stringify!($intr), ".rs"))?;
|
|
write!(f, "
|
|
#![deny(warnings)]
|
|
|
|
extern crate libm;
|
|
|
|
use std::panic;
|
|
|
|
#[test]
|
|
fn {0}() {{
|
|
const CASES: &[((u64, i16), u64)] = &[
|
|
{1}
|
|
];
|
|
|
|
for case in CASES {{
|
|
let ((i1, i2), expected) = *case;
|
|
|
|
if let Ok(outf) = panic::catch_unwind(|| {{
|
|
libm::{0}(f64::from_bits(i1), i2 as i32)
|
|
}}) {{
|
|
let outi = outf.to_bits();
|
|
|
|
if !((outf.is_nan() && f64::from_bits(expected).is_nan()) ||
|
|
libm::_eq(outi, expected)) {{
|
|
panic!(
|
|
\"input: {{:?}}, output: {{}}, expected: {{}}\",
|
|
(i1, i2),
|
|
outi,
|
|
expected,
|
|
);
|
|
}}
|
|
}} else {{
|
|
panic!(
|
|
\"input: {{:?}}, output: PANIC, expected: {{}}\",
|
|
(i1, i2),
|
|
expected,
|
|
);
|
|
}}
|
|
}}
|
|
}}
|
|
",
|
|
stringify!($intr),
|
|
cases)?;
|
|
)*
|
|
|
|
Ok(())
|
|
}
|
|
};
|
|
}
|
|
|
|
fn main() -> Result<(), Box<Error>> {
|
|
fs::remove_dir_all("tests").ok();
|
|
fs::create_dir("tests")?;
|
|
|
|
let mut rng = XorShiftRng::from_rng(&mut rand::thread_rng())?;
|
|
|
|
f32_f32(&mut rng)?;
|
|
f32f32_f32(&mut rng)?;
|
|
f32f32f32_f32(&mut rng)?;
|
|
f32i32_f32(&mut rng)?;
|
|
f64_f64(&mut rng)?;
|
|
f64f64_f64(&mut rng)?;
|
|
f64f64f64_f64(&mut rng)?;
|
|
f64i32_f64(&mut rng)?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/* Functions to test */
|
|
|
|
// With signature `fn(f32) -> f32`
|
|
f32_f32! {
|
|
// acosf,
|
|
floorf,
|
|
truncf,
|
|
// asinf,
|
|
// atanf,
|
|
cbrtf,
|
|
cosf,
|
|
ceilf,
|
|
// coshf,
|
|
exp2f,
|
|
expf,
|
|
log10f,
|
|
log1pf,
|
|
log2f,
|
|
logf,
|
|
roundf,
|
|
// sinf,
|
|
// sinhf,
|
|
// tanf,
|
|
// tanhf,
|
|
fabsf,
|
|
sqrtf,
|
|
}
|
|
|
|
// With signature `fn(f32, f32) -> f32`
|
|
f32f32_f32! {
|
|
// atan2f,
|
|
fdimf,
|
|
hypotf,
|
|
fmodf,
|
|
powf,
|
|
}
|
|
|
|
// With signature `fn(f32, f32, f32) -> f32`
|
|
f32f32f32_f32! {
|
|
// fmaf,
|
|
}
|
|
|
|
// With signature `fn(f32, i32) -> f32`
|
|
f32i32_f32! {
|
|
scalbnf,
|
|
}
|
|
|
|
// With signature `fn(f64) -> f64`
|
|
f64_f64! {
|
|
acos,
|
|
// asin,
|
|
// atan,
|
|
cbrt,
|
|
ceil,
|
|
// cos,
|
|
// cosh,
|
|
exp,
|
|
exp2,
|
|
// expm1,
|
|
floor,
|
|
log,
|
|
log10,
|
|
log1p,
|
|
log2,
|
|
round,
|
|
// sin,
|
|
// sinh,
|
|
sqrt,
|
|
// tan,
|
|
// tanh,
|
|
trunc,
|
|
fabs,
|
|
}
|
|
|
|
// With signature `fn(f64, f64) -> f64`
|
|
f64f64_f64! {
|
|
// atan2,
|
|
fdim,
|
|
fmod,
|
|
hypot,
|
|
// pow,
|
|
}
|
|
|
|
// With signature `fn(f64, f64, f64) -> f64`
|
|
f64f64f64_f64! {
|
|
fma,
|
|
}
|
|
|
|
// With signature `fn(f64, i32) -> f64`
|
|
f64i32_f64! {
|
|
scalbn,
|
|
}
|