RealComparisons.h

Go to the documentation of this file.

#ifndef LARCORE_COREUTILS_REALCOMPARISONS_H
#define LARCORE_COREUTILS_REALCOMPARISONS_H

// C/C++ standard libraries
#include <cmath> // std::abs()
#include <utility> // std::move()


namespace lar {
  namespace util {
    
    template <typename RealType>
    struct RealComparisons {
      using Value_t = RealType; 
      
      constexpr RealComparisons(Value_t threshold): threshold(threshold) {}
      
      constexpr bool zero(Value_t value) const
        { return std::abs(value) <= threshold; }
      
      constexpr bool nonZero(Value_t value) const
        { return !zero(value); }
      
      constexpr bool equal(Value_t a, Value_t b) const
        { return zero(a - b); }
      
      constexpr bool nonEqual(Value_t a, Value_t b) const
        { return !equal(a, b); }
      
      constexpr bool strictlyNegative(Value_t value) const
        { return value < -threshold; }
      
      constexpr bool strictlyPositive(Value_t value) const
        { return value > threshold; }
      
      constexpr bool nonNegative(Value_t value) const
        { return value >= -threshold; }
      
      constexpr bool nonPositive(Value_t value) const
        { return value <= threshold; }
      
      constexpr bool strictlySmaller(Value_t a, Value_t b) const
        { return strictlyNegative(a - b); }
      
      constexpr bool nonSmaller(Value_t a, Value_t b) const
        { return nonNegative(a - b); }
      
      constexpr bool strictlyGreater(Value_t a, Value_t b) const
        { return strictlyPositive(a - b); }
      
      constexpr bool nonGreater(Value_t a, Value_t b) const
        { return nonPositive(a - b); }
      
      constexpr bool within(Value_t value, Value_t lower, Value_t upper) const
        { return nonNegative(value - lower) && nonPositive(value - upper); }
      
      constexpr bool withinSorted
        (Value_t value, Value_t lower, Value_t upper) const
        {
          return (lower < upper)
            ? within(value, lower, upper)
            : within(value, upper, lower)
            ;
        } // sortedWithin
      
      Value_t threshold; 
      
    }; // struct RealComparisons<>
    
    
    //--------------------------------------------------------------------------
    template <typename RealType>
    struct Vector2DComparison {
      
      using Comp_t = RealComparisons<RealType>;
      
      constexpr Vector2DComparison(Comp_t const& comparer)
        : comparer(comparer) {}
      
      Vector2DComparison(Comp_t&& comparer): comparer(std::move(comparer)) {}
      
      constexpr Vector2DComparison(RealType threshold): comparer(threshold) {}
      
      constexpr Comp_t comp() const { return comparer; }
      
      template <typename Vect>
      constexpr bool zero(Vect const& v) const
        { return comp().zero(v.X()) && comp().zero(v.Y()); }
      
      template <typename Vect>
      constexpr bool nonZero(Vect const& v) const { return !zero(v); }
      
      template <typename VectA, typename VectB>
      constexpr bool equal(VectA const& a, VectB const& b) const
        { return comp().equal(a.X(), b.X()) && comp().equal(a.Y(), b.Y()); }
      
      template <typename VectA, typename VectB>
      constexpr bool nonEqual(VectA const& a, VectB const& b) const
        { return !equal(a, b); }
      
        private:
      Comp_t const comparer; 
      
    }; // struct Vector2DComparison
    
    
    //--------------------------------------------------------------------------
    template <typename RealType>
    auto makeVector2DComparison(RealType threshold)
      { return Vector2DComparison<RealType>(threshold); }
    
    template <typename RealType>
    auto makeVector2DComparison
      (lar::util::RealComparisons<RealType> const& comp)
      { return Vector2DComparison<RealType>(comp); }
    
    
    //--------------------------------------------------------------------------
    template <typename RealType>
    struct Vector3DComparison {
      
      using Comp_t = RealComparisons<RealType>;
      
      using Comp2D_t = Vector2DComparison<typename Comp_t::Value_t>;
      
      constexpr Vector3DComparison(Comp_t const& comparer)
        : comparer(comparer) {}
      
      Vector3DComparison(Comp_t&& comparer): comparer(std::move(comparer)) {}
      
      constexpr Vector3DComparison(RealType threshold): comparer(threshold) {}
      
      constexpr Comp_t comp() const { return comp2D().comp(); }
      
      constexpr Comp2D_t comp2D() const { return comparer; }
      
      template <typename Vect>
      constexpr bool zero(Vect const& v) const
        { return comp2D().zero(v) && comp().zero(v.Z()); }
      
      template <typename Vect>
      constexpr bool nonZero(Vect const& v) const { return !zero(v); }
      
      template <typename VectA, typename VectB>
      constexpr bool equal(VectA const& a, VectB const& b) const
        { return comp2D().equal(a, b) && comp().equal(a.Z(), b.Z()); }
      
      template <typename VectA, typename VectB>
      constexpr bool nonEqual(VectA const& a, VectB const& b) const
        { return !equal(a, b); }
      
        private:
      Comp2D_t comparer;
      
    }; // struct Vector3DComparison
    
    
    //--------------------------------------------------------------------------
    template <typename RealType>
    auto makeVector3DComparison(RealType threshold)
      { return Vector3DComparison<RealType>(threshold); }
    
    template <typename RealType>
    auto makeVector3DComparison
      (lar::util::RealComparisons<RealType> const& comp)
      { return Vector3DComparison<RealType>(comp); }
    
    
    //--------------------------------------------------------------------------
    
    
  } // namespace util
} // namespace lar


#endif // LARCORE_COREUTILS_REALCOMPARISONS_H