RAND_RandomNumberDistribution.h

#ifndef RAND_RandomNumberDistribution_H
#define RAND_RandomNumberDistribution_H
 
//inherited class header
#include "RAND_Object.h"
 
//random number generator header
#include "RAND_RandomNumberGenerator.h"
 
template<typename T,class I,class D>
class RAND_RandomNumberDistribution : public   RAND_Object {
  
    // ATTRIBUTES
    
public:
   
  
   
private:
 
    //internal distribution 
    I *mDistribution;
   
    
    //class This
    typedef RAND_RandomNumberDistribution<T,I,D> Self;
    
  
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    RAND_RandomNumberDistribution(void) {
        mDistribution=null;
    }
  
  
  
    // DESTRUCTORS 
  
    
    virtual ~RAND_RandomNumberDistribution(void) {
        freeDistribution();
    }
  
  
public:
 
    
      //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=RAND_Object::getContentsMemorySize();
        mem+=(mDistribution==null)?0:sizeof(*mDistribution);
        
        return mem;
    }
 
private:
    inline void freeDistribution() {
        if (mDistribution!=NULL) delete mDistribution;
        mDistribution=null;
    }
protected:
    inline void initialize(I& dist) {
        freeDistribution();
        mDistribution=new I(dist);
    }
 
    // RANDOM  method
    // ==============
public:
    
    template<typename T1,class G,class D1>
    inline T random(RAND_RandomNumberGenerator<T1,G,D1>& generator)  {
        return (*mDistribution)(generator.getGenerator());
    }
 
 
    inline I& getDistribution() {
        return *mDistribution;
    }
    
    inline T minValue() const {
        mDistribution->min();
    }
    inline T maxValue() const {
        mDistribution->max();
    }
 
     
    inline tReal pdf(const T& x) const {
        return static_cast<const D*>(this)->pdf(x);
    }
    inline tReal  cdf(const T& x) const {
        return static_cast<const D*>(this)->cdf(x);
    }
    inline tReal icdf(const T& y) const {
        return static_cast<const D*>(this)->icdf(y);
    }
    
    
public:
    // OTHERS methods
 
 
 
};
 
#endif