randomgen.h

Go to the documentation of this file.

/*
 *  randomgen.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef RANDOMGEN_H
#define RANDOMGEN_H

/*                                                          
 * Problems:                                                
 * Some problems remain to be solved:                       
 * -- portability has to be confirmed (on compilers other   
 *    than g++ and > 32 Bit architectures.                  
 *                                                          
 * History:                                                 
 *     (1) first version (<= V1.0) by Gewaltig              
 *     (2) rewritten for C++ (V2.0) by Diesmann 6.9.93      
 *         Note! The July 8,1993 Version contains an error  
 *         in random3 and in random2. In this Version the   
 *         correct lines are marked.                        
 *     (3) 16.9.93 class Normal is no longer a RNG   but    
 *         a deviation. This change was necessary to pre-   
 *         vent side effects in cases where random numbers  
 *         are used in several classes of one program.      
 *     (4) Rewritten C++ base class and three more          
 *         generators added.     (Gewaltig)                 
 *     (5) Completely re-designed: GSL based, randomdict    
 *         introduced (HEP)                                 
 *     (6) GSL and standalone version now provide the       
 *         knuthlfg originally introduced in (4)            
 *         Diesmann 21.08.02                                
 *     (7) virtual function binomial added as interface      
 *         for BinomialRandomDev to reach binomial function 
 *         of gslrandomgen                                  
 *     (8) Buffered drawing of RNG, all non-drand() methods 
 *         now go via drand(); binomial removed, now imple- 
 *         mented in BinomialRandomDev. (HEP, 28.06.04)     
 *     (9) All code derived from the GSL removed (HEP, 09.01.08).
 */

#include <vector>
#include <cmath>

#include "lockptr.h"

namespace librandom {

  class RandomGen;
  
  typedef lockPTR<RandomGen> RngPtr;

  class RandomGen {

  private:
    static const size_t DEFAULT_BUFFSIZE;

  public:

    RandomGen();

    // ensures proper clean up
    virtual ~RandomGen() {};
    
    double        drand(void);                 
    double        operator()(void);            
    double        drandpos(void);              
    unsigned long ulrand(const unsigned long); 

    void seed(const unsigned long);   

    size_t get_buffsize(void) const;  
    void set_buffsize(const size_t);  

    static RngPtr create_knuthlfg_rng(unsigned long);

    static const unsigned long DefaultSeed;  

    virtual RngPtr clone(const unsigned long) = 0;

  protected:

    virtual void seed_(unsigned long) =0;  
    virtual double drand_() =0;            

  private:

    void refill_();    

    std::vector<double> buffer_;               
    std::vector<double>::const_iterator next_; 
    std::vector<double>::const_iterator end_;  

    // prohibit copying of RNG
    RandomGen(const RandomGen&);
    
  };
  
  class GenericRNGFactory 
  {
  public:
    virtual RngPtr create(unsigned long) const =0;
    
    virtual ~GenericRNGFactory() {}
  };

  template <typename Generator>
  class BuiltinRNGFactory : public GenericRNGFactory
  {
    RngPtr create(unsigned long s) const { return RngPtr(new Generator(s)); }
  };
  
  inline
  double RandomGen::drand(void)
  {
    if ( next_ == end_ )
      refill_();

    return *next_++;
  }

  inline
  double RandomGen::operator()(void)
  {
    return drand();
  }

  inline
  double RandomGen::drandpos(void)
  {
    double r;
    
    do {
      r = drand();
    } while ( r == 0.0 );

    return r;
  }

  inline
  unsigned long RandomGen::ulrand(const unsigned long n)
  {
    // no check for size of n required, since n is ulong
    return static_cast<unsigned long>(std::floor(n * drand()));
  }

  inline 
  size_t RandomGen::get_buffsize(void) const
  {
    return buffer_.size();
  }

}

#endif  // RANDOMGEN_H