CORE_Field.h

#ifndef CORE_Field_H
#define CORE_Field_H
 
//inherited class header
#include "CORE_Collection.h"
 
//storage header
#include "CORE_Array.h"
 
//file header
#include <fstream>
 
//string functions headers
#include "functions_string.h"
 
template <typename T,typename K,K D,class S,class I>
class CORE_Field : public CORE_Collection<T,I> {
 
    
private:
 
    //storage class of type T and with storage implementation S
    S mStorage;
 
    //shorter class name
    typedef CORE_Field<T,K,D,S,I> Self;
    
    // CONSTRUCTORS
protected:
    CORE_Field() {
       
    }
   
    
    // DESTRUCTORS
    virtual ~CORE_Field() {
    }
 
 
public:
 
    //memory method
    //=============
    
    virtual  tMemSize getMemorySize() const override {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
   
 
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=CORE_Collection<T,I>::getContentsMemorySize();
        mem+=mStorage.getContentsMemorySize();
        return mem;
    }
   
    
    
public:
 
   
    //allocation methods
    //===================
   
    inline void setElementsNumber(const tInteger& n)   {
       mStorage.setSize(n*D);
    };
    inline void fitToElementsNumber(const tInteger& n)   {
       mStorage.fitToSize(n*D);
    };
    inline  tIndex getElementsNumber()  const {
        return mStorage.getSize()/D;
    };
    
    inline void setSize(const tIndex& n)   {
        mStorage.setSize(D*(n/D));
    };
    
    inline void resize(const tIndex& n)   {
        mStorage.resize(D*(n/D));
    };
    
    
    inline  tIndex getSize()  const {
        return mStorage.getSize();
    };
    
 
    inline K getDimension() const {
        return D;
    }
 
    //accessor operators
    //====================
    
    inline const T& operator[](const tIndex& i) const {
        return mStorage[i];
    };
    inline T& operator[](const tIndex& i)  {
        return mStorage[i];
    };
 
    
    
    inline const T& operator()(const tInteger& i,const K& d) const {
        return mStorage[D*i+d];
    };
    inline T& operator()(const tInteger& i,const K d)  {
        return mStorage[D*i+d];
    };
      
    inline const T* operator()(const tInteger& i) const {
        return &mStorage[D*i];
    };
    inline T* operator()(const tInteger& i)  {
        return &mStorage[D*i];
    };
    
    //accessor iterator
    //==================
    inline constexpr auto cbegin() const {
        return getStorage().cbegin();
    }
    inline constexpr auto cend() const {
        return getStorage().cend();
    }
    inline  auto begin() {
        return getStorage().begin();
    }
    inline auto end()  {
        return getStorage().end();
    }
 
    inline  auto rbegin() {
        return getStorage().rbegin();
    }
    inline auto rend()  {
        return getStorage().rend();
    }
 
    inline constexpr auto crbegin() const {
        return getStorage().crbegin();
    }
    inline constexpr auto crend() const {
        return getStorage().crend();
    }
 
  
    inline  auto sbegin() {
        return CORE_StrideIterator<T*,D>(&mStorage[0]);
    }
    inline auto send()  {
        return CORE_StrideIterator<T*,D>(&mStorage[0]+mStorage.getSize());
    }
 
    inline  constexpr auto csbegin() const {
        return CORE_ConstantStrideIterator<const T*,D>(&mStorage[0]);
    }
    inline constexpr auto csend()  const {
        return CORE_ConstantStrideIterator<const T*,D>(&mStorage[0]+mStorage.getSize());
    }
 
 
    
    //accessor methods
    //==================
    
    inline const T& get(const tIndex& i,const K& d) const {
        return mStorage[i*D+d];
    };
    inline T& get(const tIndex& i,const K& d)  {
        return  mStorage[i*D+d];
    }
     
     
    inline const T* getValues() const {
        return mStorage.getValues();
    }
    inline T* getValues() {
        return mStorage.getValues();
    }
 
    inline const S& getStorage() const {
        return mStorage;
    }
    inline  S& getStorage()  {
        return mStorage;
    }
    
    //assignment operators
    //====================
    inline  Self& operator=(const T& v)  {
        initialize(v);
        return *this;
    }
    inline Self& operator=(const std::initializer_list<T>& values)  {
        mStorage.copy(D*(values.size()/D),values);
        return *this;
    }
    inline Self& operator=(std::initializer_list<T>&& values)  {
        mStorage.copy(D*(values.size()/D),values);
        return *this;
    }
    
