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 {

//TODO @group etc
inline unsigned long intrand(cRNG *rng, long 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