CORE_StdPtrField.h

#ifndef CORE_StdPtrField_H
#define CORE_StdPtrField_H
 
//inherited header
#include "CORE_Field.h"
 
//corresponding array header
#include "CORE_StdPtrArray.h"
 
template <typename T,typename K,K D>
class CORE_StdPtrField : public CORE_Field<T,K,D,CORE_StdPtrArray<T>,CORE_StdPtrField<T,K,D>> {
    
private:
    
    //This class type
    typedef CORE_StdPtrField<T,K,D>  Self;
    
    
    
    // CONSTRUCTORS
public:
    CORE_StdPtrField() : CORE_Field<T,K,D,CORE_StdPtrArray<T>,Self>() {
    }
    
   
    
    // DESTRUCTORS
    virtual ~CORE_StdPtrField() {
    }
    
    
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)  {
        this->initialize(v);
        return *this;
    }
    inline Self& operator=(std::initializer_list<T>&& values)  {
        this->copy(values);
        return *this;
    }
    inline Self& operator=(const 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)  {
        this->copy(values);
        return *this;
        
    }
    
    template<typename Q>
    inline  Self& operator=(const std::valarray<Q>& values)  {
        this->copy(values);
        return *this;
    }
    
    template<typename Q>
    inline  Self& operator=(const std::vector<Q>& values)  {
        this->copy(values);
        return *this;
    }
 
    inline  Self& operator=(const Self& values)  {
        this->copy(values);
        return *this;
    }
    inline  Self& operator=(Self&& values)  {
        this->copy(values);
        return *this;
    }
 
    template<typename Q,class S1,class I1>
    inline  Self& operator=(const CORE_Field<Q,K,D,S1,I1>& values)  {
        this->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 Q& v) {
        this->getStorage().initialize(v);
    }
    template<typename Q>
    inline void initialize(const std::array<Q,D>& a) {
        //begin iterator on a
        const Q* iA=a.data();
        //end iterator on a
        const Q *eA=iA+D;
 
        //begin iterator on values
        T* iV=this->getStorage().getValues();
        
        //end iterator on values
        const T* eV=iV+this->getSize();
        
        while (iV!=eV) {
            iA=a.data();
            while (iA!=eA) {
                (*iV)=(*iA);
                iV++;
                iA++;
            }
           
        }
    }
    template<typename Q>
    inline tBoolean  setSharedValues(const tIndex& capacity,const tIndex& size,Q* values) {
        return this->getStorage().setSharedValues(capacity,size,values);
    }
 
    template<typename Q>
    inline tBoolean  setSharedValues(const tIndex& capacity,Q* values) {
        return setSharedValues(capacity,capacity,values);
        
    }
    template<typename Q,class I1>
    inline tBoolean  setSharedValues(CORE_PtrArray<Q,I1>& array) {
        return setSharedValues(array.mCapacity,array.getSize(),array.getValues());
    }
    
    
    
    //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()  {
        Normalize(this->getSize(),this->getValues());
    }
    
    inline static void Normalize(const tIndex& n,T* values)  {
 
        //iterator on values
        T* iV=values;
        
        //end iterator on values
        T *iVe=values+n;
 
        //iterato on corrdinates of elements
        T* iVd=null;
        
        //end iterator on values for a D length
        T *iVde=null;
        
        T invNi;//inverse of the norm of the field Vi
 
        //error to detect null
        T eps=std::numeric_limits<T>::epsilon();
        
        while (iV!=iVe) {
            
            
                
            //invNi=\sum_{d=0}^{D-1} V_{i,d}
            invNi=0;
            iVd=iV;//begin of loop of size D
            iVde=iV+D;//end of loop on size D
            while (iVd!=iVde) {
                invNi+=(*iVd)*(*iVd);
                iVd++;
            }
            if (invNi>eps) {
                //not null value
                invNi=1./sqrt(invNi);
            } 
            //normalize vector i
            while (iV!=iVde) {
                (*iV)*=invNi;
                iV++;
            }
        }//end loop on elements
    }
    
   
    
    //Data consistency
    //=================
   
 
    //transform methods
    //==================
  
 
    //algebric methods
    //================
    
   
     
    template<class I>
    inline void mod2(CORE_Array<T,I>& X) const {
        //number of elements = size() / D
        tInteger n=this->getElementsNumber();
        
        //resize X  to n
        X.setSize(n);
 
        //start ietrator on values
        const T* iV=this->getValues();
        
        //end iterator on values
        const T* iVe=iV+n*D;
        
        //end iterator on values on dimension 
        const T* iVde=null;
        
        //start iterator on X
        T* iX=&X[0];
 
        while (iV!=iVe) {
 
            //loop only on D elements
            iVde=iV+D;
            //Xi=0
            (*iX)=0;
            //Xi=\sum_d Vi^2
            while (iV!=iVde) {
                (*iX)+=(*iV)*(*iV);
                iV++;
            }
            iX++;
        }
        
    }
 
    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_StdPtrArray<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;
    }
      
  
    
};
 
//defualt dimension
#ifndef DIMENSION_TYPE
#define DIMENSION_TYPE
typedef  tUCInt tDimension;//d in [0,256[
#endif
 
typedef  CORE_StdPtrField<tReal,tDimension,3> CORE_Real3DPtrField;
 
 
 
//default field
#ifndef DEFAULT_FIELD
#define DEFAULT_FIELD
typedef CORE_Real3DPtrField CORE_Real3DField ;
#endif
 
#endif