Add additional constants to primitive floating point numbers

These follow the values defined in the C99 standard

src/libcore/num/f32.rs

@@ -508,6 +508,14 @@ impl Real for f32 {
     fn tanh(&self) -> f32 { tanh(*self) }
 }
 
+impl Bounded for f32 {
+    #[inline(always)]
+    fn min_value() -> f32 { 1.17549435e-38 }
+
+    #[inline(always)]
+    fn max_value() -> f32 { 3.40282347e+38 }
+}
+
 impl Primitive for f32 {
     #[inline(always)]
     fn bits() -> uint { 32 }
@@ -532,6 +540,27 @@ impl Float for f32 {
     #[inline(always)]
     fn is_NaN(&self) -> bool { *self != *self }
 
+    #[inline(always)]
+    fn mantissa_digits() -> uint { 24 }
+
+    #[inline(always)]
+    fn digits() -> uint { 6 }
+
+    #[inline(always)]
+    fn epsilon() -> f32 { 1.19209290e-07 }
+
+    #[inline(always)]
+    fn min_exp() -> int { -125 }
+
+    #[inline(always)]
+    fn max_exp() -> int { 128 }
+
+    #[inline(always)]
+    fn min_10_exp() -> int { -37 }
+
+    #[inline(always)]
+    fn max_10_exp() -> int { 38 }
+
     /// Returns `true` if the number is infinite
     #[inline(always)]
     fn is_infinite(&self) -> bool {

src/libcore/num/f64.rs

@@ -548,6 +548,14 @@ impl RealExt for f64 {
     fn yn(&self, n: int) -> f64 { yn(n as c_int, *self) }
 }
 
+impl Bounded for f64 {
+    #[inline(always)]
+    fn min_value() -> f64 { 2.2250738585072014e-308 }
+
+    #[inline(always)]
+    fn max_value() -> f64 { 1.7976931348623157e+308 }
+}
+
 impl Primitive for f64 {
     #[inline(always)]
     fn bits() -> uint { 64 }
@@ -584,6 +592,27 @@ impl Float for f64 {
         !(self.is_NaN() || self.is_infinite())
     }
 
+    #[inline(always)]
+    fn mantissa_digits() -> uint { 53 }
+
+    #[inline(always)]
+    fn digits() -> uint { 15 }
+
+    #[inline(always)]
+    fn epsilon() -> f64 { 2.2204460492503131e-16 }
+
+    #[inline(always)]
+    fn min_exp() -> int { -1021 }
+
+    #[inline(always)]
+    fn max_exp() -> int { 1024 }
+
+    #[inline(always)]
+    fn min_10_exp() -> int { -307 }
+
+    #[inline(always)]
+    fn max_10_exp() -> int { 308 }
+
     ///
     /// Fused multiply-add. Computes `(self * a) + b` with only one rounding error. This
     /// produces a more accurate result with better performance than a separate multiplication

src/libcore/num/float.rs

@@ -700,6 +700,14 @@ impl Signed for float {
     fn is_negative(&self) -> bool { *self < 0.0 || (1.0 / *self) == neg_infinity }
 }
 
+impl Bounded for float {
+    #[inline(always)]
+    fn min_value() -> float { Bounded::min_value::<f64>() as float }
+
+    #[inline(always)]
+    fn max_value() -> float { Bounded::max_value::<f64>() as float }
+}
+
 impl Primitive for float {
     #[inline(always)]
     fn bits() -> uint { Primitive::bits::<f64>() }
@@ -724,6 +732,27 @@ impl Float for float {
     #[inline(always)]
     fn is_NaN(&self) -> bool { *self != *self }
 
+    #[inline(always)]
+    fn mantissa_digits() -> uint { Float::mantissa_digits::<f64>() }
+
+    #[inline(always)]
+    fn digits() -> uint { Float::digits::<f64>() }
+
+    #[inline(always)]
+    fn epsilon() -> float { Float::epsilon::<f64>() as float }
+
+    #[inline(always)]
+    fn min_exp() -> int { Float::min_exp::<f64>() }
+
+    #[inline(always)]
+    fn max_exp() -> int { Float::max_exp::<f64>() }
+
+    #[inline(always)]
+    fn min_10_exp() -> int { Float::min_10_exp::<f64>() }
+
+    #[inline(always)]
+    fn max_10_exp() -> int { Float::max_10_exp::<f64>() }
+
     /// Returns `true` if the number is infinite
     #[inline(always)]
     fn is_infinite(&self) -> bool {

src/libcore/num/num.rs

@@ -219,6 +219,7 @@ pub trait Bounded {
 ///
 pub trait Primitive: Num
                    + NumCast
+                   + Bounded
                    + Neg<Self>
                    + Add<Self,Self>
                    + Sub<Self,Self>
@@ -235,7 +236,6 @@ pub trait Primitive: Num
 ///
 pub trait Int: Integer
              + Primitive
-             + Bounded
              + Bitwise
              + BitCount {}
 
@@ -255,6 +255,14 @@ pub trait Float: Real
     fn is_infinite(&self) -> bool;
     fn is_finite(&self) -> bool;
 
+    fn mantissa_digits() -> uint;
+    fn digits() -> uint;
+    fn epsilon() -> Self;
+    fn min_exp() -> int;
+    fn max_exp() -> int;
+    fn min_10_exp() -> int;
+    fn max_10_exp() -> int;
+
     fn mul_add(&self, a: Self, b: Self) -> Self;
     fn next_after(&self, other: Self) -> Self;
 }