Point_operators_functions.hpp

/*
 * Point_operators_functions.hpp
 *
 *  Created on: Jun 20, 2016
 *      Author: i-bird
 */

#ifndef OPENFPM_DATA_SRC_SPACE_SHAPE_POINT_OPERATORS_FUNCTIONS_HPP_
#define OPENFPM_DATA_SRC_SPACE_SHAPE_POINT_OPERATORS_FUNCTIONS_HPP_

#define CREATE_ARG_FUNC_CLASS(fun_base,fun_name,OP_ID) \
\
template <typename orig, typename exp1, typename exp2>\
class point_expression_op<orig,exp1,exp2, OP_ID >\
{\
    const exp1 o1;\
\
    mutable typename std::remove_const<typename orig::coord_type>::type scal;\
\
public:\
\
    typedef orig orig_type;\
\
    typedef int is_expression;\
\
    typedef int has_init;\
\
    typedef typename orig::coord_type return_type;\
\
    static const unsigned int nvals = exp1::nvals;\
    \
    typedef typename first_or_second_pt<has_coordtype<exp1>::value,exp1,exp2>::coord_type coord_type;\
    \
\
    __device__ __host__ inline explicit point_expression_op(const exp1 & o1)\
    :o1(o1),scal(0)\
    {}\
\
    __device__ __host__ inline void init() const\
    {\
        o1.init();\
    }\
\
    template<typename r_type=typename std::remove_reference<decltype(o1.value(0))>::type > __device__ __host__  inline r_type value(size_t k) const\
    {\
        return fun_base(o1.value(k));\
    }\
\
    template <typename T> __device__ __host__  operator T() const\
    {\
        init();\
        return fun_base(o1.value(0));\
    }\
};

#define CREATE_ARG_FUNC(fun_base,fun_name,OP_ID) \
\
template<typename orig,typename exp1, typename exp_2, unsigned int op1>\
__device__ __host__ inline point_expression_op<orig,point_expression_op<orig,exp1,exp_2,op1>,void, OP_ID >\
fun_name(const point_expression_op<orig,exp1,exp_2,op1> & va)\
{\
    point_expression_op<orig,point_expression_op<orig,exp1,exp_2,op1>,void,OP_ID> exp_sum(va);\
\
    return exp_sum;\
}\
\
\
template<unsigned int dim, typename T>\
__device__ __host__ inline point_expression_op<Point<dim,T>,Point<dim,T>,void, OP_ID >\
fun_name(const Point<dim,T> & va)\
{\
    point_expression_op<Point<dim,T>,Point<dim,T>,void,OP_ID> exp_sum(va);\
\
    return exp_sum;\
}

template <typename orig, typename exp1, typename exp2>
class point_expression_op<orig,exp1,exp2,POINT_NORM_INF>
{
    const exp1 o1;

    mutable typename std::remove_const<typename orig::coord_type>::type scal;

public:

    typedef orig orig_type;

    typedef int is_expression;

    typedef int has_init;

    typedef typename orig::coord_type return_type;

    static const unsigned int nvals = 1;

    typedef typename exp1::coord_type coord_type;

    __device__ __host__ inline explicit point_expression_op(const exp1 & o1)
            :o1(o1),scal(0.0)
    {}

    __device__ __host__ inline void init() const
    {
        scal = 0.0;

        for (size_t i = 0 ; i < orig::dims ; i++) {
            if (fabs(o1.value(i)) > scal) {
                scal=fabs(o1.value(i));
            }
        }
            //scal += o1.value(i) * o1.value(i);

        //scal = sqrt(scal);

        o1.init();
    }

    template<typename r_type=typename std::remove_reference<decltype(o1.value(0))>::type > __device__ __host__ inline r_type value(size_t k) const
    {
        return scal;
    }

    template <typename T>__device__ __host__  operator T() const
    {
        init();
        return scal;
    }
};


template <typename orig, typename exp1, typename exp2>
class point_expression_op<orig,exp1,exp2,POINT_NORM>
{
    const exp1 o1;

    mutable typename std::remove_const<typename orig::coord_type>::type scal;

public:

    typedef orig orig_type;

    typedef int is_expression;

    typedef int has_init;

    typedef typename orig::coord_type return_type;

    static const unsigned int nvals = 1;

    typedef typename exp1::coord_type coord_type;

    __device__ __host__ inline explicit point_expression_op(const exp1 & o1)
    :o1(o1),scal(0.0)
    {}

    __device__ __host__ inline void init() const
    {
        scal = 0.0;

        for (size_t i = 0 ; i < orig::dims ; i++)
            scal += o1.value(i) * o1.value(i);

        scal = sqrt(scal);

        o1.init();
    }

