Point.hpp

#ifndef POINT_HPP
#define POINT_HPP
 
#include <boost/fusion/sequence/intrinsic/at_c.hpp>
#include <boost/fusion/include/at_c.hpp>
#include <boost/fusion/container/vector.hpp>
#include <boost/fusion/include/vector.hpp>
#include <boost/fusion/container/vector/vector_fwd.hpp>
#include <boost/fusion/include/vector_fwd.hpp>
#include "boost/multi_array.hpp"
#include "memory_ly/Encap.hpp"
#include "Point_operators.hpp"
 
template<typename T>
struct native_encapsulated_type
{
    typedef T type;
};
 
template<unsigned int dim ,typename T> class Point
{
    public:
 
    typedef int is_vtk_writable;
 
    typedef T coord_type;
 
    typedef boost::fusion::vector<T[dim]> type;
 
    typedef int yes_is_point;
 
    type data;
 
    static const unsigned int x = 0;
 
    typedef typename native_encapsulated_type<T[dim]>::type type_native;
 
    template<typename orig, typename exp1, typename exp2, unsigned int op> __device__ __host__ Point(const point_expression_op<orig,exp1,exp2,op> & p_exp)
    {
        this->operator=(p_exp);
    }
 
    __device__ __host__ inline Point(const Point<dim,T> && p)
    {
        for(size_t i = 0; i < dim ; i++)
        {get(i) = p.get(i);}
    }
 
    __device__ __host__ inline Point(const Point<dim,T> & p)
    {
        for(size_t i = 0; i < dim ; i++)
        {get(i) = p.get(i);}
    }
 
    __device__ __host__ inline Point(const T (&p)[dim])
    {
        for(size_t i = 0; i < dim ; i++)
        {get(i) = p[i];}
    }
 
    __device__ __host__ inline Point(T d)
    {
        this->operator=(d);
    }
 
    template <typename S> __device__ __host__ inline Point(const Point<dim,S> & p)
    {
        for (size_t i = 0 ; i < dim ; i++)
        {get(i) = static_cast<S>(p.get(i));}
    }
 
    template <unsigned int d, typename M> inline Point(const encapc<d,Point<dim,T>,M> & p)
    {
        for (size_t i = 0 ; i < dim ; i++)
            get(i) = p.template get<0>()[i];
    }
 
    template <typename vmpl> inline __device__ __host__  Point(const openfpm::detail::multi_array::sub_array_openfpm<T,1,vmpl> & mar)
    {
        for (unsigned int i = 0 ; i < dim ; i++)
        {get(i) = mar[i];}
    }
 
    template <typename vmpl> inline __device__ __host__  Point(const openfpm::detail::multi_array::const_sub_array_openfpm<T,1,vmpl> & mar)
    {
        for (unsigned int i = 0 ; i < dim ; i++)
        {get(i) = mar[i];}
    }
 
    __device__ __host__ inline Point(std::initializer_list<T> p1)
    {
        size_t i = 0;
        for(T x : p1)
        {get(i) = x;i++;}
    }
 
    __device__ __host__  inline Point()
    {}
 
    __device__ __host__ inline const T & get(unsigned int i) const
    {
        return boost::fusion::at_c<x>(data)[i];
    }
 
    inline T get_vtk(size_t i) const
    {
        return boost::fusion::at_c<x>(data)[i];
    }
 
    __device__ __host__ inline T& get(unsigned int i)
    {
        return boost::fusion::at_c<x>(data)[i];
    }
 
    __device__ __host__ inline T& operator[](unsigned int i)
    {
        return get(i);
    }
 
    __device__ __host__ inline const T& operator[](unsigned int i) const
    {
        return get(i);
    }
 
    __device__ __host__ T norm() const
    {
        T n = 0.0;
 
        for (size_t i = 0 ; i < dim ; i++)
            n+=get(i) * get(i);
 
        return sqrt(n);
    }
 
    __device__ __host__ T norm1() const
    {
        T n = 0.0;
 
        for (size_t i = 0 ; i < dim ; i++)
            n+=abs(get(i));
 
        return n;
    }
 
    __device__ __host__ T distance(const Point<dim,T> & q) const
    {
        T tot = 0.0;
 
        for (size_t i = 0 ; i < dim ; i++)
            tot += (this->get(i)  - q.get(i)) * (this->get(i)  - q.get(i));
 
        return sqrt(tot);
    }
 
    T distance2(const Point<dim,T> & q) const
    {
        T tot = 0.0;
 
        for (size_t i = 0 ; i < dim ; i++)
            tot += (this->get(i)  - q.get(i)) * (this->get(i)  - q.get(i));
 
        return tot;
    }
 
 
    __device__ __host__ inline void zero()
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            get(i) = 0;
        }
    }
 
    inline void one()
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            get(i) = 1;
        }
    }
 
    inline static Point<dim,T> zero_p()
    {
        Point<dim,T> p;
 
        for (size_t i = 0 ; i < dim ; i++)
        {
            p.get(i) = 0;
        }
 
        return p;
    }
 
    std::string toPointString() const
    {
        std::stringstream ps;
 
        for (size_t i = 0 ; i < dim ; i++)
            ps << "x[" << i << "]=" << get(i) << " ";
 
        ps << "\n";
 
        return ps.str();
    }
 
    void swap(Point<dim,T> & p)
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            T tmp = get(i);
            get(i) = p.get(i);
            p.get(i) = tmp;
        }
    }
 
    __device__ __host__ inline bool operator==(const Point<dim,T> & p) const
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (p.get(i) != get(i))
            {return false;}
        }
 
        return true;
    }
 
    __device__ __host__ inline bool operator!=(const Point<dim,T> & p) const
    {
        return !this->operator==(p);
    }
 
    std::string to_string() const
    {
        return toString();
    }
 
    std::string toString() const
    {
        std::string str;
 
        for (size_t i = 0 ; i < dim - 1 ; i++)
        {
            // coverty[dead_error_line]
            str += std::to_string(static_cast<double>(get(i))) + " ";
        }
        str += std::to_string(static_cast<double>(get(dim-1)));
 
        return str;
    }
 
    __device__ __host__ T & value(size_t i)
    {
        return get(i);
    }
 
    __device__ __host__ inline T value(size_t i) const
    {
        return get(i);
    }
 
    T (&asArray())[dim]
    {
        return boost::fusion::at_c<x>(data);
    }
 
    template<typename A> Point<dim,A> convertPoint() const
    {
        Point<dim,A> p;
 
        for (size_t i = 0; i < dim ; i++)
            p.get(i) = static_cast<A>(get(i));
 
        return p;
    }
 
 
    static bool noPointers()
    {
        return true;
    }
 
 
    template<typename orig, typename exp1, typename exp2, unsigned int op> __device__ __host__ Point<dim,T> & operator=(const point_expression_op<orig,exp1,exp2,op> & p_exp)
    {
        p_exp.init();
 
        for (size_t i = 0; i < dim ; i++)
        {get(i) = p_exp.value(i);}
 
        return *this;
    }
 
    template<typename any>
    __device__ __host__ Point<dim,T> & operator=(const point_expression<any> & p_exp)
    {
        p_exp.init();
 
        for (size_t i = 0; i < dim ; i++)
            get(i) = p_exp.value(i);
 
        return *this;
    }
 
    __device__ __host__ Point<dim,T> & operator=(const T (& p)[dim])
    {
        for (size_t i = 0; i < dim ; i++)
            get(i) = p[i];
 
        return *this;
    }
 
    template<typename T1, typename check = typename std::enable_if<std::is_const<T1>::value == false>::type> __device__ __host__ Point<dim,T> & operator=(const point_expression<const T1[dim]> & p_exp)
    {
        p_exp.init();
 
        for (size_t i = 0; i < dim ; i++)
            get(i) = p_exp.value(i);
 
        return *this;
    }
 
    template<typename aT> __device__ __host__ inline Point<dim,T> operator/(const aT (&ar)[dim])
    {
        Point<dim,T> result;
 
        for (size_t i = 0 ; i < dim ; i++)
            result.get(i) = get(i) / ar[i];
 
        return result;
    }
 
    template<typename aT> __device__ __host__ inline Point<dim,T> operator/=(const aT c)
    {
        for (size_t i = 0 ; i < dim ; i++)
            get(i) = get(i) / c;
 
        return *this;
    }
 
 
    __device__ __host__ Point<dim,T> & operator=(T d)
    {
        for (size_t i = 0; i < dim ; i++)
            get(i) = d;
 
        return *this;
    }
 
    __device__ __host__ inline Point<dim,T> & operator=(const Point<dim,T> & p)
    {
        for (size_t i = 0 ; i < dim ; i++)
            get(i) = p.get(i);
 
        return *this;
    }
 
    __device__ __host__ inline Point<dim,T> & operator-=(const Point<dim,T> & p)
    {
        for (size_t i = 0 ; i < dim ; i++)
            get(i) -= p.get(i);
 
        return *this;
    }
 
    __device__ __host__ inline Point<dim,T> & operator+=(const Point<dim,T> & p)
    {
        for (size_t i = 0 ; i < dim ; i++)
        {get(i) += p.get(i);}
 
        return *this;
    }
 
    __device__ __host__ inline void init() const
    {}
 
 
    static const unsigned int max_prop = 1;
    static const unsigned int max_prop_real = 1;
 
    static const unsigned int dims = dim;
 
    static const unsigned int nvals = dim;
};
 
