•All Classes Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages

Implementing almass specific random number generation and probability distribution classes, based on/wrapping std functionality. More...

#include <iostream>
#include <fstream>
#include <chrono>
#include <math.h>
#include <sstream>
#include <random>
#include <algorithm>
#include "ALMaSS_Random.h"
#include "../Landscape/MapErrorMsg.h"
#include "../Landscape/Configurator.h"

Typedefs
using	DISCRETE_DIST = std::discrete_distribution<>

using	UNIINT_DIST = std::uniform_int_distribution< int >

using	NORMAL_DIST = std::normal_distribution< double >

using	UNIREAL_DIST = std::uniform_real_distribution< double >

using	GAMMA_DIST = std::gamma_distribution< double >

using	CAUCHY_DIST = std::cauchy_distribution< double >

using	EXPONENTIAL_DIST = std::exponential_distribution< double >

Functions
std::mt19937	g_generator (seed_seq)

void	g_generator_fixed_fnc (const unsigned int s)

std::uniform_real_distribution	g_uni_std_dist (0, 1)

std::uniform_int_distribution	g_uni_dist2 (0, 9999)

std::uniform_int_distribution	g_uni_dist3 (0, 999)

double	g_rand_uni_fnc ()

int	g_rand_uni2_fnc ()

int	g_rand_uni3_fnc ()

int	g_random_fnc (const int a_range)

int	g_binomial_coefficient (const int n, const int k)

std::vector< double >	g_beta_binomial_probabilities_fnc (const int a_n, const double a_alpha, const double a_beta, const bool a_noZero)
	Local utility function for generating the weights-vector for the beta binomial distribution from input parameters. More...

void	g_init_random_seed_fnc ()
	Init_random_seed() randomizes the random generator based on the configuration (either fixed seed or random seed) More...

Variables
CfgBool	cfg_Fixed_random_sequence

CfgInt	cfg_FixedRandomSeed

std::seed_seq	seed_seq

Detailed Description

Implementing almass specific random number generation and probability distribution classes, based on/wrapping std functionality.

Author: Luminita C. Totu

Version: August 2023

LICENSE

DESCRIPTION

This file contains the definition of the rng global object, which holds the basic randomess source (the seeded pseudo random generator). The file also contains the definition of functions declared in almass_random-h header file

Typedef Documentation

◆ CAUCHY_DIST

using CAUCHY_DIST = std::cauchy_distribution<double>

◆ DISCRETE_DIST

using DISCRETE_DIST = std::discrete_distribution<>

◆ EXPONENTIAL_DIST

using EXPONENTIAL_DIST = std::exponential_distribution<double>

◆ GAMMA_DIST

using GAMMA_DIST = std::gamma_distribution<double>

◆ NORMAL_DIST

using NORMAL_DIST = std::normal_distribution<double>

◆ UNIINT_DIST

using UNIINT_DIST = std::uniform_int_distribution<int>

◆ UNIREAL_DIST

using UNIREAL_DIST = std::uniform_real_distribution<double>

Function Documentation

◆ g_beta_binomial_probabilities_fnc()

std::vector<double> g_beta_binomial_probabilities_fnc	(	const int	a_n,
		const double	a_alpha,
		const double	a_beta,
		const bool	a_noZero
	)

Local utility function for generating the weights-vector for the beta binomial distribution from input parameters.

Parameters

a_n	the maximum value of the random variate
a_alpha	a_alpha, a_beta parameters of the underlying beta distribution, together determine the shape/profile of the distribution
a_beta	a_alpha, a_beta parameters of the underlying beta distribution, together determine the shape/profile of the distribution
a_noZero	a_noZero extra parameter to cancel out the probability for the zero value (started as quick hack for beetle feature)

Returns: The distribution

                                                                                                                                    {
     std::vector<double> probabilities(a_n + 1);
  
     for (int k = 0; k <= a_n; k = k + 1)
     {
         const double cnk = g_binomial_coefficient(a_n, k);
         const double b1 = std::beta(k + a_alpha, -k + a_beta + a_n);
         const double b2 = std::beta(a_alpha, a_beta);
         probabilities[k] = cnk * b1 / b2;
     }
     if (a_noZero) { probabilities[0] = 0; }
     return probabilities;
 }

References g_binomial_coefficient().

Referenced by probability_distribution::probability_distribution().

◆ g_binomial_coefficient()

int g_binomial_coefficient	(	const int	n,
		const int	k
	)

A function to calculate binomial coefficients

                                                      {
     if (k == 0 || k == n)   return 1;
     return g_binomial_coefficient(n - 1, k - 1) + g_binomial_coefficient(n - 1, k);
 }

Referenced by g_beta_binomial_probabilities_fnc().

◆ g_generator()

std::mt19937 g_generator ( seed_seq )

Referenced by g_generator_fixed_fnc(), g_rand_uni2_fnc(), g_rand_uni3_fnc(), g_rand_uni_fnc(), probability_distribution::Get(), and probability_distribution::Geti().

◆ g_generator_fixed_fnc()

void g_generator_fixed_fnc ( const unsigned int s )

fixed seed for the random generator

                                                  {
     g_generator.seed(s);
 }

