source: src/RandomNumbers/RandomNumberGenerator_Encapsulation.hpp@ 3f9eba

/*
 * RandomNumberGenerator_Encapsulation.hpp
 *
 *  Created on: Dec 31, 2010
 *      Author: heber
 */

#ifndef RANDOMNUMBERGENERATOR_ENCAPSULATION_HPP_
#define RANDOMNUMBERGENERATOR_ENCAPSULATION_HPP_

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "RandomNumberDistribution.hpp"
#include "RandomNumberEngine.hpp"
#include "RandomNumberGenerator.hpp"
#include "RandomNumberGeneratorFactory.hpp"

#include "unittests/RandomNumberGeneratorFactoryUnitTest.hpp"

/** Template class that encapsulates the random number generators from
 *  random::boost.
 *
 * We inherit the interface RandomNumberGenerator such that all are
 * accessible in the same way (i.e. RandomNumberGeneratorFactory will
 * spit out only references to RandomNumberGenerator).
 *
 * Note that we always returns double values although the distribution
 * might be integer or even a discrete distribution of integers.
 *
 * We need three template parameters:
 * -# the generator - generates uniform random numbers
 * -# the distribution - transforms uniform into a desired distribution
 */
template <class engine, class distribution>
class RandomNumberGenerator_Encapsulation : public RandomNumberGenerator
{
  /**
   * Factory is friend such that it can access private cstor.
   */
  friend class RandomNumberGeneratorFactory;
  friend class RandomNumberGeneratorFactoryTest;

public:
  /** obtain a random number via generator and the specific distribution.
   *
   */
  double operator()() const {
    return randomgenerator();
  }

  /** Set the generator's seed.
   *
   * @param _seed seed to set to
   */
  void seed(unsigned int _seed) {
    engine_type.seed(_seed);
  }

  /** Getter for the type name of the internal engine.
   *
   */
  std::string EngineName() {
    return engine_type.name();
  }

  /** Getter for the type name of the internal distribution.
   *
   */
  std::string DistributionName() {
    return distribution_type.name();
  }

  /** Constructor that instantiates a specific random number generator and
   * distribution.
   * @param _generator_type instance of the desired generator
   * @param _distribution_type instance of the desired distribution
   */
  RandomNumberGenerator_Encapsulation(
      RandomNumberEngine &_engine_type,
      RandomNumberDistribution &_distribution_type
      ) :
    engine_type(static_cast<RandomNumberEngine_Encapsulation<engine> &>(_engine_type)),
    distribution_type(static_cast<RandomNumberDistribution_Encapsulation<distribution> &>(_distribution_type)),
    randomgenerator(boost::variate_generator<engine, distribution> (
        engine_type.getEngine(),
        distribution_type.getDistribution()
        ))
  {
    // note that we instantiate the variate_generator with the copied instances!
  }

  /** Destructor of the class.
   *
   */
  ~RandomNumberGenerator_Encapsulation() {}
private:
  RandomNumberEngine_Encapsulation<engine> engine_type;
  RandomNumberDistribution_Encapsulation<distribution> distribution_type;
  mutable boost::variate_generator<engine, distribution> randomgenerator;
};

#endif /* RANDOMNUMBERGENERATOR_ENCAPSULATION_HPP_ */