Revert "Merge pull request #48 from mattico/add_float_quickcheck"

This reverts commit e34a6058df, reversing
changes made to cab88e6133.

src/float/add.rs

@@ -9,27 +9,27 @@ macro_rules! add {
         #[allow(unused_parens)]
         #[cfg_attr(not(test), no_mangle)]
         pub extern fn $intrinsic(a: $ty, b: $ty) -> $ty {
-            let one =               Wrapping(1 as <$ty as Float>::Int);
+            let one = Wrapping(1 as <$ty as Float>::Int);
-            let zero =              Wrapping(0 as <$ty as Float>::Int);
+            let zero = Wrapping(0 as <$ty as Float>::Int);
 
-            let bits =              Wrapping(<$ty>::bits() as <$ty as Float>::Int);
+            let bits =             Wrapping(<$ty>::bits() as <$ty as Float>::Int);
-            let significand_bits =  Wrapping(<$ty>::significand_bits() as <$ty as Float>::Int);
+            let significand_bits = Wrapping(<$ty>::significand_bits() as <$ty as Float>::Int);
-            let exponent_bits =     Wrapping(<$ty>::exponent_bits() as <$ty as Float>::Int);
+            let exponent_bits =    bits - significand_bits - one;
-            let max_exponent =      (one << exponent_bits.0 as usize) - one;
+            let max_exponent =     (one << exponent_bits.0 as usize) - one;
 
-            let implicit_bit =      one << significand_bits.0 as usize;
+            let implicit_bit =     one << significand_bits.0 as usize;
-            let significand_mask =  implicit_bit - one;
+            let significand_mask = implicit_bit - one;
-            let sign_bit =          one << (significand_bits + exponent_bits).0 as usize;
+            let sign_bit =         one << (significand_bits + exponent_bits).0 as usize;
-            let abs_mask =          sign_bit - one;
+            let abs_mask =         sign_bit - one;
-            let exponent_mask =     abs_mask ^ significand_mask;
+            let exponent_mask =    abs_mask ^ significand_mask;
-            let inf_rep =           exponent_mask;
+            let inf_rep =          exponent_mask;
-            let quiet_bit =         implicit_bit >> 1;
+            let quiet_bit =        implicit_bit >> 1;
-            let qnan_rep =          exponent_mask | quiet_bit;
+            let qnan_rep =         exponent_mask | quiet_bit;
 
-            let mut a_rep =         Wrapping(a.repr());
+            let mut a_rep = Wrapping(a.repr());
-            let mut b_rep =         Wrapping(b.repr());
+            let mut b_rep = Wrapping(b.repr());
-            let a_abs =             a_rep & abs_mask;
+            let a_abs = a_rep & abs_mask;
-            let b_abs =             b_rep & abs_mask;
+            let b_abs = b_rep & abs_mask;
 
             // Detect if a or b is zero, infinity, or NaN.
             if a_abs - one >= inf_rep - one ||
@@ -188,7 +188,7 @@ mod tests {
     use core::{f32, f64};
 
     use float::Float;
-    use qc::{F32, F64};
+    use qc::{U32, U64};
 
     // NOTE The tests below have special handing for NaN values.
     // Because NaN != NaN, the floating-point representations must be used
@@ -212,18 +212,107 @@ mod tests {
         }
     }
 
+    // TODO: Add F32/F64 to qc so that they print the right values (at the very least)
     check! {
         fn __addsf3(f: extern fn(f32, f32) -> f32,
-                    a: F32,
+                    a: U32,
-                    b: F32)
+                    b: U32)
                     -> Option<FRepr<f32> > {
-            Some(FRepr(f(a.0, b.0)))
+            let (a, b) = (f32::from_repr(a.0), f32::from_repr(b.0));
+            Some(FRepr(f(a, b)))
         }
 
         fn __adddf3(f: extern fn(f64, f64) -> f64,
-                    a: F64,
+                    a: U64,
-                    b: F64) -> Option<FRepr<f64> > {
+                    b: U64) -> Option<FRepr<f64> > {
-            Some(FRepr(f(a.0, b.0)))
+            let (a, b) = (f64::from_repr(a.0), f64::from_repr(b.0));
+            Some(FRepr(f(a, b)))
         }
     }
+
+    // More tests for special float values
+
+    #[test]
+    fn test_float_tiny_plus_tiny() {
+        let tiny = f32::from_repr(1);
+        let r = super::__addsf3(tiny, tiny);
+        assert!(r.eq_repr(tiny + tiny));
+    }
+
+    #[test]
+    fn test_double_tiny_plus_tiny() {
+        let tiny = f64::from_repr(1);
+        let r = super::__adddf3(tiny, tiny);
+        assert!(r.eq_repr(tiny + tiny));
+    }
+
+    #[test]
+    fn test_float_small_plus_small() {
+        let a = f32::from_repr(327);
+        let b = f32::from_repr(256);
+        let r = super::__addsf3(a, b);
+        assert!(r.eq_repr(a + b));
+    }
+
+    #[test]
+    fn test_double_small_plus_small() {
+        let a = f64::from_repr(327);
+        let b = f64::from_repr(256);
+        let r = super::__adddf3(a, b);
+        assert!(r.eq_repr(a + b));
+    }
+
+    #[test]
+    fn test_float_one_plus_one() {
+        let r = super::__addsf3(1f32, 1f32);
+        assert!(r.eq_repr(1f32 + 1f32));
+    }
+
+    #[test]
+    fn test_double_one_plus_one() {
+        let r = super::__adddf3(1f64, 1f64);
+        assert!(r.eq_repr(1f64 + 1f64));
+    }
+
+    #[test]
+    fn test_float_different_nan() {
+        let a = f32::from_repr(1);
+        let b = f32::from_repr(0b11111111100100010001001010101010);
+        let x = super::__addsf3(a, b);
+        let y = a + b;
+        assert!(x.eq_repr(y));
+    }
+
+    #[test]
+    fn test_double_different_nan() {
+        let a = f64::from_repr(1);
+        let b = f64::from_repr(0b1111111111110010001000100101010101001000101010000110100011101011);
+        let x = super::__adddf3(a, b);
+        let y = a + b;
+        assert!(x.eq_repr(y));
+    }
+
+    #[test]
+    fn test_float_nan() {
+        let r = super::__addsf3(f32::NAN, 1.23);
+        assert_eq!(r.repr(), f32::NAN.repr());
+    }
+
+    #[test]
+    fn test_double_nan() {
+        let r = super::__adddf3(f64::NAN, 1.23);
+        assert_eq!(r.repr(), f64::NAN.repr());
+    }
+
+    #[test]
+    fn test_float_inf() {
+        let r = super::__addsf3(f32::INFINITY, -123.4);
+        assert_eq!(r, f32::INFINITY);
+    }
+
+    #[test]
+    fn test_double_inf() {
+        let r = super::__adddf3(f64::INFINITY, -123.4);
+        assert_eq!(r, f64::INFINITY);
+    }
 }

