CORE_StdValField.h

#ifndef CORE_StdValField_H
#define CORE_StdValField_H
 
//inherited header
#include "CORE_Field.h"
 
//corresponding array header
#include "CORE_StdValArray.h"
 
template <typename T,typename K,K D>
class CORE_StdValField : public CORE_Field<T,K,D,CORE_StdValArray<T>,CORE_StdValField<T,K,D>> {
    
private:
    
    //This class type
    typedef CORE_StdValField<T,K,D>  Self;
    
    
    
    // CONSTRUCTORS
public:
    CORE_StdValField() : CORE_Field<T,K,D,CORE_StdValArray<T>,Self>() {
    }
    
   
    
    // DESTRUCTORS
    virtual ~CORE_StdValField() {
    }
    
    
private:
    
    
    
    
    //MEMORY
    //=====
public:
    virtual  tMemSize getMemorySize() const override {
        return sizeof(*this)+this->getContentsMemorySize();
    }
    
    //allocation methods
    //===================
    
public:
    static inline CORE_UniquePointer<Self> New() {
        return CORE_UniquePointer<Self>(new Self(),CORE_Object::Delete());
    }
    
   
    
    
    //accessor operators
    //====================
    
 
    //accessor iterator
    //=================
    
    
    //accessor methods
    //=================
    
    
    //assignment operators
    //====================
    inline  Self& operator=(const T& v)  {
        initialize(v);
        return *this;
    }
    inline Self& operator=(const std::initializer_list<T>& values)  {
        this->copy(values);
        return *this;
    }
    inline Self& operator=(std::initializer_list<T>&& values)  {
        this->copy(values);
        return *this;
    }
    
   
    template<size_t N,typename Q>
    inline  Self& operator=(const std::array<Q,N>& values)  {
        copy(values);
        return *this;
        
    }
    
    template<typename Q>
    inline  Self& operator=(const std::valarray<Q>& values)  {
        copy(values);
        return *this;
    }
    
    template<typename Q>
    inline  Self& operator=(const std::vector<Q>& values)  {
        copy(values);
        return *this;
    }
 
    inline  Self& operator=(const Self& values)  {
        copy(values);
        return *this;
    }
    inline  Self& operator=(Self&& values)  {
        copy(values);
        return *this;
    }
 
    template<typename Q,class S1,class I1>
    inline  Self& operator=(const CORE_Field<Q,K,D,S1,I1>& values)  {
        copy(values);
        return *this;
    }
    template<typename Q,class S1,class I1>
    inline  Self& operator=(CORE_Field<Q,K,D,S1,I1>&& values)  {
        copy(values);
        return *this;
    }
    
   
     //initializers methods
    //====================
    
 
    template<typename Q>
    inline void initialize(const std::array<Q,D>& a) {
        auto iA=a.begin();
        auto iAe=a.end();
        //compute Vi:=Vi/norm
        auto F=[&iA,&iAe](auto& Vi) {
                 
                   //compute Vi:=Vi/norm
                   auto Vid=&Vi;
                   std::for_each(iA,iAe,[&Vid](const auto& Aid){(*Vid)=Aid;Vid++;});
 
                   //return the value
                   return Vi;
               };
        
        //apply the function F
        std::transform(this->sbegin(),this->send(),
                       this->sbegin(),F);
    }
    
    
    
 
    
    
    //compound assignement operators (+=,-=,*=,/=,^=...)
    //===================================================
      //arithmetic type compound operators
    //====================================
    inline Self& operator+=(const T& v) {
        this->getStorage()+=v;
        return (*this);
    }
    inline Self& operator-=(const T& v) {
        this->getStorage()-=v;
        return (*this);
      
    }
    
    inline Self& operator*=(const T& v) {
        this->getStorage()*=v;
        return (*this);
        
    }
    inline Self& operator/=(const T& v) {
        this->getStorage()/=v;
        return (*this);
    }
 
    //integer type compond operators
    //===============================
    inline Self& operator%=(const T& v) requires functions_type::isIntegerType<T>{
        this->getStorage()%=v;
        return (*this);
    }
    
    inline Self& operator&=(const T& v) requires functions_type::isIntegerType<T>{
        this->getStorage()&=v;
        return (*this);
    }
    
    inline Self& operator|=(const T& v) requires functions_type::isIntegerType<T>{
        this->getStorage()|=v;
        return (*this);
    }
    
    inline Self& operator^=(const T& v) requires functions_type::isIntegerType<T> {
         this->getStorage()^=v;
        return (*this);
    }
    inline  Self& operator<<=(const T& v) requires functions_type::isIntegerType<T> {
        this->getStorage()<<=v;
        return (*this);
    }
    
