fix partialord implementation for orderedfloat

src/lib.rs

@@ -30,7 +30,7 @@ const CANONICAL_ZERO_BITS: u64 = 0x0u64;
 ///
 /// NaN is sorted as *greater* than all other values and *equal*
 /// to itself, in contradiction with the IEEE standard.
-#[derive(PartialOrd, Debug, Default, Clone, Copy)]
+#[derive(Debug, Default, Clone, Copy)]
 pub struct OrderedFloat<T: Float>(pub T);
 
 impl<T: Float> OrderedFloat<T> {
@@ -55,13 +55,21 @@ impl<T: Float> AsMut<T> for OrderedFloat<T> {
     }
 }
 
+impl<T: Float + PartialOrd> PartialOrd for OrderedFloat<T> {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
 impl<T: Float + PartialOrd> Ord for OrderedFloat<T> {
-    fn cmp(&self, other: &OrderedFloat<T>) -> Ordering {
-        match self.partial_cmp(&other) {
+    fn cmp(&self, other: &Self) -> Ordering {
+        let lhs = self.as_ref();
+        let rhs = other.as_ref();
+        match lhs.partial_cmp(&rhs) {
             Some(ordering) => ordering,
             None => {
-                if self.as_ref().is_nan() {
-                    if other.as_ref().is_nan() {
+                if lhs.is_nan() {
+                    if rhs.is_nan() {
                         Ordering::Equal
                     } else {
                         Ordering::Greater

tests/test.rs

@@ -26,6 +26,31 @@ describe! ordered_float32 {
         assert_eq!(OrderedFloat(f32_nan).cmp(&OrderedFloat(-100000.0f32)), Greater);
         assert_eq!(OrderedFloat(-100.0f32).cmp(&OrderedFloat(Float::nan())), Less);
     }
+
+    it "should compare regular floats with comparison operators" {
+        assert!(OrderedFloat(7.0f32) == OrderedFloat(7.0));
+        assert!(OrderedFloat(7.0f32) <= OrderedFloat(7.0));
+        assert!(OrderedFloat(7.0f32) >= OrderedFloat(7.0));
+        assert!(OrderedFloat(8.0f32) > OrderedFloat(7.0));
+        assert!(OrderedFloat(8.0f32) >= OrderedFloat(7.0));
+        assert!(OrderedFloat(4.0f32) < OrderedFloat(7.0));
+        assert!(OrderedFloat(4.0f32) <= OrderedFloat(7.0));
+    }
+
+    it "should compare NaN with comparison operators" {
+        let f32_nan: OrderedFloat<f32> = OrderedFloat(Float::nan());
+        assert!(f32_nan == f32_nan);
+        assert!(f32_nan <= f32_nan);
+        assert!(f32_nan >= f32_nan);
+        assert!(f32_nan > OrderedFloat(-100000.0f32));
+        assert!(f32_nan >= OrderedFloat(-100000.0f32));
+        assert!(OrderedFloat(-100.0f32) < f32_nan);
+        assert!(OrderedFloat(-100.0f32) <= f32_nan);
+        assert!(f32_nan > OrderedFloat(Float::infinity()));
+        assert!(f32_nan >= OrderedFloat(Float::infinity()));
+        assert!(f32_nan > OrderedFloat(Float::neg_infinity()));
+        assert!(f32_nan >= OrderedFloat(Float::neg_infinity()));
+    }
 }
 
 describe! ordered_float64 {
@@ -41,6 +66,31 @@ describe! ordered_float64 {
         assert_eq!(OrderedFloat(f64_nan).cmp(&OrderedFloat(-100000.0f64)), Greater);
         assert_eq!(OrderedFloat(-100.0f64).cmp(&OrderedFloat(Float::nan())), Less);
     }
+
+    it "should compare regular floats with comparison operators" {
+        assert!(OrderedFloat(7.0) == OrderedFloat(7.0));
+        assert!(OrderedFloat(7.0) <= OrderedFloat(7.0));
+        assert!(OrderedFloat(7.0) >= OrderedFloat(7.0));
+        assert!(OrderedFloat(8.0) > OrderedFloat(7.0));
+        assert!(OrderedFloat(8.0) >= OrderedFloat(7.0));
+        assert!(OrderedFloat(4.0) < OrderedFloat(7.0));
+        assert!(OrderedFloat(4.0) <= OrderedFloat(7.0));
+    }
+
+    it "should compare NaN with comparison operators" {
+        let f64_nan: OrderedFloat<f64> = OrderedFloat(Float::nan());
+        assert!(f64_nan == f64_nan);
+        assert!(f64_nan <= f64_nan);
+        assert!(f64_nan >= f64_nan);
+        assert!(f64_nan > OrderedFloat(-100000.0));
+        assert!(f64_nan >= OrderedFloat(-100000.0));
+        assert!(OrderedFloat(-100.0) < f64_nan);
+        assert!(OrderedFloat(-100.0) <= f64_nan);
+        assert!(f64_nan > OrderedFloat(Float::infinity()));
+        assert!(f64_nan >= OrderedFloat(Float::infinity()));
+        assert!(f64_nan > OrderedFloat(Float::neg_infinity()));
+        assert!(f64_nan >= OrderedFloat(Float::neg_infinity()));
+    }
 }
 
 describe! not_nan32 {