This is a class that generates random numbers i.e. named the Random Number Generator (RNG). More...

#include <RNG.h>

Public Member Functions
	RNG ()
	default constructor More...

void	setRandomSeed (unsigned long int new_seed)
	This is the seed for the random number generator. (note the call to seed_LFG is only required really if using that type of generator, but the other one is always required. More...

Mdouble	getRandomNumber (Mdouble min, Mdouble max)
	This is a random generating routine can be used for initial positions. More...

Mdouble	test ()
	This function tests the quality of random numbers, based on the chi-squared test. More...

void	setLinearCongruentialGeneratorParmeters (unsigned const int a, unsigned const int c, unsigned const int m)
	This functions set the parameters for the LCG random number generator. It goes multiplier, addition, mod. More...

void	randomise ()
	sets the random variables such that they differ for each run More...

void	setLaggedFibonacciGeneratorParameters (const unsigned int p, const unsigned int q)
	This function sets the parameters for the LFG random number generator. More...

void	setRandomNumberGenerator (RNGType type)
	Allows the user to set which random number generator is used. More...

Private Member Functions
Mdouble	getRandomNumberFromLinearCongruentialGenerator (Mdouble min, Mdouble max)
	This is a basic Linear Congruential Generator Random. More...

Mdouble	getRandomNumberFromLaggedFibonacciGenerator (Mdouble min, Mdouble max)
	This is a Lagged Fibonacci Generator. More...

void	seedLaggedFibonacciGenerator ()
	This seed the LFG. More...

Private Attributes
unsigned long int	randomSeedLinearCongruentialGenerator_
	This is the initial seed of the RNG. More...

std::vector< Mdouble >	randomSeedLaggedFibonacciGenerator_
	This is the seeds required for the LFG. More...

unsigned long int	a_
	This are the two parameters that control the LCG random generated. More...

unsigned long int	c_

unsigned long int	m_

unsigned long int	p_
	This are the parameters that control the LFG random generator. More...

unsigned long int	q_

RNGType	type_
	This is the type of random number generator. More...

Detailed Description

This is a class that generates random numbers i.e. named the Random Number Generator (RNG).

This is a stand-along class; but is encapsulated (used) by the MD class. To make it architecture safe the both LCG and function is hard codes i.e. does not use the internal C++ one.

Todo:: (AT) implement new C++-standard RNG instead of this one (Kudos on the hard work done here though ;). NB: maybe something for Mercury 2?

Definition at line 52 of file RNG.h.

Constructor & Destructor Documentation

RNG::RNG ( )

default constructor

This is a random number generator and returns a Mdouble within the range specified.

Todo:

{Thomas: This code does sth. when min>max; I would prefer to throw an error.}

{the random seed should be stored in restart}

Definition at line 33 of file RNG.cc.

References a_, c_, LAGGED_FIBONACCI_GENERATOR, m_, p_, q_, randomSeedLaggedFibonacciGenerator_, randomSeedLinearCongruentialGenerator_, seedLaggedFibonacciGenerator(), and type_.

 {
     randomSeedLinearCongruentialGenerator_ = 0;
     a_ = 1103515245;
     c_ = 12345;
     m_ = 1024 * 1024 * 1024;
     type_ = RNGType::LAGGED_FIBONACCI_GENERATOR;
     p_ = 607;
     q_ = 273;
     randomSeedLaggedFibonacciGenerator_.resize(p_);
     seedLaggedFibonacciGenerator();
 }

Member Function Documentation

Mdouble RNG::getRandomNumber	(	Mdouble	min,
		Mdouble	max
	)

This is a random generating routine can be used for initial positions.

Definition at line 69 of file RNG.cc.

References getRandomNumberFromLaggedFibonacciGenerator(), getRandomNumberFromLinearCongruentialGenerator(), LAGGED_FIBONACCI_GENERATOR, LINEAR_CONGRUENTIAL_GENERATOR, and type_.

Referenced by Chute::createBottom(), ChuteInsertionBoundary::generateParticle(), CubeInsertionBoundary::generateParticle(), HopperInsertionBoundary::generateParticle(), ChuteBottom::setupInitialConditions(), and test().

 {   
     switch (type_)
     {
         case RNGType::LINEAR_CONGRUENTIAL_GENERATOR:
             return getRandomNumberFromLinearCongruentialGenerator(min, max);
         case RNGType::LAGGED_FIBONACCI_GENERATOR:
             return getRandomNumberFromLaggedFibonacciGenerator(min, max);
     }    
 }

Mdouble RNG::getRandomNumberFromLaggedFibonacciGenerator	(	Mdouble	min,
		Mdouble	max
	)

private

This is a Lagged Fibonacci Generator.

This is a basic Linear Fibonacci Generator Random Is described by three parameters, the multiplication a, the addition c and the mod m.

Definition at line 115 of file RNG.cc.

References p_, q_, and randomSeedLaggedFibonacciGenerator_.

Referenced by getRandomNumber().

 {
     Mdouble new_seed = fmod(randomSeedLaggedFibonacciGenerator_[0] + randomSeedLaggedFibonacciGenerator_[p_ - q_], static_cast<Mdouble>(1.0));
     //Update the random seed
     for (unsigned int i = 0; i < p_ - 1; i++)
     {
         randomSeedLaggedFibonacciGenerator_[i] = randomSeedLaggedFibonacciGenerator_[i + 1];
     }
     randomSeedLaggedFibonacciGenerator_[p_ - 1] = new_seed;
     
     //Generate a random number in the required range
     
     Mdouble random_num;
     
     Mdouble range = max - min;
     random_num = min + range * new_seed;
     
     return random_num;
 }

Mdouble RNG::getRandomNumberFromLinearCongruentialGenerator	(	Mdouble	min,
		Mdouble	max
	)

private

This is a basic Linear Congruential Generator Random.

This is a basic Linear Congruential Generator Random Is described by three parameters, the multiplication a, the addition c and the mod m.

Definition at line 83 of file RNG.cc.

References a_, c_, m_, and randomSeedLinearCongruentialGenerator_.

Referenced by getRandomNumber(), and seedLaggedFibonacciGenerator().

 {
     //Update the random seed
     randomSeedLinearCongruentialGenerator_ = (a_ * randomSeedLinearCongruentialGenerator_ + c_) % m_;
     
     //Generate a random number in the required range
     
     Mdouble random_num;
     
     Mdouble range = max - min;
     random_num = min + range * randomSeedLinearCongruentialGenerator_ / (static_cast<Mdouble>(m_) + 1.0);
     
     return random_num;
 }

void RNG::randomise ( )

sets the random variables such that they differ for each run

Definition at line 59 of file RNG.cc.

References setRandomSeed().

Referenced by DPMBase::readNextArgument().

 {
     setRandomSeed(static_cast<unsigned long int>(time(nullptr)));
 }

void RNG::seedLaggedFibonacciGenerator ( )

private

This seed the LFG.

Definition at line 103 of file RNG.cc.

References getRandomNumberFromLinearCongruentialGenerator(), p_, and randomSeedLaggedFibonacciGenerator_.

Referenced by RNG(), setLaggedFibonacciGeneratorParameters(), and setRandomSeed().

 {
     for (unsigned int i = 0; i < p_; i++)
     {
         randomSeedLaggedFibonacciGenerator_[i] = getRandomNumberFromLinearCongruentialGenerator(0, 1.0);
     }
 }

void RNG::setLaggedFibonacciGeneratorParameters	(	const unsigned int	p,
		const unsigned int	q
	)

This function sets the parameters for the LFG random number generator.

Definition at line 188 of file RNG.cc.

References p_, q_, randomSeedLaggedFibonacciGenerator_, and seedLaggedFibonacciGenerator().

 {
     //p must be greater than q so makes sure this is true. Not sure what happens if you set p=q, in the LFG alogrithm.
     if (p > q)
     {
         p_ = p;
         q_ = q;
     }
     else
     {
         p_ = p;
         q_ = q;
     }
     
     randomSeedLaggedFibonacciGenerator_.resize(p_);
     seedLaggedFibonacciGenerator();
     
 }

void RNG::setLinearCongruentialGeneratorParmeters	(	unsigned const int	a,
		unsigned const int	c,
		unsigned const int	m
	)

This functions set the parameters for the LCG random number generator. It goes multiplier, addition, mod.

Definition at line 52 of file RNG.cc.

References a_, c_, and m_.

 {
     a_ = a;
     c_ = c;
     m_ = m;
 }

void RNG::setRandomNumberGenerator ( RNGType type )

Allows the user to set which random number generator is used.

Definition at line 64 of file RNG.cc.

References type_.

 {
     type=type_;
 }

void RNG::setRandomSeed ( unsigned long int new_seed )

This is the seed for the random number generator. (note the call to seed_LFG is only required really if using that type of generator, but the other one is always required.

Definition at line 46 of file RNG.cc.

References randomSeedLinearCongruentialGenerator_, and seedLaggedFibonacciGenerator().

Referenced by DPMBase::constructor(), and randomise().

 {
     randomSeedLinearCongruentialGenerator_ = new_seed;
     seedLaggedFibonacciGenerator();
 }

Mdouble RNG::test ( )

This function tests the quality of random numbers, based on the chi-squared test.

It reports a probability that the random number being generated are coming from a uniform distributed. If this number is less than 0.95, it is strongly advised that you change the parameters being used

Definition at line 140 of file RNG.cc.

References mathsFunc::chi_squared_prob(), and getRandomNumber().

 {
     //This are the fixed parameters that define the test
     static unsigned int num_of_tests = 100000;
     static Mdouble max_num = 100.0;
     static unsigned int num_of_bins = 10;
     
     //This is the generated random_number
     Mdouble rn;
     //This is the bin the random number will lie in
     unsigned int bin = 0;
     //This is a vector of bins
     std::vector<int> count;
     count.resize(num_of_bins);
     
     //Initialisation of the bins
     for (unsigned int i = 0; i < num_of_bins; i++)
     {
         count[bin] = 0;
     }
     
     //Loop over a number of tests
     for (unsigned int i = 0; i < num_of_tests; i++)
     {
         rn = getRandomNumber(0.0, max_num);
         bin = static_cast<unsigned int>(std::floor(rn * num_of_bins / max_num));
         
         //Add one to the bin count
         count[bin]++;
         
     }
     
     //Final post-process the result and report on the random number
     Mdouble chi_cum = 0.0;
     Mdouble expected = num_of_tests / num_of_bins;
     
     for (unsigned int i = 0; i < num_of_bins; i++)
     {
         chi_cum = chi_cum + (count[i] - expected) * (count[i] - expected) / expected;
         std::cout << i << " : " << count[i] << " : " << (count[i] - expected) * (count[i] - expected) / expected << std::endl;
     }
     //end for loop over computing the chi-squared value.
     std::cout << chi_cum << std::endl;
     
     return mathsFunc::chi_squared_prob(chi_cum, num_of_bins);
 }