    inline Self& operator>>=(const T& v) requires functions_type::isIntegerType<T> {
        this->getStorage()>>=v;
        return (*this);
    }
    
    //class type compound operatos
    //=============================
    
    template<class Q,class S,class I>
    inline Self& operator+=(const CORE_Field<Q,K,D,S,I>& X) {
        this->getStorage()+=X.getStorage();
        return (*this);
    }
    template<class Q,class S,class I>
    inline Self& operator-=(const CORE_Field<Q,K,D,S,I>& X) {
        this->getStorage()-=X.getStorage();
        return (*this);
    }
    template<class Q,class S,class I>
    inline Self& operator*=(const CORE_Field<Q,K,D,S,I>& X) {
        //T=F(T,V)
        this->getStorage()*=X.getStorage();
        return (*this);
    }
    template<class Q,class S,class I>
    inline Self& operator/=(const CORE_Field<Q,K,D,S,I>& X) {
        this->getStorage()/=X.getStorage();
        return (*this);
    }
    
 
    //transform methods
    //=================
    
   
 
    template<typename LambdaFct>
    static inline void ElementsTransform(LambdaFct&& F,
                                         Self& X) {
         
        std::transform(X.sbegin(),X.send(),
                       X.sbegin(),F);
        
    }
    
  
    template<typename LambdaFct>
    inline void elementsTransform(LambdaFct&& F) {
        this->ElementsTransform(F,(*this));
    }
    
   
   
    inline void normalize()  {
      
        //error to detect null
        T eps=std::numeric_limits<T>::epsilon();
 
        T norm=0;
 
        
        //compute Vi:=Vi/norm
        auto F=[&norm,&eps](auto& Vi) {
                   //compute Norm2
                   norm=0;
                   std::for_each_n(&Vi,D,[&norm](const auto& Vid){
                                             norm+=Vid*Vid;
                                         });                        
 
                   //compute invers of norm
                   if (norm>eps) {
                       norm=1./sqrt(norm);
                   }
                   
                   //compute Vi:=Vi/norm
                   std::for_each_n(&Vi,D,[&norm](auto& Vid){Vid*=norm;});
 
                   //return the value
                   return Vi;
               };
        
        //apply the function F
        // T* start=&(*(this->sbegin()));
        // T* end=&(*(this->send()));
        // std::cout<<"start:"<<start<<" end:"<<end<<" length="<<(end-start)<<"\n";
        std::transform(this->sbegin(),this->send(),
                       this->sbegin(),F);
        
    }
    
   
    //Data consistency
    //=================
   
 
    //transform methods
    //==================
  
 
    //algebric methods
    //================
    
   
     
    template<class I>
    inline void mod2(CORE_Array<T,I>& X) const {
        X.setSize(this->getElementsNumber());
        auto Vi=this->csbegin();
        for(auto & Xi : X) {
            Xi=0;
            std::for_each_n(&(*Vi),D,[&Xi](const auto& Vid) {Xi+=Vid*Vid;});
            Vi++;
        }
        
    }
    
    
    template<class Q,class S1,class I1>
    inline T& scalarProduct(const CORE_Field<Q,K,D,S1,I1>& X,T& s)  const  {
        return this->getStorage().scalarProduct(X.getStorage(),s);
    }
    
    template<class Q,class S1,class I1>
    inline T& scalarProduct(const std::valarray<Q>& weights,const CORE_Field<Q,K,D,S1,I1>& X,T& s)  const  {
         //number of elements
        tIndex n=this->getElementsNumber();
 
        
       
 
        if (weights.size()==0) {
            return CORE_Field<T,K,D,CORE_StdValArray<T>,Self>::scalarProduct(X,s);
        }
 
        //increment of W
        tBoolean incW=(weights.size()>1);
        //values of W
        const tReal *iWs=&weights[0];
 
        //values of this
        const T* iYs=this->getValues();
        const T* iYe=iYs+n*D;
        const T* iYd=null;
        
        //values of X
        const Q* iXs=X.getValues();
        tBoolean incX=(X.getElementsNumber()>1);
        const Q* iXd=null;
        
        //s=sum_i  Xi Yi
        s=0;
        while (iYs!=iYe) {//loop on elements
            iYd=iYs+D;
            iXd=iXs;
            while(iYs!=iYd) {//loop on D
                s+=(*iWs)*(*iXd)*(*iYs);
                iYs++;
                iXd++;
            }//end loop on D
            iWs+=incW;
            iXs+=incX*D;
        }//end loop on element
        
        return s;
    }
      
    
};
 
 
#ifndef DIMENSION_TYPE
#define  DIMENSION_TYPE
typedef  tUCInt tDimension;//d in [0,256[
#endif
 
typedef  CORE_StdValField<tReal,tDimension,3> CORE_Real3DValField;
 
 
 
 
#endif