References g_generator().

Referenced by g_init_random_seed_fnc().

◆ g_init_random_seed_fnc()

void g_init_random_seed_fnc ( )

Init_random_seed() randomizes the random generator based on the configuration (either fixed seed or random seed)

                                   {
         int seed = 0;
  
         // Randomize the random generator.
         if (cfg_Fixed_random_sequence.value())
         {
             seed = cfg_FixedRandomSeed.value();
             srand(seed); // Use of rand() discouraged. use internal almass_random.h functionality
             g_generator_fixed_fnc(seed);
  
             /* Logging */
             std::cout << "Setting a fixed seed for random number generation: " << seed << "\n";
             g_msg->WarnAddInfo(WARN_MSG, "Setting a fixed seed for random number generation: ", seed);
         }
         else
         {
             seed = static_cast<int>(time(nullptr));
             //std::ofstream RecordSeedFile;
             //RecordSeedFile.open("RecordedSeed.txt");
             //RecordSeedFile << seed;
             //RecordSeedFile.close();
             srand(seed); // Use of rand() discouraged. use internal almass_random.h functionality 
  
             /* Logging */
             //std::cout << "Setting a timestamp-based seed for srand: " << seed << "\n";
             //g_msg->WarnAddInfo(WARN_MSG, "Setting a timestamp-based seed for srand: ", seed);
             /* Recover the boost seed */
             std::string boost_seed_seq_str;
             if (seed_seq.size() > 10) { boost_seed_seq_str = "More than 10 elements, too long to display"; }
             else
             {
                 std::uintmax_t iter[10] = { 0 };
                 boost_seed_seq_str = "(" + std::to_string(seed_seq.size()) + " element/s) ";
                 seed_seq.param(iter);
                 for (int i = 0; i < seed_seq.size(); i++) { boost_seed_seq_str = boost_seed_seq_str + std::to_string(iter[i]) + " "; }
             }
             std::cout << "Setting a timestamp-based seed sequence for random number generation: " << boost_seed_seq_str << "\n";
             //g_msg->WarnAddInfo(WARN_MSG, "Setting a timestamp-based seed sequence for boost: ", boost_seed_seq_str);
         }
     }

References cfg_Fixed_random_sequence, cfg_FixedRandomSeed, g_generator_fixed_fnc(), g_msg, seed_seq, CfgInt::value(), CfgBool::value(), WARN_MSG, and MapErrorMsg::WarnAddInfo().

Referenced by main().

◆ g_rand_uni2_fnc()

int g_rand_uni2_fnc ( )

g_rand_uni2() Return a random integer number from {0,1,...,9999} with uniform probability Function implemented for old code compatibility. Ideally not to be used in new code.

62 { return g_uni_dist2(g_generator); }

References g_generator(), and g_uni_dist2().

◆ g_rand_uni3_fnc()

int g_rand_uni3_fnc ( )

g_rand_uni2() Return a random integer number from {0,1,...,999} with uniform probability Function implemented for old code compatibility. Ideally not to be used in new code.

68 { return g_uni_dist3(g_generator); }

References g_generator(), and g_uni_dist3().

◆ g_rand_uni_fnc()

double g_rand_uni_fnc ( )

frequently used function to return a double between [0,1) with uniform probability

56 { return g_uni_std_dist(g_generator);}

References g_generator(), and g_uni_std_dist().

◆ g_random_fnc()

int g_random_fnc ( const int a_range )

random(a_range) Return a random integer number from {0,1,...,a_range-1} with uniform probability Function implemented for old code compatibility. Ideally not to be used in new code.

                                     {
     //old version 1: int result = (int)(((double) rand() / RAND_MAX. ) * a_range);
     //old version 2: return (int)(g_rand_uni() * a_range);
     //old version 3: int result = rand()%a_range;
     //Note: (int) rounds always down
     // Tested. This is at least as fast as any of the older versions
     return static_cast<int>(g_rand_uni_fnc() * a_range);
     //std::uniform_int_distribution<> temp_uni_dist(0, a_range-1);
     //return temp_uni_dist(g_generator);
 }

References g_rand_uni_fnc().

◆ g_uni_dist2()

std::uniform_int_distribution g_uni_dist2	(	0	,
		9999
	)

Referenced by g_rand_uni2_fnc().

◆ g_uni_dist3()

std::uniform_int_distribution g_uni_dist3	(	0	,
		999
	)

Referenced by g_rand_uni3_fnc().

◆ g_uni_std_dist()

std::uniform_real_distribution g_uni_std_dist	(	0	,
		1
	)

Referenced by g_rand_uni_fnc().

Variable Documentation

◆ cfg_Fixed_random_sequence

CfgBool cfg_Fixed_random_sequence

Referenced by g_init_random_seed_fnc().

◆ cfg_FixedRandomSeed

CfgInt cfg_FixedRandomSeed

Referenced by g_init_random_seed_fnc().

◆ seed_seq

std::seed_seq seed_seq

Initial value:

{
    
    static_cast<std::uintmax_t>(std::chrono::steady_clock::now().time_since_epoch().count())
}

Referenced by g_init_random_seed_fnc().