Classes for explicit (done by the programmer) vectorization (SIMD) of computations. More...

Collaboration diagram for Vectorization (SIMD):

Namespaces
namespace	simd::SizeTag

Classes
class	ARRAY_T
	Symbols that need to be defined before including this header: More...

class	simd::Array< Scalar_t, N >
	A simple SIMD type relying on implicit vectorization, i.e. done by the compiler, explicitly vectorized specializations are defined after. More...

Macros
#define	MAKE_UNARY_FUN(NAME, IMPL) FORCEINLINE ARRAY_T NAME(const ARRAY_T& x) { return IMPL(x.reg); }

#define	MAKE_UNARY_FUN(NAME, IMPL)

#define	MAKE_BINARY_FUN(NAME, IMPL)

#define	MAKE_BINARY_FUN(NAME, IMPL)

#define	FOREACH SU2_OMP_SIMD for (size_t k = 0; k < Size; ++k)

#define	FOREACH SU2_OMP_SIMD for (size_t k = 0; k < ARRAY_T::Size; ++k)

#define	ARRAY_T Array<double, 2>

#define	ARRAY_T Array<float, 4>

#define	SCALAR_T double

#define	SCALAR_T float

#define	REGISTER_T __m128d

#define	REGISTER_T __m128

#define	SIZE_TAG SizeTag::TWO()

#define	SIZE_TAG SizeTag::FOUR()

Functions
FORCEINLINE ARRAY_T	operator- (const ARRAY_T &x)

FORCEINLINE ARRAY_T	sqrt (const ARRAY_T &x)

FORCEINLINE ARRAY_T	abs (const ARRAY_T &x)

FORCEINLINE ARRAY_T	sign (const ARRAY_T &x)

