Add repr() and from_repr() to Float

Author: mattico

src/float/add.rs

@@ -1,10 +1,9 @@
-use core::mem::transmute;
-
 use float::Float;
 
 macro_rules! add {
     ($intrinsic:ident: $ty:ty) => {
         /// Returns `a + b`
+        #[allow(unused_parens)]
         #[cfg_attr(not(test), no_mangle)]
         pub extern fn $intrinsic(a: $ty, b: $ty) -> $ty {
             let bits =             <$ty>::bits() as <$ty as Float>::Int;
@@ -21,8 +20,8 @@ macro_rules! add {
             let quiet_bit =        implicit_bit >> 1;
             let qnan_rep =         exponent_mask | quiet_bit;
 
-            let mut a_rep = unsafe { transmute::<_, <$ty as Float>::Int>(a) };
-            let mut b_rep = unsafe { transmute::<_, <$ty as Float>::Int>(b) };
+            let mut a_rep = a.repr();
+            let mut b_rep = b.repr();
             let a_abs = a_rep & abs_mask;
             let b_abs = b_rep & abs_mask;
 
@@ -31,17 +30,17 @@ macro_rules! add {
                 b_abs - 1 >= inf_rep - 1 {
                 // NaN + anything = qNaN
                 if a_abs > inf_rep {
-                    return unsafe { transmute(transmute::<_, <$ty as Float>::Int>(a) | quiet_bit) };
+                    return (<$ty as Float>::from_repr(a_abs | quiet_bit));
                 }
                 // anything + NaN = qNaN
                 if b_abs > inf_rep {
-                    return unsafe { transmute(transmute::<_, <$ty as Float>::Int>(b) | quiet_bit) };
+                    return (<$ty as Float>::from_repr(b_abs | quiet_bit));
                 }
 
                 if a_abs == inf_rep {
                     // +/-infinity + -/+infinity = qNaN
-                    if unsafe { transmute::<_, <$ty as Float>::Int>(a) ^ transmute::<_, <$ty as Float>::Int>(b) == sign_bit } {
-                        return unsafe { transmute(qnan_rep) };
+                    if a.repr() ^ b.repr() == sign_bit {
+                        return (<$ty as Float>::from_repr(qnan_rep));
                     } else {
                         // +/-infinity + anything remaining = +/- infinity
                         return a;
@@ -57,7 +56,7 @@ macro_rules! add {
                 if a_abs == 0 {
                     // but we need to get the sign right for zero + zero
                     if b_abs == 0 {
-                        return unsafe { transmute(transmute::<_, <$ty as Float>::Int>(a) & transmute::<_, <$ty as Float>::Int>(b)) };
+                        return (<$ty as Float>::from_repr(a.repr() & b.repr()));
                     } else {
                         return b;
                     }
@@ -120,14 +119,17 @@ macro_rules! add {
             if subtraction {
                 a_significand -= b_significand;
                 // If a == -b, return +zero.
-                if a_significand == 0 { return unsafe { transmute(0 as <$ty as Float>::Int) }; }
+                if a_significand == 0 { 
+                    return (<$ty as Float>::from_repr(0)); 
+                }
 
                 // If partial cancellation occured, we need to left-shift the result
                 // and adjust the exponent:
                 if a_significand < implicit_bit << 3 {
-                    let shift = <<$ty as Float>::Int>::leading_zeros(a_significand) - <<$ty as Float>::Int>::leading_zeros(implicit_bit << 3);
+                    let shift = (a_significand.leading_zeros() 
+                        - (implicit_bit << 3).leading_zeros()) as <$ty as Float>::Int;
                     a_significand <<= shift;
-                    a_exponent -= shift as <$ty as Float>::Int;
+                    a_exponent -= shift;
                 }
             } else /* addition */ {
                 a_significand += b_significand;
@@ -142,7 +144,9 @@ macro_rules! add {
             }
 
             // If we have overflowed the type, return +/- infinity:
-            if a_exponent >= max_exponent { return unsafe { transmute(inf_rep | result_sign) }; }
+            if a_exponent >= max_exponent { 
+                return (<$ty>::from_repr(inf_rep | result_sign));
+            }
 
             if a_exponent <= 0 {
                 // Result is denormal before rounding; the exponent is zero and we
@@ -167,7 +171,7 @@ macro_rules! add {
             // correct result in that case.
             if round_guard_sticky > 0x4 { result += 1; }
             if round_guard_sticky == 0x4 { result += result & 1; }
-            return unsafe { transmute(result) };
+            return (<$ty>::from_repr(result));
         }
     }
 }

src/float/mod.rs

@@ -1,10 +1,11 @@
-use core::ops::*;
+use core::mem::transmute;
 use core::num::One;
+use core::ops::*;
 
 pub mod add;
 
 /// Trait for some basic operations on floats
-pub trait Float {
+pub trait Float: Sized {
     /// A uint of the same with as the float
     type Int: Sized + Copy + Clone + Sub<Output=Self::Int> + 
         ShlAssign<Self::Int> + Shl<Self::Int, Output=Self::Int> + One;
@@ -15,6 +16,12 @@ pub trait Float {
     /// Returns the bitwidth of the significand
     fn significand_bits() -> u32;
 
+    /// Returns `self` transmuted to `Self::Int`
+    fn repr(self) -> Self::Int;
+
+    /// Returns a `Self::Int` transmuted back to `Self` 
+    fn from_repr(a: Self::Int) -> Self;
+
     /// Returns (normalized exponent, normalized significand)
     fn normalize(significand: Self::Int) -> (Self::Int, Self::Int);
 }
@@ -27,6 +34,12 @@ impl Float for f32 {
     fn significand_bits() -> u32 {
         23
     }
+    fn repr(self) -> Self::Int {
+        unsafe { transmute(self) }
+    }
+    fn from_repr(a: Self::Int) -> Self {
+        unsafe { transmute(a) }
+    }
     fn normalize(significand: Self::Int) -> (Self::Int, Self::Int) {
         let shift = Self::Int::leading_zeros(significand) 
             - Self::Int::leading_zeros(Self::Int::one() << Self::significand_bits());
@@ -41,6 +54,12 @@ impl Float for f64 {
     fn significand_bits() -> u32 {
         52
     }
+    fn repr(self) -> Self::Int {
+        unsafe { transmute(self) }
+    }
+    fn from_repr(a: Self::Int) -> Self {
+        unsafe { transmute(a) }
+    }
     fn normalize(significand: Self::Int) -> (Self::Int, Self::Int) {
         let shift = Self::Int::leading_zeros(significand) 
             - Self::Int::leading_zeros(Self::Int::one() << Self::significand_bits());