functions_grid.h

#ifndef FUNCTIONS_GRID_H
#define FUNCTIONS_GRID_H
 
//types of the code
#include "types.h"
#include "functions_type.h"
 
//standart library
#include <stdlib.h>
 
//for type name
#include <cxxabi.h>
 
//include the Template condition
#include<type_traits>
 
//regex header for string manipulation
#include <regex>
 
//template type verification header
#include<type_traits>
#include<concepts>
 
//math header isnan
#include <math.h>
 
#ifdef DEBUG
//define the assert method
#include<cassert>
#endif
 
namespace functions_grid {
 
 
    //index of element form indices
    //==============================
 
    //level index function I1=a_0+d_. I_2
    //                     ...
    //                     In=a_{n-1}
    
    template<typename S,typename T,typename Q,size_t N,size_t L> requires (L==N)
        inline  S getLevelElementIndex(const T* Dl,const Q *Al) {
        return (S) (*Al);
    }
    template<typename S,typename T,typename Q,size_t N,size_t L> requires (L<N)
        inline S getLevelElementIndex(const T* Dl,const Q *Al) {
        return (S) ((*Al)+(*Dl)*getLevelElementIndex<S,T,Q,N,L+1>(Dl+1,Al+1));
    }
    template<typename S,typename T,typename Q,size_t N>
    inline S getElementIndex(const std::array<T,N>& D,const std::array<Q,N>& I) {
        return getLevelElementIndex<S,T,Q,N,1>(D.data(),I.data());
    }
    template<typename S,typename T,size_t N>
    inline S getElementIndex(const T* D,const T* I) {
        return getLevelElementIndex<S,T,T,N,1>(D,I);
    }
    template<typename S,typename T,typename Q,size_t N,size_t M>
    inline S getElementIndex(const std::array<T,N>& D,const std::array<Q,M>& I) {
        return getLevelElementIndex<S,T,Q,M,1>(D.data(),I.data());
    }
  
 
    //indices of element from it index
    //=================================
    
    template<typename T,typename S,size_t N,size_t i> requires (i==N)
        inline void getLevelElementIndices(const  T* Di,S& index,T *Ai) {
        (*Ai)=index;
    }
    template<typename T,typename S,size_t N,size_t i> requires (i<N)
        inline void getLevelElementIndices(const T* Di,S& index,T *Ai) {
        (*Ai)=index%(*Di);
        index/=(*Di);
        getLevelElementIndices<T,S,N,i+1>(Di+1,index,Ai+1);
    }
    
    template<typename T,typename S,size_t N> requires functions_type::isArithmeticType<T>
    inline void getElementIndices(const std::array<T,N>& D,S& index,std::array<T,N>& I) {
        return getLevelElementIndices<T,S,N,1>(D.data(),index,I.data());
    }
    template<typename T,typename S,size_t N,size_t M> requires functions_type::isArithmeticType<T>
    inline void getElementIndices(const std::array<T,N>& D,S& index,std::array<T,M>& I) {
        return getLevelElementIndices<T,S,M,1>(D.data(),index,I.data());
    }
    template<typename T,typename S,size_t N> requires functions_type::isArithmeticType<T>
    inline void getElementIndices(const T* D,S& index,T* I) {
        return getLevelElementIndices<T,S,N,1>(D,index,I);
    }
 
    //next element indices method
    //============================
    
    template<typename T,size_t N,size_t L> requires (L==N)
        inline void nextLevelElementIndices(const T* Nl,T* Il) {
        (*Il)++;
    }
    template<typename T,size_t N,size_t L> requires (L<N)
        inline void nextLevelElementIndices(const T* Nl,T* Il) {
        (*Il)++;
        if ((*Il)==(*Nl)) {
            (*Il)=0;
            nextLevelElementIndices<T,N,L+1>(Nl+1,Il+1);
        }
    }
   
  
 
    template<typename T,size_t N> requires (functions_type::isArithmeticType<T>)
        inline void nextElementIndices(const std::array<T,N>& size,std::array<T,N>& indices) {
        return nextLevelElementIndices<T,N,1>(size.data(),indices.data());
    }
    template<typename T,size_t N> requires (functions_type::isArithmeticType<T>)
        inline void nextElementIndices(const T* size,T* indices) {
        return nextLevelElementIndices<T,N,1>(size,indices);
    }
 
    //has next element indices method
    //============================
    
    template<typename T,size_t N,size_t L> requires (L==N)
        inline  tBoolean hasNextLevelElement(const T* Nl,T* Il) {
        (*Il)++;
        return ((*Il)<(*Nl));
    }
    template<typename T,size_t N,size_t L> requires (L<N)
        inline  tBoolean hasNextLevelElement(const T* Nl,T* Il) {
        (*Il)++;
        if ((*Il)==(*Nl)) {
            (*Il)=0;
            return hasNextLevelElement<T,N,L+1>(Nl+1,Il+1);
        }
        return true;
    }
    
    
    
    template<typename T,size_t N> requires (functions_type::isArithmeticType<T>)
        inline tBoolean hasNextElement(const std::array<T,N>& size,std::array<T,N>& indices) {
        return hasNextLevelElement<T,N,1>(size.data(),indices.data());
    }
 
 
   
 
    //next element indices within a block
    //===================================
 
    template<typename T,size_t N,size_t L> requires (L==N)
        inline tBoolean hasNextLevelElementIndicesWithinBlock(const T* Nl,const T* Sl,const T* El,T* Il) {
        (*Il)++;
        return ((*Il)<(*El));
    }
    
    template<typename T,size_t N,size_t L> requires (L<N)
        inline tBoolean  hasNextLevelElementIndicesWithinBlock(const T* Nl,const T* Sl,const T* El,T* Il) {
        (*Il)++;
        if ((*Il)==(*El)) {
            (*Il)=(*Sl);
            return hasNextLevelElementIndicesWithinBlock<T,N,L+1>(Nl+1,Sl+1,El+1,Il+1);
        }
        return true;
    }
    
    template<typename T,size_t N> requires (functions_type::isArithmeticType<T>)
        inline  tBoolean hasNextElementIndicesWithinBlock(const std::array<T,N>& size,
                                                          const std::array<T,N>& start,
                                                          const std::array<T,N>& end,
                                                          std::array<T,N>& indices) {
        return hasNextLevelElementIndicesWithinBlock<T,N,1>(size.data(),start.data(),end.data(),indices.data());
    }
 
   
    template<typename T,size_t N,size_t i> requires (i==N)
        inline tBoolean isLevelIndicesInBound(const  T* Di,const T *Bi) {
        return (*Di)<(*Bi);
    }
    template<typename T,size_t N,size_t i> requires (i<N)
        inline tBoolean isLevelIndicesInBound(const T* Di,const T *Bi) {
        return ((*Di)<(*Bi)) && isLevelIndicesInBound<T,N,i+1>(Di+1,Bi+1);
    }
    
    template<typename T,size_t N> requires functions_type::isArithmeticType<T>
    inline tBoolean isIndicesInBound(const T* I,const T*  Ns) {
        return isLevelIndicesInBound<T,N,1>(I,Ns);
    }             
      
    template<typename T,size_t N> requires functions_type::isArithmeticType<T>
    inline tBoolean isIndicesInBound(const std::array<T,N>& I,const std::array<T,N>&  Ns) {
        return isLevelIndicesInBound<T,N,1>(I.data(),Ns.data());
    }             
    
}
 
#endif