    template<size_t N,typename Q>
    inline  Self& operator=(const std::array<Q,N>& values)  {
        mStorage.copy(D*(N/D),values);
        return *this;    
    }
 
    template<typename Q>
    inline  Self& operator=(const std::array<Q,D>& values)  {
        this->copy(values);
        return *this;    
    }
    
    template<typename Q>
    inline  Self& operator=(const std::valarray<Q>& values)  {
        mStorage.copy(D*(values.size()/D),values);
        return *this;
    }
    
    template<typename Q>
    inline  Self& operator=(const std::vector<Q>& values)  {
        mStorage.copy(D*(values.size()/D),values);
        return *this;
    }
    inline  Self& operator=(const Self& cpy)  {
        mStorage.copy(cpy.getStorage());
        return *this;
    }
    inline  Self& operator=(Self&& cpy)  {
        mStorage.copy(cpy.getStorage());
        return *this;
    }
    template<typename Q,class S1,class I1>
    inline  Self& operator=(const CORE_Field<Q,K,D,S1,I1>& cpy)  {
        mStorage.copy(cpy.getStorage());
        return *this;
    }
    template<typename Q,class S1,class I1>
    inline  Self& operator=(CORE_Field<Q,K,D,S1,I1>&& cpy)  {
        mStorage.copy(cpy.getStorage());
        return *this;
    }
     
    //copy methods
    //============
public:
    
   
 
    template<typename Q>
    inline void copy(const tIndex& n , const Q* vs) {
        mStorage.copy(D*(n/D),vs);
    }
 
    
    template<typename Q,size_t N>
    inline void copy(const std::array<Q,N>& vs) {
        mStorage.copy(D*(vs.size()/D),vs);
    }
 
       
    template<typename Q>
    inline void copy(const std::array<Q,D>& vs) {
        initialize(vs);
    }
 
    template<typename Q>
    inline void copy(const std::valarray<Q>& vs) {
        mStorage.copy(D*(vs.size()/D),vs);
    }
 
    template<typename Q>
    inline void copy(std::valarray<Q>&& vs) {
        mStorage.copy(D*(vs.size()/D),vs);
    }
    
     
    template<typename Q>
    inline void copy(const std::vector<Q>& vs) {
        mStorage.copy(D*(vs.size()/D),vs);
    }
    
    
    inline void copy(const std::initializer_list<T>& vs) {
        mStorage.copy(D*(vs.size()/D),vs);
    }
    inline void copy(std::initializer_list<T>&& vs) {
        mStorage.copy(D*(vs.size()/D),vs);
    }
    
    
    template<typename Q,class S1,class I1>
    inline void copy(const CORE_Field<Q,K,D,S1,I1>& cpy) {
        mStorage.copy(cpy.getStorage());
    }
    
    template<typename Q,class S1,class I1>
    inline void copy(CORE_Field<Q,K,D,S1,I1>&& cpy) {
        mStorage.copy(cpy->getStorage());
    }
    
   
    
    //initializers methods
    //====================
 
    inline void initialize(const T& v) {
        getStorage().initialize(v);
    }
 
    template<typename Q>
    inline void initialize(const std::array<Q,D>& vs) {
        static_cast<I*>(this)->initialize(vs);
    }
    
    inline void setUniformRandomizeSeed(const tULLInt& seed) {
        getStorage().setUniformRandomizeSeed(seed);
    }
    inline void setUniformRandomizeSeed() {
       getStorage().setUniformRandomizeSeed();
    }
    
    inline void uniformRandomize(const T& min,const T& max) {
        getStorage().uniformRandomize(min,max);
    }
    
    //compound assignement operators (+=,-=,*=,/=,^=...)
    //=================================================
    
    
    //T compound assignement operators (+=,-=,*=,/=,^=...)
    //-----------------------------------------------------
    inline Self& operator+=(const T& v) {
        mStorage+=v;
        return (*this);
    }
    inline Self& operator-=(const T& v) {
        mStorage-=v;
        return (*this);
      
    }
    
    inline Self& operator*=(const T& v) {
        mStorage*=v;
        return (*this);
        
    }
    inline Self& operator/=(const T& v) {
        mStorage/=v;
        return (*this);
        
    }
    
  
    
    //integer compound assignement operators (+=,-=,*=,/=,^=...)
    //-----------------------------------------------------
 
