Changeset 364

Timestamp:

Aug 5, 2005, 10:25:21 AM (18 years ago)

Author:

Peter

Message:

added classes to random, now has all functionality that former random_singleton had except general distributions

Location:

trunk/lib/utility

Files:

• Random.h (modified) (2 diffs)
• random_singleton.cc (modified) (2 diffs)
• random_singleton.h (modified) (2 diffs)

trunk/lib/utility/Random.h

@@ -57 +57 @@
   public:
 
-    inline double operator()(void) const { return gsl_rng_uniform(rng_->rng()); }
-
-  };
-
-
-
+    inline double operator()(void) const { return gsl_rng_uniform(rng_->rng());}
+
+  };
+
+  ///
+  /// Class to generate Gaussian random numbers. 
+  ///
   class RandomGaussian : public RandomContinuous
   {
@@ -83 +84 @@
   };
 
-
-  class RandomDiscrete {
-  };
-
-
-  class RandomDiscreteUniform : public RandomDiscrete {
+  ///
+  /// @brief exponential
+  ///
+  class RandomExponential : public RandomContinuous
+  {
+  public:
+    ///
+    /// Constructor
+    ///
+    inline RandomExponential(const double m=1) 
+      : m_(m){}
+
+    ///
+    ///
+    ///
+    inline double operator()(void) const 
+    { return gsl_ran_exponential(rng_->rng(), m_); }
+
+    ///
+    ///
+    ///
+    inline double operator()(const double m) const 
+    { return gsl_ran_exponential(rng_->rng(), m); }
+
+  private:
+    double m_;
+  };
+
+
+  ///
+  /// Base class for discrete random distributions.
+  ///
+  class RandomDiscrete 
+  {
+  public:
+    ///
+    /// Constructor
+    ///
+    inline RandomDiscrete(void) { rng_=RNG::instance(89); }
+
+    ///
+    /// Common interface for all Discrete Random Classes
+    ///
+    virtual long operator()(void) const = 0;
+    
+  protected:
+    RNG* rng_;
+  };
+
+
+  class RandomDiscreteUniform : public RandomDiscrete 
+  {
+  public:
+    ///
+    /// Constructor.
+    ///
+    inline RandomDiscreteUniform(const u_long range, const long min=0) 
+      : min_(min), range_(range) {}
+
+    ///
+    /// @return A random number between \a min_ and \a range_ - \a min_
+    ///
+    inline long operator()(void) const 
+    { return gsl_rng_uniform_int(rng_->rng(), range_)+min_; }
+
+    ///
+    /// @return A random number between 0 and \a range.
+    ///
+    inline long operator()(const u_long range) const 
+    { return gsl_rng_uniform_int(rng_->rng(), range); }
+
+    ///
+    /// @return A random number between \a min and \a range - \a min
+    ///
+    inline long operator()(const u_long range, const long min) const 
+    { return gsl_rng_uniform_int(rng_->rng(), range)+min; }
+
+
+  private:
+    long min_;
+    u_long range_;
+  };
+
+
+  ///
+  /// @brief Poisson
+  ///
+  class RandomPoisson : public RandomContinuous
+  {
+  public:
+    ///
+    /// Constructor
+    ///
+    inline RandomPoisson(const double m=1) 
+      : m_(m){}
+
+    ///
+    ///
+    ///
+    inline double operator()(void) const 
+    { return gsl_ran_poisson(rng_->rng(), m_); }
+
+    ///
+    ///
+    ///
+    inline double operator()(const double m) const 
+    { return gsl_ran_poisson(rng_->rng(), m); }
+
+  private:
+    double m_;
   };
 

trunk/lib/utility/random_singleton.cc

@@ -2 +2 @@
 
 #include <c++_tools/utility/random_singleton.h>
+
+#include <c++_tools/gslapi/vector.h>
 
 namespace theplu {
@@ -55 +57 @@
 }
 
-/**
-double random_singleton::get_poisson(const double m) const
+void random_singleton::general_distribution_prob(const gslapi::vector& p)
 {
- 
+
 }
-*/
 
 }} // of namespace utility and namespace theplu

trunk/lib/utility/random_singleton.h

@@ -13 +13 @@
 
 namespace theplu {
+namespace gslapi {
+  class vector;
+}
+
 namespace utility {  
 
-  ///
+  ///
   /// Class defining interface for different random stuff.
   ///
@@ -111 +115 @@
     /// @see rnd_discrete
     ///
-    inline void general_distribution_prob( const size_t& k, 
-                                           const double* p )
-    { gen_ = gsl_ran_discrete_preproc( k, p ); }
+    void general_distribution_prob( const gslapi::vector& p);
 
     ///