src/float/mod.rs

@@ -10,45 +10,21 @@ pub trait Float: Sized + Copy {
     /// Returns the bitwidth of the float type
     fn bits() -> u32;
 
-    /// Returns the bitwidth of the exponent
-    fn exponent_bits() -> u32;
-
     /// Returns the bitwidth of the significand
     fn significand_bits() -> u32;
 
-    /// Returns a mask for the sign bit of `self`
-    fn sign_mask() -> Self::Int;
-
-    /// Returns a mask for the exponent portion of `self`
-    fn exponent_mask() -> Self::Int;
-
-    /// Returns a mask for the significand portion of `self`
-    fn significand_mask() -> Self::Int;
-
-    /// Returns the sign bit of `self`
-    fn sign(self) -> bool;
-
-    /// Returns the exponent portion of `self`, shifted to the right
-    fn exponent(self) -> Self::Int;
-
-    /// Returns the significand portion of `self`
-    fn significand(self) -> Self::Int;
-
     /// Returns `self` transmuted to `Self::Int`
     fn repr(self) -> Self::Int;
 
     #[cfg(test)]
     /// Checks if two floats have the same bit representation. *Except* for NaNs! NaN can be
-    /// represented in multiple different ways. This method returns `true` if two NaNs are
+    /// represented in multiple different ways. This methods returns `true` if two NaNs are
     /// compared.
     fn eq_repr(self, rhs: Self) -> bool;
 
     /// Returns a `Self::Int` transmuted back to `Self`
     fn from_repr(a: Self::Int) -> Self;
 
-    /// Constructs a `Self` from its parts
-    fn from_parts(sign: bool, exponent: Self::Int, significand: Self::Int) -> Self;
-
     /// Returns (normalized exponent, normalized significand)
     fn normalize(significand: Self::Int) -> (i32, Self::Int);
 }
