Test.h

Go to the documentation of this file.

#ifndef _utl_Test_h_
#define _utl_Test_h_

#include <utl/Triple.h>
#include <boost/format.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/tuple/tuple_comparison.hpp>
#include <boost/tuple/tuple_io.hpp>
#include <cmath>


namespace utl {

  struct IsSpace {
    bool operator()(const char x) const
    { return x == ' ' || x == '\r' || x == '\n' || x == '\t'; }
  };


  class Equal {
  public:
    template<typename T>
    bool operator()(const T& lhs, const T& rhs) const
    { return lhs == rhs; }

    static const char* Name() { return "equal"; }
  };


  class Less {
  public:
    template<typename T>
    bool operator()(const T& lhs, const T& rhs) const
    { return lhs < rhs; }

    static const char* Name() { return "less"; }
  };


  class LessOrEqual {
  public:
    template<typename T>
    bool operator()(const T& lhs, const T& rhs) const
    { return lhs <= rhs; }

    static const char* Name() { return "less or equal"; }
  };


  class Greater {
  public:
    template<typename T>
    bool operator()(const T& lhs, const T& rhs) const
    { return lhs > rhs; }

    static const char* Name() { return "greater"; }
  };


  class GreaterOrEqual {
  public:
    template<typename T>
    bool operator()(const T& lhs, const T& rhs) const
    { return lhs >= rhs; }

    static const char* Name() { return "greater or equal"; }
  };



  class CloseTo {
  public:
    CloseTo(const double eps = 1e-6) : fEpsilon(eps) { }

    template<typename T>
    bool operator()(const T& lhs, const T& rhs) const
    { return IsCloseTo(lhs, rhs); }

    boost::format Name() const
    { return boost::format("close (@%g) to") % fEpsilon; }

  protected:
    template<typename T>
    bool IsCloseAbs(const T& lhs, const T& rhs) const
    { return std::abs(double(lhs) - double(rhs)) < fEpsilon; }

    bool IsCloseAbs(const utl::Triple& lhs, const utl::Triple& rhs) const
    { return std::sqrt(TupleDist2(lhs, rhs)) < fEpsilon; }

    template<typename T>
    bool IsCloseRel(const T& lhs, const T& rhs) const
    { return 2*std::abs(double(lhs) - double(rhs)) / (std::abs(double(lhs)) + std::abs(double(rhs))) < fEpsilon; }

    bool
    IsCloseRel(const utl::Triple& lhs, const utl::Triple& rhs)
      const
    {
      return (2*sqrt(TupleDist2(lhs, rhs)) /
        (sqrt(TupleDist2(lhs, utl::Triple(0,0,0))) +
         sqrt(TupleDist2(rhs, utl::Triple(0,0,0))))) < fEpsilon;
    }

    template<typename T>
    bool
    IsCloseTo(const T& lhs, const T& rhs)
      const
    {
      if (IsCloseAbs(lhs, rhs))
        return true;
      else
        return IsCloseRel(lhs, rhs);
    }

    // tuple distance
    template<typename Head, typename Tail>
    static
    double
    TupleDist2(const boost::tuples::cons<Head, Tail>& lhs,
               const boost::tuples::cons<Head, Tail>& rhs)
    {
      const double t = lhs.get_head() - rhs.get_head();
      return t*t + TupleDist2(lhs.get_tail(), rhs.get_tail());
    }

    static double TupleDist2(const boost::tuples::null_type& /*lhs*/,
                             const boost::tuples::null_type& /*rhs*/)
    { return 0; }

    double fEpsilon;
  };


  class CloseAbs : public CloseTo {
  public:
    CloseAbs(const double eps = 1e-6) : CloseTo(eps) { }

    template<typename T>
    bool operator()(const T& lhs, const T& rhs) const
    { return IsCloseAbs(lhs, rhs); }

    boost::format Name() const
    { return boost::format("absolutely close (@%g) to") % fEpsilon; }
  };


  class CloseRel : public CloseTo {
  public:
    CloseRel(const double eps = 1e-6) : CloseTo(eps) { }

    template<typename T>
    bool operator()(const T& lhs, const T& rhs) const
    { return IsCloseRel(lhs, rhs); }

    boost::format Name() const
    { return boost::format("relatively close (@%g) to") % fEpsilon; }
  };


  template<typename Predicate>
  class Not : public Predicate {
  public:
    Not() : Predicate() { }

    Not(const double eps) : Predicate(eps) { }

    template<typename T>
    bool operator()(const T& x) const
    { return !Predicate::operator()(x); }

    template<typename T, typename U>
    bool operator()(const T& x, const U& y) const
    { return !Predicate::operator()(x, y); }

    template<typename T, typename U, typename W>
    bool operator()(const T& x, const U& y, const W& z) const
    { return !Predicate::operator()(x, y, z); }

    static boost::format Name()
    { return boost::format("not-%s") % Predicate().Name(); }
  };


  inline
  utl::Triple
  Diff(const utl::Triple& lhs, const utl::Triple& rhs)
  {
    return utl::Triple(lhs.get<0>() - rhs.get<0>(),
                       lhs.get<1>() - rhs.get<1>(),
                       lhs.get<2>() - rhs.get<2>());
  }



  template<class Predicate, typename T>
  inline bool Test(const Predicate& pred, const T& lhs, const T& rhs)
  { return pred(lhs, rhs); }


  template<class Predicate, typename T>
  inline bool Test(const T& lhs, const T& rhs)
  { return Test(Predicate(), lhs, rhs); }


  template<class Predicate, typename T, typename U>
  inline bool Test(const T& lhs, const T& rhs, const U& eps)
  { return Test(Predicate(eps), lhs, rhs); }

}


#endif