CORE_StdPtrArray.h

#ifndef CORE_StdPtrArray_H
#define CORE_StdPtrArray_H
 
#include "CORE_PtrArray.h"
 
//numeric functions headers
#include "functions_numeric.h"
 
template <typename T>
class CORE_StdPtrArray : public CORE_PtrArray<T,CORE_StdPtrArray<T>> {
 
private:
    
    //This class type
    typedef CORE_StdPtrArray<T>  Self;
    
    
 
    // CONSTRUCTORS
public:
    CORE_StdPtrArray() : CORE_PtrArray<T,Self>() {
    }
    CORE_StdPtrArray(const  CORE_PtrArray<T,Self>& c) {
        copy(c);
    }
 
 
    
    // DESTRUCTORS
    virtual ~CORE_StdPtrArray() {
    }
    
    
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)  {
        copy(values.size(),values);
        return *this;
    }
       
    inline Self& operator=(std::initializer_list<T>&& values)  {
        copy(values.size(),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=(const Self&& values)  {
        copy(values);
        return *this;
    }
 
    template<typename Q,class I1>
    inline  Self& operator=(const CORE_Array<Q,I1>& values)  {
        copy(values);
        return *this;
    }
    template<typename Q,class I1>
    inline  Self& operator=(const CORE_Array<Q,I1>&& values)  {
        copy(values);
        return *this;
    }
    
   
    
    
    
    //copy methods
    //=============
 
     
    template<typename Q,class I>
    inline void copy(const CORE_Array<Q,I>& cpy) {
        this->setSize(cpy.getSize());
        Copy(cpy.getSize(),cpy.getValues(),this->getValues());
    }
   
    template<typename Q,class I>
    inline void copy(CORE_Array<Q,I>&& cpy) {
        this->setSize(cpy.getSize());
        Copy(cpy.getSize(),cpy.getValues(),this->getValues());
    }
   
    template<class I>
    inline void copy(const Self& cpy) {
        this->setSize(cpy.getSize());
        Copy(cpy.getSize(),cpy.getValues(),this->getValues());
    }
   
    template<class I>
    inline void copy(Self&& cpy) {
        this->setSize(cpy.getSize());
        Copy(cpy.getSize(),cpy.getValues(),this->getValues());
    }
 
  
    template<typename Q>
    inline void copy(const tIndex& n , const Q* Vs) {
        this->setSize(n);
        Copy(n,Vs,this->getValues());
    }
    
    inline void copy(const tIndex& n,const std::initializer_list<T>& Vs) {
        tIndex p=functions_numeric::min(n,Vs.size());
        this->setSize(p);
        Copy(p,Vs,this->getValues());
    }
    inline void copy(const tIndex& n,std::initializer_list<T>&& Vs) {
        tIndex p=functions_numeric::min(n,Vs.size());
        this->setSize(p);
        Copy(p,Vs,this->getValues());
    }
    template<typename Q,size_t N>
    inline void copy(const tIndex& n,const std::array<Q,N>& Vs) {
        tIndex p=functions_numeric::min(n,N);
        this->setSize(p);
        Copy(p,Vs.getData(),this->getValues());
    }
    
    template<typename Q>
    inline void copy(const tIndex& n,const std::valarray<Q>& Vs) {
        tIndex p=functions_numeric::min(n,Vs.size());
        this->setSize(p); 
        Copy(p,&Vs[0],this->getValues());
    }
    template<typename Q>
    inline void copy(const tIndex&n , const std::vector<Q>& Vs) {
        tIndex p=functions_numeric::min(n,Vs.size());
        this->setSize(p);
        Copy(Vs.size(),Vs,this->getValues());
    }
   
 
    //static Copy
    //===========
  
    
    template<typename Q>
    inline static void Copy(const tIndex& n,const Q* X,T* R) {
       
        //begin iterator of X
        const Q* iX=X;
        
        //begin iterator of R
        T* iR=R;
 
        if (sizeof(T)==sizeof(Q)) {
             memcpy(iR,iX,sizeof(T)*n);
        } else {
            //en iterator of R
            const T* iRe=R+n;
            
            //loop on values
            while (iR!=iRe) {
                (*iR)=(*iX);
                iR++;
                iX++;
            }
        }
    }
 
      
    template<typename Q>
    inline static void Copy(const tIndex& n,const std::vector<Q>& X,T* R) {
 
        //begin iterator of R
        T *iR=R;
        //end iterator on R
        T *iRe=R+n;
        
        //begin iterator of X
        auto iX=X.cbegin();
        
        while (iR!=iRe) {
            (*iR)=(*iX);
            iR++;
            iX++;
        }
    }
        
    inline static void Copy(const tIndex& n,std::initializer_list<T> X,T* R) {
 
      
        
        //begin iterator of R
        T *iR=R;
        //end iterator on R
        T *iRe=R+n;
        
        //begin iterator of X
        auto iX=X.begin();
        
        while (iR!=iRe) {
            (*iR)=(*iX);
            iR++;
            iX++;
        }
    }
 
    
    //initializers methods
    //====================
 
    inline void initialize(const T& v) {
        if (this->getSize()>0) {
            if (fabs(v)<std::numeric_limits<T>::epsilon()) {
                memset(this->getValues(),0,this->getSize()*sizeof(T));
            } else {
                //begin iterator of R=This
                T *iR=this->getValues();
                //begin iterator of R
                const T* iRe=iR+this->getSize();
                
                //loop on values
                while (iR!=iRe) {
                    (*iR)=v;
                    iR++;
                }
            }
        }
    }
    
    inline static void UniformRandomize(const T& min,const T& max,const tIndex& n,T* values){
       
        T alpha=(max-min)/RAND_MAX;
 
        //begin iterator
        T* iV=values;
        const T* iVe=values;
        iVe+=n;
 
        //loops:
        while (iV<iVe) {
            (*iV)=alpha*((T)std::rand())+min;
            iV++;
        }
    }
   
   
 
    inline void uniformRandomize(const T& min,const T& max) {
        UniformRandomize(min,max,this->getSize(),this->getValues());
    }
    
    
    //compound assignement operators (+=,-=,*=,/=,^=...)
    //===================================================
 
    //arithmetic type compound operators
    //====================================
    
    inline Self& operator+=(const T& v) {
        Add(v,this->getSize(),this->getValues());
        return (*this);
    }
    inline Self& operator-=(const T& v) {
        Add(-v,this->getSize(),this->getValues());
        return (*this);
      
    }
    
    inline Self& operator*=(const T& v) {
        Multiply(v,this->getSize(),this->getValues());
        return (*this);
        
    }
    inline Self& operator/=(const T& v) {
        if (fabs(v)<std::numeric_limits<T>::epsilon()) {
            throw CORE_Exception("core",
                                 "CORE_StdPtrArray/=",
                                 "division by 0");
        }
        Multiply(1./v,this->getSize(),this->getValues());
        return (*this);
    }
 
    //integer type compound operators
    //===============================
    inline Self& operator%=(const T& v) requires functions_type::isIntegerType<T>   {
        transform([&v](const auto& x){return x%v;});
        return (*this);
    }
    
    inline Self& operator&=(const T& v) requires functions_type::isIntegerType<T>  {
        transform([&v](const auto& x){return x&v;});
        return (*this);
    }
    
    inline Self& operator|=(const T& v) requires functions_type::isIntegerType<T> {
        transform([&v](const auto& x){return x|v;});
        return (*this);
    }
 
    inline Self& operator^=(const T& v) requires functions_type::isIntegerType<T> {
        transform([&v](const auto& x){return x^v;});
        return (*this);
    }
    inline Self& operator<<=(const T& v) requires functions_type::isIntegerType<T> {
        transform([&v](const auto& x){return x<<v;});
        return (*this);
    }
    
    inline Self& operator>>=(const T& v) requires functions_type::isIntegerType<T>  {
        transform([&v](const auto& x){return x>>v;});
        return (*this);
    }
 
    //class type compound operatos
    //=============================
    
    template<typename Q,class I>
    inline Self& operator+=(const CORE_Array<Q,I>& X) {
        //min dimension
        tIndex p=functions_numeric::min(X.getSize(),this->getSize());
        Add(p,X.getValues(),this->getValues());
        return (*this);
    }
    
    template<typename Q,class I>
    inline Self& operator-=(const CORE_Array<Q,I>& X) {
        tIndex p=functions_numeric::min(X.getSize(),this->getSize());
        Sub(p,X.getValues(),this->getValues());
        return (*this);
    }
    template<typename Q,class I>
    inline Self& operator*=(const CORE_Array<Q,I>& X) {
        //min dimension
        tIndex p=functions_numeric::min(X.getSize(),this->getSize());
        Multiply(p,X.getValues(),this->getValues());
        return (*this);
    }
 
  
    template<typename Q,class I>
    inline Self& operator/=(const CORE_Array<Q,I>& X) {
        tIndex p=functions_numeric::min(X.getSize(),this->getSize());
        Divide(p,X.getValues(),this->getValues());
        return (*this);
    }
    
  
    //transform methods
    //=================
 
    
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F) {
        Transform(F,(*this));
    }
   
    template<typename LambdaFct>
        inline void transform(LambdaFct&& F,
                              const CORE_Array<T,Self>& X) {
        Transform(F,X,(*this));
    }
   
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F,
                          const CORE_Array<T,Self>& X,
                          const CORE_Array<T,Self>& Y) {
       
        Transform(F,X,Y,*this);
    }
    
    template<typename LambdaFct>
    static inline void Transform(LambdaFct&& F,
                                 Self& R) {
        std::transform(R.cbegin(),R.cend(),R.begin(),F);
    }
    
   
    template<typename LambdaFct>
    static inline void Transform(LambdaFct&& F,
                                 const CORE_Array<T,Self>& X,
                                 Self& R) {
        R.setSize(X.getsize());
        std::transform(X.cbegin(),X.cend(),R.begin(),F);
    }
  
    template<typename LambdaFct>
    static inline void Transform(LambdaFct&& F,
                                 const CORE_Array<T,Self>& X,
                                 const CORE_Array<T,Self>& Y,
                                 Self& R) {
        if (X.getSize()!=Y.getSize())
            throw CORE_Exception("core",
                                 "CORE_StdPtrArray::Transform(F,X,Y,R)",
                                 "X ("+std::to_string(X.getSize())+") & Y ("+std::to_string(Y.getSize())+") have not same size");
        
                                                       
        R.setSize(X.getSize());
        std::transform(X.cbegin(),X.cend(),
                       Y.cbegin(),
                       R.begin(),F);
    }
    template<typename Q>
    inline static void Add(const Q& X,const tIndex& n,T* R) {
       
        //iterator on R
        T* iR=R;
        
        //iterator at end of R
        const T* iRe=iR;iRe+=n;
        
        while (iR!=iRe) {//loop on index
            (*iR)+=X;//This[i]+=X[i]
            iR++;
        } 
    }
    template<typename Q>
    inline static void Add(const tIndex& n,const Q* X,T* R) {
        
        
        //iterator on X
        const Q* iX=X;
        
        //iterator on R
        T* iR=R;
        
        //iterator at end of R
        const T* iRe=iR;iRe+=n;
        
        while (iR!=iRe) {//loop on index
            (*iR)+=(*iX);//This[i]+=X[i]
            iX++;
            iR++;
        } 
    }
    template<typename Q>
    inline static void Sub(const tIndex& n,const Q* X,T* R) {
        
        
        //iterator on X
        const Q* iX=X;
        
        //iterator on R
        T* iR=R;
        
        //iterator at end of R
        const T* iRe=iR;iRe+=n;
        
        while (iR!=iRe) {//loop on index
            (*iR)-=(*iX);//This[i]-=X[i]
            iX++;
            iR++;
        } 
    }
 
    
    template<typename Q>
    requires functions_type::isArithmeticType<Q>
    inline static void Multiply(const Q& X,const tIndex& n,T* R) {
        
       
        
        //iterator on R
        T* iR=R;
        
        //iterator at end of R
        const T* iRe=iR;iRe+=n;
        
        while (iR!=iRe) {//loop on index
            (*iR)*=X;//This[i]*=X
            iR++;
        } 
    }
 
 
    template<typename Q>
    inline static void Multiply(const tIndex& n,const Q* X,T* R) {
        
        
        //iterator on X
        const Q* iX=X;
        
        //iterator on R
        T* iR=R;
        
        //iterator at end of R
        const T* iRe=iR;iRe+=n;
        
        while (iR!=iRe) {//loop on index
            (*iR)*=(*iX);//This[i]*=X[i]
            iX++;
            iR++;
        } 
    }
    template<typename Q>
    inline static void Divide(const tIndex& n,const Q* X,T* R) {
 
        Q eps=std::numeric_limits<Q>::epsilon();
        
        //iterator on X
        const Q* iX=X;
        
        //iterator on R
        T* iR=R;
        
        //iterator at end of R
        const T* iRe=iR;iRe+=n;
        
        while (iR!=iRe) {//loop on index
            if (fabs(*iX)<eps) {
                throw CORE_Excpetion("core","CORE_StdPtrArray::Divide(n,X,X)",
                                     "division by 0 at index "+std::to_string(iX-X));
            }
            (*iR)/=(*iX);//This[i]*=X[i]
            iX++;
            iR++;
        } 
    }
 
    
    
 
    inline void normalize() {
        Normalize(this->getSize(),this->getValues());
    }
 
    template<typename Q, size_t N>
    static void Normalize(std::array<Q,N>& a) {
        Normalize(N,a.data());
    }
    static void Normalize(const tIndex& n,T* values) {
        T norm=0;
        
        T* iV=values;//iterator on values
 
        const T* iVe=iV;//end iterator on values
        iVe+=n;
 
        //loop on elements to compute norm
        while (iV!=iVe) {norm+=(*iV)*(*iV);iV++;}
        
        //compute inverse of norm
        if (norm>std::numeric_limits<T>::epsilon()) {
            norm=sqrt(1./norm);
        }
        //update the values
        iV=values;
        while (iV!=iVe) {(*iV)*=norm;iV++;}
        
    }
 
    template<typename Q,class I>
    inline void axpy(const Q& alpha, const CORE_Array<Q,I>& X,const T& beta) {
        tIndex p=functions_numeric::min(X.getSize(),this->getSize());
        AXPY(p,alpha,X.getValues(),beta,this->getValues());
    }
 
 
    
    template<typename Q>
    inline void AXPY(const tIndex& n,const Q& alpha, const Q* X,const T& beta,T* Y) {
        const Q* iX=X;
        T *iY=Y;
        const T *iYe=iY+n;
        while (iY!=iYe) {
            (*iY)=beta*(*iY)+alpha*(*iX);
            iX++;
            iY++;
        }
    }
    
    
    //Data consistency
    //=================
    inline  tBoolean isNANContained() const {
        return IsNANContained(this->getSize(),this->getValues());
    }
    inline  static tBoolean IsNANContained(const tIndex& n , const T* values) {
        //loop on all values and stop the loop when the first nan value is found and return true
        //return false otherwise
        const T* iR=values;
        const T* iRe=iR+n;
        while (iR!=iRe) {
            if (std::isnan(*iR)) return true;
            iR++;
        }
        return false;
    }
 
 
    //algebric methods
    //================
    
    
   
    inline void sum(T& s) const {
        s=Sum(this->getSize(),this->getValues());
    }
      
   
    inline static T Sum(const tIndex& n,const T* values)  {
        const T* iR=values;
        const T* iRe=iR+n;
        T s=0;
        while (iR!=iRe) {
            s+=(*iR);
            iR++;
        }
        return s;
    }
    
    inline void prod(T& prod) const {
         prod=Prod(this->getSize(),this->getValues());
    }
    inline static T Prod(const tIndex& n,const T* values) {
        const T* iR=values;
        const T* iRe=iR+n;
        T p=1;
        while (iR!=iRe) {
            p*=(*iR);
            iR++;
        }
        return p;
    }
  
     
    template<typename Q,class I>
    inline T&  scalarProduct(const CORE_Array<Q,I>& X,T& s)  const  {
        tIndex n=functions_numeric::min(this->getSize(),X.getSize());
        s=ScalarProduct(n,X.getValues(),this->getValues());
        return s;
    }
 
    
    template<typename Q>
    inline static T ScalarProduct(const tIndex n,const Q* X,const T* Y)    {
 
        //s=\sum_{i=0}^{n-1} X[i].Y[i]
        
        T s=0;
        
        //iterator on Y
        const T* iY=Y;
        //iterator on X
        const Q* iX=X;
        //ietrator at end of X
        const Q* iXe=iX;iXe+=n;
        
        while (iX!=iXe) {
            s+=(*iX)*(*iY);
            iX++;
            iY++;
        }
        
        return s;
    }
   
    inline tReal l2Norm2()  const  {
        return L2Distance2(0,(T*)null,this->getSize(),this->getValues());
    }
    template<typename Q,class I>
    inline tReal l2Distance2(const CORE_Array<Q,I>& X)  const  {
        return L2Distance2(X.getSize(),X.getValues(),this->getSize(),this->getValues());
    }
    inline tReal linfDistance(tIndex& imax)  const  {
        return LinfDistance(0,(T*)null,
                            this->getSize(),this->getValues(),
                            imax);
    }
    template<typename Q,class I>
    inline tReal linfDistance(const CORE_Array<Q,I>& X,tIndex& imax)  const  {
        return LinfDistance(X.getSize(),X.getValues(),
                            this->getSize(),this->getValues(),
                            imax);
    }
    
    template<typename Q>
    inline static tReal  L2Distance2(const tIndex& nX,const Q* Xs,
                                     const tIndex& nY,const T* Ys) {
        tIndex p=functions_numeric::min(nX,nY);
        tReal s=0;
        const Q* iX =Xs;
        const Q* iXe=Xs+p;
        const T* iY =Ys;
        tReal tmp;
        //s+=|X_i-Y_i|^2 i in [0,p[
        while (iX!=iXe) {
            tmp=(*iX)-(*iY);
            s+=tmp*tmp;
            //next index
            iX++;
            iY++;
        }
        //s+=|X_i|^2 i in [p,nX[
        iXe=Xs+nX;
        while (iX!=iXe) {
            s=(*iX)*(*iX);
            //next index
            iX++;
        }
 
        //s+=|Y_i|^2 i in [p,nY[
        const T* iYe=Ys+nY;
        while (iY!=iYe) {
            s=(*iY)*(*iY);
            //next index
            iY++;
        }
        return s;
    }
    
    template<typename Q>
    inline static tReal  LinfDistance(const tIndex& nX,const Q* Xs,
                                      const tIndex& nY,const T* Ys,
                                      tIndex& imax) {
        tIndex p=functions_numeric::min(nX,nY);
        
        tReal s=0;
        imax=0;
        tIndex i=0;
        const Q* iX =Xs;
        const Q* iXe=Xs+p;
        const T* iY =Ys;
        tReal tmp;
        //s+=|X_i-Y_i|^2 i in [0,p[
        while (iX!=iXe) {
            tmp=std::fabs((*iX)-(*iY));
            if (tmp>s) {
                s=tmp;
                imax=i;
            }
            //next index
            iX++;
            iY++;
            i++;
        }
        //s+=|X_i|^2 i in [p,nX[
        iXe=Xs+nX;
        while (iX!=iXe) {
            tmp=std::fabs(*iX);
            if (tmp>s) {
                s=tmp;
                imax=i;
            }
            //next index
            iX++;
            i++;
        }
 
        //s+=|Y_i|^2 i in [p,nY[
        const T* iYe=Ys+nY;
        while (iY!=iYe) {
            tmp=std::fabs(*iY);
            if (tmp>s) {
                s=tmp;
                imax=i;
            }
            //next index
            iY++;
            i++;
        }
        return s;
    }
    
    
    //ordered type  methods
    //=======================
      
    inline void min(T& m) const requires functions_type::isOrderedType<T> {
        m=Min(this->getSize(),this->getValues());
    }
    inline static T Min(const tIndex& n ,const T* values) requires functions_type::isOrderedType<T> {
        const T* iR=values;
        const T* iRe=iR+n;
        T minValue=(*iR);
        while (iR!=iRe) {
            minValue=((*iR)<minValue)?(*iR):minValue;
            iR++;
        }
        return minValue;
    }
    inline void max(T& m) const requires functions_type::isOrderedType<T> {
        m=Max(this->getSize(),this->getValues());
    }
    
    
    inline static T Max(const tIndex& n ,const T* values) requires functions_type::isOrderedType<T> {
        const T* iR=values;
        const T* iRe=iR+n;
        T maxValue=(*iR);
        while (iR!=iRe) {
            maxValue=((*iR)>maxValue)?(*iR):maxValue;
            iR++;
        }
        return maxValue;
    }
 
    
    
    inline void directionalSort(const tUChar& order) requires functions_type::isOrderedType<T>{
        switch(order) {
        case 'i':
            std::sort(this->begin(),this->end(),std::less<T>());
            break;
        case 'd':
            std::sort(this->begin(),this->end(),std::greater<T>());
            break;
        }
        
    }
    
};
 
 
 
typedef  CORE_StdPtrArray<tReal> CORE_RealPtrArray;
 
typedef  CORE_StdPtrArray<tBoolean> CORE_BooleanPtrArray;
 
typedef  CORE_StdPtrArray<tInteger> CORE_IntegerPtrArray;
typedef  CORE_StdPtrArray<tRelativeInteger> CORE_RelativeIntegerPtrArray;
 
 
//default array
#ifndef DEFAULT_ARRAY
#define DEFAULT_ARRAY
typedef CORE_RealPtrArray CORE_RealArray;
 
typedef CORE_BooleanPtrArray CORE_BooleanArray;
 
typedef CORE_IntegerPtrArray CORE_IntegerArray;
typedef CORE_RelativeIntegerPtrArray CORE_RelativeIntegerArray;
#endif
 
#endif