CORE_ValArray.h

#ifndef CORE_ValArray_H
#define CORE_ValArray_H
 
#include "CORE_Array.h"
 
 
//numerics functin header
#include "functions_numeric.h"
 
#include <vector>
#include <span>
 
template <typename T,class I>
class CORE_ValArray : public CORE_Array<T,I> {
 
    
private:
  
    std::valarray<T> mValues;
 
    // CONSTRUCTORS
public:
    CORE_ValArray()  {
    }
 
    explicit CORE_ValArray(const tIndex& n) : mValues(n)  {
    }
   
    
    
    // DESTRUCTORS
    virtual ~CORE_ValArray() {
    }
    
    
private:
    
    
    
    
    //MEMORY
    //=====
public:
    virtual  tMemSize getMemorySize() const override {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const override {
        tMemSize mem=CORE_Array<T,I>::getContentsMemorySize();
        mem+=mValues.size()*sizeof(T);
        return mem;
    }
    
    //allocation methods
    //===================
public:
    inline void setSize(const tIndex& n)   {
        //avoid no need re-allocation
        if (n!=mValues.size()) mValues.resize(n);
    };
    inline  tIndex getSize()  const {
        return mValues.size();
    };
   
    inline void resize(const tIndex& n) {
        std::valarray<T> newValues(n);
        //copy the p values of old values withinh newValues
        tIndex p=functions_numeric::min(n,this->getSize());
        Copy(p,mValues,newValues);
        mValues.swap(newValues);
        
    }
   
    //accessor operators
    //====================
public:
    inline const T& operator[](const tIndex& i) const {
#ifdef DEBUG
        if (i>=mValues.size()) {
            throw CORE_Exception("core",
                                 "CORE_ValArray[]",
                                 "CORE_ValArray["+std::to_string(i)+"] is out of bounds [0,"+std::to_string(mValues.size())+"[ for reading");
        }
#endif
        return mValues[i];
    };
    inline T& operator[](const tIndex& i)  {
#ifdef DEBUG
        if (i>=mValues.size()) {
            throw CORE_Exception("core",
                                 "CORE_ValArray[]",
                                 "CORE_ValArray["+std::to_string(i)+"] is out of bounds [0,"+std::to_string(mValues.size())+"[ for writing ");
        }
#endif
        return  mValues[i];
    };
 
  
    //iterator accessor
    //=================
public:
    inline constexpr auto cbegin() const {
        return std::cbegin(this->mValues);
    }
    inline constexpr auto cend() const {
        return std::cend(this->mValues);
    }
    inline  auto begin() {
        return  std::begin(this->mValues);
    }
    inline auto end()  {
        return std::end(this->mValues);
    }
 
    inline  auto rbegin() {
        //return  std::ranges::rbegin(this->mValues);
        return  rbegin(this->mValues);
    }
    inline auto rend()  {
        //return std::ranges::rend(this->mValues);
        return rend(this->mValues);
    }
 
    inline constexpr auto crbegin() const {
        //return std::ranges::crbegin(this->mValues);
        return crbegin(this->mValues);
    }
    inline constexpr auto crend() const {
        //return std::ranges::crend(this->mValues);
        return crend(this->mValues);
    }
 
    //accessor methods
    //================
public:
    inline std::valarray<T>& getArray() {
        return mValues;
    }
    inline const std::valarray<T>& getArray() const {
        return mValues;
    }
    
    inline const T* getValues() const {
        return &mValues[0];
    }
    inline T* getValues() {
        return &mValues[0];
    }
    
    
 
    //assignment operators
    //====================
    
   
    //copy methods
    //============
 
    //initializers
    //============
    
 
    //compound assignement operator
    //=============================
    
 
  
 
    //transform methods
    //==================
      
 
    inline void swap(CORE_ValArray<T,I>& a)  {
        mValues.swap(a.getArray());
    }
    inline void swap(const tIndex& i,const tIndex& j)  {
        std::swap(mValues[i],mValues[j]);
    }
 
    
    //array algebric operators
    //==========================
 
   
 
    
    //Data consistency
    //=================
    
  
     
    
 
    //algebric methods
    //================
    
   
    
    
};
 
 
#endif