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

Implementing almass specific random number generation and probability distribution classes, based on/wrapping c ++ std library functionality. Boost library is not used anymore. More...

Classes
class	probability_distribution

Functions
double	g_rand_uni_fnc ()

int	g_rand_uni2_fnc ()

int	g_rand_uni3_fnc ()

int	g_random_fnc (int a_range)

void	g_generator_fixed_fnc (unsigned int s=42)

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

Detailed Description

Implementing almass specific random number generation and probability distribution classes, based on/wrapping c ++ std library functionality. Boost library is not used anymore.

Author: Luminita C. Totu

Version: August 2023

LICENSE

DESCRIPTION

This files make it possible to use a simple syntax for generating random numbers from a specified distribution

USAGE-A

Steps needed to use an almass probability distribution object

(1) Include the module header file

       #include "ALMaSS_Random.h"

(2) Define a "probability_distribution" object. Here are some examples:

      probability_distribution p1("DISCRETE", "1.0 2.5 4 5.1 7"); // weights for the variable number of outcomes {0,1,2,...}
      probability_distribution p1("NORMAL", "1.0 3.0"); // mean and standard deviation 
      probability_distribution p3("BETABINOMIAL", "14 2 1 0"); // Outcome max value, alpha, beta from binomial distribution, and the no_zero flag
      probability_distribution p4("UNIREAL", "0 1");  // // [min,max)
      probability_distribution p5("UNIREAL", "0 1");  // // [min.max]

(3) Use the probability distribution to make an random extraction. Here are some examples:

     int x = p1.geti();   // or  int x = p1.get(); the casting from double to int is automatic
     double x = p2.get();

USAGE-B

Steps needed to one of the generic random functions g_rand_uni(), g_rand_uni2() or g_rand_uni3() ( backward compatibility for some of the code, also common used distributions )

(1) Include the module header file

       #include "ALMaSS_Random.h"

(2) Use the g_rand_uni()

      double x = g_rand_uni();   // random real number between [0,1)

Function Documentation

◆ g_generator_fixed_fnc()

void g_generator_fixed_fnc ( const unsigned int s )

Function to reset the seed of the generator

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 ( )

The following three functions are for code backward compatibility. Preferably not use for new code.

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

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().