probability_distribution Class Reference

#include <ALMaSS_Random.h>

Public Member Functions
	probability_distribution (const std::string &prob_type, std::string prob_params)
double	Get () const
int	Geti () const
	~probability_distribution ()

Private Attributes
const std::string	DISCRETE_DIST_S { "DISCRETE" }
const std::string	BETABINOMIAL_DIST_S { "BETABINOMIAL" }
const std::string	NORMAL_DIST_S { "NORMAL" }
const std::string	UNIREAL_DIST_S { "UNIREAL" }
const std::string	UNIINT_DIST_S { "UNIINT" }
const std::string	BETA_DIST_S { "BETA" }
const std::string	GAMMA_DIST_S { "GAMMA" }
const std::string	CAUCHY_DIST_S { "CAUCHY" }
const std::string	EXPONENTIAL_DIST_S { "EXPONENTIAL" }
void *	m_probDistrib
void *	m_probDistrib1
void *	m_probDistrib2
int	m_type

Static Private Attributes
static const int	DISCRETE_DIST_T = 1
static const int	NORMAL_DIST_T = 2
static const int	UNIREAL_DIST_T = 3
static const int	UNIINT_DIST_T = 4
static const int	BETA_DIST_T = 5
static const int	GAMMA_DIST_T = 6
static const int	CAUCHY_DIST_T = 7
static const int	EXPONENTIAL_DIST_T = 8

Detailed Description

ALMaSS Probability Distribution class, wrapping around the Boost-library random distributions classes

Constructor & Destructor Documentation

probability_distribution()

probability_distribution::probability_distribution	(	const std::string &	prob_type,
		std::string	prob_params
	)

Constructor of the class, version 1

Parameters

