00001 #ifndef RANDOMDISTRIBUTION_H_
00002 #define RANDOMDISTRIBUTION_H_
00003
00011 #include <boost/shared_ptr.hpp>
00012 using boost::shared_ptr;
00013
00014 #include <boost/random.hpp>
00015
00016 #include <vector>
00017
00018 #include "RandomEngine.h"
00019
00020 #include "RandomDistributionBase.h"
00021
00023 class BernoulliDistribution : public RandomDistributionBoostImplementation< boost::bernoulli_distribution<double> >
00024 {
00025 public:
00026 BernoulliDistribution( double p=0 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( p ) ) {};
00027 };
00028
00030 class BinomialDistribution : public RandomDistributionBoostImplementation< boost::binomial_distribution<int,double> >
00031 {
00032 public:
00033 BinomialDistribution( int n=1, double p=0.5 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t(n, p) ) {};
00034 };
00035
00037 class CauchyDistribution : public RandomDistributionBoostImplementation< boost::cauchy_distribution<double> >
00038 {
00039 public:
00040 CauchyDistribution( double median=0, double sigma=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t(median, sigma) ) {};
00041 };
00042
00044 class ConstantNumber : public RandomDistribution
00045 {
00046 public:
00047
00048 ConstantNumber( double c=1 ) : c(c) {};
00049 virtual ~ConstantNumber() {};
00050
00051 virtual double get( RandomEngine &eng )
00052 {
00053 return c;
00054 };
00055
00056 virtual RandomDistribution *clone(void) const
00057 {
00058 return new ConstantNumber( c );
00059 };
00060
00061 private:
00062 double c;
00063 };
00064
00066 class ExponentialDistribution : public RandomDistributionBoostImplementation< boost::exponential_distribution<double> >
00067 {
00068 public:
00069 ExponentialDistribution( double lambda=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t(lambda) ) {};
00070 };
00071
00073 class GammaDistribution : public RandomDistributionBoostImplementation< boost::gamma_distribution<double> >
00074 {
00075 public:
00076 GammaDistribution( double alpha=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t(alpha) ) {};
00077 };
00078
00080 class GeometricDistribution : public RandomDistributionBoostImplementation< boost::geometric_distribution<int,double> >
00081 {
00082 public:
00083 GeometricDistribution( double p=0.5 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t(p) ) {};
00084 };
00085
00087 class LogNormalDistribution : public RandomDistributionBoostImplementation< boost::lognormal_distribution<double> >
00088 {
00089 public:
00090 LogNormalDistribution( double mean=0, double sigma=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( mean, sigma ) ) {};
00091 };
00092
00094 class NormalDistribution : public RandomDistributionBoostImplementation< boost::normal_distribution<double> >
00095 {
00096 public:
00097 NormalDistribution( double mean=0, double sigma=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( mean, sigma ) ) {};
00098 };
00099
00101 class PoissonDistribution : public RandomDistributionBoostImplementation< boost::poisson_distribution<int,double> >
00102 {
00103 public:
00104 PoissonDistribution( double mean=0 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( mean ) ) {};
00105 };
00106
00108
00111 class TriangleDistribution : public RandomDistributionBoostImplementation< boost::triangle_distribution<double> >
00112 {
00113 public:
00114 TriangleDistribution( double a=0, double b=0.5, double c=1 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( a, b, c ) ) {};
00115 };
00116
00118 class UniformDistribution : public RandomDistributionBoostImplementation< boost::uniform_real<double> >
00119 {
00120 public:
00121 UniformDistribution( double a=0, double b=0.5 ) : RandomDistributionBoostImplementation<boost_dist_t>( boost_dist_t( a, b ) ) {};
00122 };
00123
00125 class UniformIntegerDistribution : public RandomDistribution
00126 {
00127 public:
00128 UniformIntegerDistribution( int a=0, int b=1 ) : a(a), b(b), range(b-a+1) {};
00129 virtual ~UniformIntegerDistribution() {};
00130 virtual double get( RandomEngine &eng );
00131 virtual RandomDistribution *clone(void) const
00132 {
00133 return new UniformIntegerDistribution(a,b);
00134 };
00135 private:
00136 int a, b, range;
00137 };
00138
00139 class STLRandomNumberGenerator
00140 {
00141 public:
00142 STLRandomNumberGenerator( RandomEngine &eng );
00143
00144 unsigned operator()(unsigned N);
00145 protected:
00146
00147 RandomEngine ŋ
00148 };
00149
00151 class ClippedDistribution : public RandomDistribution
00152 {
00153 public:
00154 ClippedDistribution( RandomDistribution const& dist, double a, double b, size_t n=1 );
00155 virtual ~ClippedDistribution();
00156 virtual double get( RandomEngine &eng );
00157 virtual RandomDistribution *clone(void) const
00158 {
00159 return new ClippedDistribution(*dist,a,b,n);
00160 };
00161 private:
00162 RandomDistribution *dist;
00163 double a,b,range;
00164 size_t n;
00165 };
00166
00167
00169 class Gamma2Distribution : public GammaDistribution
00170 {
00171 public:
00172 Gamma2Distribution(double a, double b);
00173 virtual ~Gamma2Distribution()
00174 {
00175 }
00176
00177 virtual double get(RandomEngine &eng);
00178
00179 virtual RandomDistribution *clone(void) const
00180 {
00181 return new Gamma2Distribution(a,b);
00182 };
00183
00184 protected:
00185 double a, b;
00186 };
00187
00188
00190 class BndGammaDistribution : public Gamma2Distribution
00191 {
00192 public:
00193 BndGammaDistribution(double mu, double cv, double upperBound);
00194 virtual ~BndGammaDistribution()
00195 {
00196 }
00197
00198 virtual double get(RandomEngine &eng);
00199
00200 virtual RandomDistribution *clone(void) const
00201 {
00202 return new BndGammaDistribution(mu, cv, ub);
00203 };
00204
00205 protected:
00206 UniformDistribution uniform;
00207 double mu, cv, ub;
00208 };
00209
00210
00212 class BndNormalDistribution : public NormalDistribution
00213 {
00214 public:
00215 BndNormalDistribution(double mu, double cv, double lowerBound, double upperBound);
00216 virtual ~BndNormalDistribution()
00217 {
00218 }
00219
00220 virtual double get(RandomEngine &eng);
00221
00222 virtual RandomDistribution *clone(void) const
00223 {
00224 return new BndNormalDistribution(mu, cv, lb, ub);
00225 };
00226
00227 protected:
00228 UniformDistribution uniform;
00229 double mu, cv, lb, ub;
00230 };
00231
00232
00234 class QuadDistribution : public UniformDistribution
00235 {
00236 public:
00237 QuadDistribution(double a, double b);
00238 virtual ~QuadDistribution()
00239 {
00240 }
00241
00242 virtual double get(RandomEngine &eng);
00243
00244 virtual RandomDistribution *clone(void) const
00245 {
00246 return new QuadDistribution(a, b);
00247 };
00248
00249 protected:
00250 double a,b;
00251 };
00252
00253 #endif