1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
// Copyright (c) 2018 The predicates-rs Project Developers. // // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your // option. This file may not be copied, modified, or distributed // except according to those terms. use std::fmt; 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(Debug, Clone, Copy, PartialEq)] 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. Sometimes more control is needed and you will /// need to set `IsClosePredicate::epsilon` separately from `IsClosePredicate::ulps`. /// /// # Examples /// /// ``` /// use predicates::prelude::*; /// /// let a = 0.15_f64 + 0.15_f64 + 0.15_f64; /// let predicate_fn = predicate::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::prelude::*; /// /// let a = 0.15_f64 + 0.15_f64 + 0.15_f64; /// let predicate_fn = predicate::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::prelude::*; /// /// let a = 0.15_f64 + 0.15_f64 + 0.15_f64; /// let predicate_fn = predicate::float::is_close(a).ulps(5); /// ``` pub fn ulps(mut self, ulps: <f64 as Ulps>::U) -> Self { self.ulps = ulps; self } } impl Predicate<f64> for IsClosePredicate { fn eval(&self, variable: &f64) -> bool { variable.approx_eq(&self.target, self.epsilon, self.ulps) } } impl fmt::Display for IsClosePredicate { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "var ~= {} +/- {} ({})", 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::prelude::*; /// /// 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 = predicate::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, } }