    template<typename r_type=typename std::remove_reference<decltype(o1.value(0))>::type > __device__ __host__ inline r_type value(size_t k) const
    {
        return scal;
    }

    template <typename T>__device__ __host__  operator T() const
    {
        init();
        return scal;
    }
};

template <typename orig, typename exp1, typename exp2>
class point_expression_op<orig,exp1,exp2,POINT_NORM2>
{
    const exp1 o1;

    mutable typename std::remove_const<typename orig::coord_type>::type scal;

public:

    typedef orig orig_type;

    typedef int has_init;

    typedef int is_expression;

    typedef typename orig::coord_type return_type;

    static const unsigned int nvals = 1;

    typedef typename exp1::coord_type coord_type;

    __device__ __host__  inline explicit point_expression_op(const exp1 & o1)
    :o1(o1),scal(0.0)
    {}

    __device__ __host__ inline void init() const
    {
        scal = 0.0;

        for (size_t i = 0 ; i < orig::dims ; i++)
            scal += o1.value(i) * o1.value(i);

        o1.init();
    }

    template<typename r_type=typename std::remove_reference<decltype(o1.value(0))>::type > __device__ __host__ inline r_type value(size_t k) const
    {
        return scal;
    }

    template <typename T> __device__ __host__  operator T() const
    {
        init();
        return scal;
    }
};


CREATE_ARG_FUNC_CLASS(std::abs,abs,POINT_ABS)
CREATE_ARG_FUNC_CLASS(std::exp,exp,POINT_EXP)
CREATE_ARG_FUNC_CLASS(std::exp2,exp2,POINT_EXP2)
CREATE_ARG_FUNC_CLASS(std::expm1,expm1,POINT_EXPM1)
CREATE_ARG_FUNC_CLASS(std::log,log,POINT_LOG)
CREATE_ARG_FUNC_CLASS(std::log10,log10,POINT_LOG10)
CREATE_ARG_FUNC_CLASS(std::log2,log2,POINT_LOG2)
CREATE_ARG_FUNC_CLASS(std::log1p,log1p,POINT_LOG1P)
CREATE_ARG_FUNC_CLASS(std::sqrt,sqrt,POINT_SQRT)
CREATE_ARG_FUNC_CLASS(std::cbrt,cbrt,POINT_CBRT)
CREATE_ARG_FUNC_CLASS(std::sin,sin,POINT_SIN)
CREATE_ARG_FUNC_CLASS(std::cos,cos,POINT_COS)
CREATE_ARG_FUNC_CLASS(std::tan,tan,POINT_TAN)
CREATE_ARG_FUNC_CLASS(std::asin,asin,POINT_ASIN)
CREATE_ARG_FUNC_CLASS(std::acos,acos,POINT_ACOS)
CREATE_ARG_FUNC_CLASS(std::atan,atan,POINT_ATAN)
CREATE_ARG_FUNC_CLASS(std::sinh,sinh,POINT_SINH)
CREATE_ARG_FUNC_CLASS(std::cosh,cosh,POINT_COSH)
CREATE_ARG_FUNC_CLASS(std::tanh,tanh,POINT_TANH)
CREATE_ARG_FUNC_CLASS(std::asinh,asinh,POINT_ASINH)
CREATE_ARG_FUNC_CLASS(std::acosh,acosh,POINT_ACOSH)
CREATE_ARG_FUNC_CLASS(std::atanh,atanh,POINT_ATANH)
CREATE_ARG_FUNC_CLASS(std::erf,erf,POINT_ERF)
CREATE_ARG_FUNC_CLASS(std::erfc,erfc,POINT_ERFC)
CREATE_ARG_FUNC_CLASS(std::tgamma,tgamma,POINT_TGAMMA)
CREATE_ARG_FUNC_CLASS(std::lgamma,lgamma,POINT_LGAMMA)
CREATE_ARG_FUNC_CLASS(std::ceil,ceil,POINT_CEIL)
CREATE_ARG_FUNC_CLASS(std::floor,floor,POINT_FLOOR)
CREATE_ARG_FUNC_CLASS(std::trunc,trunc,POINT_TRUNC)
CREATE_ARG_FUNC_CLASS(std::round,round,POINT_ROUND)
CREATE_ARG_FUNC_CLASS(std::nearbyint,nearbyint,POINT_NEARBYINT)
CREATE_ARG_FUNC_CLASS(std::rint,rint,POINT_RINT)


/* \brief Calculate the norm of the point
 *
 * \param va point expression one
 *
 * \return an object that encapsulate the expression
 *
 */
