VSelector.h

// -*- C++ -*-
//
// VSelector.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_VSelector_H
#define ThePEG_VSelector_H
// This is the definition of the ThePEG::VSelector class.
 
#include "ThePEG/Config/ThePEG.h"
#include <stdexcept>
#include <algorithm>
#include <stdexcept>
 
namespace ThePEG {
 
template <typename T, typename WeightType = double>
class VSelector {
 
public:
 
  typedef vector<WeightType> WeightVector;
 
  typedef typename WeightVector::const_iterator WIterator;
 
  typedef vector<T> ObjectVector;
 
  typedef typename ObjectVector::iterator iterator;
 
  typedef typename ObjectVector::const_iterator const_iterator;
 
  typedef typename ObjectVector::size_type size_type;
 
public:
 
  VSelector(size_type reserved = 0) : theSum() 
  {
    reserve(reserved);
  }
 
  void swap(VSelector & s) {
    theSums.swap(s.theSums);
    theWeights.swap(s.theWeights);
    theObjects.swap(s.theObjects);
    std::swap(theSum, s.theSum);
  }
 
  WeightType insert(WeightType d, const T & t) {
    WeightType newSum = theSum + d;
    if ( newSum <= theSum ) return d;
    theSums.push_back(theSum = newSum);
    theWeights.push_back(d);
    theObjects.push_back(t);
    return theSum;
  }
 
  WeightType reweight(WeightType, const T &);
 
  WeightType erase(const T &);
 
  void replace(const T & told, const T & tnew) {
    for ( iterator it = theObjects.begin(); it != theObjects.end(); ++it )
      if ( *it == told ) *it = tnew;
  }
 
  T & select(double rnd, double * remainder = 0) {
    return theObjects[iselect(rnd, remainder)];
  }
 
  T & operator[](double rnd) {
    return select(rnd, 0);
  }
 
  const T & select(double rnd, double * remainder = 0) const {
    return theObjects[iselect(rnd, remainder)];
  }
 
  const T & operator[](double rnd) const {
    return select(rnd, 0);
  }
 
  template <typename RNDGEN>
  T & select(RNDGEN & rnd) {
    double rem = 0.0;
    T & t = select(rnd(), &rem);
    rnd.push_back(rem);
    return t;
  }
 
  template <typename RNDGEN>
  const T & select(RNDGEN & rnd) const {
    double rem = 0.0;
    const T & t = select(rnd(), &rem);
    rnd.push_back(rem);
    return t;
  }
 
  WeightType sum() const { return theSum; }
 
  const_iterator begin() const { return theObjects.begin(); }
 
  const_iterator end() const { return theObjects.end(); }
 
  bool empty() const { return theObjects.empty(); }
 
  size_type size() const { return theObjects.size(); }
 
  void reserve(size_type reserved) {
    theSums.reserve(reserved);
    theWeights.reserve(reserved);
    theObjects.reserve(reserved);
  }
 
  void clear() {
    theSums.clear();
    theWeights.clear();
    theObjects.clear();
    theSum = WeightType();
  }
 
  template <typename OStream>
  void output(OStream &) const;
 
  template <typename IStream>
  void input(IStream &);
 
protected:
 
  size_type iselect(double rnd, double * remainder) const;
 
private:
 
  WeightVector theSums;
 
  WeightVector theWeights;
 
  ObjectVector theObjects;
 
  WeightType theSum;
 
};
 
template <typename OStream, typename T, typename WeightType>
inline OStream & operator<<(OStream & os,
                            const VSelector<T,WeightType> & s) {
  s.output(os);
  return os;
}
 
template <typename IStream, typename T, typename WeightType>
inline IStream & operator>>(IStream & is, 
                            VSelector<T,WeightType> & s) {
  s.input(is);
  return is;
}
 
 
}
 
#include "VSelector.tcc"
 
#endif /* ThePEG_VSelector_H */