SM_MultiStochasticFunctions.h

#ifndef SM_MultiStochasticFunctions_H
#define SM_MultiStochasticFunctions_H
 
//base class header
#include "SM_MultiStochasticFunctionsInterface.h"
 
//uniform int distribution class
#include "RNDB_UniformIntDistribution.h"
//random number generator header
#include "RNDB_MT19937.h"
 
//stochastic function implemented headers
#include "SM_StochasticFunctions.h"
 
//OMP header
//#include "OMP_Thread.h"
 
template<class F>
class SM_MultiStochasticFunctions  : public SM_MultiStochasticFunctionsInterface  {
  
    // ATTRIBUTES
  
public:
   
  
   
private:
    typedef SM_MultiStochasticFunctions<F> SelfClass;
    typedef SM_MultiStochasticFunctionsInterface SuperClass;
 
    //seed int boost uniform generator
    RNDB_UniformIntDistribution mSeedDistribution;
    //random number generator 
    RNDB_MT19937 mSeedGenerator;
    
    //stochatic normal & uniform  functions per thread
    std::vector<CORE_UniquePointer<F>> mFs;
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    SM_MultiStochasticFunctions(void) {
       
    }
private:
   
  
  
  
    // DESTRUCTORS 
protected:
    
    virtual ~SM_MultiStochasticFunctions(void) {
    }
 
 
 
public:
    //MEMORY
    
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=SuperClass::getContentsMemorySize();
        for(const auto& f: mFs) mem+=f->getContentsMemorySize();
        mem+=mSeedDistribution.getContentsMemorySize();
        mem+=mSeedGenerator.getContentsMemorySize();
        return mem;
    }
public:
    // CREATE class
    inline static CORE_UniquePointer<SelfClass> New() {
        CORE_UniquePointer<SelfClass> p=CORE_UniquePointer<SelfClass>(new SelfClass(),
                                                                      CORE_Object::Delete());
        
        p->createFs();
        //return the boost stochastic function
        return p;
    }
    
private:
 
    inline void createFs() {
        // if (F::IsThreadSafe()) {
        //     tInteger nThreads=OMP_Thread::GetThreadsNumber();
        //     mFs.resize(nThreads);
        //     for(auto& f:mFs) {
        //         f=F::New();
        //     }
        // } else {
        mFs.resize(1);
        mFs[0]=F::New();
        //}
    }
    
public:
    virtual SM_StochasticFunctionsInterface& operator()(const tInteger& threadId) override {
        ASSERT_IN(threadId<mFs.size());
        return *mFs[threadId].get();
    }
    
    inline F& operator[](const tInteger& threadId) {
        ASSERT_IN(threadId<mFs.size());
        return *mFs[threadId].get();
    }
    inline const F& operator[](const tInteger& threadId) const {
        ASSERT_IN(threadId<mFs.size());
        return *mFs[threadId].get();
    }
    
    // SET & GET methods
    // =================
 
    virtual tInteger getSize() const final {
        return mFs.size();
    }
 
    virtual void setSeed(const tULLInt& seed) final {
        mSeedGenerator.setSeed(seed);
        for(auto& f:mFs) {
            f->setSeed(seed);
        }
    }
    
    virtual void setSeed() final {
        mSeedGenerator.setSeed();
        for(auto& f:mFs) {
            f->setSeed();
        }
        
    }
       
    virtual  void randomSeed(const tInteger& coresNumber,const tInteger& coreIndex) final {
        
        
        //number of threads per core
        tInteger threadsNumber=mFs.size();
       
        
        //generate the seed
        //tInteger nSeeds=coreIndex*threadsNumber;
 
        //genarate 1000 random numbers
        tULLInt seed=0;
        for(tInteger t=0;t<1000;t++) {
            seed=mSeedDistribution.random(mSeedGenerator);
        }
      
        //thread index: coreIndex*threadsNumber
        for(tInteger t=0;t<coreIndex*threadsNumber;t++) {
            seed=mSeedDistribution.random(mSeedGenerator);
        }
        
        //total number of threads : nCores x threadsNumber
        for(auto& f:mFs) {
            //jump number for the thread
            f->setSeed(seed);
            
            //generate the seed for the next thread
            seed=mSeedDistribution.random(mSeedGenerator);
          
        }
       
        
    }
    virtual  void jump(const tInteger& coresNumber,const tInteger& coreIndex,
                       const tULLInt& jumpsNumber,const tULLInt& nRNGs) final {
        
        
        //number of threads per core
        tInteger threadsNumber=mFs.size();
        
        //number of random number to generate by thread
        tULLInt nRNGs_thread=nRNGs/threadsNumber;
 
        //number of random number generated for threads t in [0,threadsNumber[ within coreIndex
        tULLInt S_t=jumpsNumber;
 
       
        
        //generate the seed
        //tInteger nSeeds=coreIndex*threadsNumber;
 
        //genarate 1000 random numbers
        tULLInt seed=0;
        for(tInteger t=0;t<1000;t++) {
            seed=mSeedDistribution.random(mSeedGenerator);
        }
      
        //thread index: coreIndex*threadsNumber
        for(tInteger t=0;t<coreIndex*threadsNumber;t++) {
            seed=mSeedDistribution.random(mSeedGenerator);
        }
        
        //total number of threads : nCores x threadsNumber
        for(auto& f:mFs) {
            //jump number for the thread
            f->jump(S_t,seed);
            
            //generate the seed for the next thread
            seed=mSeedDistribution.random(mSeedGenerator);
            
            //jumps numbe rfor next threads
            S_t+=nRNGs_thread;
        }
       
        
    }
    
 
    virtual tString toString() const override {
        std::stringstream ret;
        ret<<" number of stoachastic functions per core :" <<mFs.size()<<" of  type :"<<mFs[0]->toString()<<"\n";
        return ret.str();
    }
 
    
};
 
#endif