distrib.h

//==========================================================================
// DISTRIB.H
//                     OMNeT++/OMNEST
//            Discrete System Simulation in C++
//
//==========================================================================
 
// Authors: Werner Sandmann (ws), Kay Michael Masslow (kmm), Kyeong Soo (Joseph) Kim (jk)
// Documentation, maintenance: Andras Varga
 
#ifndef __OMNETPP_DISTRIB_H
#define __OMNETPP_DISTRIB_H
 
#include "simkerneldefs.h"
#include "crng.h"
#include "simtime.h"
 
namespace omnetpp {
 
inline uint32_t intrand(cRNG *rng, uint32_t r)  {return rng->intRand(r);}
 
inline double dblrand(cRNG *rng)  {return rng->doubleRand();}
SIM_API double uniform(cRNG *rng, double a, double b);
 
inline SimTime uniform(cRNG *rng, SimTime a, SimTime b) {return uniform(rng, a.dbl(), b.dbl());}
 
SIM_API double exponential(cRNG *rng, double mean);
 
inline SimTime exponential(cRNG *rng, SimTime mean) {return exponential(rng, mean.dbl());}
 
SIM_API double normal(cRNG *rng, double mean, double stddev);
 
inline SimTime normal(cRNG *rng, SimTime mean, SimTime stddev) {return normal(rng, mean.dbl(), stddev.dbl());}
 
SIM_API double truncnormal(cRNG *rng, double mean, double stddev);
 
inline SimTime truncnormal(cRNG *rng, SimTime mean, SimTime stddev) {return truncnormal(rng, mean.dbl(), stddev.dbl());}
 
SIM_API double gamma_d(cRNG *rng, double alpha, double theta);
 
SIM_API double beta(cRNG *rng, double alpha1, double alpha2);
 
SIM_API double erlang_k(cRNG *rng, unsigned int k, double mean);
 
SIM_API double chi_square(cRNG *rng, unsigned int k);
 
SIM_API double student_t(cRNG *rng, unsigned int i);
 
SIM_API double cauchy(cRNG *rng, double a, double b);
 
SIM_API double triang(cRNG *rng, double a, double b, double c);
 
inline double lognormal(cRNG *rng, double m, double w)
{
    return exp(normal(rng, m, w));
}
 
SIM_API double weibull(cRNG *rng, double a, double b);
 
SIM_API double pareto_shifted(cRNG *rng, double a, double b, double c);
 
SIM_API int intuniform(cRNG *rng, int a, int b);
 
SIM_API int intuniformexcl(cRNG *rng, int a, int b);
 
inline int bernoulli(cRNG *rng, double p)
{
    double U = rng->doubleRand();
    return (p > U) ? 1 : 0;
}
 
SIM_API int binomial(cRNG *rng, int n, double p);
 
SIM_API int geometric(cRNG *rng, double p);
 
SIM_API int negbinomial(cRNG *rng, int n, double p);
 
//
// hypergeometric() doesn't work yet
//
// /* *
//  * Returns a random integer from the hypergeometric distribution with
//  * parameters a,b and n.
//  *
//  * If you have a+b items (a items of type A and b items of type B)
//  * and you draw n items from them without replication, this function
//  * will return the number of type A items in the drawn set.
//  *
//  * Generation uses inverse transform due to Fishman (see Banks, page 165).
//  *
//  * @param a, b  a,b>0
//  * @param n     0<=n<=a+b
//  * @param rng the underlying random number generator
//  */
// SIM_API int hypergeometric(cRNG *rng, int a, int b, int n);
 
SIM_API int poisson(cRNG *rng, double lambda);
 
}  // namespace omnetpp
 
 
#endif