Interval.h

// -*- C++ -*-
//
// Interval.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_Interval_H
#define ThePEG_Interval_H
// This is the declaration of the Interval class.
 
#include <utility>
#include <vector>
#include "Interval.fh"
#include "ThePEG/Utilities/UnitIO.h"
 
namespace ThePEG {
 
template <typename T, typename CMP>
class Interval {
 
public:
 
  Interval() : theLimits(pair<T,T>()) {}
 
  Interval(T dn, T up) : theLimits(pair<T,T>(dn, up)) {}
 
  bool operator==(const Interval & i) const {
    return lower() == i.lower() && upper() == i.upper();
  }
 
  bool operator<(const Interval & i) const {
    return cmp(lower(), i.lower()) ||
      ( lower() == i.lower() && cmp(upper(), i.upper()) );
  }
 
  bool check() const { return cmp(lower(), upper()); }
 
  bool operator()(T x) const { return includes(x); }
 
  bool includes(T x) const { return !cmp(x, lower()) && cmp(x, upper()); }
 
  bool includes(const Interval<T,CMP> & i) const {
    return includes(i.lower()) && !cmp(upper(), i.upper());
  }
 
  Interval<T,CMP> chopUpper(T x) {
    Interval<T,CMP> r;
    if ( includes(x) ) {
      r.lower(x);
      r.upper(upper());
      upper(x);
    }
    return r;
  }
 
  Interval<T,CMP> chopLower(T x) {
    Interval<T,CMP> r;
    if ( includes(x) ) {
      r.lower(lower());
      r.upper(x);
      lower(x);
    }
    return r;
  }
 
  Interval<T,CMP> overlap(const Interval & i) const {
    Interval<T,CMP> res;
    if ( operator==(i) ) res = i;
    if ( includes(i.upper()) || includes(i.lower()) )
      res = Interval<T,CMP>(max(lower(),i.lower()), min(upper(), i.upper()));
    return res;
  }
 
  Interval<T,CMP> sum(const Interval & i) const {
    Interval<T,CMP> res;
    if ( operator==(i) ) res = i;
    if ( includes(i.upper()) || includes(i.lower()) )
      res = Interval<T,CMP>(min(lower(),i.lower()), max(upper(), i.upper()));
    return res;
  }
 
  T upper() const { return theLimits.second; }
 
  T lower() const { return theLimits.first; }
 
  void upper(T up) { theLimits.second = up; }
 
  void lower(T dn) { theLimits.first = dn; }
 
  template <typename Iterator>
  bool check(Iterator first, Iterator last);
 
  template <typename Iterator>
  bool checkAll(Iterator first, Iterator last);
 
  std::vector< Interval<T,CMP> > split(Interval<T,CMP>, T x);
  
  template<typename Iterator>
  std::vector< Interval<T,CMP> > split(Interval<T,CMP>,
                                       Iterator first, Iterator last);
 
private:
 
  std::pair<T,T> theLimits;
 
  static CMP cmp;
 
};
 
typedef Interval<double> DInterval;
 
template <typename T, typename CMP>
inline Interval<T,CMP> makeInterval(T dn, T up) { return Interval<T,CMP>(dn, up); }
 
template <typename OStream, typename T, typename CMP>
inline OStream & operator<<(OStream & os, const Interval<T,CMP> & i) {
  os << i.lower() << i.upper();
  return os;
}
 
template <typename IStream, typename T, typename CMP>
inline IStream & operator>>(IStream & is, Interval<T,CMP> & i) {
  T up, dn;
  is >> dn >> up;
  i.lower(dn);
  i.upper(up);
  return is;
}
 
template <typename OStream, typename T, typename CMP, typename UT>
void ounitstream(OStream & os, const Interval<T,CMP> & i, UT & u) {
  os << ounit(i.lower(), u) << ounit(i.upper(), u);
}
 
template <typename IStream, typename T, typename CMP, typename UT>
void iunitstream(IStream & is, Interval<T,CMP> & i, UT & u) {
  T low, upp;
  is >> iunit(low, u) >> iunit(upp, u);
  i = Interval<T,CMP>(low, upp);
}
 
}
 
#ifndef ThePEG_TEMPLATES_IN_CC_FILE
#include "Interval.tcc"
#endif
 
#endif /* ThePEG_Interval_H */