template <unsigned int N, typename T> std::string toPointString(const T (&p)[N] )
{
    std::stringstream ps;
 
    for (size_t i = 0 ; i < N ; i++)
        ps << "x[" << i << "]=" << p[i] << " ";
 
    ps << "\n";
 
    return ps.str();
}
 
template <unsigned int N, typename T, typename Mem> std::string toPointString(const encapc<1,Point<N,T>,Mem> & p )
{
    std::stringstream ps;
 
    for (size_t i = 0 ; i < N ; i++)
        ps << "x[" << i << "]=" << p.template get<Point<N,T>::x>()[i] << " ";
 
    ps << "\n";
 
    return ps.str();
}
 
 
 
template<unsigned int dim, typename T>  using VectorS = Point<dim,T>;
 
template<typename T, bool is_point = is_Point<T>::value>
struct rank_gen
{
    typedef boost::mpl::int_<std::rank<T>::value> type;
};
 
template<typename T>
struct rank_gen<T,true>
{
    typedef boost::mpl::int_<1> type;
};
 
template<unsigned int dim, typename T>
std::ostream& operator<<(std::ostream& os, const Point<dim, T>& p)
{
    for (unsigned int i = 0; i < dim; i++)
    {
        os << p.get(i);
        if(i < dim - 1)
            os << " ";
    }
    return os;
}
template<typename T>
std::ostream& operator<<(std::ostream& os, const Point<1, T>& p)
{
    os << p.get(0);
    return os;
}
 
#endif