grid_key.hpp

#ifndef GRID_KEY_DX
#define GRID_KEY_DX
 
#include "Grid/comb.hpp"
#include "Grid/grid_key_expression.hpp"
#include "Space/Shape/Point.hpp"
 
template<unsigned int dim, typename index_type>
class grid_key_dx
{
public:
 
    template<typename exp1>
    __device__ __host__ inline grid_key_dx(const grid_key_dx_expression<dim,exp1> & exp)
    {
        for (size_t i = 0 ; i < dim ; i++)
            this->k[i] = exp.value(i);
    }
 
    __device__ __host__  inline grid_key_dx()
    {}
 
    __device__ __host__ inline grid_key_dx(std::initializer_list<long int> p1)
    {
        size_t i = 0;
        for(long int x : p1)
        {
            set_d(i,x);
            i++;
            if (i >= dim)
                break;
        }
    }
 
    __device__ __host__ inline grid_key_dx(const grid_key_dx<dim,index_type> & key)
    :grid_key_dx(key.k)
    {
    }
 
    __device__ __host__ inline grid_key_dx(const size_t (&k)[dim])
    {
        for (size_t i = 0 ; i < dim ; i++)
            this->k[i] = k[i];
    }
 
    __device__ __host__ inline grid_key_dx(const long int (&k)[dim])
    {
        for (size_t i = 0 ; i < dim ; i++)
        {this->k[i] = k[i];}
    }
 
    __device__ __host__ inline grid_key_dx(const short (&k)[dim])
    {
        for (size_t i = 0 ; i < dim ; i++)
        {this->k[i] = k[i];}
    }
 
    __device__ __host__ inline grid_key_dx(const unsigned short (&k)[dim])
    {
        for (size_t i = 0 ; i < dim ; i++)
        {this->k[i] = k[i];}
    }
 
    __device__ __host__ inline grid_key_dx(const int (&k)[dim])
    {
        for (size_t i = 0 ; i < dim ; i++)
        {this->k[i] = k[i];}
    }
 
    __device__ __host__ inline grid_key_dx(const unsigned int (&k)[dim])
    {
        for (size_t i = 0 ; i < dim ; i++)
        {this->k[i] = k[i];}
    }
 
