source: trunk/lib/utility/random_singleton.h @ 312

// $Id: random_singleton.h 312 2005-05-12 07:57:20Z peter $

#ifndef _theplu_utility_random_singleton_ 
#define _theplu_utility_random_singleton_ 


// #include <cstdlib>
// #include <cstdio>
#include <string>

#include <gsl/gsl_rng.h>
#include <gsl/gsl_randist.h>

namespace theplu {
namespace utility {  

  /**
     Class defining interface for different random
     stuff.
  */
  class random_singleton
  {
  private:
    /**
       pointer to an instance of the class.
    */
    static random_singleton *singleobj_;

    /**
       GSL stuff
    */
    gsl_rng* r_; 
    gsl_ran_discrete_t* gen_;  // general purpose distribution 

    /**
       Private constructor. Only way to 
       create object is via get_instance().
    */
    random_singleton();

  public:
    /**
       Method used to instantiate an object from this class.
       The seed is zero by default. If user wish to use time
       the user should specify a negative seed. Note that if an
       object already exists the method will return that object
       and hence no new object is created.
    */
    static random_singleton* get_instance( int seed = 0 );


    /** 
  A random unsgined long integer number is returned from a
  uniform distribution.

  @return If \a n is zero, or left out, a number between [ \a
  min, \a max ] is returned, otherwise a number between 0 and n-1
  is returned.

  The values of \a min and \a max are obtained via
  get_uniform_int_min() and get_uniform_int_max().
    */
    inline u_long get_uniform_int(const u_long n=0) const;


    /** 
  A random number (double precision) is returned 
  from a uniform distribution between [ 0, 1 [. 
    */
    inline double get_uniform_double() const;


    /** 
  A random number (double precision) is returned 
  from a gaussioan distribution between where \a sigma
  can be specified by caller. \a sigma (\f$\sigma\f$) is 
  the standard deviation in a gaussian distribution: \n\n
  \f$f(x) = \frac{1}{\sqrt{2\pi\sigma^2}}e^{-\frac{x^2}{2\sigma^2}}\f$ \n\n
  Default is \a sigma = 1.  
    */
    inline double get_gaussian( const double& sigma ) const;


    /** 
  A random number (double precision) is returned 
  from an exponential distribution. \a mu (\f$\mu\f$), the mean, 
  can be specified by caller: \f$f(x) = \frac{1}{\mu}e^{-\frac{x}{\mu}}\f$.
  Default is \a mu = 1.  
    */
    inline double get_exponential( const double& mu ) const;
    

    ///
    /// @brief random number from Poisson distribution 
    ///
    /// Probability that returned number i \f$ k \f$ is \f$ P(k) =
    /// \frac{m^k}{k!}e^{-m} \f$
    inline u_int get_poisson(const double m) const
    { return gsl_ran_poisson(r_, m); }
    
    /** 
        @See get_uniform_int()!
    */
    inline u_long get_uniform_min() const;
 

    /** 
        @See get_uniform_int()!
    */
    inline u_long get_uniform_max() const;


    /**
       Return seed to user for documentation purposes.
    */
    inline int get_seed() const;

    /**
       Set a new seed
    */
    void set_seed( const int& seed );


    /**
       Set probabilities \a p for the general purpose 
       distribution. 
    */
    inline void set_general_distribution_prob( const size_t& k, 
                 const double* p );
    

    /**
       Get a random number (index) from the general purpose
       distribution
    */
    inline size_t get_rnd_discrete();


    /**
       GSL has different types of random genenerators. This function 
       returns the one used.
    */
    std::string get_generator_type(void) const;

    ///
    /// Operator for STL
    ///
    ///inline double operator()(void) { return get_uniform_double();}


    /**
       Destructor returning memory using GSL free functions
    */
    ~random_singleton();
  }; // random_singleton
  
  struct my_uniform_rng
  {
  public:
    inline u_long operator()(u_long i) {
      return random_singleton::get_instance()->get_uniform_int(i);
    }
  };

double random_singleton::get_exponential( const double& mu ) const
{
  return gsl_ran_exponential( r_, mu );
}


double random_singleton::get_gaussian( const double& sigma ) const
{
  return gsl_ran_gaussian( r_, sigma );
}


inline std::string random_singleton::get_generator_type() const
{ 
  return static_cast<std::string>( gsl_rng_name( r_ ) );
}


size_t random_singleton::get_rnd_discrete()
{
  return gsl_ran_discrete( r_, gen_ );
}


int random_singleton::get_seed() const
{
  return gsl_rng_default_seed;
}


double random_singleton::get_uniform_double() const
{
  return gsl_rng_uniform( r_ );
}


u_long random_singleton::get_uniform_int(const u_long n) const
{
    return ( n ? gsl_rng_uniform_int(r_,n) : gsl_rng_get( r_ ));
}


u_long random_singleton::get_uniform_min() const
{
  return gsl_rng_min( r_ );
}


u_long random_singleton::get_uniform_max() const
{
  return gsl_rng_max( r_ );
}


void random_singleton::set_general_distribution_prob( const size_t& k, 
                  const double* p )
{
  gen_ = gsl_ran_discrete_preproc( k, p ); 
}

}} // of namespace utility and namespace theplu

#endif