Proto_Point.H

#pragma once
#ifndef _PROTO_POINT_Ht__
#define _PROTO_POINT_Ht__
#include "Proto_cuda.H"
#include "Proto_gpu.H"

#include "Proto_PAssert.H"

#include <iostream>
#include <array>

namespace Proto 
{
  #ifdef PR_HDF5
  class HDF5Handler;
  #endif

  class Point
  {
  #ifdef PR_HDF5
  friend class Proto::HDF5Handler;
  #endif
  public:


    CUDA_DECORATION inline Point();


    CUDA_DECORATION inline Point(const int (&a_tuple)[DIM]);


    template<typename... vals>
    CUDA_DECORATION inline explicit Point(vals... args) { unpack(0, args...); }
    
    CUDA_DECORATION inline Point(const Point& a_pt);
        



    inline static Point Ones(int a_scale=1);
    

    inline static Point Unit() { return Ones(1); }
    

    CUDA_DECORATION
    inline static Point Zeros();



    inline static Point Zeroes() { return Zeros(); }
  

    inline static Point Zero() { return Zeros(); }
    

    CUDA_DECORATION
    inline static Point Basis(int a_dir, int a_scale=1);




    CUDA_DECORATION inline const int&  operator[](unsigned char a_index) const;


    CUDA_DECORATION inline int&  operator[](unsigned char a_index);
            
        



    CUDA_DECORATION inline Point& operator=(const Point& a_rhs);


    CUDA_DECORATION inline bool operator<(const Point& a_rhs) const;


    CUDA_DECORATION inline bool operator==(const Point& a_pt) const;


    CUDA_DECORATION inline bool operator!=(const Point& a_pt) const;
        

    CUDA_DECORATION inline Point operator+(const Point& a_rhs) const;


    CUDA_DECORATION inline Point operator-(const Point& a_rhs) const;


    CUDA_DECORATION inline Point operator*(const Point& a_pt) const;


    CUDA_DECORATION inline Point operator/(const Point& a_pt) const;
        

    CUDA_DECORATION inline Point operator%(const Point& a_pt) const;


    inline Point operator+(int a_nref) const;


    inline Point operator-(int a_nref) const;


    inline Point operator*(int a_nref) const;


    inline Point operator/(int a_nref) const;


    inline Point operator%(int a_nref) const;
        
    CUDA_DECORATION inline void operator+=(const Point& a_pt);

    CUDA_DECORATION inline void operator-=(const Point& a_pt);

    CUDA_DECORATION  inline void operator*=(const Point& a_pt);


    CUDA_DECORATION inline void operator/=(const Point& a_pt);

    CUDA_DECORATION inline void operator%=(const Point& a_pt);
        
    inline void operator+=(int a_n);

    inline void operator-=(int a_n);

    inline void operator*=(int a_n);


    inline void operator/=(int a_n);

    inline void operator%=(int a_n); 

    inline Point coarsen(unsigned int a_refRatio) const;



    inline size_t linearSize() const
    {
      size_t retval = DIM*sizeof(int);
      return retval;
    }

    inline void linearOut(char* a_buf) const
    {
      int* intbuf = (int *) a_buf;
      for(int idir = 0; idir < DIM; idir++)
      {
        intbuf[idir] = m_tuple[idir];
      }
    }

    inline void linearIn(const char* a_buf) 
    {
      const int* intbuf = (int *) a_buf;
      for(int idir = 0; idir < DIM; idir++)
      {
        m_tuple[idir] = intbuf[idir];
      }
    }


    inline int sum() const;


    inline int absSum() const;



    inline void print() const;


    int m_tuple[DIM]; 

    private:

    template<typename... vars>
        CUDA_DECORATION inline void unpack(int D, int i, vars... args)
        {
            if (D < DIM)
            {
                m_tuple[D] = i;
                unpack(D+1, args...);
            }
        }
  }; //end class Point

  template<>
  CUDA_DECORATION
      inline void Point::unpack(int D, int i)
      {
          if (D < DIM)
          {
              m_tuple[D] = i;
          }
      }


  
  inline std::ostream& operator <<(std::ostream& a_os, const Point& a_pt)
  {
      a_os << "(" ;
      for (int dir = 0; dir < DIM; dir++) 
      {
          a_os << a_pt[dir];
          if(a_pt[dir] < 10)
          {
              a_os << " ";
          }
          if (dir < DIM-1) 
          {
              a_os << ",";
          }
      }
      a_os << ")";
      return a_os;
  }

  inline Point operator*(int a_scale, Point a_pt)
  {
      return (a_pt*a_scale);
  }

  inline Point operator-(Point a_pt)
  {
      return a_pt*(-1);
  }


#include "implem/Proto_PointImplem.H"
} //end namespace Proto
#endif //end include guard