[in]	prob_type	a string containing the label of the distribution, must match the supported/predefined values
[in]	prob_params	a string containing space,comma, or tab separated numerical values of the required parameters associated with the distribution type

                                                                                                    {
    // take the argument string and split it into numerical values ( make this a function )
    replace(prob_params.begin(), prob_params.end(), ',', ' '); // replace all commas with spaces (for easier parsing
    std::istringstream iss(prob_params);
    std::vector<double> number_args;
 
    double temp;
    while(iss >> temp) { number_args.push_back(temp); }
 
    int no_args = number_args.size();
 
    // for each supported probability distribution type, perform initialization
    if (prob_type == DISCRETE_DIST_S)
    {
        m_probDistrib = new DISCRETE_DIST(number_args.begin(), number_args.end());
        m_type = DISCRETE_DIST_T;
        return;
    }
    if (prob_type == BETABINOMIAL_DIST_S)
    {
        if (no_args != 4)
        {
            g_msg->Warn(WARN_MSG, "Number of arguments for a Beta Binomial distribution needs to be 4. It is now: ", no_args);
            exit(1);
        }
        std::vector<double> temp_weights = g_beta_binomial_probabilities_fnc(static_cast<int>(number_args[0]), number_args[1], number_args[2], static_cast<bool>(number_args[3]));
        m_probDistrib = new DISCRETE_DIST(temp_weights.begin(), temp_weights.end());
 
        // max value, alpha, beta, prob(outcome=0) = 0 boolean option
        m_type = DISCRETE_DIST_T;
        return;
    }
    if (prob_type == NORMAL_DIST_S)
    {
        if (no_args != 2)
        {
            g_msg->Warn(WARN_MSG, "Number of arguments for a Normal distribution needs to be 2. It is now: ", no_args);
            exit(1);
        }
        if (number_args[1] < 0)
        {
            g_msg->Warn(WARN_MSG, "Std. deviation (sigma) parameter of normal distribution is negative:", static_cast<int>(number_args[1]));
            exit(1);
        }
        m_probDistrib = new NORMAL_DIST(number_args[0], number_args[1]); //  mean, sigma>0
        m_type = NORMAL_DIST_T;
        return;
    }
    if (prob_type == UNIREAL_DIST_S)
    {
        if (no_args != 2)
        {
            g_msg->Warn(WARN_MSG, "Number of arguments for a uniform  real distribution needs to be 2. It is now: ", no_args);
            exit(1);
        }
        if (number_args[0] > number_args[1])
        {
            g_msg->Warn(WARN_MSG, "Min param > Max param of uniform real distribution :",
                        std::to_string(number_args[0]) + " " + std::to_string(number_args[1]));
            exit(1);
        }
        m_probDistrib = new UNIREAL_DIST(number_args[0], number_args[1]); // [min, max)
        m_type = UNIREAL_DIST_T;
        return;
    }
    if (prob_type == UNIINT_DIST_S)
    {
        if (no_args != 2)
        {
            g_msg->Warn(WARN_MSG, "Number of arguments for a uniform int distribution needs to be 2. It is now: ", no_args);
            exit(1);
        }
        if (number_args[0] > number_args[1])
        {
            g_msg->Warn(WARN_MSG, "Min param > Max param of uniform integer distribution :",
                        std::to_string(number_args[0]) + " " + std::to_string(number_args[1]));
            exit(1);
        }
        m_probDistrib = new UNIINT_DIST(static_cast<int>(number_args[0]), static_cast<int>(number_args[1])); // [min, max]
        m_type = UNIINT_DIST_T;
        return;
    }
    if (prob_type == BETA_DIST_S)
    {
        if (no_args != 2)
        {
            g_msg->Warn(WARN_MSG, "Number of arguments for a beta distribution needs to be 2. It is now: ", no_args);
            exit(1);
        }
        if (number_args[0] <= 0 || number_args[1] <= 0)
        {
            g_msg->Warn(WARN_MSG, "The parameters of the beta distribution need to be strictly positive values. They are now: ",
                        std::to_string(number_args[0]) + " " + std::to_string(number_args[1]));
            exit(1);
        }
        m_probDistrib1 = new GAMMA_DIST(number_args[0], 1.0); // use two gamma distributions to generate a beta distribution
        m_probDistrib2 = new GAMMA_DIST(number_args[1], 1.0);
        m_type = BETA_DIST_T;
    }
    else if (prob_type == GAMMA_DIST_S)
    {
        if (no_args != 2)
        {
            g_msg->Warn(WARN_MSG, "Number of arguments for a gamma distribution needs to be 2. It is now: ", no_args);
            exit(1);
        }
        if (number_args[0] <= 0 || number_args[1] <= 0)
        {
            g_msg->Warn(WARN_MSG, "The parameters of the gamma distribution need to be strictly positive values. They are now: ",
                        std::to_string(number_args[0]) + " " + std::to_string(number_args[1]));
            exit(1);
        }
        m_probDistrib = new GAMMA_DIST(number_args[0], number_args[1]); // alpha and beta
        m_type = GAMMA_DIST_T;
        return;
    }
    else if (prob_type == CAUCHY_DIST_S)
    {
        if (no_args != 2)
        {
            g_msg->Warn(WARN_MSG, "Number of arguments for a cauchy distribution needs to be 2. It is now: ", no_args);
            exit(1);
        }
        if (number_args[1] <= 0)
        {
            g_msg->Warn(WARN_MSG, "The scale parameters of the cauchy distribution need to be a strictly positive value. They are now: ",
                        std::to_string(number_args[1]));
            exit(1);
        }
        m_probDistrib = new CAUCHY_DIST(number_args[0], number_args[1]); // location and scale
        m_type = CAUCHY_DIST_T;
        return;
    }
    else if (prob_type == EXPONENTIAL_DIST_S)
    {
        if (no_args != 1)
        {
            g_msg->Warn(WARN_MSG, "Number of arguments for a exponential distribution needs to be 1. It is now: ", no_args);
            exit(1);
        }
        if (number_args[1] <= 0)
        {
            g_msg->Warn(WARN_MSG, "The scale parameters of the exponential distribution need to be a strictly positive value. They are now: ",
                        std::to_string(number_args[1]));
            exit(1);
        }
        m_probDistrib = new EXPONENTIAL_DIST(number_args[0]); // location and scale
        m_type = EXPONENTIAL_DIST_T;
        return;
    }
    else
    {
        g_msg->Warn(WARN_UNDEF, "Unknown distribution type string value: ", prob_type);
        exit(1);
    }
}

