Add Orderable trait

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: brendanzab

src/libcore/core.rc

@@ -104,10 +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/f32.rs

@@ -224,6 +224,20 @@ impl Ord for f32 {
     fn gt(&self, other: &f32) -> bool { (*self) > (*other) }
 }
 
+impl Orderable for f32 {
+    #[inline(always)]
+    fn min(&self, other: &f32) -> f32 { fmin(*self, *other) }
+
+    #[inline(always)]
+    fn max(&self, other: &f32) -> f32 { fmax(*self, *other) }
+
+    #[inline(always)]
+    fn clamp(&self, mn: &f32, mx: &f32) -> f32 {
+        if *self > *mx { *mx } else
+        if *self < *mn { *mn } else { *self }
+    }
+}
+
 impl Zero for f32 {
     #[inline(always)]
     fn zero() -> f32 { 0.0 }
@@ -768,6 +782,17 @@ mod tests {
         num::test_num(10f32, 2f32);
     }
 
+    #[test]
+    fn test_orderable() {
+        assert_eq!(1f32.min(&2f32), 1f32);
+        assert_eq!(2f32.min(&1f32), 1f32);
+        assert_eq!(1f32.max(&2f32), 2f32);
+        assert_eq!(2f32.max(&1f32), 2f32);
+        assert_eq!(1f32.clamp(&2f32, &4f32), 2f32);
+        assert_eq!(8f32.clamp(&2f32, &4f32), 4f32);
+        assert_eq!(3f32.clamp(&2f32, &4f32), 3f32);
+    }
+
     #[test]
     fn test_floor() {
         assert_fuzzy_eq!(1.0f32.floor(), 1.0f32);

src/libcore/num/f64.rs

@@ -245,6 +245,20 @@ impl Ord for f64 {
     fn gt(&self, other: &f64) -> bool { (*self) > (*other) }
 }
 
+impl Orderable for f64 {
+    #[inline(always)]
+    fn min(&self, other: &f64) -> f64 { fmin(*self, *other) }
+
+    #[inline(always)]
+    fn max(&self, other: &f64) -> f64 { fmax(*self, *other) }
+
+    #[inline(always)]
+    fn clamp(&self, mn: &f64, mx: &f64) -> f64 {
+        if *self > *mx { *mx } else
+        if *self < *mn { *mn } else { *self }
+    }
+}
+
 impl Zero for f64 {
     #[inline(always)]
     fn zero() -> f64 { 0.0 }
@@ -809,6 +823,17 @@ mod tests {
         num::test_num(10f64, 2f64);
     }
 
+    #[test]
+    fn test_orderable() {
+        assert_eq!(1f64.min(&2f64), 1f64);
+        assert_eq!(2f64.min(&1f64), 1f64);
+        assert_eq!(1f64.max(&2f64), 2f64);
+        assert_eq!(2f64.max(&1f64), 2f64);
+        assert_eq!(1f64.clamp(&2f64, &4f64), 2f64);
+        assert_eq!(8f64.clamp(&2f64, &4f64), 4f64);
+        assert_eq!(3f64.clamp(&2f64, &4f64), 3f64);
+    }
+
     #[test]
     fn test_floor() {
         assert_fuzzy_eq!(1.0f64.floor(), 1.0f64);

src/libcore/num/float.rs

@@ -384,6 +384,24 @@ impl Ord for float {
     fn gt(&self, other: &float) -> bool { (*self) > (*other) }
 }
 
+impl Orderable for float {
+    #[inline(always)]
+    fn min(&self, other: &float) -> float {
+        fmin(*self as f64, *other as f64) as float
+    }
+
+    #[inline(always)]
+    fn max(&self, other: &float) -> float {
+        fmax(*self as f64, *other as f64) as float
+    }
+
+    #[inline(always)]
+    fn clamp(&self, mn: &float, mx: &float) -> float {
+        if *self > *mx { *mx } else
+        if *self < *mn { *mn } else { *self }
+    }
+}
+
 impl Zero for float {
     #[inline(always)]
     fn zero() -> float { 0.0 }
@@ -738,6 +756,17 @@ mod tests {
         num::test_num(10f, 2f);
     }
 
+    #[test]
+    fn test_orderable() {
+        assert_eq!(1f.min(&2f), 1f);
+        assert_eq!(2f.min(&1f), 1f);
+        assert_eq!(1f.max(&2f), 2f);
+        assert_eq!(2f.max(&1f), 2f);
+        assert_eq!(1f.clamp(&2f, &4f), 2f);
+        assert_eq!(8f.clamp(&2f, &4f), 4f);
+        assert_eq!(3f.clamp(&2f, &4f), 3f);
+    }
+
     #[test]
     fn test_floor() {
         assert_fuzzy_eq!(1.0f.floor(), 1.0f);

src/libcore/num/int-template.rs

@@ -152,6 +152,24 @@ impl Eq for T {
     fn ne(&self, other: &T) -> bool { return (*self) != (*other); }
 }
 
+impl Orderable for T {
+    #[inline(always)]
+    fn min(&self, other: &T) -> T {
+        if *self < *other { *self } else { *other }
+    }
+
+    #[inline(always)]
+    fn max(&self, other: &T) -> T {
+        if *self > *other { *self } else { *other }
+    }
+
+    #[inline(always)]
+    fn clamp(&self, mn: &T, mx: &T) -> T {
+        if *self > *mx { *mx } else
+        if *self < *mn { *mn } else { *self }
+    }
+}
+
 impl Zero for T {
     #[inline(always)]
     fn zero() -> T { 0 }
@@ -535,6 +553,17 @@ mod tests {
         num::test_num(10 as T, 2 as T);
     }
 
+    #[test]
+    fn test_orderable() {
+        assert_eq!((1 as T).min(&(2 as T)), 1 as T);
+        assert_eq!((2 as T).min(&(1 as T)), 1 as T);
+        assert_eq!((1 as T).max(&(2 as T)), 2 as T);
+        assert_eq!((2 as T).max(&(1 as T)), 2 as T);
+        assert_eq!((1 as T).clamp(&(2 as T), &(4 as T)), 2 as T);
+        assert_eq!((8 as T).clamp(&(2 as T), &(4 as T)), 4 as T);
+        assert_eq!((3 as T).clamp(&(2 as T), &(4 as T)), 3 as T);
+    }
+
     #[test]
     pub fn test_signed() {
         assert_eq!((1 as T).abs(), 1 as T);

src/libcore/num/num.rs

@@ -24,6 +24,9 @@ use kinds::Copy;
 
 pub mod strconv;
 
+///
+/// The base trait for numeric types
+///
 pub trait Num: Eq + Zero + One
              + Neg<Self>
              + Add<Self,Self>
@@ -37,6 +40,16 @@ pub trait IntConvertible {
     fn from_int(n: int) -> Self;
 }
 
+pub trait Orderable: Ord {
+    // These should be methods on `Ord`, with overridable default implementations. 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).
+    fn min(&self, other: &Self) -> Self;
+    fn max(&self, other: &Self) -> Self;
+    fn clamp(&self, mn: &Self, mx: &Self) -> Self;
+}
+
 pub trait Zero {
     fn zero() -> Self;      // FIXME (#5527): This should be an associated constant
     fn is_zero(&self) -> bool;
@@ -62,7 +75,7 @@ pub fn abs<T:Ord + Zero + Neg<T>>(v: T) -> T {
 }
 
 pub trait Integer: Num
-                 + Ord
+                 + Orderable
                  + Quot<Self,Self>
                  + Rem<Self,Self> {
     fn div(&self, other: &Self) -> Self;
@@ -86,7 +99,7 @@ pub trait Round {
 }
 
 pub trait Fractional: Num
-                    + Ord
+                    + Orderable
                     + Round
                     + Quot<Self,Self> {
     fn recip(&self) -> Self;

src/libcore/num/uint-template.rs

@@ -117,6 +117,24 @@ impl Eq for T {
     fn ne(&self, other: &T) -> bool { return (*self) != (*other); }
 }
 
+impl Orderable for T {
+    #[inline(always)]
+    fn min(&self, other: &T) -> T {
+        if *self < *other { *self } else { *other }
+    }
+
+    #[inline(always)]
+    fn max(&self, other: &T) -> T {
+        if *self > *other { *self } else { *other }
+    }
+
+    #[inline(always)]
+    fn clamp(&self, mn: &T, mx: &T) -> T {
+        if *self > *mx { *mx } else
+        if *self < *mn { *mn } else { *self }
+    }
+}
+
 impl Zero for T {
     #[inline(always)]
     fn zero() -> T { 0 }
@@ -367,6 +385,17 @@ mod tests {
         num::test_num(10 as T, 2 as T);
     }
 
+    #[test]
+    fn test_orderable() {
+        assert_eq!((1 as T).min(&(2 as T)), 1 as T);
+        assert_eq!((2 as T).min(&(1 as T)), 1 as T);
+        assert_eq!((1 as T).max(&(2 as T)), 2 as T);
+        assert_eq!((2 as T).max(&(1 as T)), 2 as T);
+        assert_eq!((1 as T).clamp(&(2 as T), &(4 as T)), 2 as T);
+        assert_eq!((8 as T).clamp(&(2 as T), &(4 as T)), 4 as T);
+        assert_eq!((3 as T).clamp(&(2 as T), &(4 as T)), 3 as T);
+    }
+
     #[test]
     fn test_gcd() {
         assert_eq!((10 as T).gcd(&2), 2 as T);

src/libcore/prelude.rs

@@ -38,7 +38,7 @@ pub use iter::{BaseIter, ReverseIter, MutableIter, ExtendedIter, EqIter};
 pub use iter::{CopyableIter, CopyableOrderedIter, CopyableNonstrictIter};
 pub use iter::{Times, 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};