template<typename orig,typename exp1, typename exp2, unsigned int op1>
__device__ __host__  inline point_expression_op<orig,point_expression_op<orig,exp1,exp2,op1>,void,POINT_NORM>
norm(const point_expression_op<orig,exp1,exp2,op1> & va)
{
    point_expression_op<orig,point_expression_op<orig,exp1,exp2,op1>,void,POINT_NORM> exp_sum(va);

    return exp_sum;
}


/* \brief norm of a scalar
 *
 * \param d scalar double or float
 *
 * \return d
 *
 */
template <typename T>
__device__ __host__  T norm(T d)
{
    return d;
}

/* \brief Calculate the norm of the point
 *
 * \param va point expression one
 *
 * \return an object that encapsulate the expression
 *
 */
template<typename T, typename vmpl>
__device__ __host__  inline point_expression_op<Point<subar_dim<vmpl>::type::value,T>,
                                                point_expression<openfpm::detail::multi_array::sub_array_openfpm<T,1,vmpl>>,
                                                void,
                                                POINT_NORM>
norm(const point_expression<openfpm::detail::multi_array::sub_array_openfpm<T,1,vmpl>> & d)
{
        point_expression_op<Point<subar_dim<vmpl>::type::value,T>,
                            point_expression<openfpm::detail::multi_array::sub_array_openfpm<T,1,vmpl>>,
                            void,
                            POINT_NORM> exp_sum( (point_expression<openfpm::detail::multi_array::sub_array_openfpm<T,1,vmpl>>(d)) );

        return exp_sum;
}

/* \brief Calculate the norm of the point
 *
 * \param va point expression one
 *
 * \return an object that encapsulate the expression
 *
 */
template<unsigned int dim, typename T>
__device__ __host__  inline point_expression_op<Point<dim,T>,point_expression<T[dim]>,void,POINT_NORM>
norm(const point_expression<T[dim]> & d)
{
        point_expression_op<Point<dim,T>,point_expression<T[dim]>,void,POINT_NORM> exp_sum( (point_expression<T[dim]>(d)) );

        return exp_sum;
}


/* \brief Divide two points expression
 *
 * \param va point expression one
 * \param vb point expression two
 *
 * \return an object that encapsulate the expression
 *
 */
template<unsigned int dim, typename T>
__device__ __host__ inline point_expression_op<Point<dim,T>,Point<dim,T>,void,POINT_NORM>
norm(const Point<dim,T> & va)
{
    point_expression_op<Point<dim,T>,Point<dim,T>,void,POINT_NORM> exp_sum(va);

    return exp_sum;
}



/* \brief Calculate the norm of the point
 *
 * \param va point expression one
 *
 * \return an object that encapsulate the expression
 *
 */
template<typename orig,typename exp1, typename exp2, unsigned int op1>
__device__ __host__ inline point_expression_op<orig,point_expression_op<orig,exp1,exp2,op1>,void,POINT_NORM2>
norm2(const point_expression_op<orig,exp1,exp2,op1> & va)
{
    point_expression_op<orig,point_expression_op<orig,exp1,exp2,op1>,void,POINT_NORM2> exp_sum(va);

    return exp_sum;
}


/* \brief norm of a scalar
 *
 * \param d scalar double or float
 *
 * \return d
 *
 */
template <typename T>__device__ __host__ T norm2(T d)
{
    return d*d;
}


/* \brief Calculate the norm of the point
 *
 * \param va point expression one
 *
 * \return an object that encapsulate the expression
 *
 */
template<unsigned int dim, typename T>
__device__ __host__ inline point_expression_op<Point<dim,T>,point_expression<T[dim]>,void,POINT_NORM2>
norm2(const point_expression<T[dim]> & d)
{
        point_expression_op<Point<dim,T>,point_expression<T[dim]>,void,POINT_NORM2> exp_sum( (point_expression<T[dim]>(d)) );

        return exp_sum;
}


/* \brief Divide two points expression
 *
 * \param va point expression one
 * \param vb point expression two
 *
 * \return an object that encapsulate the expression
 *
 */
template<unsigned int dim, typename T>
__device__ __host__ inline point_expression_op<Point<dim,T>,Point<dim,T>,void,POINT_NORM2>
norm2(const Point<dim,T> & va)
{
    point_expression_op<Point<dim,T>,Point<dim,T>,void,POINT_NORM2> exp_sum(va);

    return exp_sum;
}


template <typename T, typename P> __device__ __host__  auto distance(T exp1, P exp2) -> decltype(norm(exp1 - exp2))
{
    return norm(exp1 - exp2);
}




/* \brief Calculate the norm of the point
 *
 * \param va point expression one
 *
 * \return an object that encapsulate the expression
 *
 */
