[#1] Removing unneeded imports and adjusting code.

Bounded was brought over from the weave library since weave is being
eliminated. Also, at some point along the way, rust 1.43.0, f32 and
f64 started defining NaN, so now we are using the compiler definitions.

src/bounded.rs

@@ -0,0 +1,100 @@
+/// Primitive types that have upper and lower bounds.
+pub trait Bounded
+{
+   /// The minimum value for this type.
+   const MIN: Self;
+
+   /// The maximum value for this type.
+   const MAX: Self;
+}
+
+
+
+/// A macro for making implementation of
+/// the Bounded trait easier.
+macro_rules! bounded_trait_impl
+{
+   ($T: ty, $minVal: expr, $maxVal: expr) =>
+   {
+      impl Bounded for $T
+      {
+         const MIN: $T = $minVal;
+
+         const MAX: $T = $maxVal;
+      }
+   }
+}
+
+
+// Implement the Bounded for all the primitive types.
+bounded_trait_impl!(u8, 0u8, !0u8);
+bounded_trait_impl!(u16, 0u16, !0u16);
+bounded_trait_impl!(u32, 0u32, !0u32);
+bounded_trait_impl!(u64, 0u64, !0u64);
+bounded_trait_impl!(usize, 0usize, !0usize);
+
+bounded_trait_impl!(i8, (!0i8 ^ (!0u8 >> 1u8) as i8),
+                        !(!0i8 ^ (!0u8 >> 1u8) as i8));
+bounded_trait_impl!(i16, (!0i16 ^ (!0u16 >> 1u16) as i16),
+                         !(!0i16 ^ (!0u16 >> 1u16) as i16));
+bounded_trait_impl!(i32, (!0i32 ^ (!0u32 >> 1u32) as i32),
+                         !(!0i32 ^ (!0u32 >> 1u32) as i32));
+bounded_trait_impl!(i64, (!0i64 ^ (!0u64 >> 1u64) as i64),
+                         !(!0i64 ^ (!0u64 >> 1u64) as i64));
+bounded_trait_impl!(isize, (!0isize ^ (!0usize >> 1usize) as isize),
+                           !(!0isize ^ (!0usize >> 1usize) as isize));
+
+bounded_trait_impl!(f32, -3.40282347e+38f32, 3.40282347e+38f32);
+bounded_trait_impl!(f64, -1.7976931348623157e+308f64,
+                         1.7976931348623157e+308f64);
+
+
+
+#[cfg(test)]
+mod tests
+{
+   macro_rules! bounds_test
+   {
+      ($T: ident, $func_name: ident, $minVal: expr, $maxVal: expr) =>
+      {
+         #[test]
+         fn $func_name()
+         {
+            use bounded::Bounded;
+
+
+
+            assert_eq!($T::MIN, $minVal);
+            assert_eq!($T::MAX, $maxVal);
+         }
+      }
+   }
+
+   bounds_test!(u8, min_max_u8, 0u8, !0u8);
+   bounds_test!(u16, min_max_u16, 0u16, !0u16);
+   bounds_test!(u32, min_max_u32, 0u32, !0u32);
+   bounds_test!(u64, min_max_u64, 0u64, !0u64);
+   bounds_test!(usize, min_max_usize, 0usize, !0usize);
+
+   bounds_test!(i8, min_max_i8,
+    -1i8 << (((::std::mem::size_of::<i8>() as i8)*8i8)-1i8),
+    !(-1i8 << (((::std::mem::size_of::<i8>() as i8)*8i8)-1i8)));
+   bounds_test!(i16, min_max_i16,
+    -1i16 << (((::std::mem::size_of::<i16>() as i16)*8i16)-1i16),
+    !(-1i16 << (((::std::mem::size_of::<i16>() as i16)*8i16)-1i16)));
+   bounds_test!(i32, min_max_i32,
+    -1i32 << (((::std::mem::size_of::<i32>() as i32)*8i32)-1i32),
+    !(-1i32 << (((::std::mem::size_of::<i32>() as i32)*8i32)-1i32)));
+   bounds_test!(i64, min_max_i64,
+    -1i64 << (((::std::mem::size_of::<i64>() as i64)*8i64)-1i64),
+    !(-1i64 << (((::std::mem::size_of::<i64>() as i64)*8i64)-1i64)));
+   bounds_test!(isize, min_max_isize,
+    -1isize << (((::std::mem::size_of::<isize>() as isize)*8isize)-1isize),
+    !(-1isize << (((::std::mem::size_of::<isize>() as isize)*8isize)-1isize)));
+
+   bounds_test!(f32, min_max_f32,
+                -3.40282347e+38f32, 3.40282347e+38f32);
+   bounds_test!(f64, min_max_f64,
+                -1.7976931348623157e+308f64,
+                1.7976931348623157e+308f64);
+}