RandomDistribution.h

Go to the documentation of this file.

#ifndef RANDOMDISTRIBUTION_H_
#define RANDOMDISTRIBUTION_H_

#include <boost/shared_ptr.hpp>
using boost::shared_ptr;

#include <boost/random.hpp>

#include <vector>

#include "RandomEngine.h"

class RandomDistribution
{
public:
    virtual ~RandomDistribution() {};

    double operator()(RandomEngine &eng ) { return get( eng ); };
    shared_ptr< std::vector<double> > operator()(RandomEngine &eng, size_t n );
    virtual RandomDistribution *clone(void) const = 0;
protected:
    virtual double get( RandomEngine &eng ) { return 0; };
};

template< typename boost_dist >
class RandomDistributionBoostImplementation : public RandomDistribution
{
protected:
    typedef boost_dist boost_dist_t;

public:
    RandomDistributionBoostImplementation( boost_dist const& d ) : m_dist( d ) {};
    virtual ~RandomDistributionBoostImplementation() {};

    virtual double get( RandomEngine &eng )
    {
        return m_dist( eng );
    };

    virtual RandomDistribution *clone(void) const
    {
        return new RandomDistributionBoostImplementation( m_dist );
    };

private:
    boost_dist m_dist;

};

class BernoulliDistribution : public RandomDistributionBoostImplementation< boost::bernoulli_distribution<double> >
{
public:
    BernoulliDistribution( double p=0 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( p ) ) {};
};

class BinomialDistribution : public RandomDistributionBoostImplementation< boost::binomial_distribution<int,double> >
{
public:
    BinomialDistribution( int n=1, double p=0.5 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t(n, p) ) {};
};

class CauchyDistribution : public RandomDistributionBoostImplementation< boost::cauchy_distribution<double> >
{
public:
    CauchyDistribution( double median=0, double sigma=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t(median, sigma) ) {};
};

class ConstantNumber : public RandomDistribution
{
public:

    ConstantNumber( double c=1 ) : c(c) {};
    virtual ~ConstantNumber() {};

    virtual double get( RandomEngine &eng )
    {
        return c;
    };

    virtual RandomDistribution *clone(void) const
    {
        return new ConstantNumber( c );
    };

private:
    double c;
};

class ExponentialDistribution : public RandomDistributionBoostImplementation< boost::exponential_distribution<double> >
{
public:
    ExponentialDistribution( double lambda=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t(lambda) ) {};
};

class GammaDistribution : public RandomDistributionBoostImplementation< boost::gamma_distribution<double> >
{
public:
    GammaDistribution( double alpha=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t(alpha) ) {};
};

class GeometricDistribution : public RandomDistributionBoostImplementation< boost::geometric_distribution<int,double> >
{
public:
    GeometricDistribution( double p=0.5 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t(p) ) {};
};

class LogNormalDistribution : public RandomDistributionBoostImplementation< boost::lognormal_distribution<double> >
{
public:
    LogNormalDistribution( double mean=0, double sigma=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( mean, sigma ) ) {};
};

class NormalDistribution : public RandomDistributionBoostImplementation< boost::normal_distribution<double> >
{
public:
    NormalDistribution( double mean=0, double sigma=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( mean, sigma ) ) {};
};

class PoissonDistribution : public RandomDistributionBoostImplementation< boost::poisson_distribution<int,double> >
{
public:
    PoissonDistribution( double mean=0 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( mean ) ) {};
};


class TriangleDistribution : public RandomDistributionBoostImplementation< boost::triangle_distribution<double> >
{
public:
    TriangleDistribution( double a=0, double b=0.5, double c=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( a, b, c ) ) {};
};

class UniformDistribution : public RandomDistributionBoostImplementation< boost::uniform_real<double> >
{
public:
    UniformDistribution( double a=0, double b=0.5 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( a, b ) ) {};
};

class UniformIntegerDistribution : public RandomDistribution
{
public:
    UniformIntegerDistribution( int a=0, int b=1 ) : a(a), b(b), range(b-a+1) {};
    virtual ~UniformIntegerDistribution() {};
    virtual double get( RandomEngine &eng );
    virtual RandomDistribution *clone(void) const
    {
        return new UniformIntegerDistribution(a,b);
    };
private:
    int a, b, range;
};

class ClippedDistribution : public RandomDistribution
{
public:
    ClippedDistribution( RandomDistribution const& dist, double a, double b, size_t n=1 );
    virtual ~ClippedDistribution();
    virtual double get( RandomEngine &eng );
    virtual RandomDistribution *clone(void) const
    {
        return new ClippedDistribution(*dist,a,b,n);
    };
private:
    RandomDistribution *dist;
    double a,b,range;
    size_t n;
};


class Gamma2Distribution : public GammaDistribution
{
public:
    Gamma2Distribution(double a, double b);
    virtual ~Gamma2Distribution()
    {
    }

    virtual double get(RandomEngine &eng);

    virtual RandomDistribution *clone(void) const
    {
        return new Gamma2Distribution(a,b);
    };

protected:
    double a, b;
};


class BndGammaDistribution : public Gamma2Distribution
{
public:
    BndGammaDistribution(double mu, double cv, double upperBound);
    virtual ~BndGammaDistribution()
    {
    }

    virtual double get(RandomEngine &eng);

    virtual RandomDistribution *clone(void) const
    {
        return new BndGammaDistribution(mu, cv, ub);
    };

protected:
    UniformDistribution uniform;
    double mu, cv, ub;
};


class BndNormalDistribution : public NormalDistribution
{
public:
    BndNormalDistribution(double mu, double cv, double lowerBound, double upperBound);
    virtual ~BndNormalDistribution()
    {
    }

    virtual double get(RandomEngine &eng);

    virtual RandomDistribution *clone(void) const
    {
        return new BndNormalDistribution(mu, cv, lb, ub);
    };

protected:
    UniformDistribution uniform;
    double mu, cv, lb, ub;
};


class QuadDistribution : public UniformDistribution
{
public:
    QuadDistribution(double a, double b);
    virtual ~QuadDistribution()
    {
    }

    virtual double get(RandomEngine &eng);

    virtual RandomDistribution *clone(void) const
    {
        return new QuadDistribution(a, b);
    };

protected:
    double a,b;
};

#endif /*RANDOMDISTRIBUTION_H_*/

---