References BETA_DIST_S, BETA_DIST_T, BETABINOMIAL_DIST_S, CAUCHY_DIST_S, CAUCHY_DIST_T, DISCRETE_DIST_S, DISCRETE_DIST_T, EXPONENTIAL_DIST_S, EXPONENTIAL_DIST_T, g_beta_binomial_probabilities_fnc(), g_msg, GAMMA_DIST_S, GAMMA_DIST_T, m_probDistrib, m_probDistrib1, m_probDistrib2, m_type, NORMAL_DIST_S, NORMAL_DIST_T, UNIINT_DIST_S, UNIINT_DIST_T, UNIREAL_DIST_S, UNIREAL_DIST_T, MapErrorMsg::Warn(), WARN_MSG, and WARN_UNDEF.

~probability_distribution()

probability_distribution::~probability_distribution

(

)

                                                    {
    switch (m_type)
    {
    case DISCRETE_DIST_T:
    {
        delete static_cast<DISCRETE_DIST*>(m_probDistrib);
        return;
    }
    case NORMAL_DIST_T:
    {
        delete static_cast<NORMAL_DIST*>(m_probDistrib);
        return;
    }
    case UNIREAL_DIST_T:
    {
        delete static_cast<UNIREAL_DIST*>(m_probDistrib);
        return;
    }
    case UNIINT_DIST_T:
    {
        delete static_cast<UNIINT_DIST*>(m_probDistrib);
        return;
    }
    case BETA_DIST_T:
    {
        delete static_cast<GAMMA_DIST*>(m_probDistrib1);
        delete static_cast<GAMMA_DIST*>(m_probDistrib2);
        return;
    }
    case GAMMA_DIST_T:
    {
        delete static_cast<GAMMA_DIST*>(m_probDistrib);
        return;
    }
    case CAUCHY_DIST_T:
    {
        delete static_cast<CAUCHY_DIST*>(m_probDistrib);
        return;
    }
    case EXPONENTIAL_DIST_T:
    {
        delete static_cast<EXPONENTIAL_DIST*>(m_probDistrib);
        return;
    }
    default:
        g_msg->Warn(WARN_BUG, "Unknown distribution type number: ", std::to_string(m_type));
    }
};

References BETA_DIST_T, CAUCHY_DIST_T, DISCRETE_DIST_T, EXPONENTIAL_DIST_T, g_msg, GAMMA_DIST_T, m_probDistrib, m_probDistrib1, m_probDistrib2, m_type, NORMAL_DIST_T, UNIINT_DIST_T, UNIREAL_DIST_T, MapErrorMsg::Warn(), and WARN_BUG.

Member Function Documentation

Get()

double probability_distribution::Get

(

)

const

Returns a numerical random variate extracted from the defined probability distribution

Returns

