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 "Grid/Encap.hpp"

template<unsigned int dim ,typename T> class Point
{
    public:

    typedef T coord_type;

    typedef boost::fusion::vector<T[dim]> type;

    type data;

    static const unsigned int x = 0;

    inline T get(int i) const
    {
        return boost::fusion::at_c<x>(data)[i];
    }

    inline T& get(int i)
    {
        return boost::fusion::at_c<x>(data)[i];
    }

    inline T& operator[](size_t i)
    {
        return get(i);
    }

    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;
    }

    inline Point<dim,T> operator*(T c)
    {
        Point<dim,T> result;

        for (size_t i = 0 ; i < dim ; i++)
        {
            result.get(i) = get(i) * c;
        }

        return result;
    }

    template<typename aT> inline Point<dim,T> operator*(const Point<dim,aT> & p)
    {
        Point<dim,T> result;

        for (size_t i = 0 ; i < dim ; i++)
        {
            result.get(i) = get(i) * p.get(i);
        }

        return result;
    }

    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;
    }

    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;
    }

    T norm()
    {
        T n = 0.0;

        for (size_t i = 0 ; i < dim ; i++)
        {
            n+=get(i) * get(i);
        }

        return sqrt(n);
    }

    template<typename aT> inline Point<dim,T> operator+(const Point<dim,aT> & p)
    {
        Point<dim,T> result;

        for (size_t i = 0 ; i < dim ; i++)
        {
            result.get(i) = get(i) + p.get(i);
        }

        return result;
    }

    template<typename aT> 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> inline Point<dim,T> operator/(const aT c)
    {
        Point<dim,T> result;

        for (size_t i = 0 ; i < dim ; i++)
        {
            result.get(i) = get(i) / c;
        }

        return result;
    }

    inline Point<dim,T> operator-(const Point<dim,T> & p)
    {
        Point<dim,T> result;

        for (size_t i = 0 ; i < dim ; i++)
        {
            result.get(i) = get(i) - p.get(i);
        }

        return result;
    }

    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();
    }

    std::string toString() const
    {
        std::string str;

        for (size_t i = 0 ; i < dim - 1 ; i++)
        {
            str += std::to_string(get(i)) + " ";
        }
        str += std::to_string(get(dim-1));

        return str;
    }

    inline Point(const Point<dim,T> && p)
    {
        for(size_t i = 0; i < dim ; i++)
        {get(i) = p.get(i);}
    }

    inline Point(const Point<dim,T> & p)
    {
        for(size_t i = 0; i < dim ; i++)
        {get(i) = p.get(i);}
    }

    inline Point(const T (&p)[dim])
    {
        for(size_t i = 0; i < dim ; i++)
        {get(i) = p[i];}
    }

    template <typename S> 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];
    }

    inline Point(std::initializer_list<T> p1)
    {
        size_t i = 0;
        for(T x : p1)
        {get(i) = x;i++;}
    }

    inline Point()
    {}

    T & value(size_t i)
    {
        return get(i);
    }

    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;
    }

    static const unsigned int max_prop = 1;
    static const unsigned int dims = 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();
}

#endif