@@ -58,21 +34,9 @@ impl Float for f32 {
     fn bits() -> u32 {
         32
     }
-    fn exponent_bits() -> u32 {
-        8
-    }
     fn significand_bits() -> u32 {
         23
     }
-    fn sign_mask() -> Self::Int {
-        1 << (Self::bits() - 1)
-    }
-    fn exponent_mask() -> Self::Int {
-        ((1 << Self::exponent_bits()) - 1) << Self::significand_bits()
-    }
-    fn significand_mask() -> Self::Int {
-        (1 << Self::significand_bits()) - 1
-    }
     fn repr(self) -> Self::Int {
         unsafe { mem::transmute(self) }
     }
@@ -87,21 +51,6 @@ impl Float for f32 {
     fn from_repr(a: Self::Int) -> Self {
         unsafe { mem::transmute(a) }
     }
-    
-    fn from_parts(sign: bool, exponent: Self::Int, significand: Self::Int) -> Self {
-        Self::from_repr(((sign as Self::Int) << (Self::bits() - 1)) |
-            exponent & Self::exponent_mask() |
-            significand & Self::significand_mask())
-    }
-    fn sign(self) -> bool {
-        (self.repr() & Self::sign_mask()) != 0
-    }
-    fn exponent(self) -> Self::Int {
-        self.repr() >> Self::significand_bits() & Self::exponent_mask()
-    }
-    fn significand(self) -> Self::Int {
-        self.repr() & Self::significand_mask()
-    }
     fn normalize(significand: Self::Int) -> (i32, Self::Int) {
         let shift = significand.leading_zeros()
             .wrapping_sub((1u32 << Self::significand_bits()).leading_zeros());
@@ -113,21 +62,9 @@ impl Float for f64 {
     fn bits() -> u32 {
         64
     }
-    fn exponent_bits() -> u32 {
-        11
-    }
     fn significand_bits() -> u32 {
         52
     }
-    fn sign_mask() -> Self::Int {
-        1 << (Self::bits() - 1)
-    }
-    fn exponent_mask() -> Self::Int {
-        ((1 << Self::exponent_bits()) - 1) << Self::significand_bits()
-    }
-    fn significand_mask() -> Self::Int {
-        (1 << Self::significand_bits()) - 1
-    }
     fn repr(self) -> Self::Int {
         unsafe { mem::transmute(self) }
     }
@@ -142,20 +79,6 @@ impl Float for f64 {
     fn from_repr(a: Self::Int) -> Self {
         unsafe { mem::transmute(a) }
     }
-    fn from_parts(sign: bool, exponent: Self::Int, significand: Self::Int) -> Self {
-        Self::from_repr(((sign as Self::Int) << (Self::bits() - 1)) |
-            exponent & Self::exponent_mask() |
-            significand & Self::significand_mask())
-    }
-    fn sign(self) -> bool {
-        (self.repr() & Self::sign_mask()) != 0
-    }
-    fn exponent(self) -> Self::Int {
-        self.repr() >> Self::significand_bits() & Self::exponent_mask()
-    }
-    fn significand(self) -> Self::Int {
-        self.repr() & Self::significand_mask()
-    }
     fn normalize(significand: Self::Int) -> (i32, Self::Int) {
         let shift = significand.leading_zeros()
             .wrapping_sub((1u64 << Self::significand_bits()).leading_zeros());

src/qc.rs

@@ -5,12 +5,10 @@
 
 use std::boxed::Box;
 use std::fmt;
-use core::{f32, f64};
 
 use quickcheck::{Arbitrary, Gen};
 
 use int::LargeInt;
-use float::Float;
 
 // Generates values in the full range of the integer type
 macro_rules! arbitrary {
@@ -73,7 +71,6 @@ macro_rules! arbitrary {
 arbitrary!(I32: i32);
 arbitrary!(U32: u32);
 
-
 // These integers are "too large". If we generate e.g. `u64` values in the full range then there's
 // only `1 / 2^32` chance of seeing a value smaller than `2^32` (i.e. whose higher "word" (32-bits)
 // is `0`)! But this is an important group of values to tests because we have special code paths for
@@ -146,57 +143,6 @@ macro_rules! arbitrary_large {
 arbitrary_large!(I64: i64);
 arbitrary_large!(U64: u64);
 
-
-macro_rules! arbitrary_float {
-    ($TY:ident : $ty:ident) => {
-        #[derive(Clone, Copy)]
-        pub struct $TY(pub $ty);
-
-        impl Arbitrary for $TY {
-            fn arbitrary<G>(g: &mut G) -> $TY
-                where G: Gen
-            {
-                let special = [
-                    -0.0, 0.0, $ty::NAN, $ty::INFINITY, -$ty::INFINITY
-                ];
-
-                if g.gen_weighted_bool(10) { // Random special case
-                    $TY(*g.choose(&special).unwrap())
-                } else if g.gen_weighted_bool(10) { // NaN variants
-                    let sign: bool = g.gen();
-                    let exponent: <$ty as Float>::Int = g.gen();
-                    let significand: <$ty as Float>::Int = 0;
-                    $TY($ty::from_parts(sign, exponent, significand))
-                } else if g.gen() { // Denormalized
-                    let sign: bool = g.gen();
-                    let exponent: <$ty as Float>::Int = 0;
-                    let significand: <$ty as Float>::Int = g.gen();
-                    $TY($ty::from_parts(sign, exponent, significand))
-                } else { // Random anything
-                    let sign: bool = g.gen();
-                    let exponent: <$ty as Float>::Int = g.gen();
-                    let significand: <$ty as Float>::Int = g.gen();
-                    $TY($ty::from_parts(sign, exponent, significand))
-                }
-            }
-
-            fn shrink(&self) -> Box<Iterator<Item=$TY>> {
-                ::quickcheck::empty_shrinker()
-            }
-        }
-
-        impl fmt::Debug for $TY {
-            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                fmt::Debug::fmt(&self.0, f)
-            }
-        }
-    }
-}
-
-arbitrary_float!(F32: f32);
-arbitrary_float!(F64: f64);
-
-
 // Convenience macro to test intrinsics against their reference implementations.
 //
 // Each intrinsic is tested against both the `gcc_s` library as well as
@@ -317,4 +263,3 @@ macro_rules! check {
         }
     )
 }
-