m 0.1.1

A C free / pure Rust mathematical library ("libm") for `no_std` code
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

use std::{f32, f64, fmt};

use quickcheck::{Arbitrary, Gen};

use {FloatExt, Sign};

macro_rules! check {
    ($(
        fn $name:ident($f:ident: extern fn($($farg:ty),+) -> $fret:ty,
                       $($arg:ident: $t:ty),+) -> Option<$ret:ty> {
            $($code:tt)*
        }
    )+) => {
        mod tests {
            use std::mem;

            use quickcheck::TestResult;

            use FloatExt;
            use qc::*;

            $(
                #[test]
                fn $name() {
                    fn check($($arg: $t),+) -> TestResult {
                        fn $name($f: extern fn($($farg),+) -> $fret,
                                 $($arg:$t),+)
                                 -> Option<$ret> {
                            $($code)*
                        }

                        let our_answer = $name(super::$name, $($arg),+);
                        let libm_f: unsafe extern "C" fn($($farg),+) -> $fret =
                            ::m::$name;
                        let libm_answer =
                            $name(unsafe { mem::transmute(libm_f) }, $($arg),+);

                        if our_answer.is_none() {
                            return TestResult::discard();
                        }

                        let our_answer = our_answer.unwrap();
                        let libm_answer = libm_answer.unwrap();

                        let print_values = || {
                            print!("\r{} - Args: ", stringify!($name));
                            $(print!("{} = {:?} ", stringify!($arg), $arg);)+
                                print!("\n");
                            println!("  us:   {:?}", our_answer);
                            println!("  libm: {:?}", libm_answer);
                        };

                        if !our_answer.0.eq_repr(libm_answer.0) {
                            print_values();
                            TestResult::from_bool(false)
                        } else {
                            TestResult::from_bool(true)
                        }
                    }

                    ::quickcheck::quickcheck(check as fn($($t),*) -> TestResult)
                }
            )+
        }
    }
}

#[derive(Clone, Copy, PartialEq)]
pub struct F32(pub f32);

impl fmt::Debug for F32 {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{} (0x{:08x})", self.0, self.0.repr())
    }
}

#[derive(Clone, Copy, PartialEq)]
pub struct F64(pub f64);

impl fmt::Debug for F64 {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{} (0x{:016x})", self.0, self.0.repr())
    }
}

macro_rules! arbitrary_float {
    ($ty:ident, $fty:ident) => {
        impl Arbitrary for $ty {
            fn arbitrary<G>(g: &mut G) -> $ty
                where G: Gen
            {
                let special =
                    [-0.0, 0.0, $fty::NAN, $fty::INFINITY, $fty::NEG_INFINITY];

                let (sign, mut exponent, mut significand) = g.gen();
                if g.gen_weighted_bool(10) {
                    return $ty(*g.choose(&special).unwrap());
                } else if g.gen_weighted_bool(10) {
                    // NaN variants
                    significand = 0;
                } else if g.gen() {
                    // denormalize
                    exponent = 0;
                }

                $ty($fty::from_parts(Sign::from_bool(sign),
                                     exponent,
                                     significand))
            }
        }
    }
}

arbitrary_float!(F32, f32);
arbitrary_float!(F64, f64);