arrithm.h File Reference

#include <type_traits>
#include "arrays.h"
#include "misc.h"

Include dependency graph for arrithm.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	declareDeepUnaryOperatorTemplates(IN, OP)
#define	declareDeepReducedArithmeticTemplates(OUT, OP, IN)
#define	declareShallowReducedArithmeticTemplates(OUT, OP, IN)
#define	declareDeepBinaryOperatorTemplates(OUT, OP, IN)

Macro Definition Documentation

#define declareDeepBinaryOperatorTemplates	(		OUT,
			OP,
			IN
	)

#define declareDeepReducedArithmeticTemplates	(		OUT,
			OP,
			IN
	)

Value:

\
template <                                                                    \
    class T1,                                                                 \
    class T2,                                                                 \
    class = typename std::enable_if<is_scalar<T2>::value>::type               \
> OUT<T1> operator OP##= (OUT<T1> & a, T2 const & b)                          \
{                                                                             \
    T1 * restrict pa = a.data();                                              \
                                                                              \
    size_t N = a.size();                                                      \
    for (size_t i = 0; i < N; i++)                                            \
        pa[i] OP##= b;                                                        \
                                                                              \
    return a;                                                                 \
}                                                                             \
                                                                              \
template <class T1, class T2>                                                 \
OUT<T1> operator OP##= (OUT<T1> & a, IN<T2> const & b)                        \
{                                                                             \
    assert(a.size() == b.size());                                             \
                                                                              \
    T1       * restrict pa = a.data();                                        \
    T2 const * restrict pb = b.data();                                        \
                                                                              \
    size_t N = a.size();                                                      \
    for (size_t i = 0; i < N; i++)                                            \
        pa[i] OP##= pb[i];                                                    \
                                                                              \
    return a;                                                                 \
}

#define declareDeepUnaryOperatorTemplates	(		IN,
			OP
	)

Value:

\
template <class T>                                                            \
IN<T> operator OP (IN<T> const & a)                                           \
{                                                                             \
    IN<T> b(a);                                                               \
    for (T & e : b)                                                           \
        e = OP e;                                                             \
    return b;                                                                 \
}

#define declareShallowReducedArithmeticTemplates	(		OUT,
			OP,
			IN
	)

Value:

\
template <                                                                    \
    class T1,                                                                 \
    class T2,                                                                 \
    class = typename std::enable_if<is_scalar<T2>::value>::type               \
> OUT<T1> operator OP##= (OUT<T1> a, T2 const & b)                            \
{                                                                             \
    T1 * restrict pa = a.data();                                              \
                                                                              \
    size_t N = a.size();                                                      \
    for (size_t i = 0; i < N; i++)                                            \
        pa[i] OP##= b;                                                        \
                                                                              \
    return a;                                                                 \
}                                                                             \
                                                                              \
template <class T1, class T2>                                                 \
OUT<T1> operator OP##= (OUT<T1> a, IN<T2> b)                                  \
{                                                                             \
    assert(a.size() == b.size());                                             \
                                                                              \
    T1       * restrict pa = a.data();                                        \
    T2 const * restrict pb = b.data();                                        \
                                                                              \
    size_t N = a.size();                                                      \
    for (size_t i = 0; i < N; i++)                                            \
        pa[i] OP##= pb[i];                                                    \
                                                                              \
    return a;                                                                 \
}