the random number, returned as a double type

                                           {
    switch (m_type)
    {
    case DISCRETE_DIST_T:
        {
            const int x = (*static_cast<DISCRETE_DIST*>(m_probDistrib))(g_generator);
            return x;
        }
    case NORMAL_DIST_T:
        {
            const double x = (*static_cast<NORMAL_DIST*>(m_probDistrib))(g_generator);
            return x;
        }
    case UNIREAL_DIST_T:
        {
            const double x = (*static_cast<UNIREAL_DIST*>(m_probDistrib))(g_generator);
            return x;
        }
    case UNIINT_DIST_T:
        {
            const int x = (*static_cast<UNIINT_DIST*>(m_probDistrib))(g_generator);
            return x;
        }
    case BETA_DIST_T:
        {
            const double x_1 = (*static_cast<GAMMA_DIST*>(m_probDistrib1))(g_generator);
            const double x_2 = (*static_cast<GAMMA_DIST*>(m_probDistrib2))(g_generator);
            const double x = x_1 / (x_1 + x_2); // beta distribution
            return x;
        }
    case GAMMA_DIST_T:
        {
            const double x = (*static_cast<GAMMA_DIST*>(m_probDistrib))(g_generator);
            return x;
        }
    case CAUCHY_DIST_T:
        {
            const double x = (*static_cast<CAUCHY_DIST*>(m_probDistrib))(g_generator);
            return x;
        }
 
    case EXPONENTIAL_DIST_T:
        {
            const double x = (*static_cast<EXPONENTIAL_DIST*>(m_probDistrib))(g_generator);
            return x;
        }
    default:
        g_msg->Warn(WARN_BUG, "Unknown distribution type number: ", std::to_string(m_type));
        return 0; // should never happen, all supported types are included here
    }
}

References BETA_DIST_T, CAUCHY_DIST_T, DISCRETE_DIST_T, EXPONENTIAL_DIST_T, g_generator(), g_msg, GAMMA_DIST_T, m_probDistrib, m_probDistrib1, m_probDistrib2, m_type, NORMAL_DIST_T, UNIINT_DIST_T, UNIREAL_DIST_T, MapErrorMsg::Warn(), and WARN_BUG.

Referenced by Osmia_Female::FindNestLocation(), Osmia_Population_Manager::GetFirstCocoonProvisioningMass(), Osmia_Female::LayEgg(), Osmia_Female::PlanEggsPerNest(), and Osmia_Female::st_Dispersal().

Geti()

int probability_distribution::Geti

(

)

const

Returns an integer random variate extracted from the defined probability distribution Maybe marginally faster than get(), as it has less types to check

Returns

the random number, returned as an integer; returns zero if the underlying prob is a continuous and not a discrete one

                                         {
    switch (m_type)
    {
    case DISCRETE_DIST_T:
        {
            const int x = (*static_cast<DISCRETE_DIST*>(m_probDistrib))(g_generator);
            return x;
        }
    case UNIINT_DIST_T:
        {
            const int x = (*static_cast<UNIINT_DIST*>(m_probDistrib))(g_generator);
            return x;
        }
    default:
        return 0; // can happen, not all types are integer 
    }
}

References DISCRETE_DIST_T, g_generator(), m_probDistrib, m_type, and UNIINT_DIST_T.

Referenced by Osmia_InCocoon::st_Develop().

Member Data Documentation

BETA_DIST_S

const std::string probability_distribution::BETA_DIST_S { "BETA" }

private

BETA, the continuous/real-valued beta distribution. BETA distribution is implemented using two gamma distributions since it is not included in the standard library.

Parametres are alpha and beta. The outcomes belong to [0,1]

Referenced by probability_distribution().

BETA_DIST_T

const int probability_distribution::BETA_DIST_T = 5

staticprivate

Referenced by Get(), probability_distribution(), and ~probability_distribution().

BETABINOMIAL_DIST_S

const std::string probability_distribution::BETABINOMIAL_DIST_S { "BETABINOMIAL" }

private

BETABINOMIAL, a beta-binomial discrete distribution with outcomes {0,1,2,..,N}

It needs 4 parameters: N (int) - max value of the outcome alpha, beta (real) - the beta binomial parameters, determine the shape of probabilities over the outcome space no_zero (numerical boolean) - extra parameter to cancel out the probability for the zero value

Referenced by probability_distribution().

CAUCHY_DIST_S

const std::string probability_distribution::CAUCHY_DIST_S { "CAUCHY" }

private

CAUCHY, the continuous/real-valued gamma distribution

Parametres are alpha and beta. The outcomes is any real number.

Referenced by probability_distribution().