    template<typename ...T> inline grid_key_dx(const comb<dim> & cmb)
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] = cmb[i];
    }
 
    template<typename ...T> __device__ __host__ inline grid_key_dx(const size_t v,const T...t)
    {
#if defined(SE_CLASS1) && !defined(__NVCC__)
        if (sizeof...(t) != dim -1)
        {std::cerr << "Error grid_key: " << __FILE__ << " " << __LINE__ << " creating a key of dimension " << dim << " require " << dim << " numbers " << sizeof...(t) + 1 << " provided" << "\n";}
#endif
        k[dim-1] = v;
        invert_assign(t...);
    }
 
    __device__ __host__ inline  grid_key_dx<dim,index_type> move(int i, int m) const
    {
        grid_key_dx<dim,index_type> tmp = *this;
 
        tmp.k[i] += m;
 
        return tmp;
    }
 
    inline void zero()
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] = 0;
    }
 
    inline void one()
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] = 1;
    }
 
    inline void invalid()
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] = -1;
    }
 
    inline bool isValid()
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (k[i] != -1)
                return true;
        }
 
        return false;
    }
 
    __device__ __host__
    inline grid_key_dx<dim,index_type> & operator+=(const grid_key_dx<dim,index_type> & p)
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] += p.k[i];
 
        return *this;
    }
 
    __device__ __host__
    inline grid_key_dx<dim,index_type> & operator-=(const grid_key_dx<dim,index_type> & p)
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] -= p.k[i];
 
        return *this;
    }
 
    __device__ __host__
    inline grid_key_dx_sum<dim,grid_key_dx<dim,index_type>,grid_key_dx<dim,index_type>>
    operator+(const grid_key_dx<dim,index_type> & p) const
    {
        grid_key_dx_sum<dim,grid_key_dx<dim,index_type>,grid_key_dx<dim,index_type>> exp_sum(*this,p);
 
        return exp_sum;
    }
 
    __device__ __host__
    inline grid_key_dx_sum<dim,grid_key_dx<dim>,Point<dim,long int>>
    operator+(const Point<dim,long int> & p) const
    {
        grid_key_dx_sum<dim,grid_key_dx<dim>,Point<dim,long int>> exp_sum(*this,p);
 
        return exp_sum;
    }
 
    __device__ __host__
    inline grid_key_dx_sum<dim,grid_key_dx<dim>,comb<dim>> operator+(const comb<dim> & cmb) const
    {
        grid_key_dx_sum<dim,grid_key_dx<dim>,comb<dim>> exp_sum(*this,cmb);
 
        return exp_sum;
    }
 
    __device__ __host__
    inline grid_key_dx_sub<dim,grid_key_dx<dim,index_type>,grid_key_dx<dim,index_type>>
    operator-(const grid_key_dx<dim,index_type> & cmb) const
    {
        grid_key_dx_sub<dim,grid_key_dx<dim,index_type>,grid_key_dx<dim,index_type>> exp_sum(*this,cmb);
 
        return exp_sum;
    }
 
    template <typename T>
    __device__ __host__ inline grid_key_dx_sub<dim,grid_key_dx<dim,index_type>,grid_key_dx_expression<dim,T>> operator-(const grid_key_dx_expression<dim,T> & cmb) const
    {
        grid_key_dx_sub<dim,grid_key_dx<dim,index_type>,grid_key_dx_expression<dim,T>> exp_sum(*this,cmb);
 
        return exp_sum;
    }
 
    template<unsigned int dim_t> bool operator==(const grid_key_dx<dim_t,index_type> & key_t) const
    {
        if (dim != dim_t)
        {
            return false;
        }
 
        // Check the two key index by index
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (k[i] != key_t.k[i])
            {
                return false;
            }
        }
 
        // identical key
        return true;
    }
 
 
    template<unsigned int dim_t> bool operator!=(const grid_key_dx<dim_t,index_type> & key_t)
    {
        return !this->operator==(key_t);
    }
 
    bool operator<(const grid_key_dx<dim,index_type> & key_t) const
    {
        // Check the two key index by index
 
        for (long int i = dim-1 ; i >= 0; --i)
        {
            if (k[i] < key_t.k[i])
            {
                return true;
            }
            else if (k[i] > key_t.k[i])
            {
                return false;
            }
        }
 
        // identical key
        return false;
    }
 
    static bool noPointers()
    {
        return true;
    }
 
    template<typename a, typename ...T>
    __device__ __host__ inline void set(a v, T...t)
    {
#ifdef SE_CLASS1
        if (sizeof...(t) != dim -1)
            std::cerr << "Error grid_key: " << __FILE__ << " " << __LINE__ << "setting a key of dimension " << dim << " require " << dim << " numbers " << sizeof...(t) + 1 << " provided" << std::endl;
#endif
        k[dim-1] = v;
        invert_assign(t...);
    }
 
    const long int(& get_k() const)[dim]
    {
        return k;
    }
 
    Point<dim,long int> toPointS() const
    {
        Point<dim,long int> p;
 
        for (size_t i = 0; i < dim ; i++)
        {
            p.get(i) = get(i);
        }
 
        return p;
    }
 
    std::string to_string() const
    {
        return this->toPointS().toString();
    }
 
    template<typename typeT = size_t>
    __host__ __device__ inline Point<dim,typeT> toPoint() const
    {
        Point<dim,typeT> p;
 
        for (size_t i = 0; i < dim ; i++)
        {
            p.get(i) = get(i);
        }
 
        return p;
    }
 
 
    __device__ __host__ inline mem_id value(size_t i) const
    {
        return k[i];
    }
 
    __device__ __host__  index_type operator[](index_type i) const
    {
        return get(i);
    }
 
    __device__ __host__  index_type get(index_type i) const
    {
        return k[i];
    }
 
    __device__ __host__   void set_d(index_type i, index_type id)
    {
#if defined(SE_CLASS1) && !defined(__NVCC__)
 
        if (i >= dim)
            std::cerr << "grid_key_dx error: " << __FILE__ << " " << __LINE__ << " try to access dimension " << i << " on a grid_key_dx of size " << dim << "\n";
 
#endif
        k[i] = id;
    }
 
private:
 
    index_type k[dim];
 
    template<typename a, typename ...T> __device__ __host__ void invert_assign(a v,T...t)
    {
        k[sizeof...(T)] = v;
        invert_assign(t...);
    }
 
    template<typename a, typename ...T> __device__ __host__ void invert_assign(a v)
    {
        k[0] = v;
    }
 
    __device__ __host__ void invert_assign()
    {
    }
 
};
 
 
template<unsigned int dim, unsigned int p>
class grid_key_d
{
public:
 
 
    template<typename a, typename ...T>grid_key_d(a v,T...t)
    {
        k[dim-1] = v;
        invert_assign(t...);
    }
 
    template<typename a, typename ...T>void invert_assign(a v,T...t)
    {
        k[sizeof...(T)] = v;
        invert_assign(t...);
    }
 
    template<typename a, typename ...T>void invert_assign(a v)
    {
        k[0] = v;
    }
 
    mem_id k[dim];
};
 
 
#endif