FORCEINLINE ARRAY_T	operator+ (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	operator+ (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	operator+ (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	operator- (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	operator- (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	operator- (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	operator* (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	operator* (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	operator* (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	operator/ (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	operator/ (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	operator/ (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	operator< (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	operator< (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	operator< (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	operator> (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	operator> (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	operator> (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	operator== (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	operator== (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	operator== (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	operator!= (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	operator!= (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	operator!= (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	operator<= (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	operator<= (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	operator<= (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	operator>= (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	operator>= (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	operator>= (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	fmax (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	fmax (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	fmax (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	fmin (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	fmin (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	fmin (SCALAR_T b, const ARRAY_T &a)

FORCEINLINE ARRAY_T	exp (const ARRAY_T &x)

FORCEINLINE ARRAY_T	pow (const ARRAY_T &a, const ARRAY_T &b)

FORCEINLINE ARRAY_T	pow (const ARRAY_T &a, SCALAR_T b)

FORCEINLINE ARRAY_T	pow (SCALAR_T b, const ARRAY_T &a)

template<class T >
constexpr size_t	simd::preferredLen ()
	Convert the SIMD size (bytes) to a lenght (num elems).

template<>
constexpr size_t	simd::preferredLen< su2double > ()

__m128d	simd::set1_p (SizeTag::TWO, double p)

__m128d	simd::load_p (SizeTag::TWO, const double *p)

__m128d	simd::loadu_p (SizeTag::TWO, const double *p)

void	simd::store_p (double *p, __m128d x)

void	simd::storeu_p (double *p, __m128d x)

void	simd::stream_p (double *p, __m128d x)

__m128d	simd::add_p (__m128d a, __m128d b)

__m128d	simd::sub_p (__m128d a, __m128d b)

__m128d	simd::mul_p (__m128d a, __m128d b)

__m128d	simd::div_p (__m128d a, __m128d b)

__m128d	simd::max_p (__m128d a, __m128d b)

__m128d	simd::min_p (__m128d a, __m128d b)

__m128d	simd::eq_p (__m128d a, __m128d b)

__m128d	simd::lt_p (__m128d a, __m128d b)

__m128d	simd::le_p (__m128d a, __m128d b)

__m128d	simd::ne_p (__m128d a, __m128d b)

__m128d	simd::ge_p (__m128d a, __m128d b)

__m128d	simd::gt_p (__m128d a, __m128d b)

__m128d	simd::sqrt_p (__m128d x)

__m128d	simd::abs_p (__m128d x)

__m128d	simd::neg_p (__m128d x)

__m128d	simd::sign_p (__m128d x)

__m128	simd::set1_p (SizeTag::FOUR, float p)

__m128	simd::load_p (SizeTag::FOUR, const float *p)

__m128	simd::loadu_p (SizeTag::FOUR, const float *p)

void	simd::store_p (float *p, __m128 x)

void	simd::storeu_p (float *p, __m128 x)

void	simd::stream_p (float *p, __m128 x)

__m128	simd::add_p (__m128 a, __m128 b)

__m128	simd::sub_p (__m128 a, __m128 b)

__m128	simd::mul_p (__m128 a, __m128 b)

__m128	simd::div_p (__m128 a, __m128 b)

__m128	simd::max_p (__m128 a, __m128 b)

__m128	simd::min_p (__m128 a, __m128 b)

__m128	simd::eq_p (__m128 a, __m128 b)

__m128	simd::lt_p (__m128 a, __m128 b)

__m128	simd::le_p (__m128 a, __m128 b)

__m128	simd::ne_p (__m128 a, __m128 b)

__m128	simd::ge_p (__m128 a, __m128 b)

__m128	simd::gt_p (__m128 a, __m128 b)

__m128	simd::sqrt_p (__m128 x)

__m128	simd::abs_p (__m128 x)

__m128	simd::neg_p (__m128 x)

__m128	simd::sign_p (__m128 x)

Variables
constexpr size_t	simd::PREFERRED_SIZE = 16

constexpr uint64_t	simd::abs_mask_d = 0x7FFFFFFFFFFFFFFFL

constexpr uint32_t	simd::abs_mask_s = 0x7FFFFFFFU

constexpr uint64_t	simd::sign_mask_d = 0x8000000000000000L

constexpr uint32_t	simd::sign_mask_s = 0x80000000U

Detailed Description

Classes for explicit (done by the programmer) vectorization (SIMD) of computations.

Macro Definition Documentation

◆ ARRAY_T [1/2]

#define ARRAY_T Array<double, 2>

Create specialization for array of 2 doubles (this should be always available).

Create specialization for array of 4 floats (this should be always available).

◆ ARRAY_T [2/2]

#define ARRAY_T Array<float, 4>

Create specialization for array of 2 doubles (this should be always available).

Create specialization for array of 4 floats (this should be always available).

◆ FOREACH [1/2]

#define FOREACH SU2_OMP_SIMD for (size_t k = 0; k < Size; ++k)

Compatibility mode overloads, element-wise implementation.

◆ FOREACH [2/2]

#define FOREACH SU2_OMP_SIMD for (size_t k = 0; k < ARRAY_T::Size; ++k)

Compatibility mode overloads, element-wise implementation.

◆ MAKE_BINARY_FUN [1/2]

#define MAKE_BINARY_FUN	(	NAME,
		IMPL
	)

Value:

  FORCEINLINE ARRAY_T NAME(const ARRAY_T& a, const ARRAY_T& b) { return IMPL(a.reg, b.reg); }         \
  FORCEINLINE ARRAY_T NAME(const ARRAY_T& a, SCALAR_T b) { return IMPL(a.reg, set1_p(SIZE_TAG, b)); } \
  FORCEINLINE ARRAY_T NAME(SCALAR_T b, const ARRAY_T& a) { return IMPL(set1_p(SIZE_TAG, b), a.reg); }

◆ MAKE_BINARY_FUN [2/2]

#define MAKE_BINARY_FUN	(	NAME,
		IMPL
	)

Value:

  FORCEINLINE ARRAY_T NAME(const ARRAY_T& a, const ARRAY_T& b) { \
    ARRAY_T res;                                                 \
    FOREACH { res[k] = IMPL(a[k], b[k]); }                       \
    return res;                                                  \
  }                                                              \
  FORCEINLINE ARRAY_T NAME(const ARRAY_T& a, SCALAR_T b) {       \
    ARRAY_T res;                                                 \
    FOREACH { res[k] = IMPL(a[k], b); }                          \
    return res;                                                  \
  }                                                              \
  FORCEINLINE ARRAY_T NAME(SCALAR_T b, const ARRAY_T& a) {       \
    ARRAY_T res;                                                 \
    FOREACH { res[k] = IMPL(b, a[k]); }                          \
    return res;                                                  \
  }

◆ MAKE_UNARY_FUN [1/2]

#define MAKE_UNARY_FUN	(	NAME,
		IMPL
	)	FORCEINLINE ARRAY_T NAME(const ARRAY_T& x) { return IMPL(x.reg); }

SIMD overloads, NAME is the operator or function, IMPL the intrinsic function that implements it.

◆ MAKE_UNARY_FUN [2/2]

#define MAKE_UNARY_FUN	(	NAME,
		IMPL
	)

Value:

  FORCEINLINE ARRAY_T NAME(const ARRAY_T& x) { \
    ARRAY_T res;                               \
    FOREACH { res[k] = IMPL(x[k]); }           \
    return res;                                \
  }

SIMD overloads, NAME is the operator or function, IMPL the intrinsic function that implements it.

◆ REGISTER_T [1/2]

#define REGISTER_T __m128d

◆ REGISTER_T [2/2]

#define REGISTER_T __m128

◆ SCALAR_T [1/2]

#define SCALAR_T double

◆ SCALAR_T [2/2]

#define SCALAR_T float

◆ SIZE_TAG [1/2]

#define SIZE_TAG SizeTag::TWO()

◆ SIZE_TAG [2/2]

#define SIZE_TAG SizeTag::FOUR()

Function Documentation

◆ abs()

FORCEINLINE ARRAY_T abs ( const ARRAY_T & x )

◆ abs_p() [1/2]

__m128 simd::abs_p ( __m128 x )

inline

◆ abs_p() [2/2]

__m128d simd::abs_p ( __m128d x )

inline

◆ add_p() [1/2]

__m128 simd::add_p	(	__m128	a,
		__m128	b
	)

inline

◆ add_p() [2/2]

__m128d simd::add_p	(	__m128d	a,
		__m128d	b
	)

inline

◆ div_p() [1/2]

__m128 simd::div_p	(	__m128	a,
		__m128	b
	)

inline

◆ div_p() [2/2]

__m128d simd::div_p	(	__m128d	a,
		__m128d	b
	)

inline

◆ eq_p() [1/2]

__m128 simd::eq_p	(	__m128	a,
		__m128	b
	)

inline

◆ eq_p() [2/2]

__m128d simd::eq_p	(	__m128d	a,
		__m128d	b
	)

inline

◆ exp()

FORCEINLINE ARRAY_T exp ( const ARRAY_T & x )

◆ fmax() [1/3]

FORCEINLINE ARRAY_T fmax	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ fmax() [2/3]

FORCEINLINE ARRAY_T fmax	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ fmax() [3/3]

FORCEINLINE ARRAY_T fmax	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ fmin() [1/3]

FORCEINLINE ARRAY_T fmin	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ fmin() [2/3]

FORCEINLINE ARRAY_T fmin	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ fmin() [3/3]

FORCEINLINE ARRAY_T fmin	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ ge_p() [1/2]

__m128 simd::ge_p	(	__m128	a,
		__m128	b
	)

inline

◆ ge_p() [2/2]

__m128d simd::ge_p	(	__m128d	a,
		__m128d	b
	)

inline

◆ gt_p() [1/2]

__m128 simd::gt_p	(	__m128	a,
		__m128	b
	)

inline

◆ gt_p() [2/2]

__m128d simd::gt_p	(	__m128d	a,
		__m128d	b
	)

inline

◆ le_p() [1/2]

__m128 simd::le_p	(	__m128	a,
		__m128	b
	)

inline

◆ le_p() [2/2]

__m128d simd::le_p	(	__m128d	a,
		__m128d	b
	)

inline

◆ load_p() [1/2]

__m128 simd::load_p	(	SizeTag::FOUR	,
		const float *	p
	)

inline

◆ load_p() [2/2]

__m128d simd::load_p	(	SizeTag::TWO	,
		const double *	p
	)

inline

◆ loadu_p() [1/2]

__m128 simd::loadu_p	(	SizeTag::FOUR	,
		const float *	p
	)

inline

◆ loadu_p() [2/2]

__m128d simd::loadu_p	(	SizeTag::TWO	,
		const double *	p
	)

inline

◆ lt_p() [1/2]

__m128 simd::lt_p	(	__m128	a,
		__m128	b
	)

inline

◆ lt_p() [2/2]

__m128d simd::lt_p	(	__m128d	a,
		__m128d	b
	)

inline

◆ max_p() [1/2]

__m128 simd::max_p	(	__m128	a,
		__m128	b
	)

inline

◆ max_p() [2/2]

__m128d simd::max_p	(	__m128d	a,
		__m128d	b
	)

inline

◆ min_p() [1/2]

__m128 simd::min_p	(	__m128	a,
		__m128	b
	)

inline

◆ min_p() [2/2]

__m128d simd::min_p	(	__m128d	a,
		__m128d	b
	)

inline

◆ mul_p() [1/2]

__m128 simd::mul_p	(	__m128	a,
		__m128	b
	)

inline

◆ mul_p() [2/2]

__m128d simd::mul_p	(	__m128d	a,
		__m128d	b
	)

inline

◆ ne_p() [1/2]

__m128 simd::ne_p	(	__m128	a,
		__m128	b
	)

inline

◆ ne_p() [2/2]

__m128d simd::ne_p	(	__m128d	a,
		__m128d	b
	)

inline

◆ neg_p() [1/2]

__m128 simd::neg_p ( __m128 x )

inline

◆ neg_p() [2/2]

__m128d simd::neg_p ( __m128d x )

inline

◆ operator!=() [1/3]

FORCEINLINE ARRAY_T operator!=	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ operator!=() [2/3]

FORCEINLINE ARRAY_T operator!=	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ operator!=() [3/3]

FORCEINLINE ARRAY_T operator!=	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ operator*() [1/3]

FORCEINLINE ARRAY_T operator*	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ operator*() [2/3]

FORCEINLINE ARRAY_T operator*	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ operator*() [3/3]

FORCEINLINE ARRAY_T operator*	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ operator+() [1/3]

FORCEINLINE ARRAY_T operator+	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ operator+() [2/3]

FORCEINLINE ARRAY_T operator+	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ operator+() [3/3]

FORCEINLINE ARRAY_T operator+	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ operator-() [1/4]

FORCEINLINE ARRAY_T operator-	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ operator-() [2/4]

FORCEINLINE ARRAY_T operator-	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ operator-() [3/4]

FORCEINLINE ARRAY_T operator- ( const ARRAY_T & x )

◆ operator-() [4/4]

FORCEINLINE ARRAY_T operator-	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ operator/() [1/3]

FORCEINLINE ARRAY_T operator/	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ operator/() [2/3]

FORCEINLINE ARRAY_T operator/	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ operator/() [3/3]

FORCEINLINE ARRAY_T operator/	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ operator<() [1/3]

FORCEINLINE ARRAY_T operator<	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ operator<() [2/3]

FORCEINLINE ARRAY_T operator<	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ operator<() [3/3]

FORCEINLINE ARRAY_T operator<	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ operator<=() [1/3]

FORCEINLINE ARRAY_T operator<=	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ operator<=() [2/3]

FORCEINLINE ARRAY_T operator<=	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ operator<=() [3/3]

FORCEINLINE ARRAY_T operator<=	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ operator==() [1/3]

FORCEINLINE ARRAY_T operator==	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ operator==() [2/3]

FORCEINLINE ARRAY_T operator==	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ operator==() [3/3]

FORCEINLINE ARRAY_T operator==	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ operator>() [1/3]

FORCEINLINE ARRAY_T operator>	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ operator>() [2/3]

FORCEINLINE ARRAY_T operator>	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ operator>() [3/3]

FORCEINLINE ARRAY_T operator>	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ operator>=() [1/3]

FORCEINLINE ARRAY_T operator>=	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ operator>=() [2/3]

FORCEINLINE ARRAY_T operator>=	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ operator>=() [3/3]

FORCEINLINE ARRAY_T operator>=	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ pow() [1/3]

FORCEINLINE ARRAY_T pow	(	const ARRAY_T &	a,
		const ARRAY_T &	b
	)

◆ pow() [2/3]

FORCEINLINE ARRAY_T pow	(	const ARRAY_T &	a,
		SCALAR_T	b
	)

◆ pow() [3/3]

FORCEINLINE ARRAY_T pow	(	SCALAR_T	b,
		const ARRAY_T &	a
	)

◆ preferredLen()

template<class T >

constexpr size_t simd::preferredLen ( )

constexpr

Convert the SIMD size (bytes) to a lenght (num elems).

◆ preferredLen< su2double >()

template<>

constexpr size_t simd::preferredLen< su2double > ( )

constexpr

◆ set1_p() [1/2]

__m128 simd::set1_p	(	SizeTag::FOUR	,
		float	p
	)

inline

◆ set1_p() [2/2]

__m128d simd::set1_p	(	SizeTag::TWO	,
		double	p
	)

inline

◆ sign()

FORCEINLINE ARRAY_T sign ( const ARRAY_T & x )

◆ sign_p() [1/2]

__m128 simd::sign_p ( __m128 x )

inline

◆ sign_p() [2/2]

__m128d simd::sign_p ( __m128d x )

inline

◆ sqrt()

FORCEINLINE ARRAY_T sqrt ( const ARRAY_T & x )

◆ sqrt_p() [1/2]

__m128 simd::sqrt_p ( __m128 x )

inline

◆ sqrt_p() [2/2]

__m128d simd::sqrt_p ( __m128d x )

inline

◆ store_p() [1/2]

void simd::store_p	(	double *	p,
		__m128d	x
	)

inline

◆ store_p() [2/2]

void simd::store_p	(	float *	p,
		__m128	x
	)

inline

◆ storeu_p() [1/2]

void simd::storeu_p	(	double *	p,
		__m128d	x
	)

inline

◆ storeu_p() [2/2]

void simd::storeu_p	(	float *	p,
		__m128	x
	)

inline

◆ stream_p() [1/2]

void simd::stream_p	(	double *	p,
		__m128d	x
	)

inline

◆ stream_p() [2/2]

void simd::stream_p	(	float *	p,
		__m128	x
	)

inline

◆ sub_p() [1/2]

__m128 simd::sub_p	(	__m128	a,
		__m128	b
	)

inline

◆ sub_p() [2/2]

__m128d simd::sub_p	(	__m128d	a,
		__m128d	b
	)

inline

Variable Documentation

◆ abs_mask_d

constexpr uint64_t simd::abs_mask_d = 0x7FFFFFFFFFFFFFFFL

constexpr

◆ abs_mask_s

constexpr uint32_t simd::abs_mask_s = 0x7FFFFFFFU

constexpr

◆ PREFERRED_SIZE

constexpr size_t simd::PREFERRED_SIZE = 16

constexpr

◆ sign_mask_d

constexpr uint64_t simd::sign_mask_d = 0x8000000000000000L

constexpr

◆ sign_mask_s

constexpr uint32_t simd::sign_mask_s = 0x80000000U

constexpr

Namespaces

Classes

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ ARRAY_T [1/2]

◆ ARRAY_T [2/2]

◆ FOREACH [1/2]

◆ FOREACH [2/2]

◆ MAKE_BINARY_FUN [1/2]

◆ MAKE_BINARY_FUN [2/2]

◆ MAKE_UNARY_FUN [1/2]

◆ MAKE_UNARY_FUN [2/2]

◆ REGISTER_T [1/2]

◆ REGISTER_T [2/2]

◆ SCALAR_T [1/2]

◆ SCALAR_T [2/2]

◆ SIZE_TAG [1/2]

◆ SIZE_TAG [2/2]

Function Documentation

◆ abs()

◆ abs_p() [1/2]

◆ abs_p() [2/2]

◆ add_p() [1/2]

◆ add_p() [2/2]

◆ div_p() [1/2]

◆ div_p() [2/2]

◆ eq_p() [1/2]

◆ eq_p() [2/2]

◆ exp()

◆ fmax() [1/3]

◆ fmax() [2/3]

◆ fmax() [3/3]

◆ fmin() [1/3]

◆ fmin() [2/3]

◆ fmin() [3/3]

◆ ge_p() [1/2]

◆ ge_p() [2/2]

◆ gt_p() [1/2]

◆ gt_p() [2/2]

◆ le_p() [1/2]

◆ le_p() [2/2]

◆ load_p() [1/2]

◆ load_p() [2/2]

◆ loadu_p() [1/2]

◆ loadu_p() [2/2]

◆ lt_p() [1/2]

◆ lt_p() [2/2]

◆ max_p() [1/2]

◆ max_p() [2/2]

◆ min_p() [1/2]

◆ min_p() [2/2]

◆ mul_p() [1/2]

◆ mul_p() [2/2]

◆ ne_p() [1/2]

◆ ne_p() [2/2]

◆ neg_p() [1/2]

◆ neg_p() [2/2]

◆ operator!=() [1/3]

◆ operator!=() [2/3]

◆ operator!=() [3/3]

◆ operator*() [1/3]

◆ operator*() [2/3]

◆ operator*() [3/3]

◆ operator+() [1/3]

◆ operator+() [2/3]

◆ operator+() [3/3]

◆ operator-() [1/4]

◆ operator-() [2/4]

◆ operator-() [3/4]

◆ operator-() [4/4]

◆ operator/() [1/3]

◆ operator/() [2/3]

◆ operator/() [3/3]

◆ operator<() [1/3]

◆ operator<() [2/3]

◆ operator<() [3/3]

◆ operator<=() [1/3]