CAUCHY_DIST_T

const int probability_distribution::CAUCHY_DIST_T = 7

staticprivate

Referenced by Get(), probability_distribution(), and ~probability_distribution().

DISCRETE_DIST_S

const std::string probability_distribution::DISCRETE_DIST_S { "DISCRETE" }

private

DISCRETE, custom build distribution with outcomes {0,1,2,..}

Needs as parameters a (not necesarilly normalized) set of weights (real numbers). The weights correspond to the outcomes {0,1,2,...} Therefore the number of weights give the number of outcomes, where zero is included

Referenced by probability_distribution().

DISCRETE_DIST_T

const int probability_distribution::DISCRETE_DIST_T = 1

staticprivate

Referenced by Get(), Geti(), probability_distribution(), and ~probability_distribution().

EXPONENTIAL_DIST_S

const std::string probability_distribution::EXPONENTIAL_DIST_S { "EXPONENTIAL" }

private

EXPONENTIAL, the continuous/real-valued exponential distribution

Parametres are lamda. The outcomes is any real number.

Referenced by probability_distribution().

EXPONENTIAL_DIST_T

const int probability_distribution::EXPONENTIAL_DIST_T = 8

staticprivate

Referenced by Get(), probability_distribution(), and ~probability_distribution().

GAMMA_DIST_S

const std::string probability_distribution::GAMMA_DIST_S { "GAMMA" }

private

GAMMA, the continuous/real-valued cauchy distribution

Parametres are location and scale. The outcomes belong to [0,max]

Referenced by probability_distribution().

GAMMA_DIST_T

const int probability_distribution::GAMMA_DIST_T = 6

staticprivate

Referenced by Get(), probability_distribution(), and ~probability_distribution().

m_probDistrib

void* probability_distribution::m_probDistrib

private

Referenced by Get(), Geti(), probability_distribution(), and ~probability_distribution().

m_probDistrib1

void* probability_distribution::m_probDistrib1

private

Referenced by Get(), probability_distribution(), and ~probability_distribution().

m_probDistrib2

void* probability_distribution::m_probDistrib2

private

Referenced by Get(), probability_distribution(), and ~probability_distribution().

m_type

int probability_distribution::m_type

private

Referenced by Get(), Geti(), probability_distribution(), and ~probability_distribution().

NORMAL_DIST_S

const std::string probability_distribution::NORMAL_DIST_S { "NORMAL" }

private

NORMAL, a continuous normal distribution

It needs two parameters: the mean (real number) and the standard deviation (real number, >=0)

Referenced by probability_distribution().

NORMAL_DIST_T

const int probability_distribution::NORMAL_DIST_T = 2

staticprivate

Referenced by Get(), probability_distribution(), and ~probability_distribution().

UNIINT_DIST_S

const std::string probability_distribution::UNIINT_DIST_S { "UNIINT" }

private

UNIINT, a discrete uniform distribution

Parametres are min and max, both integer values. The outcomes belong to {min, min+1, ... , max}

Referenced by probability_distribution().

UNIINT_DIST_T

const int probability_distribution::UNIINT_DIST_T = 4

staticprivate

Referenced by Get(), Geti(), probability_distribution(), and ~probability_distribution().

UNIREAL_DIST_S

const std::string probability_distribution::UNIREAL_DIST_S { "UNIREAL" }

private

UNIREAL, a continuous uniform distribution

Parametres are min and max, both real values. The outcomes belong to [min,max)

Referenced by probability_distribution().

UNIREAL_DIST_T

const int probability_distribution::UNIREAL_DIST_T = 3

staticprivate

Referenced by Get(), probability_distribution(), and ~probability_distribution().

---

The documentation for this class was generated from the following files:

• /builds/ALMaSS/ALMaSS_MIDox/BatchALMaSS/ALMaSS_Random.h
• /builds/ALMaSS/ALMaSS_MIDox/BatchALMaSS/ALMaSS_Random.cpp