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