source: trunk/lib/random/Random.h @ 366

Last change on this file since 366 was 366, checked in by Peter, 16 years ago

moved namespace random to its own directory

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 4.0 KB
Line 
1 // $Id: Random.h 366 2005-08-05 08:58:56Z peter $
2
3#ifndef _theplu_random_
4#define _theplu_random_
5
6
7#include <gsl/gsl_rng.h>
8#include <gsl/gsl_randist.h>
9
10namespace theplu {
11namespace random { 
12
13  ///
14  /// The RNG class provides a single global random number generator
15  /// instance with one point of access to the generator.
16  ///
17  /// This is probably not thread safe.
18  ///
19  /// @see Design Patterns (the singleton and adapter pattern)
20  ///
21  class RNG
22  {
23  public:
24
25    virtual ~RNG(void);
26
27    static RNG* instance(int seed);
28
29    inline const gsl_rng* rng(void) const { return rng_; }
30
31  private:
32
33    RNG(void);
34
35    static RNG* instance_;
36    gsl_rng* rng_;
37  };
38
39
40
41  ///
42  /// @brief continuous random distributions.
43  /// Base for continuous random distributions.
44  ///
45  class RandomContinuous
46  {
47  public:
48
49    ///
50    /// @brief Constructor
51    ///
52    inline RandomContinuous(void) { rng_=RNG::instance(89); }
53
54    virtual double operator()(void) const = 0;
55
56  protected:
57    RNG* rng_;
58  };
59
60
61  ///
62  /// @brief Uniform distribution
63  ///
64  /// Class for generating a random number from a flat distribution
65  /// between zero and unity.
66  ///
67  /// Distribution function \f$ f(x) = 1 \f$ for \f$ 0 \le x < 1 \f$
68  /// Expectation value: 0.5
69  /// Variance: \f$ \frac{1}{12} \f$
70  ///
71  class RandomContinuousUniform : public RandomContinuous
72  {
73  public:
74
75    inline double operator()(void) const { return gsl_rng_uniform(rng_->rng());}
76
77  };
78
79  ///
80  /// Class to generate Gaussian random numbers.
81  ///
82  class RandomGaussian : public RandomContinuous
83  {
84  public:
85    inline RandomGaussian(const double s=1, const double m=0) 
86      : m_(m), s_(s) {}
87
88    inline double operator()(void) const 
89    { return gsl_ran_gaussian(rng_->rng(), s_)+m_; }
90
91    inline double operator()(const double s) const 
92    { return gsl_ran_gaussian(rng_->rng(), s); }
93
94    inline double operator()(const double s, const double m) const 
95    { return gsl_ran_gaussian(rng_->rng(), s)+m; }
96
97  private:
98    double m_;
99    double s_;
100  };
101
102  ///
103  /// @brief exponential
104  ///
105  class RandomExponential : public RandomContinuous
106  {
107  public:
108    ///
109    /// Constructor
110    ///
111    inline RandomExponential(const double m=1) 
112      : m_(m){}
113
114    ///
115    ///
116    ///
117    inline double operator()(void) const 
118    { return gsl_ran_exponential(rng_->rng(), m_); }
119
120    ///
121    ///
122    ///
123    inline double operator()(const double m) const 
124    { return gsl_ran_exponential(rng_->rng(), m); }
125
126  private:
127    double m_;
128  };
129
130
131  ///
132  /// @brief discrete random distributions.
133  /// Base for discrete random distributions.
134  ///
135  class RandomDiscrete
136  {
137  public:
138    ///
139    /// Constructor
140    ///
141    inline RandomDiscrete(void) { rng_=RNG::instance(89); }
142
143    ///
144    /// Common interface for all Discrete Random Classes
145    ///
146    virtual long operator()(void) const = 0;
147   
148  protected:
149    RNG* rng_;
150  };
151
152
153  class RandomDiscreteUniform : public RandomDiscrete
154  {
155  public:
156    ///
157    /// Constructor.
158    ///
159    inline RandomDiscreteUniform(const u_long range, const long min=0) 
160      : min_(min), range_(range) {}
161
162    ///
163    /// @return A random number between \a min_ and \a range_ - \a min_
164    ///
165    inline long operator()(void) const 
166    { return gsl_rng_uniform_int(rng_->rng(), range_)+min_; }
167
168    ///
169    /// @return A random number between 0 and \a range.
170    ///
171    inline long operator()(const u_long range) const 
172    { return gsl_rng_uniform_int(rng_->rng(), range); }
173
174    ///
175    /// @return A random number between \a min and \a range - \a min
176    ///
177    inline long operator()(const u_long range, const long min) const 
178    { return gsl_rng_uniform_int(rng_->rng(), range)+min; }
179
180
181  private:
182    long min_;
183    u_long range_;
184  };
185
186
187  ///
188  /// @brief Poisson
189  ///
190  class RandomPoisson : public RandomContinuous
191  {
192  public:
193    ///
194    /// Constructor
195    ///
196    inline RandomPoisson(const double m=1) 
197      : m_(m){}
198
199    ///
200    ///
201    ///
202    inline double operator()(void) const 
203    { return gsl_ran_poisson(rng_->rng(), m_); }
204
205    ///
206    ///
207    ///
208    inline double operator()(const double m) const 
209    { return gsl_ran_poisson(rng_->rng(), m); }
210
211  private:
212    double m_;
213  };
214
215  ///
216  /// @brief General
217  ///
218  class RandomDiscreteGeneral : public RandomDiscrete {
219  };
220
221
222}} // of namespace random and namespace theplu
223
224#endif
Note: See TracBrowser for help on using the repository browser.