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::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 lar::util

#endif // LARCORE_COREUTILS_REALCOMPARISONS_H