fuzzy.hpp

Go to the documentation of this file.

 
/*****************************************************************************
** Ifdefs
*****************************************************************************/
 
#ifndef ECL_MATH_FUZZY_HPP_
#define ECL_MATH_FUZZY_HPP_
 
/*****************************************************************************
** Includes
*****************************************************************************/
 
//#include "num_traits.hpp"
#include <cmath> // floating point std::abs
#include <cstdlib> // integral std::abs
#include <algorithm> // std::min, std::max
#include <ecl/type_traits/numeric_limits.hpp>
 
/*****************************************************************************
** Namespaces
*****************************************************************************/
 
namespace ecl {
namespace implementations {
 
/****************************************************************************
* Implementation of fuzzy comparisons                                       *
****************************************************************************/
 
template<typename Scalar,
         bool IsInteger>
struct scalar_fuzzy_default_impl {};
 
template<typename Scalar>
struct scalar_fuzzy_default_impl<Scalar, false>
{
        typedef typename ecl::numeric_limits<Scalar>::Precision Precision;
 
        template<typename OtherScalar>
        static inline bool isApprox(const Scalar& x, const OtherScalar& y, const Precision& prec) {
                // casting just in case y is an integer type.
                return std::abs(x - static_cast<Scalar>(y)) <= std::min( std::abs(x),  std::abs(static_cast<Scalar>(y))) * prec;
        }
 
        template<typename OtherScalar>
        static inline bool isApproxOrLessThan(const Scalar& x, const OtherScalar& y, const Precision& prec) {
                return x <= y || isApprox(x, y, prec);
        }
};
 
template<typename Scalar>
struct scalar_fuzzy_default_impl<Scalar, true> {
 
        typedef typename ecl::numeric_limits<Scalar>::Precision Precision;
 
        template<typename OtherScalar>
        static inline bool isApprox(const Scalar& x, const OtherScalar& y, const Precision& prec) {
                // this will trigger if default argument is used (dummy precision for integers == 0)
                if ( ecl::numeric_limits<OtherScalar>::is_integer ) {
                        return x == y;
                } else {
                        // only get here if its not complex, so OtherScalar has to be a floating type
                        typename ecl::numeric_limits<OtherScalar>::Precision precision;
                        if ( prec == 0.0 ) {
                                precision = ecl::numeric_limits<OtherScalar>::dummy_precision;
                        } else {
                                precision = static_cast<OtherScalar>(prec);
                        }
                        return std::abs(static_cast<OtherScalar>(x) - y) <= std::min( std::abs(static_cast<OtherScalar>(x)),  std::abs(y)) * precision;
                }
        }
        template<typename OtherScalar>
        static inline bool isApproxOrLessThan(const Scalar& x, const OtherScalar& y, const Precision&) {
                return x <= y;
        }
};
 
// * @brief Fuzzy math implementation for complex numbers.
// *
// * Specialisation of fuzzy math functions for complex numbers.
// *
// * @tparam Scalar : autoselected by numeric traits as always being complex.
// */
//template<typename Scalar>
//struct scalar_fuzzy_default_impl<Scalar, true, false> {
//      typedef typename ecl::NumTraits<Scalar>::Precision Precision;
//
//      static inline bool isApprox(const Scalar& x, const Scalar& y, const Precision& prec) {
//              return ei_abs2(x - y) <= std::min(ei_abs2(x), ei_abs2(y)) * prec * prec;
//      }
//};
 
template<typename Scalar>
struct scalar_fuzzy_impl : implementations::scalar_fuzzy_default_impl<Scalar, numeric_limits<Scalar>::is_integer> {};
 
} // implementations
 
/*****************************************************************************
** Direct Interfaces
*****************************************************************************/
 
template<typename Scalar, typename OtherScalar>
inline bool isApprox(const Scalar& x, const OtherScalar& y, typename numeric_limits<Scalar>::Precision precision = numeric_limits<Scalar>::dummy_precision) {
        return implementations::scalar_fuzzy_impl<Scalar>::isApprox(x, y, precision);
}
 
template<typename Scalar, typename OtherScalar>
inline bool isApproxOrLessThan(const Scalar& x, const OtherScalar& y, typename numeric_limits<Scalar>::Precision precision = numeric_limits<Scalar>::dummy_precision) {
        return implementations::scalar_fuzzy_impl<Scalar>::isApproxOrLessThan(x, y, precision);
}
 
 
 
} // namespace ecl
 
#endif /* ECL_MATH_FUZZY_HPP_ */