template<typename orig,typename exp1, typename exp2, unsigned int op1>
__device__ __host__ inline point_expression_op<orig,point_expression_op<orig,exp1,exp2,op1>,void,POINT_NORM_INF>
norm_inf(const point_expression_op<orig,exp1,exp2,op1> & va)
{
    point_expression_op<orig,point_expression_op<orig,exp1,exp2,op1>,void,POINT_NORM_INF> exp_sum(va);

    return exp_sum;
}


/* \brief norm of a scalar
 *
 * \param d scalar double or float
 *
 * \return d
 *
 */
template <typename T>__device__ __host__ T norm_inf(T d)
{
    return abs(d);
}


/* \brief Calculate the norm of the point
 *
 * \param va point expression one
 *
 * \return an object that encapsulate the expression
 *
 */
template<unsigned int dim, typename T>
__device__ __host__ inline point_expression_op<Point<dim,T>,point_expression<T[dim]>,void,POINT_NORM_INF>
norm_inf(const point_expression<T[dim]> & d)
{
    point_expression_op<Point<dim,T>,point_expression<T[dim]>,void,POINT_NORM_INF> exp_sum( (point_expression<T[dim]>(d)) );

    return exp_sum;
}


/* \brief Divide two points expression
 *
 * \param va point expression one
 * \param vb point expression two
 *
 * \return an object that encapsulate the expression
 *
 */
template<unsigned int dim, typename T>
__device__ __host__ inline point_expression_op<Point<dim,T>,Point<dim,T>,void,POINT_NORM_INF>
norm_inf(const Point<dim,T> & va)
{
    point_expression_op<Point<dim,T>,Point<dim,T>,void,POINT_NORM_INF> exp_sum(va);

    return exp_sum;
}


template <typename T, typename P> __device__ __host__  auto distance_inf(T exp1, P exp2) -> decltype(norm_inf(exp1 - exp2))
{
    return norm_inf(exp1 - exp2);
}



CREATE_ARG_FUNC(std::abs,abs,POINT_ABS)
CREATE_ARG_FUNC(std::exp,exp,POINT_EXP)
CREATE_ARG_FUNC(std::exp2,exp2,POINT_EXP2)
CREATE_ARG_FUNC(std::expm1,expm1,POINT_EXPM1)
CREATE_ARG_FUNC(std::log,log,POINT_LOG)
CREATE_ARG_FUNC(std::log10,log10,POINT_LOG10)
CREATE_ARG_FUNC(std::log2,log2,POINT_LOG2)
CREATE_ARG_FUNC(std::log1p,log1p,POINT_LOG1P)
CREATE_ARG_FUNC(std::sqrt,sqrt,POINT_SQRT)
CREATE_ARG_FUNC(std::cbrt,cbrt,POINT_CBRT)
CREATE_ARG_FUNC(std::sin,sin,POINT_SIN)
CREATE_ARG_FUNC(std::cos,cos,POINT_COS)
CREATE_ARG_FUNC(std::tan,tan,POINT_TAN)
CREATE_ARG_FUNC(std::asin,asin,POINT_ASIN)
CREATE_ARG_FUNC(std::acos,acos,POINT_ACOS)
CREATE_ARG_FUNC(std::atan,atan,POINT_ATAN)
CREATE_ARG_FUNC(std::sinh,sinh,POINT_SINH)
CREATE_ARG_FUNC(std::cosh,cosh,POINT_COSH)
CREATE_ARG_FUNC(std::tanh,tanh,POINT_TANH)
CREATE_ARG_FUNC(std::asinh,asinh,POINT_ASINH)
CREATE_ARG_FUNC(std::acosh,acosh,POINT_ACOSH)
CREATE_ARG_FUNC(std::atanh,atanh,POINT_ATANH)
CREATE_ARG_FUNC(std::erf,erf,POINT_ERF)
CREATE_ARG_FUNC(std::erfc,erfc,POINT_ERFC)
CREATE_ARG_FUNC(std::tgamma,tgamma,POINT_TGAMMA)
CREATE_ARG_FUNC(std::lgamma,lgamma,POINT_LGAMMA)
CREATE_ARG_FUNC(std::ceil,ceil,POINT_CEIL)
CREATE_ARG_FUNC(std::floor,floor,POINT_FLOOR)
CREATE_ARG_FUNC(std::trunc,trunc,POINT_TRUNC)
CREATE_ARG_FUNC(std::round,round,POINT_ROUND)
CREATE_ARG_FUNC(std::nearbyint,nearbyint,POINT_NEARBYINT)
CREATE_ARG_FUNC(std::rint,rint,POINT_RINT)


#endif /* OPENFPM_DATA_SRC_SPACE_SHAPE_POINT_OPERATORS_FUNCTIONS_HPP_ */