rand_num_generator.hpp

RFID reader 语 tag 模拟器

 #ifndef RAND_NUM_GENERATOR_H
 #define RAND_NUM_GENERATOR_H

 #include <iostream>
 using namespace std;
 #include <boost/shared_ptr.hpp>
 #include <boost/random.hpp>
 #include <boost/utility.hpp>

 #include "utility.hpp"

 class RandNumGenerator : boost::noncopyable {
 public:
    typedef boost::shared_ptr<RandNumGenerator> RandNumGeneratorPtr;

    static inline RandNumGeneratorPtr create();

    inline void setSeed(const t_uint seed);

    inline int uniformInt(const int min, const int max);

    inline double uniformZeroOne();

    inline double uniformReal(const double min, const double max);

    inline double exponential(const double lambda);

    inline double normalDistribution(const double mean, const double sigma);

    friend ostream& operator<< (ostream& s,
       const RandNumGenerator& randNumGenerator);

 private:

    typedef boost::lagged_fibonacci607 BaseGenerator;

    static const t_uint m_DEFAULT_SEED;

    t_uint m_seed;

    BaseGenerator m_baseGenerator;

    RandNumGenerator();

 };
 typedef boost::shared_ptr<RandNumGenerator> RandNumGeneratorPtr;

 // Inline Functions

 inline RandNumGeneratorPtr RandNumGenerator::create()
 {
    RandNumGeneratorPtr rand(new RandNumGenerator());
    return rand;
 }

 inline void RandNumGenerator::setSeed(t_uint seed)
 {
    m_seed = seed;
    m_baseGenerator.seed(m_seed);
 }

 inline int RandNumGenerator::uniformInt(const int min, const int max)
 {
    boost::uniform_int<> uniformInt(min, max);
    boost::variate_generator<BaseGenerator&, boost::uniform_int<> >
       generator(m_baseGenerator, uniformInt);
    int randVal = generator();
    return randVal;
 }

 inline double RandNumGenerator::uniformZeroOne()
 {
    boost::uniform_01<BaseGenerator> generator(m_baseGenerator);
    double randVal = generator();
    return randVal;
 }

 inline double RandNumGenerator::uniformReal(const double min,
    const double max)
 {
    boost::uniform_real<> uniformReal(min, max);
    boost::variate_generator<BaseGenerator&, boost::uniform_real<> >
       generator(m_baseGenerator, uniformReal);
    double randVal = generator();
    return randVal;
 }

 inline double RandNumGenerator::exponential(const double lambda)
 {
    boost::exponential_distribution<> exponentialDist(lambda);
    boost::variate_generator<BaseGenerator&,
       boost::exponential_distribution<> >
       generator(m_baseGenerator, exponentialDist);
    double randVal = generator();
    return randVal;
 }

 inline double RandNumGenerator::normalDistribution(const double mean,
    const double sigma)
 {
    boost::normal_distribution<> normalDist(mean, sigma);
    boost::variate_generator<BaseGenerator&,
       boost::normal_distribution<> >
       generator(m_baseGenerator, normalDist);
    double randVal = generator();
    return randVal;

 }

 // Overloaded Operators

 inline ostream& operator<< (ostream& s,
    const RandNumGenerator& randNumGenerator)
 {
    return s<< "RandNumGenerator state (pointer=" <<
       &randNumGenerator << ", seed=" << randNumGenerator.m_seed << ")" ;
 }

 #endif // RAND_NUM_GENERATOR_H