SM_Field.h

Go to the documentation of this file.

#ifndef SM_Field_H
#define SM_Field_H
 
 
//base class header
#include "CORE_Field.h"
 
//runner header
#include "CORE_Run.h"
 
//file stream header
#include <fstream>
//set precision header
#include<iomanip>
 
//stochastic function
#include "SM_TemplatedStochasticFunction.h"
 
//field header
#include "CORE_StdPtrField.h"
 
template<typename T,typename K>
class SM_Field : public CORE_StdPtrField<T,K,3>   {
    
    // ATTRIBUTES
private :
    typedef SM_Field<T,K> Self; 
    
public:
    // METHODS
    
    //  CONSTRUCTORS 
    
    SM_Field() {
       
    }
 
    SM_Field(std::initializer_list<T>&& values)  {
        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 Self& cpy) {
        this->copy(cpy);
        return (*this);
    }
    Self& operator=(Self&& cpy) {
        this->copy(cpy);
        return (*this);
    }
    
  
    
    //mathematical operators
    //=======================
    
    template<class R>
    requires core_functions::isRealType<R>
    inline void addStochasticNoise(const R& epsilon,
                                   SM_StochasticFunction& f) {
        //for each element of the array add a random number
        T *iV=this->getValues();
        const T *iVe=iV+this->getSize();
        while (iV!=iVe) {
            (*iV)+=epsilon*f.random();
            iV++;
        }
        
    }
  
    template<class R,class I>
    inline void addTemplatedStochasticNoise(const R& epsilon,
                                            SM_TemplatedStochasticFunction<I>& f) {
         //for each element of the array add a random number
        T *iV=this->getValues();
        const T *iVe=iV+this->getSize();
        while (iV!=iVe) {
            (*iV)+=epsilon*f.templatedRandom();
            iV++;
        }
    }
 
 
   
  
    
    
public:
    // OTHERS methods
    
    
    
private:
    
    
  
};
 
 
typedef SM_Field<tReal,tDimension> SM_RealField;
 
#endif