Fix *_exponent representation

Author: mattico

src/float/add.rs

@@ -80,8 +80,8 @@ macro_rules! add {
             }
 
             // Extract the exponent and significand from the (possibly swapped) a and b.
-            let mut a_exponent = a_rep >> significand_bits.0 as usize & max_exponent;
-            let mut b_exponent = b_rep >> significand_bits.0 as usize & max_exponent;
+            let mut a_exponent = Wrapping((a_rep >> significand_bits.0 as usize & max_exponent).0 as i32);
+            let mut b_exponent = Wrapping((b_rep >> significand_bits.0 as usize & max_exponent).0 as i32);
             let mut a_significand = a_rep & significand_mask;
             let mut b_significand = b_rep & significand_mask;
 
@@ -111,7 +111,7 @@ macro_rules! add {
 
             // Shift the significand of b by the difference in exponents, with a sticky
             // bottom bit to get rounding correct.
-            let align = a_exponent - b_exponent;
+            let align = Wrapping((a_exponent - b_exponent).0 as <$ty as Float>::Int);
             if align.0 != 0 {
                 if align < bits {
                     let sticky = ((b_significand << (bits - align).0 as usize).0 != 0) as <$ty as Float>::Int;
@@ -131,7 +131,7 @@ macro_rules! add {
                 // and adjust the exponent:
                 if a_significand < implicit_bit << 3 {
                     let shift = (a_significand.0.leading_zeros() 
-                        - (implicit_bit << 3).0.leading_zeros()) as <$ty as Float>::Int;
+                        - (implicit_bit << 3).0.leading_zeros()) as i32;
                     a_significand <<= shift as usize;
                     a_exponent -= Wrapping(shift);
                 }
@@ -143,38 +143,38 @@ macro_rules! add {
                 if (a_significand & implicit_bit << 4).0 != 0 {
                     let sticky = ((a_significand & one).0 != 0) as <$ty as Float>::Int;
                     a_significand = a_significand >> 1 | Wrapping(sticky);
-                    a_exponent += one;
+                    a_exponent += Wrapping(1);
                 }
             }
 
             // If we have overflowed the type, return +/- infinity:
-            if a_exponent >= max_exponent { 
+            if a_exponent >= Wrapping(max_exponent.0 as i32) { 
                 return (<$ty>::from_repr((inf_rep | result_sign).0));
             }
 
             if a_exponent.0 <= 0 {
                 // Result is denormal before rounding; the exponent is zero and we
                 // need to shift the significand.
-                let shift = one - a_exponent;
+                let shift = Wrapping((Wrapping(1) - a_exponent).0 as <$ty as Float>::Int);
                 let sticky = ((a_significand << (bits - shift).0 as usize).0 != 0) as <$ty as Float>::Int;
                 a_significand = a_significand >> shift.0 as usize | Wrapping(sticky);
-                a_exponent = zero;
+                a_exponent = Wrapping(0);
             }
 
             // Low three bits are round, guard, and sticky.
-            let round_guard_sticky = a_significand & Wrapping(0x7);
+            let round_guard_sticky: i32 = (a_significand.0 & 0x7) as i32;
 
             // Shift the significand into place, and mask off the implicit bit.
             let mut result = a_significand >> 3 & significand_mask;
 
             // Insert the exponent and sign.
-            result |= a_exponent << significand_bits.0 as usize;
+            result |= Wrapping(a_exponent.0 as <$ty as Float>::Int) << significand_bits.0 as usize;
             result |= result_sign;
 
             // Final rounding.  The result may overflow to infinity, but that is the
             // correct result in that case.
-            if round_guard_sticky.0 > 0x4 { result += one; }
-            if round_guard_sticky.0 == 0x4 { result += result & one; }
+            if round_guard_sticky > 0x4 { result += one; }
+            if round_guard_sticky == 0x4 { result += result & one; }
             return (<$ty>::from_repr(result.0));
         }
     }

src/float/mod.rs

@@ -20,7 +20,7 @@ pub trait Float: Sized {
     fn from_repr(a: Self::Int) -> Self;
 
     /// Returns (normalized exponent, normalized significand)
-    fn normalize(significand: Self::Int) -> (Self::Int, Self::Int);
+    fn normalize(significand: Self::Int) -> (i32, Self::Int);
 }
 
 impl Float for f32 {
@@ -37,10 +37,10 @@ impl Float for f32 {
     fn from_repr(a: Self::Int) -> Self {
         unsafe { mem::transmute(a) }
     }
-    fn normalize(significand: Self::Int) -> (Self::Int, Self::Int) {
+    fn normalize(significand: Self::Int) -> (i32, Self::Int) {
         let shift = significand.leading_zeros()
             .wrapping_sub((1u32 << Self::significand_bits()).leading_zeros());
-        (1u32.wrapping_sub(shift as Self::Int), significand << shift as Self::Int)
+        (1i32.wrapping_sub(shift as i32), significand << shift as Self::Int)
     }
 }
 impl Float for f64 {
@@ -57,9 +57,9 @@ impl Float for f64 {
     fn from_repr(a: Self::Int) -> Self {
         unsafe { mem::transmute(a) }
     }
-    fn normalize(significand: Self::Int) -> (Self::Int, Self::Int) {
+    fn normalize(significand: Self::Int) -> (i32, Self::Int) {
         let shift = significand.leading_zeros()
             .wrapping_sub((1u64 << Self::significand_bits()).leading_zeros());
-        (1u64.wrapping_sub(shift as Self::Int), significand << shift as Self::Int)
+        (1i32.wrapping_sub(shift as i32), significand << shift as Self::Int)
     }
 }