EpsilonTest.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/basic.h>
 
#include <type_traits>
 
namespace ogdf {
 
class EpsilonTest {
private:
    const double eps; 
 
public:
    explicit EpsilonTest(double epsilon = 1.0e-8) : eps(epsilon) { }
 
    // LESS: integral and floating_point
 
    template<typename T>
    inline typename std::enable_if<std::is_integral<T>::value, bool>::type less(const T& x,
            const T& y) const {
        return x < y;
    }
 
 
    template<typename T>
    inline typename std::enable_if<std::is_floating_point<T>::value, bool>::type less(const T& x,
            const T& y) const {
        return x < (y - eps);
    }
 
    // LEQ: integral and floating_point
 
    template<typename T>
    inline typename std::enable_if<std::is_integral<T>::value, bool>::type leq(const T& x,
            const T& y) const {
        return x <= y;
    }
 
 
    template<typename T>
    inline typename std::enable_if<std::is_floating_point<T>::value, bool>::type leq(const T& x,
            const T& y) const {
        return x < (y + eps);
    }
 
    // EQUAL: integral and floating_point
 
    template<typename T>
    inline typename std::enable_if<std::is_integral<T>::value, bool>::type equal(const T& x,
            const T& y) const {
        return x == y;
    }
 
 
    template<typename T>
    inline typename std::enable_if<std::is_floating_point<T>::value, bool>::type equal(const T& x,
            const T& y) const {
        return leq(x, y) && geq(x, y);
    }
 
    // GEQ: integral and floating_point
 
    template<typename T>
    inline typename std::enable_if<std::is_integral<T>::value, bool>::type geq(const T& x,
            const T& y) const {
        return x >= y;
    }
 
 
    template<typename T>
    inline typename std::enable_if<std::is_floating_point<T>::value, bool>::type geq(const T& x,
            const T& y) const {
        return x > (y - eps);
    }
 
    // GREATER: integral and floating_point
 
    template<typename T>
    inline typename std::enable_if<std::is_integral<T>::value, bool>::type greater(const T& x,
            const T& y) const {
        return x > y;
    }
 
 
    template<typename T>
    inline typename std::enable_if<std::is_floating_point<T>::value, bool>::type greater(const T& x,
            const T& y) const {
        return x > (y + eps);
    }
};
 
}