auto merge of #6071 : bjz/rust/numeric-traits, r=graydon

As part of the numeric trait reform (see issue #4819), I have added the following traits to `core::num` and implemented them for Rust's primitive numeric types:

~~~rust
pub trait Bitwise: Not<Self>
                 + BitAnd<Self,Self>
                 + BitOr<Self,Self>
                 + BitXor<Self,Self>
                 + Shl<Self,Self>
                 + Shr<Self,Self> {}

pub trait BitCount {
    fn population_count(&self) -> Self;
    fn leading_zeros(&self) -> Self;
    fn trailing_zeros(&self) -> Self;
}

pub trait Bounded {
    fn min_value() -> Self;
    fn max_value() -> Self;
}

pub trait Primitive: Num
                   + NumCast
                   + Bounded
                   + Neg<Self>
                   + Add<Self,Self>
                   + Sub<Self,Self>
                   + Mul<Self,Self>
                   + Quot<Self,Self>
                   + Rem<Self,Self> {
    fn bits() -> uint;
    fn bytes() -> uint;
}

pub trait Int: Integer
             + Primitive
             + Bitwise
             + BitCount {}

pub trait Float: Real
               + Signed
               + Primitive {
    fn NaN() -> Self;
    fn infinity() -> Self;
    fn neg_infinity() -> Self;
    fn neg_zero() -> Self;

    fn is_NaN(&self) -> bool;
    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;
}
~~~
Note: I'm not sure my implementation for `BitCount::trailing_zeros` and `BitCount::leading_zeros` is correct for uints. I also need some assistance creating appropriate unit tests for them.

More work needs to be done in implementing specialized primitive floating-point and integer methods, but I'm beginning to reach the limits of my knowledge. Please leave your suggestions/critiques/ideas on #4819 if you have them – I'd very much appreciate hearing them.

I have also added an `Orderable` trait:

~~~rust
pub trait Orderable: Ord {
    fn min(&self, other: &Self) -> Self;
    fn max(&self, other: &Self) -> Self;
    fn clamp(&self, mn: &Self, mx: &Self) -> Self;
}
~~~

This is a temporary trait until we have default methods. We don't want to encumber all implementors of Ord by requiring them to implement these functions, but at the same time we want to be able to take advantage of the speed of the specific numeric functions (like the `fmin` and `fmax` intrinsics).

Author: bors

src/libcore/core.rc

@@ -104,8 +104,11 @@ pub use iter::{CopyableOrderedIter, CopyableNonstrictIter, Times};
 pub use iter::{ExtendedMutableIter};
 
 pub use num::{Num, NumCast};
-pub use num::{Signed, Unsigned, Integer};
+pub use num::{Orderable, Signed, Unsigned, Integer};
 pub use num::{Round, Fractional, Real, RealExt};
+pub use num::{Bitwise, BitCount, Bounded};
+pub use num::{Primitive, Int, Float};
+
 pub use ptr::Ptr;
 pub use to_str::ToStr;
 pub use clone::Clone;

src/libcore/num/cmath.rs

@@ -47,7 +47,8 @@ pub mod c_double_utils {
         unsafe fn fmax(a: c_double, b: c_double) -> c_double;
         #[link_name="fmin"]
         unsafe fn fmin(a: c_double, b: c_double) -> c_double;
-        unsafe fn nextafter(x: c_double, y: c_double) -> c_double;
+        #[link_name="nextafter"]
+        unsafe fn next_after(x: c_double, y: c_double) -> c_double;
         unsafe fn frexp(n: c_double, value: &mut c_int) -> c_double;
         unsafe fn hypot(x: c_double, y: c_double) -> c_double;
         unsafe fn ldexp(x: c_double, n: c_int) -> c_double;
@@ -131,7 +132,7 @@ pub mod c_float_utils {
         #[link_name="fminf"]
         unsafe fn fmin(a: c_float, b: c_float) -> c_float;
         #[link_name="nextafterf"]
-        unsafe fn nextafter(x: c_float, y: c_float) -> c_float;
+        unsafe fn next_after(x: c_float, y: c_float) -> c_float;
         #[link_name="hypotf"]
         unsafe fn hypot(x: c_float, y: c_float) -> c_float;
         #[link_name="ldexpf"]