float_cmp.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_COMMON_FLOAT_CMP_HH
#define DUNE_COMMON_FLOAT_CMP_HH
 
namespace Dune {
  namespace FloatCmp {
    // basic constants
    enum CmpStyle {
      relativeWeak,
      relativeStrong,
      absolute,
      defaultCmpStyle = relativeWeak
    };
    enum RoundingStyle {
      towardZero,
      towardInf,
      downward,
      upward,
      defaultRoundingStyle = towardZero
    };
 
    template<class T> struct EpsilonType;
 
 
    template<class T, CmpStyle style = defaultCmpStyle>
    struct DefaultEpsilon {
      static typename EpsilonType<T>::Type value();
    };
 
    // operations in functional style
 
 
 
    template <class T, CmpStyle style /*= defaultCmpStyle*/>
    bool eq(const T &first,
            const T &second,
            typename EpsilonType<T>::Type epsilon = DefaultEpsilon<T, style>::value());
 
    template <class T, CmpStyle style /*= defaultCmpStyle*/>
    bool ne(const T &first,
            const T &second,
            typename EpsilonType<T>::Type epsilon = DefaultEpsilon<T, style>::value());
 
    template <class T, CmpStyle style /*= defaultCmpStyle*/>
    bool gt(const T &first,
            const T &second,
            typename EpsilonType<T>::Type epsilon = DefaultEpsilon<T, style>::value());
 
    template <class T, CmpStyle style /*= defaultCmpStyle*/>
    bool lt(const T &first,
            const T &second,
            typename EpsilonType<T>::Type epsilon = DefaultEpsilon<T, style>::value());
 
    template <class T, CmpStyle style /*= defaultCmpStyle*/>
    bool ge(const T &first,
            const T &second,
            typename EpsilonType<T>::Type epsilon = DefaultEpsilon<T, style>::value());
 
    template <class T, CmpStyle style /*= defaultCmpStyle*/>
    bool le(const T &first,
            const T &second,
            typename EpsilonType<T>::Type epsilon = DefaultEpsilon<T, style>::value());
 
    // rounding operations
 
    template<class I, class T, CmpStyle cstyle /*= defaultCmpStyle*/, RoundingStyle rstyle /*= defaultRoundingStyle*/>
    I round(const T &val, typename EpsilonType<T>::Type epsilon = DefaultEpsilon<T, cstyle>::value());
    // truncation
 
    template<class I, class T, CmpStyle cstyle /*= defaultCmpStyle*/, RoundingStyle rstyle /*= defaultRoundingStyle*/>
    I trunc(const T &val, typename EpsilonType<T>::Type epsilon = DefaultEpsilon<T, cstyle>::value());
 
    // group FloatCmp
  } //namespace FloatCmp
 
 
  // oo interface
 
  template<class T, FloatCmp::CmpStyle cstyle_ = FloatCmp::defaultCmpStyle,
      FloatCmp::RoundingStyle rstyle_ = FloatCmp::defaultRoundingStyle>
  class FloatCmpOps {
    typedef FloatCmp::CmpStyle CmpStyle;
    typedef FloatCmp::RoundingStyle RoundingStyle;
 
  public:
    // record template parameters
    static const CmpStyle cstyle = cstyle_;
    static const RoundingStyle rstyle = rstyle_;
    typedef T ValueType;
 
    typedef typename FloatCmp::EpsilonType<T>::Type EpsilonType;
 
  private:
    EpsilonType epsilon_;
 
    typedef FloatCmp::DefaultEpsilon<EpsilonType, cstyle> DefaultEpsilon;
 
  public:
 
    FloatCmpOps(EpsilonType epsilon = DefaultEpsilon::value());
 
    EpsilonType epsilon() const;
    void epsilon(EpsilonType epsilon__);
 
    bool eq(const ValueType &first, const ValueType &second) const;
 
    bool ne(const ValueType &first, const ValueType &second) const;
 
    bool gt(const ValueType &first, const ValueType &second) const;
 
    bool lt(const ValueType &first, const ValueType &second) const;
 
    bool ge(const ValueType &first, const ValueType &second) const;
 
    bool le(const ValueType &first, const ValueType &second) const;
 
 
    template<class I>
    I round(const ValueType &val) const;
 
 
    template<class I>
    I trunc(const ValueType &val) const;
 
  };
 
} //namespace Dune
 
#include "float_cmp.cc"
 
#endif //DUNE_COMMON_FLOAT_CMP_HH