Interval.h

Go to the documentation of this file.

#ifndef NPSTAT_INTERVAL_HH_
#define NPSTAT_INTERVAL_HH_

#include "JetMETCorrections/InterpolationTables/interface/NpstatException.h"
#include <algorithm>

namespace npstat {
  template <typename Numeric>
  class Interval {
  public:
    inline Interval() : min_(Numeric()), max_(Numeric()) {}

    inline explicit Interval(const Numeric max) : min_(Numeric()), max_(max) {
      if (min_ > max_)
        throw npstat::NpstatInvalidArgument("In npstat::Interval constructor: invalid limits");
    }

    inline Interval(const Numeric min, const Numeric max, const bool swapIfOutOfOrder = false) : min_(min), max_(max) {
      if (min_ > max_) {
        if (swapIfOutOfOrder)
          std::swap(min_, max_);
        else
          throw npstat::NpstatInvalidArgument("In npstat::Interval constructor: invalid limits");
      }
    }

    inline void setMin(const Numeric value) {
      if (value > max_)
        throw npstat::NpstatInvalidArgument("In npstat::Interval::setMin: argument above max");
      min_ = value;
    }

    inline void setMax(const Numeric value) {
      if (value < min_)
        throw npstat::NpstatInvalidArgument("In npstat::Interval::setMax: argument below min");
      max_ = value;
    }

    inline void setBounds(const Numeric minval, const Numeric maxval, const bool swapIfOutOfOrder = false) {
      if (maxval < minval && !swapIfOutOfOrder)
        throw npstat::NpstatInvalidArgument("In npstat::Interval::setBounds: invalid limits");
      min_ = minval;
      max_ = maxval;
      if (swapIfOutOfOrder && min_ > max_)
        std::swap(min_, max_);
    }

    inline const Numeric min() const { return min_; }

    inline const Numeric max() const { return max_; }

    inline void getBounds(Numeric* pmin, Numeric* pmax) const {
      *pmin = min_;
      *pmax = max_;
    }

    inline Numeric length() const { return max_ - min_; }

    inline Numeric midpoint() const { return static_cast<Numeric>((max_ + min_) * 0.5); }

    inline bool isInsideLower(const Numeric value) const { return value >= min_ && value < max_; }

    inline bool isInsideUpper(const Numeric value) const { return value > min_ && value <= max_; }

    inline bool isInsideWithBounds(const Numeric value) const { return value >= min_ && value <= max_; }

    inline bool isInside(const Numeric value) const { return value > min_ && value < max_; }


    Interval& operator*=(double r);
    Interval& operator/=(double r);


    Interval& operator+=(const Numeric value);
    Interval& operator-=(const Numeric value);

    Interval& moveMidpointTo0();


    Interval& expand(double r);

    Interval overlap(const Interval& r) const;

    Numeric overlapLength(const Interval& r) const;

    double overlapFraction(const Interval& r) const;

    template <typename Num2>
    void linearMap(const Interval<Num2>& r, double* a, double* b) const;

  private:
    Numeric min_;
    Numeric max_;
  };
}  // namespace npstat


template <typename Numeric>
bool operator==(const npstat::Interval<Numeric>& l, const npstat::Interval<Numeric>& r);

template <typename Numeric>
bool operator!=(const npstat::Interval<Numeric>& l, const npstat::Interval<Numeric>& r);

#include <cmath>
#include <cassert>

namespace npstat {
  template <typename Numeric>
  inline Interval<Numeric> Interval<Numeric>::overlap(const Interval<Numeric>& r) const {
    Interval<Numeric> over;
    if (max_ == r.min_)
      over.setBounds(max_, max_);
    else if (r.max_ == min_)
      over.setBounds(min_, min_);
    else if (max_ > r.min_ && r.max_ > min_) {
      over.min_ = min_ < r.min_ ? r.min_ : min_;
      over.max_ = max_ < r.max_ ? max_ : r.max_;
    }
    return over;
  }

  template <typename Numeric>
  inline Numeric Interval<Numeric>::overlapLength(const Interval& r) const {
    if (max_ > r.min_ && r.max_ > min_) {
      const Numeric mn = min_ < r.min_ ? r.min_ : min_;
      const Numeric mx = max_ < r.max_ ? max_ : r.max_;
      return mx - mn;
    } else
      return Numeric();
  }

  template <typename Numeric>
  inline double Interval<Numeric>::overlapFraction(const Interval& r) const {
    if (max_ > r.min_ && r.max_ > min_) {
      const Numeric mn = min_ < r.min_ ? r.min_ : min_;
      const Numeric mx = max_ < r.max_ ? max_ : r.max_;
      return (mx - mn) * 1.0 / (max_ - min_);
    } else
      return 0.0;
  }

  template <typename Numeric>
  inline Interval<Numeric>& Interval<Numeric>::operator*=(const double r) {
    min_ *= r;
    max_ *= r;
    if (max_ < min_)
      std::swap(min_, max_);
    return *this;
  }

  template <typename Numeric>
  inline Interval<Numeric>& Interval<Numeric>::moveMidpointTo0() {
    const Numeric len = max_ - min_;
    max_ = len / static_cast<Numeric>(2);
    min_ = -max_;
    return *this;
  }

  template <typename Numeric>
  inline Interval<Numeric>& Interval<Numeric>::expand(const double ir) {
    const double r = fabs(ir);
    if (r != 1.0) {
      const Numeric center(static_cast<Numeric>((max_ + min_) * 0.5));
      min_ = center + (min_ - center) * r;
      max_ = center + (max_ - center) * r;
    }
    return *this;
  }

  template <typename Numeric>
  inline Interval<Numeric>& Interval<Numeric>::operator/=(const double r) {
    if (!r)
      throw npstat::NpstatDomainError("In npstat::Interval::operator/=: division by zero");
    min_ /= r;
    max_ /= r;
    if (max_ < min_)
      std::swap(min_, max_);
    return *this;
  }

  template <typename Numeric>
  inline Interval<Numeric>& Interval<Numeric>::operator+=(const Numeric r) {
    min_ += r;
    max_ += r;
    return *this;
  }

  template <typename Numeric>
  inline Interval<Numeric>& Interval<Numeric>::operator-=(const Numeric r) {
    min_ -= r;
    max_ -= r;
    return *this;
  }

  template <typename Numeric>
  template <typename Num2>
  void Interval<Numeric>::linearMap(const Interval<Num2>& r, double* a, double* b) const {
    if (max_ == min_)
      throw npstat::NpstatDomainError("In npstat::Interval::linearMap: zero length interval");
    assert(a);
    assert(b);
    const Num2 rmax(r.max());
    const Num2 rmin(r.min());
    *a = static_cast<double>((rmax - rmin) * 1.0 / (max_ - min_));
    *b = static_cast<double>((rmax + rmin) - *a * (max_ + min_)) / 2.0;
  }
}  // namespace npstat

template <typename Numeric>
bool operator==(const npstat::Interval<Numeric>& l, const npstat::Interval<Numeric>& r) {
  return r.min() == l.min() && r.max() == l.max();
}

template <typename Numeric>
bool operator!=(const npstat::Interval<Numeric>& l, const npstat::Interval<Numeric>& r) {
  return !(l == r);
}

#endif  // NPSTAT_INTERVAL_HH_