    inline Self& operator%=(const T& v) requires functions_type::isIntegerType<T>   {
        mStorage%=v;
        return (*this);
    }
    
    inline Self& operator&=(const T& v) requires functions_type::isIntegerType<T>   {
        mStorage&=v;
        return (*this);
    }
    
    inline Self& operator|=(const T& v) requires functions_type::isIntegerType<T>   {
         mStorage|=v;
        return (*this);
    }
 
    inline Self& operator^=(const T& v) requires functions_type::isIntegerType<T>   {
        mStorage^=v;
        return (*this);
    }
    inline Self& operator<<=(const T& v) requires functions_type::isIntegerType<T>   {
        mStorage<<=v;
        return (*this);
    }
    
    inline Self& operator>>=(const T& v) requires functions_type::isIntegerType<T>   {
        mStorage>>=v;
        return (*this);
    }
    
    //I compound assignement operators (+=,-=,*=,/=,^=...)
    //-----------------------------------------------------
    template<typename T1,class S1,class I1>
    inline Self& operator+=(const CORE_Field<T1,K,D,S1,I1>& v) {
        mStorage+=v.getStorage();
        return (*this);
    }
    template<typename T1,class S1,class I1>
    inline Self& operator-=(const CORE_Field<T1,K,D,S1,I1>& v) {
        mStorage-=v.getStorage();
        return (*this);
    }
    template<typename T1,class S1,class I1>
    inline Self& operator*=(const CORE_Field<T1,K,D,S1,I1>& v) {
        mStorage*=v.getStorage();
        return (*this);
    }
    template<typename T1,class S1,class I1>
    inline Self& operator/=(const CORE_Field<T1,K,D,S1,I1>& v) {
        mStorage/=v.getStorage();
        return (*this);
    }
    
    
  
