Changeset 738 for trunk/yat/random

Timestamp:

Jan 8, 2007, 12:08:39 AM (17 years ago)

Author:

Jari Häkkinen

Message:

Fixes #8 and #179, addresses #2.

Location:

trunk/yat/random

Files:

• random.cc (modified) (6 diffs)
• random.h (modified) (4 diffs)

trunk/yat/random/random.cc

@@ -24 +24 @@
 #include "random.h"
 #include "yat/statistics/Histogram.h"
+#include "yat/utility/Exception.h"
 
 #include <fstream>
-#include <iostream>
+#include <sstream>
 
 namespace theplu {
@@ -36 +37 @@
   RNG::RNG(void)
   {
-    gsl_rng_env_setup();  // support rng/seed changes through environment vars
-    rng_ = gsl_rng_alloc(gsl_rng_default);  // Memory is allocated here!
+      // support rng/seed changes through environment vars
+    if (!gsl_rng_env_setup())
+      throw utility::GSL_error("RNG: unknown generator");
+    if (!(rng_=gsl_rng_alloc(gsl_rng_default)))
+      throw utility::GSL_error("RNG: failed to allocate memory");
   }
 
@@ -105 +109 @@
   RNG_state::RNG_state(const RNG* rng)
   {
-    rng_ = gsl_rng_clone(rng->rng()); 
+    if (!(rng_ = gsl_rng_clone(rng->rng())))
+      throw utility::GSL_error("RNG_state: failed to allocate memory");
   }
   
@@ -146 +151 @@
     gen_ = gsl_ran_discrete_preproc( hist.nof_bins(), p );
     delete p;
+    if (!gen_)
+      throw utility::GSL_error("DiscreteGeneral: failed to setup generator.");
   }
 
@@ -163 +170 @@
 
 
-  DiscreteUniform::DiscreteUniform(void)
-    : range_(rng_->max())
-  {
-  }
-
-  DiscreteUniform::DiscreteUniform(const u_long n)
+  DiscreteUniform::DiscreteUniform(u_long n)
     : range_(n)
   {
-    if (range_>rng_->max())
-      range_=rng_->max();
+    if (range_>rng_->max()) {
+      std::stringstream ss("DiscreteUniform: ");
+      ss << n << " is too large for RNG " << rng_->name();
+      throw utility::GSL_error(ss.str());
+    }
   }
 
@@ -178 +183 @@
   u_long DiscreteUniform::operator()(void) const
   {
-    return gsl_rng_uniform_int(rng_->rng(), range_);
-  }
-
-
-  u_long DiscreteUniform::operator()(const u_long n) const
-  {
-    return gsl_rng_uniform_int(rng_->rng(), n);
+    return (range_ ?
+            gsl_rng_uniform_int(rng_->rng(), range_) : gsl_rng_get(rng_->rng()));
+  }
+
+
+  u_long DiscreteUniform::operator()(u_long n) const
+  {
+    // making sure that n is not larger than the range of the
+    // underlying RNG
+    if (n>rng_->max()) {
+      std::stringstream ss("DiscreteUniform::op(): ");
+      ss << n << " is too large for RNG " << rng_->name();
+      throw utility::GSL_error(ss.str());
+    }
+    return gsl_rng_uniform_int(rng_->rng(),n);
   }
 

trunk/yat/random/random.h

@@ -48 +48 @@
   ///
   /// There is information about how to change seeding and generators
-  /// at run time without recompilation using environment
-  /// variables. RNG of course support seeding at compile time if you
-  /// don't want to bother about environment variables and GSL.
+  /// at run time without recompilation using environment variables in
+  /// the GSL manual (Chapter on random number generators). RNG of
+  /// course support seeding at compile time if you don't want to
+  /// bother about environment variables and GSL.
   ///
   /// There are many different rng's available in GSL. Currently only
@@ -65 +66 @@
   /// follow the coding style.)
   ///
-  /// This implementation may be thread safe (according to GSL
-  /// documentation), but should be checked to be so before trusting
-  /// thread safety.
+  /// The current implementation is NOT thread safe since the RNG is
+  /// implemented as a singleton. However, the underlying GSL rng's
+  /// support thread safety since each instance of GSL rng's keep
+  /// track of their own state accordning to GSL documentation.
   ///
   /// @see Design Patterns (the singleton and adapter pattern). GSL
@@ -134 +136 @@
     u_long seed_from_devurandom(void);
 
-    ///
-    /// @brief set the state
-    ///
-    /// @return see gsl_rng_memcpy
-    ///
+    /**
+       \brief Set the state to \a state.
+
+       \return 0 on success, non-zero otherwise.
+
+       \see gsl_rng_memcpy
+    */
     int set_state(const RNG_state&);
 
@@ -276 +280 @@
   {
   public:
-    ///
-    /// @brief Default constructor.
-    ///
-    DiscreteUniform(void);
-
-    ///
-    /// @brief Constructor.
-    ///
-    /// The generator will generate integers from \f$ [0,n-1] \f$. If
-    /// \a n is larger than the maximum number the random number
-    /// generator can return, then (currently) \a n is adjusted
-    /// appropriately.
-    ///
-    /// @todo If a too large \a n is given an exception should be
-    /// thrown, i.e. the behaviour of this class will change. The case
-    /// when argument is 0 is not treated gracefully (underlying GSL
-    /// functionality will not return).
-    ///
-    DiscreteUniform(const u_long n);
-
-    ///
-    /// This function returns a random integer from 0 to n-1
-    /// inclusive. All integers in the range [0,n-1] are equally
-    /// likely. n is set in constructor.
-    ///
+    /**
+       \brief Constructor.
+
+       The generator will generate integers within the range \f$
+       [0,n-1] \f$. If \a n is zero, then the whole range of the
+       underlying RNG will be used \f$ [min,max] \f$. Setting \a n to
+       zero is the preferred way to sample the whole range of the
+       underlying RNG, i.e. not setting \n to RNG.max.
+
+       \throw If \a n is larger than the maximum number the underlying
+       random number generator can return, then a GSL_error exception
+       is thrown.
+    */
+    DiscreteUniform(u_long n=0);
+
+    /**
+       \brief Get a random number
+
+       The returned integer is either in the range [RNG.min,RNG.max]
+       or [0,n-1] depending on how the random number generator was
+       created.
+
+       \see DiscreteUniform(const u_long n=0)
+    */
     u_long operator()(void) const;
 
-    ///
-    /// This function returns a random integer from 0 to n-1
-    /// inclusive. All integers in the range [0,n-1] are equally
-    /// likely.
-    ///
-    u_long operator()(const u_long n) const;
+    /**
+       \brief Get a random integer in the range \f$ [0,n-1] \f$.
+
+       All integers in the range [0,n-1] are equally likely. This
+       function should be avoided for sampling the whole range of the
+       underlying RNG.
+
+       \throw GSL_error if \an is larger than the range of the
+       underlying generator.
+    */
+    u_long operator()(u_long n) const;
 
   private: