CORE_StdValArray.h

#ifndef CORE_StdValArray_H
#define CORE_StdValArray_H
 
#include "CORE_ValArray.h"
 
//numeric function headers
#include "functions_numeric.h"
 
template <typename T>
class CORE_StdValArray : public CORE_ValArray<T,CORE_StdValArray<T>> {
 
private:
    
    //This class type
    typedef CORE_StdValArray<T>  Self;
    
    
 
    // CONSTRUCTORS
public:
    CORE_StdValArray() : CORE_ValArray<T,Self>() {
    }
 
    explicit CORE_StdValArray(const tIndex& n) : CORE_ValArray<T,Self>(n)  {
    }
 
    
    // DESTRUCTORS
    virtual ~CORE_StdValArray() {
    }
    
    
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(N,values);
        return *this;
        
    }
    
    template<typename Q>
    inline  Self& operator=(const std::valarray<Q>& values)  {
        copy(values.size(),values);
        return *this;
    }
    
    template<typename Q>
    inline  Self& operator=(const std::vector<Q>& values)  {
        copy(values.size(),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>& X) {
        Copy(X,this->getArray());
    }
 
    template<typename Q,class I>
    inline void copy(CORE_Array<Q,I>&& X) {
        Copy(X,this->getArray());
    }
     
    template<typename Q,class I>
    inline void copy(const CORE_ValArray<Q,I>& cpy) {
        Copy(cpy.getArray(),this->getArray());
    }
   
    template<typename Q,class I>
    inline void copy(CORE_ValArray<Q,I>&& cpy)  {
        Copy(cpy.getArray(),this->getArray());
    }
    
   
    
    inline void copy(const Self& cpy) {
        Copy(cpy.getArray(),this->getArray());
    }
    
    inline void copy(Self&& cpy) {
       Copy(cpy.getArray(),this->getArray());
    }
 
  
 
    template<typename Q>
    inline void copy(const tIndex& n , const Q* Vs) {
        Copy(n,Vs,this->getArray());
    }
    
    inline void copy(const tIndex& n,const std::initializer_list<T>& Vs) {
        tIndex p=functions_numeric::min(n,Vs.size());
        Copy(p,Vs,this->getArray());
    }
    inline void copy(const tIndex& n,std::initializer_list<T>&& Vs) {
        tIndex p=functions_numeric::min(n,Vs.size());
        Copy(p,Vs,this->getArray());
    }
    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);
        Copy(p,Vs.getData(),this->getArray());
    }
    
    template<typename Q>
    inline void copy(const tIndex& n, const std::valarray<Q>& Vs) {
        tIndex p=functions_numeric::min(n,Vs.size());
        Copy(p,Vs,this->getArray());
    }
    template<typename Q>
    inline void copy(const tIndex& n, const std::vector<Q>& Vs) {
        tIndex p=functions_numeric::min(n,Vs.size());
        Copy(p,Vs,this->getArray());
    }
   
 
    //static copy
    //-----------
   
    
    inline static void Copy(const std::valarray<T>& X,std::valarray<T>& R) {
        R=X;
    }
    template<typename Q,class I>
    inline static void Copy(const CORE_Array<Q,I>& X,std::valarray<T>& R) {
        R.resize(X.getSize());
        auto iX=X.cbegin();
        std::for_each(std::ranges::begin(R),std::ranges::end(R),[&iX](auto& Ri){Ri=(*iX);iX++;});
    }
    template<class Q>
    inline static void Copy(const tIndex& n,const std::valarray<Q>& X,std::valarray<T>& R) {
        if (n==X.size()) {
            R.resize(n);
            R=X;
        } else {
            R.resize(n);
            auto iX=X.cbegin();
            std::for_each(std::ranges::begin(R),std::ranges::end(R),[&iX](auto& Ri){Ri=(*iX);iX++;});
        }
            
    }
    inline static void Copy(const tIndex& n,std::initializer_list<T>&& X,std::valarray<T>& R) {
        if (n==X.size()) {
            R.resize(n);
            R=X;
        } else {
            R.resize(n);
            auto iX=X.begin();
            std::for_each(std::ranges::begin(R),std::ranges::end(R),[&iX](auto& Ri){Ri=(*iX);iX++;});
        }
        
    }
 
    inline static void Copy(const tIndex& n,std::initializer_list<T> X,std::valarray<T>& R) {
        if (n==X.size()) {
            R.resize(n);
            R=X;
        } else {
            R.resize(n);
            auto iX=X.begin();
            std::for_each(std::ranges::begin(R),std::ranges::end(R),[&iX](auto& Ri){Ri=(*iX);iX++;});
        }
        
    }
  
    template<class Q>
    inline static void Copy(const tIndex& n,const std::vector<Q>& X,std::valarray<T>& R) {
         R.resize(n);
         auto iX=X.begin();
         std::for_each(std::ranges::begin(R),std::ranges::end(R),[&iX](auto& Ri){Ri=(*iX);iX++;});
    }
 
    template<typename Q>
    inline static void Copy(const tIndex& n,const Q* X,std::valarray<T>& R) {
        R.resize(n);
        auto iX=X;
        std::for_each(std::ranges::begin(R),std::ranges::end(R),[&iX](auto& Ri){Ri=(*iX);iX++;});
    }
   
    
    
    
    //initializers methods
    //====================
    inline void initialize(const T& x) {
        for(auto& Ri: this->getArray()) {Ri=x;};
    }
  
 
    
    inline static void UniformRandomize(const T& min,const T& max,std::vector<T>& values){
        T alpha=(max-min)/RAND_MAX;
        for(auto& V : values) {V=alpha*((T)std::rand())+min;};
    }
    inline static void UniformRandomize(const T& min,const T& max,std::valarray<T>& values){
        T alpha=(max-min)/RAND_MAX;
        for(auto& V : values) {V=alpha*((T)std::rand())+min;};
    }
    template<size_t N>
    inline static void UniformRandomize(const T& min,const T& max,std::array<T,N>& values){
        T alpha=(max-min)/RAND_MAX;
        for(auto& V : values) {V=alpha*((T)std::rand())+min;};
    }
  
   
 
    inline void uniformRandomize(const T& min,const T& max) {
        UniformRandomize(min,max,this->getArray());
    }
 
    
    //compound assignement operators (+=,-=,*=,/=,^=...)
    //===================================================
 
    //arithmetic type compound operators
    //====================================
    inline Self& operator+=(const T& v) {
        this->getArray()+=v;
        return (*this);
    }
    inline Self& operator-=(const T& v) {
        this->getArray()-=v;
        return (*this);
      
    }
    
    inline Self& operator*=(const T& v) {
        this->getArray()*=v;
        return (*this);
        
    }
    inline Self& operator/=(const T& v) {
        if (fabs(v)<std::numeric_limits<T>::epsilon()) {
            throw CORE_Exception("core",
                                 "CORE_StdValArray/=",
                                 "division by 0");
        }
        this->getArray()/=v;
        return (*this);
    }
 
    //integer type compond operators
    //===============================
    inline Self& operator%=(const T& v) requires functions_type::isIntegerType<T> {
        this->getArray()%=v;
        return (*this);
    }
    
    inline Self& operator&=(const T& v) requires functions_type::isIntegerType<T> {
        this->getArray()&=v;
        return (*this);
    }
    
    inline Self& operator|=(const T& v) requires functions_type::isIntegerType<T> {
        this->getArray()|=v;
        return (*this);
    }
 
    inline Self& operator^=(const T& v) requires functions_type::isIntegerType<T> {
        this->getArray()^=v;
        return (*this);
    }
    inline Self& operator<<=(const T& v) requires functions_type::isIntegerType<T> {
        this->getArray()<<=v;
        return (*this);
    }
    
    inline Self& operator>>=(const T& v) requires functions_type::isIntegerType<T> {
        this->getArray()>>=v;
        return (*this);
    }
 
    //class type compound operatos
    //=============================
    
    template<typename Q,class I>
    inline Self& operator+=(const CORE_Array<Q,I>& X) {
        //This=F(This,X)
        transform([&](const auto& x,const auto&y){return x+y;},(*this),X);
        return (*this);
    }
    
    template<typename Q,class I>
    inline Self& operator-=(const CORE_Array<Q,I>& X) {
        //This=F(This,X)
        transform([&](const auto& x,const auto&y){return x-y;},(*this),X);
        return (*this);
    }
    template<typename Q,class I>
    inline Self& operator*=(const CORE_Array<Q,I>& X) {
        //This=F(This,X)
        transform([&](const auto& x,const auto&y){return x*y;},(*this),X);
        return (*this);
    }
 
  
    template<typename  Q,class I>
    inline Self& operator/=(const CORE_Array<Q,I>& X) {
        //This=F(This,X)
        transform([&](const auto& x,const auto&y){
                      if (y==0) throw CORE_Exception("core","CORE_Array<T>::/=","division by zero");
                      return x/y;},
            (*this),X);
        return (*this);
    }
    
    inline Self& operator+=(const Self& X) {
        this->getArray()+=X.getArray();
        return (*this);
    }
 
     
    inline Self& operator-=(const Self& X) {
        this->getArray()-=X.getArray();
        return (*this);
    }
    
    
    inline Self& operator*=(const Self& X) {
        this->getArray()*=X.getArray();
        return (*this);
    }
 
    inline Self& operator/=(const Self& X) {
        this->getArray()/=X.getArray();
        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);
    }
 
    //static Transform
    //-----------------
    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_StdValArray::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);
    }
 
 
    
 
    inline void normalize() {
        //compute the norm
        T norm=0;
        for(const auto& Vi : this->getArray()) {
            norm+=Vi*Vi;
        }
        //normalize
        if (norm>std::numeric_limits<T>::epsilon()) {
            norm=1./sqrt(norm);
            for(auto& Vi : this->getArray()) {
                Vi*=norm;
            }
        }
    }
 
    template<typename Q,class I>
    inline void axpy(const Q& alpha, const CORE_Array<Q,I>& X,const T& beta) {
        AXPY(alpha,X,beta,*this);
    }
 
 
    
    template<typename Q,class I>
    inline void AXPY(const Q& alpha, const CORE_Array<Q,I>& X,const T& beta,Self& Y) {
        std::transform(X.cbegin(),X.cend(),
                       Y.cbegin(),
                       Y.begin(),
                       [&alpha,&beta](const auto& Xi,const auto& Yi) {
                           return beta*Yi+alpha*Xi;
                       });
    }
    
 
 
   
    //Data consistency
    //=================
    inline  tBoolean isNANContained() const {
        //loop on all values and stop the loop when the first nan value is found and return true
        //return false otherwise
        return (std::find_if(this->cbegin(),
                             this->cend(),
                             [](const T& v) {
                                 return std::isnan(v);
                                 
                             })!=this->cend());
    }
 
 
    //algebric methods
    //================
    
     
    
    static inline Self& Sum(const Self& Ain,
                            Self& Aout) {
        ASSERT_IN(Ain.getSize()==Aout.getSize());
      
        auto iAin=Ain.cbegin();
        std::for_each(Aout.begin(),Aout.end(),
                      [&](auto& v) {
                          v+=(*iAin);
                          iAin++;
                      });
        
        return Aout;
    }
    
    inline void sum(T& s) const {
        s=this->getArray().sum();
    }
    inline void prod(T& p) const {
        p=1;//product value
        for(const auto& Vi : this->getArray()) p*=Vi; 
    }
  
     
    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());
        auto iV=this->cbegin();
        s=0;
        std::for_each_n(X.cbegin(),n,[&iV,&s](const auto& Xi) {s+=Xi*(*iV);iV++;});
        return s;
    }
  
    inline tReal l2Norm2()  const  {
        tReal s=0;
        for(const auto& Vi : this->getArray()) s+=Vi*Vi;
        return s;
    }
    template<typename Q,class I>
    inline tReal l2Distance2(const CORE_Array<Q,I>& X)  const  {
         //begin iterator of X
        auto iX=X.getValues();
        //end iterator on X
        auto iXe=iX+X.getSize();
 
        //min size of X a This
        tIndex p=functions_numeric::min(X.getSize(),this->getSize());
 
        //initialize the sum to 0
        tReal s=0;
        //compute the sum in [0,p[
        tReal tmp;
        std::for_each_n(this->cbegin(),p,
                        [&iX,&s,&tmp](const auto& Vi) {
                            tmp=(Vi-(*iX));
                            tmp*=tmp;
                            s+=tmp;
                            iX++;
                        });
        
        //compute the sum in [p,X.getSize()[
        while (iX!=iXe) {
            s+=(*iX)*(*iX);
            iX++;
        }
        
        //or compute the sum in [p,This->getSize()[
        std::for_each(this->cbegin()+p,this->cend(),
                       [&s](const auto& Vi) {
                          s+=Vi*Vi;
                      });
        return s;
        
    }
    inline tReal linfDistance(tIndex& imax)  const  {
        tReal s=0;
        //size is null
        if (this->getSize()==0) return s;
        //max is initialize to lowest positive real : 0
        s=0;
        imax=0;
        //temporary variable
        tIndex i=0;
        tReal tmp;
        for(const auto& Vi : this->getArray())  {
            tmp=std::fabs(Vi);
            if (tmp>s) {
                s=tmp;
                imax=i;
            }
        }
        return s;
    }
    template<typename Q,class I>
    inline tReal linfDistance(const CORE_Array<Q,I>& X,tIndex& imax)  const  {
        //begin iterator of X
        auto iX=X.getValues();
        //end iterator on X
        auto iXe=iX+X.getSize();
 
        //min size of X a This
        tIndex p=functions_numeric::min(X.getSize(),this->getSize());
 
        //initialize the max to 0
        tReal s=0;
        imax=0;
        tIndex i=0;
        //compute the max in [0,p[
        tReal tmp;
        std::for_each_n(this->cbegin(),p,
                        [&iX,&i,&imax,&s,&tmp](const auto& Vi) {
                            tmp=std::fabs(Vi-(*iX));
                            if (tmp>s) {
                                s=tmp;
                                imax=i;
                            }
                            iX++;
                            i++;
                        });
        
        //compute the max in [p,X.getSize()[
        while (iX!=iXe) {
            tmp=std::fabs((*iX));
            if (tmp>s) {
                s=tmp;
                imax=i;
            }
            iX++;
            i++;
        }
        
        //or compute the max in [p,This->getSize()[
        std::for_each(this->cbegin()+p,this->cend(),
                      [&imax,&s,&tmp,&i](const auto& Vi) {
                            tmp=std::fabs(Vi);
                            if (tmp>s) {
                                s=tmp;
                                imax=i;
                            }
                            i++;
                      });
        return s;
    }
    
    //ordored type  methods
      
    inline void min(T& m) const requires functions_type::isOrderedType<T> {
        m=this->getArray().min();
    }
    inline void max(T& m) const requires functions_type::isOrderedType<T> {
        m= this->getArray().max();
    }
    
    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;
        }
        
    }
    
};
 
 
//val array
typedef  CORE_StdValArray<tReal> CORE_RealValArray;
 
typedef  CORE_StdValArray<tInteger> CORE_IntegerValArray;
typedef  CORE_StdValArray<tRelativeInteger> CORE_RelativeIntegerValArray;
 
 
 
 
#endif