    //transformation methods
    //=======================
 
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F) {
        getStorage().transform(F);
    }
    
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F,
                          const Self& X) {
        getStorage().transform(F,X.getStorage());
    }
   
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F,
                      const Self& X,
                      const Self& Y) {
        getStorage().transform(F,X.getStorage(),Y.getStorage());
    }
    
    
 
    
    template<typename LambdaFct>
    inline void elementsTransform(LambdaFct&& F) {
        static_cast<I*>(this)->elementsTransform(F);
                        
    }
    
    inline void swap(CORE_Array<T,I>& a) {
        getStorage().swap(a);
    }
   
      
    inline void swap(CORE_Field<T,K,D,S,I>& a) {
        getStorage().swap(a.getStorage());
    }
   
    
  
 
    inline void  normalize()  {
        static_cast<I*>(this)->normalize();
    }
 
    template<typename Q,class S1,class I1>
    inline void axpy(const Q& alpha, const CORE_Field<Q,K,D,S1,I1>& X,const T& beta) {
        getStorage().axpy(alpha,X.getStorage(),beta);
    }
 
 
    
    //data consistency methods
    //========================
    inline  tBoolean isNANContained() const {
        return getStorage().isNANContained();
    }
 
    
    //algebric methods
    //================
    template<class I1>
    inline void mod2(CORE_Array<T,I1>& X) const {
        static_cast<const I*>(this)->mod2(X);
    }
    
 
    inline tReal linfNorm(tIndex& i) const {
        return getStorage().linfNorm(i);
    }
    template<typename Q,class I1>
    inline tReal linfDistance(const CORE_Field<Q,K,D,S,I1>& X,tIndex& i) const {
        tReal linf=getStorage().linfDistance(X.getStorage(),i);
        i/=getDimension();
        return linf;
    }
    
    inline void sum(T& s) const {
        return getStorage().sum(s);
    }
    inline void prod(T& p) const {
        return getStorage().prod(p);
      
    }
     
    template<class Q,class S1,class I1>
    inline T& scalarProduct(const CORE_Field<Q,K,D,S1,I1>& X,T& s)  const  {
       return static_cast<const I*>(this)->scalarProduct(X,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  {
        return static_cast<I*>(this)->scalarProduct(weights,X,s);
    }
    
    //ordonal methods
    //===============
    inline void  min(T& m) const requires functions_type::isOrderedType<T>{
        return getStorage().min(m);
        
    }
    inline void max(T& m) const requires functions_type::isOrderedType<T> {
        return getStorage().max(m);
    }
    
     
    inline void directionalSort(const tUChar& order) requires functions_type::isOrderedType<T>{
        directionalSort(order,0);
    }
    
    inline void directionalSort(const tUChar& order,const K& k) requires functions_type::isOrderedType<T>{
        switch(order) {
        case 'i':
            std::sort(this->sbegin()+k,this->send()+k,std::less<T>());
            break;
        case 'd':
            std::sort(this->sbegin()+k,this->send()+k,std::greater<T>());
            break;
        }
        
    }
    
   
    
public:
 
     
    
   
    
     //IO methods
    //===========
 
    inline tBoolean saveToFile(const tString& fileName) const {
        return saveToFile("",fileName,12);
    }
    inline tBoolean saveToFile(const tString& comments,const tString& filename,const tUCInt& nDigits) const {
        std::ofstream f(filename.c_str(),std::ios::out);
        if (f) {
            //save dimension & size
            tString comment=comments;
            functions_string::replaceAll("\n","\n#",comment);
            f<<"#"<<comment<<"\n";
            tInteger N=getElementsNumber();
            f<<N<<"\t"<<((tIndex)D)<<"\n";
            //get the values
            const T* iV=getValues();
            //end iterator iterator on values
            const T* iVe=iV+this->getSize();
            //iden itertaor on element
            const T* iVde=null;
            
            while (iV!=iVe) {//loop on elements
                iVde=iV+D;
                while (iV!=iVde) {//loop on coordinates
                    f<<std::setprecision(nDigits)<<(*iV)<<"\t";
                    //next value to print
                    iV++;
                }
                f<<"\n";
            }
            //close the file
            f.close();
          
            return true;
        }
        return false;
    }
    inline tBoolean loadFromFile(const tString& fileName) {
        tString comment;
        tInt retCode;
        return loadFromFile(fileName,comment,retCode);
    }
    
    inline tBoolean loadFromFile(const tString& filename,tString& comment,tInt& retCode) {
        std::ifstream f(filename.c_str(),std::ios::in);
        if (f) {
            std::stringstream sscomment;
            
            //for reading a line
            tString line;
            while ( std::getline(f,line) ) {
                
                //ignore if the line is a comment
                if (line.find("#")==0) {
                    functions_string::replaceAll("#","",line);
                    sscomment<<line<<"\n";
                    continue;
                }
                //set the comment
                comment=sscomment.str();
                //no comment line
                //read size & dimension
                tInteger N;
                tInt dim;
                std::stringstream iss(line);
                iss>>N;
                if (N==0)  {
                    //close the file
                    f.close();
                    //return false
                    retCode=-1;
                    return false;
                }
                iss >>dim;
                if (dim!=D) {
                    
                    //close the file
                    f.close();
                    //return false
                    retCode=-2;
                    return false;
                }
 
                //set the number of elements number
                setElementsNumber(N);
               
                //get the values
                T *iV=this->getValues();
                //get th end of values
                const T* iVe=iV+this->getSize();
                //read the values
                while ((iV!=iVe)&&(!f.eof())) {
                    f>>(*iV);
                    iV++;
                }
               
                f.close();
                if (iV!=iVe) retCode=0;
                else retCode=1;
                return (retCode==1);
            }//end loop of reading next line
 
            
            f.close();
            retCode=1;
            return true;
        }//end file exists
      
        //file does not exist
        retCode=-3;
        return false;
    }
 
    
 
    virtual tString toString() const  override {
        std::stringstream cstr;
        tIndex k=0;
        cstr<<this->getIdentityString()<<"{\n ";
        if (getSize()>0) { 
            std::for_each(this->csbegin(),this->csend(),
                          [&cstr,&k](const auto& Vi) {//Vi=values[D*i]
                              //[&i,&N,&d,&dim,&cstr](const auto& Vi) {
                              cstr<<k<<"-(";
                              //d=0;
                              std::for_each_n(&Vi,D,
                                              [&cstr](const auto& Vid){//Vid=values[D*i+d]
                                                  //[&i,&N,&d,&cstr](const auto& Vid){
                                                  //std::cout<<"print V["<<i<<"/"<<N<<"]["<<((int)d)<<"]="<<Vid<<"\n";
                                                  cstr<<std::setprecision(12)<<Vid<<",";
                                                  //d++;
                                              }
                                  );
                              k++;
                              cstr.seekp(-1, std::ios_base::end);
                              cstr<<")\n";
                          });
            cstr.seekp(-1, std::ios_base::end);
        }
        cstr<<"}\n";
        return cstr.str();
    }
 
};
 
 
#endif