Implement Zero and One for NotNaN

Author: f-fr

src/lib.rs

@@ -15,7 +15,7 @@ use std::fmt;
 use std::io;
 use std::mem;
 use unreachable::unreachable;
-use num_traits::{Bounded, Float};
+use num_traits::{Bounded, Float, One, Zero};
 
 /// A wrapper around Floats providing an implementation of Ord and Hash.
 ///
@@ -569,6 +569,16 @@ fn raw_double_bits<F: Float>(f: &F) -> u64 {
     (man & MAN_MASK) | ((exp_u64 << 52) & EXP_MASK) | ((sign_u64 << 63) & SIGN_MASK)
 }
 
+impl<T: Float + Zero> Zero for NotNaN<T> {
+    fn zero() -> Self { NotNaN(T::zero()) }
+
+    fn is_zero(&self) -> bool { self.0.is_zero() }
+}
+
+impl<T: Float + One> One for NotNaN<T> {
+    fn one() -> Self { NotNaN(T::one()) }
+}
+
 impl<T: Float + Bounded> Bounded for NotNaN<T> {
     fn min_value() -> Self {
         NotNaN(Bounded::min_value())

tests/test.rs

@@ -5,7 +5,7 @@ extern crate ordered_float;
 extern crate num_traits;
 
 pub use ordered_float::*;
-pub use num_traits::{Bounded, Float};
+pub use num_traits::{Bounded, Float, One, Zero};
 pub use std::cmp::Ordering::*;
 pub use std::{f32, f64, panic};
 
@@ -105,6 +105,15 @@ describe! not_nan32 {
         assert!(panic::catch_unwind(|| {let mut tmp = NotNan::from(0.0f32); tmp %= f32::NAN;}).is_err());
     }
 
+    it "should implement Zero" {
+        assert_eq!(NotNaN::<f32>::zero(), NotNaN::from(0.0f32));
+        assert!(NotNaN::<f32>::zero().is_zero());
+    }
+
+    it "should implement One" {
+        assert_eq!(NotNaN::<f32>::one(), NotNaN::from(1.0f32))
+    }
+
     it "should implement Bounded" {
         assert_eq!(NotNaN::<f32>::min_value(), NotNaN::from(<f32 as Bounded>::min_value()));
         assert_eq!(NotNaN::<f32>::max_value(), NotNaN::from(<f32 as Bounded>::max_value()));
@@ -173,6 +182,15 @@ describe! not_nan64 {
         assert!(panic::catch_unwind(|| {let mut tmp = NotNan::from(0.0f64); tmp %= f64::NAN;}).is_err());
     }
 
+    it "should implement Zero" {
+        assert_eq!(NotNaN::<f64>::zero(), NotNaN::from(0.0f64));
+        assert!(NotNaN::<f64>::zero().is_zero());
+    }
+
+    it "should implement One" {
+        assert_eq!(NotNaN::<f64>::one(), NotNaN::from(1.0f64))
+    }
+
     it "should implement Bounded" {
         assert_eq!(NotNaN::<f64>::min_value(), NotNaN::from(<f64 as Bounded>::min_value()));
         assert_eq!(NotNaN::<f64>::max_value(), NotNaN::from(<f64 as Bounded>::max_value()));