RandomFuns.h

Go to the documentation of this file.

#ifndef __RANDOMFUNS_H 
#define __RANDOMFUNS_H 
 
#ifndef __INTFUNBASE_H
#include "jbltools/sfh/IntFunBase.h"
#endif /* #ifndef __INTFUNBASE_H */
 
#ifndef __FLOATFUNBASE_H
#include "jbltools/sfh/FloatFunBase.h"
#endif /* #ifndef __FLOATFUNBASE_H */

#include "jbltools/sfh/FloatFunPoR.h"       // needed for default argument 

class TH1;

// Class RandomFun

class RandomFun : public FloatFun {
  public: 
    // Constructors
    explicit RandomFun (const IntFun&     seed_,           
                        int               index_,          
                        const char       *name_ = 0        
                      );
             RandomFun (const IntFun&     seed_,           
                        int               index_,          
                        const std::string &name_           
                       );
             RandomFun (const IntFun&     seed1_,          
                        const IntFun&     seed2_,          
                        int               index_,          
                        const char       *name_ = 0        
                      );
             RandomFun (const IntFun&     seed1_,          
                        const IntFun&     seed2_,          
                        int               index_,          
                        const std::string &name_           
                       );
    virtual Float_FF operator() () const;
    
    virtual const FillIterator *getIterator() const;
    
    static long long iterate (long long i) {
      return (i*a + c) % m;
    }
    static long long toInt (Float_FF d) {
      return static_cast<long long>((d*m));
    }
    static Float_FF toDouble (long long i) {
      return (Float_FF)(i)/(Float_FF)(m);
    }
    static Float_FF generateNext (Float_FF d) {
      return toDouble(iterate(toInt(d)));
    }
    
  protected:
    const IntFun& seed;                                  
    int           index;                                 
    bool          cleanup;                               

    virtual ~RandomFun();
  private:  
    // See Press, Teukolsky, Vetterling & Flannery:
    // Numerical Recipies in C, 2nd. ed.,
    // Cambridge (Cambridge Univ. Press) 1992, p. 278.
    // http://library.lanl.gov/numerical/bookcpdf/c7-1.pdf
    static const long long a;
    static const long long c;
    static const long long m;
};

// Class GaussRandomFun
class GaussRandomFun : public FloatFun {
  public: 
    // Constructors
    explicit GaussRandomFun (const FloatFun& rnd_,          
                             double    mean_,         
                             double    sigma_,        
                             const char *name_ = 0    
                      );
             GaussRandomFun (const FloatFun& rnd_,          
                             double    mean_,         
                             double    sigma_,        
                             const std::string &name_          
                            );
    virtual Float_FF operator() () const;
    
    virtual const FillIterator *getIterator() const;
    
  protected:
    const FloatFun& rnd;                   
    double          mean;                  
    double          sigma;                 

    virtual ~GaussRandomFun() {}
};

// Class Poisson1Fun
class Poisson1Fun : public IntFun {
  public: 
    explicit Poisson1Fun (const FloatFun& rnd_,        
                          double          mean_,       
                          const char     *name_ = 0    
                         );
      
    explicit Poisson1Fun (const FloatFun&    rnd_,     
                          double             mean_,    
                          const std::string& name_     
                         ) 
      : IntFun (name_), 
        rnd(rnd_),
        mean (mean_)
      {}
      
    virtual int operator() () const;
    
    virtual const FillIterator *getIterator() const;
    
  protected:
    const FloatFun& rnd;                   
    double    mean;                        

    virtual ~Poisson1Fun() {} 
};

// Class Poisson2Fun
class Poisson2Fun : public IntFun {
  public: 
    explicit Poisson2Fun (const FloatFun&    rnd_,       
                          double             mean_,      
                          const char        *name_ = 0   
                         );
      
    explicit Poisson2Fun (const FloatFun&    rnd_,       
                          double             mean_,      
                          const std::string& name_       
                         );
      
    virtual int operator() () const;
    
    virtual const FillIterator *getIterator() const;
    
  protected:
    FloatFun& gaussrnd;              

    virtual ~Poisson2Fun();
};


// Class HistoRandomFun
class HistoRandomFun : public FloatFun {
  public: 
    explicit HistoRandomFun (const FloatFun&    rnd_,       
                             const TH1&         histo,      
                             const char        *name_ = 0   
                            );
      
             HistoRandomFun (const FloatFun&    rnd_,       
                             const TH1&         histo,      
                             const std::string& name_       
                            );
      
    virtual Float_FF operator() () const;
    
    virtual const FillIterator *getIterator() const;
    
  protected:
    const FloatFun& rnd;        
    int       nbins;            
    double   *edges;            
    double   *values;           

    void init (const TH1& histo 
              );
    virtual ~HistoRandomFun();
};


// Class HistoRandomIntFun
class HistoRandomIntFun : public IntFun {
  public: 
    explicit HistoRandomIntFun (const FloatFun&    rnd_,       
                                const TH1&         histo,      
                                const char        *name_ = 0   
                                );
      
             HistoRandomIntFun (const FloatFun&    rnd_,       
                                const TH1&         histo,      
                                const std::string& name_       
                               );
      
    virtual int operator() () const;
    
    virtual const FillIterator *getIterator() const;
    
  protected:
    const FloatFun& rnd;        
    int       nbins;            
    double   *edges;            
    double   *values;           

    void init (const TH1& histo 
              );
    virtual ~HistoRandomIntFun();
};




FloatFun& gauss (const FloatFunPoR& rnd,       
                 double mean,                  
                 double sigma                  
                 );

IntFun& poisson (const FloatFunPoR& rnd,       
                 double mean                   
                );

#endif /* #ifndef __RANDOMFUNS_H */

---