randomIntTmplt.hpp

#ifndef RANDOM_INT_TEMPLT_HPP
#define RANDOM_INT_TEMPLT_HPP

#include <boost/random.hpp>

namespace jafar {
  namespace jmath {

    template <class IntType>
    class RandomIntTmplt
    {
    public:
      RandomIntTmplt(IntType min_=0, IntType max_=9, uint64_t unSeed=1);
      ~RandomIntTmplt(){};
      
      IntType get();
      
      void SetSeed(uint64_t unSeed);
      
    private:
      boost::rand48 r_n_gen;
      boost::uniform_int<> unif_dist;
      boost::variate_generator<boost::rand48&, boost::uniform_int<> > v_g;
    };
    
    template <class IntType>
    class RandomIntVectTmplt
    {
    public:
      RandomIntVectTmplt(std::size_t nSize, 
       IntType nMin=0, 
       IntType nMax=9, 
       uint64_t unSeed=1);
      ~RandomIntVectTmplt(){};
      
      std::vector<IntType>& get();
      
      std::vector<IntType>& getDifferent();
      
      void SetSeed(uint64_t unSeed);
      
    private:
      boost::rand48 r_n_gen;
      boost::uniform_int<> unif_dist;

      boost::variate_generator<boost::rand48&, boost::uniform_int<> > v_g;
      
      std::vector<IntType> u_;
    };
    
    /* Implementation */
    
    
    
    
    template <class IntType>
    RandomIntTmplt<IntType>::RandomIntTmplt(IntType nMin, 
              IntType nMax, 
              uint64_t unSeed)
      :r_n_gen(unSeed),
       unif_dist(nMin, nMax), 
       v_g(r_n_gen,unif_dist)
    {}
    
    template <class IntType>
    IntType RandomIntTmplt<IntType>::get()
    {
      return v_g();
    }
    
    template <class IntType>
    void  RandomIntTmplt<IntType>::SetSeed(uint64_t unSeed)
    {
      r_n_gen.seed((uint64_t)unSeed);
    }
    
    
    
    /*
     * class RandomIntVectTmplt
     */
    
    template <class IntType>
    RandomIntVectTmplt<IntType>::RandomIntVectTmplt(std::size_t nSize, 
                IntType nMin, 
                IntType nMax, 
                uint64_t unSeed)
      : u_(nSize,0), 
  r_n_gen(unSeed),
  unif_dist(nMin, nMax), 
  v_g(r_n_gen,unif_dist)
    {}
    
    template <class IntType>
    std::vector<IntType>& RandomIntVectTmplt<IntType>::get()
    {
      for (unsigned int i=0; i<u_.size(); i++)
  u_[i]=v_g();
      return u_;
    }
    
    
    template <class IntType>
    std::vector<IntType>& RandomIntVectTmplt<IntType>::getDifferent()
    {
      IntType n;
      unsigned int i=0;
      while (i < u_.size()) {
  n = v_g();
  // if the number is not already used, add it
  if (find(u_.begin(), u_.begin()+i, n)==(u_.begin()+i)) {
    u_[i]=n;
    i++;
  }
      }
      return u_;
    }
    

    template <class IntType>
    void  RandomIntVectTmplt<IntType>::SetSeed(uint64_t unSeed)
    {
      r_n_gen.seed((uint64_t)unSeed);
    }
    
    typedef RandomIntTmplt<int> RandomInt;
    typedef RandomIntTmplt<unsigned int> RandomUInt;
    typedef RandomIntVectTmplt<int> RandomIntVect;
    typedef RandomIntVectTmplt<unsigned int> RandomUIntVect;
    

  } // namespace jmath
} // namespace jafar

#endif // RANDOM_INT_TEMPLT_HPP