feat(float): is_close Predicate

Fixes #11

Author: epage

Cargo.toml

@@ -20,7 +20,8 @@ appveyor = { repository = "assert-rs/predicates-rs" }
 [dependencies]
 difference = { version = "2.0", optional = true }
 regex = { version="0.2", optional = true }
+float-cmp = { version="0.4", optional = true }
 
 [features]
-default = ["difference", "regex"]
+default = ["difference", "regex", "float-cmp"]
 unstable = []

src/lib.rs

@@ -87,6 +87,8 @@
 
 #[cfg(feature = "difference")]
 extern crate difference;
+#[cfg(feature = "float-cmp")]
+extern crate float_cmp;
 #[cfg(feature = "regex")]
 extern crate regex;
 

src/predicate/float/close.rs

@@ -0,0 +1,101 @@
+use float_cmp::ApproxEq;
+use float_cmp::Ulps;
+
+use Predicate;
+
+/// Predicate that ensures two numbers are "close" enough, understanding that rounding errors
+/// occur.
+///
+/// This is created by the `predicate::float::is_close`.
+#[derive(Clone, Debug)]
+pub struct IsClosePredicate {
+    target: f64,
+    epsilon: f64,
+    ulps: <f64 as Ulps>::U,
+}
+
+impl IsClosePredicate {
+    /// Set the amount of error allowed.
+    ///
+    /// Values `1`-`5` should work in most cases.  Some times more control is needed and you will
+    /// need to set `IsClosePredicate::epsilon` separately from `IsClosePredicate::ulps`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use predicates::predicate::*;
+    ///
+    /// let a = 0.15_f64 + 0.15_f64 + 0.15_f64;
+    /// let predicate_fn = float::is_close(a).distance(5);
+    /// ```
+    pub fn distance(mut self, distance: <f64 as Ulps>::U) -> Self {
+        self.epsilon = (distance as f64) * ::std::f64::EPSILON;
+        self.ulps = distance;
+        self
+    }
+
+    /// Set the absolute deviation allowed.
+    ///
+    /// This is meant to handle problems near `0`. Values `1.`-`5.` epislons should work in most
+    /// cases.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use predicates::predicate::*;
+    ///
+    /// let a = 0.15_f64 + 0.15_f64 + 0.15_f64;
+    /// let predicate_fn = float::is_close(a).epsilon(5.0 * ::std::f64::EPSILON);
+    /// ```
+    pub fn epsilon(mut self, epsilon: f64) -> Self {
+        self.epsilon = epsilon;
+        self
+    }
+
+    /// Set the relative deviation allowed.
+    ///
+    /// This is meant to handle large numbers. Values `1`-`5` should work in most cases.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use predicates::predicate::*;
+    ///
+    /// let a = 0.15_f64 + 0.15_f64 + 0.15_f64;
+    /// let predicate_fn = float::is_close(a).ulps(5);
+    /// ```
+    pub fn ulps(mut self, ulps: <f64 as Ulps>::U) -> Self {
+        self.ulps = ulps;
+        self
+    }
+}
+
+impl Predicate for IsClosePredicate {
+    type Item = f64;
+
+    fn eval(&self, variable: &f64) -> bool {
+        variable.approx_eq(&self.target, self.epsilon, self.ulps)
+    }
+}
+
+/// Create a new `Predicate` that ensures two numbers are "close" enough, understanding that
+/// rounding errors occur.
+///
+/// # Examples
+///
+/// ```
+/// use predicates::predicate::*;
+///
+/// let a = 0.15_f64 + 0.15_f64 + 0.15_f64;
+/// let b = 0.1_f64 + 0.1_f64 + 0.25_f64;
+/// let predicate_fn = float::is_close(a);
+/// assert_eq!(true, predicate_fn.eval(&b));
+/// assert_eq!(false, predicate_fn.distance(0).eval(&b));
+/// ```
+pub fn is_close(target: f64) -> IsClosePredicate {
+    IsClosePredicate {
+        target,
+        epsilon: 2.0 * ::std::f64::EPSILON,
+        ulps: 2,
+    }
+}

src/predicate/float/mod.rs

@@ -0,0 +1,8 @@
+//! Float Predicates
+//!
+//! This module contains predicates specifiuc to string handling.
+
+#[cfg(feature = "float-cmp")]
+mod close;
+#[cfg(feature = "float-cmp")]
+pub use self::close::{is_close, IsClosePredicate};

src/predicate/mod.rs

@@ -25,6 +25,7 @@ pub use self::set::{contains, contains_hashable, contains_ord, ContainsPredicate
 // specialized primitive `Predicate` types
 pub mod str;
 pub mod path;
+pub mod float;
 
 // combinators
 mod boolean;