CORE_Array.h

Go to the documentation of this file.

#ifndef CORE_Array_H
#define CORE_Array_H
 
//inherited class header
#include "CORE_Collection.h"
 
//constant stride iterator
#include "CORE_ConstantStrideIterator.h"
 
//stride iterator
#include "CORE_StrideIterator.h"
 
 
template <typename T,class I>
class CORE_Array : public CORE_Collection<T,I> {
 
    
private:
    //shorter class name
    typedef CORE_Array<T,I> Self;
   
    
    // CONSTRUCTORS
protected:
    CORE_Array() {
       
    }
   
    
    // DESTRUCTORS
    virtual ~CORE_Array() {
    }
 
 
public:
 
    //memory method
    //=============
    
    virtual  tMemSize getMemorySize() const override {
        return sizeof(*this)+this->getContentsMemorySize();
    }
 
   
 
    
    
public:
 
   
    //allocation methods
    //===================
 
   
 
    //accessors operator
    //==================
public:
 
    
    
    //accessors iterator
    //===================
public:
   
    template<int N>
    inline  auto sbegin() {
        return CORE_StrideIterator<T*,N>(&(*this)[0]);
    }
    template<int N>
    inline auto send()  {
        return CORE_StrideIterator<T*,N>(&(*this)[this->getSize()]);
    }
 
    template<int N>
    inline  constexpr auto csbegin() const {
        return CORE_ConstantStrideIterator<const T*,N>(&(*this)[0]);
    }
    template<int N>
    inline constexpr auto csend()  const {
        return CORE_ConstantStrideIterator<const T*,N>(&(*this)[this->getSize()]);
    }
 
    
    
    //accessor methods
    //================
public:
    inline const T& get(const tIndex& i) const {
        return (*this)[i];
    };
    inline T& get(const tIndex& i)  {
        return (*this)[i];
    }
 
    
    inline const T* getValues() const {
        return static_cast<const I*>(this)->getValues();
    }
    inline T* getValues() {
        return static_cast<I*>(this)->getValues();
    }
    
    
    //assignment operators
    //====================
public:
    inline  Self& operator=(const T& v)  {
        initialize(v);
        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;
    }
    template<typename Q,class I1>
    inline  Self& operator=(const CORE_Array<Q,I1>& cpy)  {
        copy(cpy);
        return *this;
    }
    inline  Self& operator=(const Self& cpy)  {
        copy(cpy);
        return *this;
    }
    template<typename Q,class I1>
    inline  Self& operator=(CORE_Array<Q,I1>&& cpy)  {
        copy(cpy);
        return *this;
    }
    inline  Self& operator=(Self&& cpy)  {
        copy(cpy);
        return *this;
    }
    
    //copy methods
    //============
public:
    
   
    
    template<typename Q>
    inline void copy(const tIndex& n , const Q* vs) {
        static_cast<I*>(this)->copy(n,vs);
    }
 
    
    template<typename Q,size_t N>
    inline void copy(const tIndex& n,const std::array<Q,N>& vs) {
        static_cast<I*>(this)->copy(n,vs);
    }
 
    template<typename Q>
    inline void copy(const tIndex& n, const std::valarray<Q>& vs) {
        static_cast<I*>(this)->copy(n,vs);
    }
    
     
    template<typename Q>
    inline void copy(const tIndex& n,const std::vector<Q>& vs) {
        static_cast<I*>(this)->copy(n,vs);
    }
 
 
    inline void copy(const tIndex& n,const std::initializer_list<T>& vs) {
        static_cast<I*>(this)->copy(n,vs);
    }
    inline void copy(const tIndex& n,std::initializer_list<T>&& vs) {
        static_cast<I*>(this)->copy(n,vs);
    }
    
    
    template<typename Q,class I1>
    inline void copy(const CORE_Array<Q,I1>& cpy) {
        static_cast<I*>(this)->copy(cpy);
    }
    
    template<typename Q,class I1>
    inline void copy(CORE_Array<Q,I1>&& cpy) {
        static_cast<I>(*this)->copy(cpy);
    }
    
   
   
      
    //initializers methods
    //====================
public:
    inline void initialize(const T& v) {
        static_cast<I*>(this)->initialize(v);
    }
    
    
    inline void uniformRandomize() {
        if (std::is_floating_point_v<T>)
            this->uniformRandomize(0,1);
        else {
            this->uniformRandomize(0,RAND_MAX);
        }
    }
     
    inline void uniformRandomize(const T& min,const T& max) {
        static_cast<I*>(this)->uniformRandomize(min,max);
    }
    
    //compound assignement operators (+=,-=,*=,/=,^=...)
    //=================================================
public:
    //T type compound assigement operators
    //-------------------------------------
    
    inline I& operator+=(const T& v) {
        return (*static_cast<I*>(this))+=v;
    }
     
    inline I& operator-=(const T& v) {
        return (*static_cast<I*>(this))-=v;
    }
    
