rndgen.h

Go to the documentation of this file.

/*
 $Id: rndgen.h,v 1.4 2004/12/12 23:44:43 pecos Exp $ 
 */

/* *********
*  
*  This file is part of:
*  NePSing, Network Protocol Simulator next generation
*  
*  Copyright (C) 2004  Tommaso Pecorella <tpecorella@mac.com>
*  
*  This library is free software; you can redistribute it and/or
*  modify it under the terms of the GNU Lesser General Public
*  License as published by the Free Software Foundation; either
*  version 2.1 of the License, or (at your option) any later version.
*  
*  This library is distributed in the hope that it will be useful,
*  but WITHOUT ANY WARRANTY; without even the implied warranty of
*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
*  Lesser General Public License for more details.
*  
*  You should have received a copy of the GNU Lesser General Public
*  License along with this library; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*  
********* */

#include <stdlib.h>
#include <math.h>

#include <gsl/gsl_rng.h>
#include <gsl/gsl_randist.h>

#ifndef ___RNDGEN_H___
#define ___RNDGEN_H___




void SetSeed(char* genType,
             int seed);

// generic functions w/o initalizers


double rndUniformDouble(double low=0.0, double high=1.0);


long int rndUniformInt(long int low=0, long int high=1);


double rndExponential(double M);


double rndGaussian(double M, double sigma);


unsigned int rndGeometric0(double M);


unsigned int rndGeometric1(double M);


/***********************************************************************
*                                                                      *
*   Negative Binomial distribution                                     *
*                                                                      *
*     p(k) = (k + r -1 ) * p^r * (1-p)^k                               *
*            (    k    )                                               *
*                                                                      *
*     mean     = r*(1-p)/p                                             *
*     variance = r*(1-p)/p^2                                           *
*                                                                      *
***********************************************************************/

long int rndNegativeBinomial(long r, float p);


/***********************************************************************
*                                                                      *
*   Pareto distribution                                                *
*                                                                      *
*     p(x) = (shape * location^shape)/(x^(shape+1))                    *
*     P(x) = 1 - (location/x)^shape                                    *
*     mean     = location * shape / (shape - 1)                        *
*     variance = location^2 * shape / ( (shape -2) * (shape - 1)^2 )   *
*                                                                      *
***********************************************************************/

double rndPareto(double location, double shape);
        

/**************************************************************************
*                                                                         *
*   Weibull distribution                                                  *
*                                                                         *
*        l = location, sh = shape, sc = scale, Gamma() = Gamma function   *
*     p(x) = sh/sc * ((x-l)/sc)^(sh-1) * e^(-((x-l)/sc)^sh)               *
*     P(x) = 1 - e^(-((x-l)/sc)^sh)                                       *
*     mean     = l + sc*Gamma((sh+1)/sh)                                  *
*     variance = sc^2 * ( Gamma((sh+2)/sh) - Gamma^2((sh+1)/sh) )         *
*                                                                         *
**************************************************************************/

double rndWeibull(double location, double scale, double shape);


double rndRayleigh(double sigma);


void rndShuffle( void* vect, size_t size, size_t elem_size );



class UniformDoubleRndGen
{
protected:
  double low, high;
  double range;

public:
    UniformDoubleRndGen(double _low=0,  
                      double _high=1)   
    : low(_low), high(_high), range(_high-_low) {};
  
  double get(); 
};


class UniformIntRndGen
{
protected:
  long int low, high;
  long int range;
public:
  UniformIntRndGen(long int _low=0, 
                   long int _high=1) 
    : low(_low), high(_high), range(_high-_low+1) {};

  long int get();
};


class ExponentialRndGen
{
protected:
  double meanExp;

public:
  ExponentialRndGen(double _mean=0) 
  : meanExp(_mean) {};
  
  double get();
};


class GaussianRndGen
{
protected:
  double mean, sigma;

public:
  GaussianRndGen(double _mean=0, 
                 double _sigma=0) 
  : mean(_mean), sigma(_sigma) {};
  
  double get();
};


class Geometric0RndGen
{
protected:
  double meanGeo0;
  double pGeo0;

public:
  Geometric0RndGen(double _mean=0) 
    : meanGeo0(_mean)
  {
    if( _mean > 0 )
      pGeo0 = 1 / (_mean + 1);
  };

  
  unsigned long int get();
};


class Geometric1RndGen
{
protected:
  double meanGeo1;
  double pGeo1;

public:
  Geometric1RndGen(double _mean=1) 
    : meanGeo1(_mean)
  {
    if( _mean > 1 )
      pGeo1 = 1 / _mean;
  };
  
  unsigned long int get();
};


class ParetoRndGen
{
protected:
  double location;
  double shape;

public:
  ParetoRndGen(double _location=1, 
               double _shape=1) 
    : location(_location), shape(_shape)
  {};

  double get();
};


class WeibullRndGen
{
protected:
  double location;
  double scale;
  double shape;

public:
  WeibullRndGen(double _location=1, 
                double _scale=1, 
                double _shape=1) 
    : location(_location), scale(_scale), shape(_shape)
  {};
  
  double get();
};


class RayleighRndGen
{
protected:
  double sigma;

public:
  RayleighRndGen(double _sigma=1) 
    : sigma(_sigma)
  {};
  
  double get();
};


#endif


/*
$Log: rndgen.h,v $
Revision 1.4  2004/12/12 23:44:43  pecos
Added Copyright message - LGPL

Revision 1.3  2004/12/11 23:53:24  pecos
Added DoxyGen comments

Revision 1.2  2004/08/11 16:32:44  pecos
Added Shuffling

Revision 1.1.1.1  2004/07/08 16:59:33  pecos
NePSing framework

Revision 1.6  2002/07/26 13:24:34  pecos
Added Negative Binomial distribution

Revision 1.1  2002/07/26 13:20:33  pecos
*** empty log message ***

Revision 1.5  2001/03/17 09:47:56  pecos
Added default params for Pareto and Weibull

Revision 1.4  2000/02/24 08:36:21  pecos
no message

Revision 1.3  1999/09/11 09:14:13  pecos
*** empty log message ***

Revision 1.2  1999/05/28 23:54:48  pecos
no message

Revision 1.1.1.1  1999/05/24 15:59:57  inesis
INeSiS Project

Revision 1.1.1.1  1999/05/24 15:17:20  inesis
INeSiS Project

Revision 1.2  1999/01/26 11:24:23  pecos
*** empty log message ***

Revision 1.2  1998/09/29 18:56:53  nanni
*** empty log message ***

Revision 1.1  1998/09/15 15:20:24  ronga
Initial revision

*/

---