SM_Field.h

#ifndef SM_Field_H
#define SM_Field_H
 
 
//base class header
#include "CORE_Field.h"
 
//runner header
#include "CORE_Run.h"
 
//io header
#include "CORE_IO.h"
 
//SM_Object header
#include "SM_Object.h"
 
//file stream header
#include <fstream>
//set precision header
#include<iomanip>
 
//field header
#include "CORE_StdPtrField.h"
 
//stochastic functions
#include "SM_MultiStochasticFunctions.h"
 
//constants header
#include "SM_Constants.h"
 
//openmp header
//#include "openMP.h"
 
template<typename T,typename K,tUCInt D>
class SM_Field : public CORE_StdPtrField<T,K,D>   {
    
    // ATTRIBUTES
private :
    typedef SM_Field<T,K,D> Self; 
    
public:
    // METHODS
    
    //  CONSTRUCTORS 
    
    SM_Field() {
       
    }
 
    SM_Field(std::initializer_list<T>&& values)  {
        this->copy(values);
    }
   
    
    
    // DESTRUCTORS 
    
    
    virtual ~SM_Field(void) {
    }
   
private:
 
    
 
public:
    // New class pointer
    //==================
    
    inline static CORE_UniquePointer<Self> New() {
        return CORE_UniquePointer<Self>(new Self(),CORE_Object::Delete());
    }
 
       
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
 
    //assignement operator
    Self& operator=(const T& v) {
        this->initialize(v);
        return (*this);
    }
    
    Self& operator=(const std::initializer_list<T>& cpy) {
        this->copy(cpy);
        return (*this);
    }
    Self& operator=(std::initializer_list<T>&& cpy) {
        this->copy(cpy);
        return (*this);
    }
    Self& operator=(const std::valarray<T>& cpy) {
        this->copy(cpy);
        return (*this);
    }
    Self& operator=(const std::array<T,D>& cpy) {
        this->copy(cpy);
        return (*this);
    }
    
    Self& operator=(const Self& cpy) {
        this->copy(cpy);
        return (*this);
    }
    Self& operator=(Self&& cpy) {
        this->copy(cpy);
        return (*this);
    }
    
  
    
    //mathematical operators
    //=======================
    
    template<class R>
    requires functions_type::isRealType<R>
    inline void addStochasticNoise(const R& epsilon,
                                   SM_MultiStochasticFunctionsInterface& fs) {
        
        tIndex n=this->getSize();
        T *Vs=this->getValues();
        //random function for the thread 0
        SM_StochasticFunctionsInterface& f=fs(0);
        
        //for each element of the array add a random number
        T *iV=Vs;
        const T *iVe=Vs;iVe+=n;
        
        while (iV!=iVe) {
            (*iV)+=epsilon*f.normalRandom();
            iV++;
            }
    }
    
    template<class R,class StochF>
    inline void addscStochasticNoise(const R& epsilon,
                                     SM_MultiStochasticFunctions<StochF>& fs) {
           
        tIndex n=this->getSize();
        T *Vs=this->getValues();
        
        
        //random function for the thread 0
        StochF& f=fs[0];
        
        //for each element of the array add a random number
        T *iV=Vs;
        const T *iVe=Vs;iVe+=n;
        
        while (iV!=iVe) {
            (*iV)+=epsilon*f.scNormalRandom();
            iV++;
        }
 
    }
 
 
  
    
    
public:
    // OTHERS methods
    
    
    
private:
 
 
  
};
 
 
 
typedef SM_Field<tReal,tDimension,SM_Constants::DIM> SM_RealField;
 
#endif