    inline I& operator*=(const T& v) {
        return (*static_cast<I*>(this))*=v;
        
    }
    inline I& operator/=(const T& v) {
        return (*static_cast<I*>(this))/=v;
    }
    
 
    //integer type compound assignement  operators
    //---------------------------------------------
    inline I& operator%=(const T& v) requires core_functions::isIntegerType<T>  {
        return (*static_cast<I>(this))%=v;
    }
    
    inline I& operator&=(const T& v) requires core_functions::isIntegerType<T>  {
       return (*static_cast<I>(this))&=v;
    }
    
    inline I& operator|=(const T& v)requires core_functions::isIntegerType<T>  {
      return (*static_cast<I>(this))|=v;
    }
 
    inline I& operator^=(const T& v) requires core_functions::isIntegerType<T>  {
        return (*static_cast<I>(this))^=v;
    }
    inline I& operator<<=(const T& v) requires core_functions::isIntegerType<T>  {
        return (*static_cast<I>(this))<<=v;
    }
    
    inline I& operator>>=(const T& v) requires core_functions::isIntegerType<T>  {
        return (*static_cast<I>(this))>>=v;
    }
    
 
    //class type compound operators
    //-----------------------------
    
    template<typename Q,class I1>
    inline I& operator+=(const CORE_Array<Q,I1>& v) {
        return (*static_cast<I*>(this))+=v;
    }
    template<typename Q,class I1>
    inline I& operator-=(const CORE_Array<Q,I1>& v) {
        return (*static_cast<I*>(this))-=v;
    }
    template<typename Q,class I1>
    inline I& operator*=(const CORE_Array<Q,I1>& v) {
        return (*static_cast<I*>(this))*=v;
    }
    template<typename Q,class I1>
    inline  I& operator/=(const CORE_Array<Q,I1>& v) {
        return (*static_cast<I*>(this))/=v;
    }
    
 
    
   
    //transformation method
    //=====================
 
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F) {
        static_cast<I*>(this)->transform(F);
    }
    
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F,
                          const Self& X) {
        static_cast<I*>(this)->transform(F,X);
    }
   
    template<typename LambdaFct>
    inline void transform(LambdaFct&& F,
                      const Self& X,
                      const Self& Y) {
        static_cast<I*>(this)->transform(F,X,Y);
    }
 
    
   
 
    
    inline void swap(Self& a) {
        static_cast<I*>(this)->swap(a);
    }
    inline void swap(const tIndex& i,const tIndex& j) {
        static_cast<I*>(this)->swap(i,j);
    }
 
 
    inline void normalize() {
        static_cast<I*>(this)->normalize();
    }
   
  
 
  
    
    template<typename Q,class I1>
    inline void axpy(const Q& alpha, const CORE_Array<Q,I1>& X,const T& beta) {
        static_cast<I*>(this)->axpy(alpha,X,beta);
    }
   
   
    
    //Data consistency
    //=================
 
public:
    inline  tBoolean isNANContained() const {
        return static_cast<const I*>(this)->isNANContained();
    }
 
    
   
    //algebric methods
    //================
public:
 
 
   
    inline void sum(T& s) const {
        return static_cast<const I*>(this)->sum(s);
    }
    inline void prod(T& p) const {
        static_cast<const I*>(this)->prod(p);
    }
     
    template<typename Q,class I1>
    inline T& scalarProduct(const CORE_Array<Q,I1>& X,T& s)  const  {
        return static_cast<const I*>(this)->scalarProduct(X,s);
    }
 
 
    inline tReal l2Norm2() const {
        return static_cast<const I*>(this)->l2Norm2();
    }
    inline tReal l2Norm() const {
        return sqrt(l2Norm2());
    }
    template<typename Q,class I1>
    inline tReal l2Distance2(const CORE_Array<Q,I1>& X) const {
        return static_cast<const I*>(this)->l2Distance2(X);
    }
    template<typename Q,class I1>
    inline tReal l2Distance(const CORE_Array<Q,I1>& X) const {
        return sqrt(l2Distance2(X));
    }
    
    inline tReal linfNorm(tIndex& i) const {
        return static_cast<const I*>(this)->linfNorm(i);
    }
    template<typename Q,class I1>
    inline tReal linfDistance(const CORE_Array<Q,I1>& X,tIndex& i) const {
        return static_cast<const I*>(this)->linfDistance(X,i);
    }
    
    //ordored type methods
    //====================
    
public:
    inline void min(T& m) const requires core_functions::isOrderedType<T>{
        static_cast<const I*>(this)->min(m);
        
    }
    inline void  max(T& m) const requires core_functions::isOrderedType<T> {
        return static_cast<const I*>(this)->min(m);
    }
    
    
    inline void sort() requires core_functions::isOrderedType<T> {
        directionalSort('i');
    }
    
    inline void directionalSort(const tUChar& order) requires core_functions::isOrderedType<T> {
        static_cast<I*>(this)->directionalSort(order);
        
    }
  
 
};
 
 
#endif