#include <arm_sve.h>
#include <array>
#include <cassert>
#include <cstddef>
#include <cstdlib>
#include <initializer_list>
#include <new>
#include <type_traits>

Include dependency graph for vectorclass_sve.hpp:

Go to the source code of this file.

Classes
struct	sve::type< T >
struct	sve::type< __fp16 >
struct	sve::type< __bf16 >
struct	sve::type< float >
struct	sve::type< int32_t >
struct	sve::type< double >
struct	sve::type< int64_t >
class	VecSVEBase< T, N >
class	VecSVEMask< base_t, N >
class	VecSVE< T, N >

Namespaces
namespace	sve
namespace	sve::instructions
namespace	sve::functions

Macros
#define	SVE_INLINE __attribute__((always_inline))
#define	_mm_prefetch(addr, hint)
#define	CACHE_LINE_SIZE (64)
#define	SVE_DISPATCH_1ARG(prefix, arg1)
#define	SVE_DISPATCH_1ARG_PREDICATED_SFX(prefix, suffix, predicate, arg1)
#define	SVE_DISPATCH_2ARG_PREDICATED_SFX(prefix, suffix, predicate, arg1, arg2)
#define	SVE_DISPATCH_1ARG_PREDICATED_NOSFX(prefix, predicate, arg1)
#define	SVE_DISPATCH_2ARG_PREDICATED_NOSFX(prefix, predicate, arg1, arg2)

Functions
template<uint32_t hint>
void SVE_INLINE	aarch64_do_prefetch (void *addr)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE void	sve::instructions::svst (const svbool_t &predicate, T *location, const sve_type_t &value)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svld (const svbool_t &predicate, const T *ptr)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svdup (T value)
template<typename T>
SVE_INLINE svbool_t	sve::instructions::svtrue ()
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE T	sve::instructions::svextract (const svbool_t &predicate, const sve_type_t &vec)
template<typename T>
SVE_INLINE svbool_t	sve::instructions::pred_from_index (const std::size_t index)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svorr (const svbool_t &predicate, const sve_type_t &v1, const sve_type_t &v2)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svsqrt (const svbool_t &predicate, const sve_type_t &v1)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svand (const svbool_t &predicate, const sve_type_t &v1, const sve_type_t &v2)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::sveq (const svbool_t &mask, const sve_type_t &v1, const sve_type_t &v2)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svadd (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svadd_n (const svbool_t &predicate, const sve_type_t &lhs, const T rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE T	sve::instructions::reduce (const svbool_t &predicate, const sve_type_t &vec)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svmul (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svmul_n (const svbool_t &predicate, const sve_type_t &lhs, const T rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svsub (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svsub_n (const svbool_t &predicate, const sve_type_t &lhs, const T rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svneg (const svbool_t &predicate, const sve_type_t &operand)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svdiv (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svdiv_n (const svbool_t &predicate, const sve_type_t &lhs, const T rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svabs (const svbool_t &predicate, const sve_type_t &operand)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::eq (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::neq (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::eq_n (const svbool_t &predicate, const sve_type_t &lhs, const T rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::neq_n (const svbool_t &predicate, const sve_type_t &lhs, const T rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::lt (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::lt_n (const svbool_t &predicate, const sve_type_t &lhs, const T rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::leq (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::leq_n (const svbool_t &predicate, const sve_type_t &lhs, const T rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::gt (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::gt_n (const svbool_t &predicate, const sve_type_t &lhs, const T rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::geq (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE svbool_t	sve::instructions::geq_n (const svbool_t &predicate, const sve_type_t &lhs, const T rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svsel (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svmin (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename T, typename sve_type_t = typename sve::type<T>::vec>
SVE_INLINE sve_type_t	sve::instructions::svmax (const svbool_t &predicate, const sve_type_t &lhs, const sve_type_t &rhs)
template<typename sve_wrapper_vector_t, typename predicate_t, typename lhs_sve_vector_t, typename rhs_sve_vector_t, std::size_t len, typename return_sve_vector_t = typename sve_wrapper_vector_t::sve_vec_t>
sve_wrapper_vector_t	sve::functions::transform (const predicate_t &predicate, const lhs_sve_vector_t lhs, const rhs_sve_vector_t rhs, return_sve_vector_t(*binary_operation)(const svbool_t &, const lhs_sve_vector_t &, const rhs_sve_vector_t &))
template<typename sve_wrapper_vector_t, typename lhs_sve_vector_t, typename rhs_sve_vector_t, std::size_t len, typename return_sve_vector_t = typename sve_wrapper_vector_t::sve_vec_t>
sve_wrapper_vector_t	sve::functions::transform (const lhs_sve_vector_t lhs, const rhs_sve_vector_t rhs, return_sve_vector_t(*binary_operation)(const svbool_t &, const lhs_sve_vector_t &, const rhs_sve_vector_t &))
template<typename sve_wrapper_vector_t, typename lhs_sve_vector_t, std::size_t len, typename return_sve_vector_t = typename sve_wrapper_vector_t::sve_vec_t, typename scalar_t = typename sve_wrapper_vector_t::sve_scalar_t>
sve_wrapper_vector_t	sve::functions::transform (const lhs_sve_vector_t lhs, const scalar_t rhs, return_sve_vector_t(binary_operation_with_scalar)(const svbool_t &, const lhs_sve_vector_t &, const scalar_t))
template<typename sve_wrapper_vector_t, typename operand_vector_t, std::size_t len, typename return_sve_vector_t = typename sve_wrapper_vector_t::sve_vec_t>
sve_wrapper_vector_t	sve::functions::transform (const operand_vector_t operand, return_sve_vector_t(unary_operation)(const svbool_t &, const operand_vector_t &))
template<typename sve_wrapper_vector_t, typename predicate_t, typename lhs_sve_vector_t, std::size_t len, typename return_sve_vector_t = typename sve_wrapper_vector_t::sve_vec_t>
sve_wrapper_vector_t	sve::functions::transform (const lhs_sve_vector_t operand, const predicate_t predicate, return_sve_vector_t(*unary_operation)(const svbool_t &, const lhs_sve_vector_t &))
template<typename sve_wrapper_vector_t, typename predicate_t, typename lhs_sve_vector_t, typename rhs_sve_vector_t, std::size_t len, typename return_sve_vector_t = typename sve_wrapper_vector_t::sve_vec_t, typename return_scalar_t = typename sve_wrapper_vector_t::sve_scalar_t>
sve_wrapper_vector_t	sve::functions::transform (const lhs_sve_vector_t lhs, const rhs_sve_vector_t rhs, const predicate_t predicate, svbool_t(binary_operation)(const svbool_t &, const lhs_sve_vector_t &, const rhs_sve_vector_t &))
template<typename sve_wrapper_vector_t, typename lhs_sve_vector_t, typename rhs_sve_vector_t, std::size_t len, typename return_sve_vector_t = typename sve_wrapper_vector_t::sve_vec_t, typename return_scalar_t = typename sve_wrapper_vector_t::sve_scalar_t>
sve_wrapper_vector_t	sve::functions::transform (const lhs_sve_vector_t lhs, const rhs_sve_vector_t rhs, svbool_t(*binary_operation)(const svbool_t &, const lhs_sve_vector_t &, const rhs_sve_vector_t &))
template<typename sve_wrapper_vector_t, typename lhs_sve_vector_t, std::size_t len, typename scalar_t = typename sve_wrapper_vector_t::sve_scalar_t, typename return_sve_vector_t = typename sve_wrapper_vector_t::sve_vec_t, typename return_scalar_t = typename sve_wrapper_vector_t::sve_scalar_t>
sve_wrapper_vector_t	sve::functions::transform (const lhs_sve_vector_t lhs, const scalar_t rhs, svbool_t(binary_operation_with_scalar)(const svbool_t &, const lhs_sve_vector_t &, const scalar_t))
template<typename T, std::size_t len, std::size_t stride, typename vec_t = typename sve::type<T>::vec>
void	sve::functions::load_into (vec_t dst, const T src)
template<typename T, std::size_t len, std::size_t stride, typename vec_t = typename sve::type<T>::vec>
void	sve::functions::store_into (T dst, const vec_t src)
static void	no_subnormals ()
template<typename T, std::size_t N>
SVE_INLINE VecSVE< T, N >	abs (const VecSVE< T, N > &v)
template<typename T, std::size_t N>
SVE_INLINE VecSVE< T, N >	sqrt (const VecSVE< T, N > &v)
template<typename T, std::size_t N>
SVE_INLINE VecSVE< T, N >	select (const VecSVEMask< T, N > &mask, const VecSVE< T, N > &v1, const VecSVE< T, N > &v2)
template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v<U>>>
SVE_INLINE VecSVE< T, N >	select (const VecSVEMask< T, N > &mask, const VecSVE< T, N > &v1, const U value)
template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v<U>>>
SVE_INLINE VecSVE< T, N >	select (const VecSVEMask< T, N > &mask, const U value, const VecSVE< T, N > &v1)
template<typename T, std::size_t N>
SVE_INLINE VecSVE< T, N >	min (const VecSVE< T, N > &lhs, const VecSVE< T, N > &rhs)
template<typename T, std::size_t N>
SVE_INLINE VecSVE< T, N >	max (const VecSVE< T, N > &lhs, const VecSVE< T, N > &rhs)
template<typename T, std::size_t N>
SVE_INLINE bool	horizontal_or (const VecSVEMask< T, N > &vec)
template<typename T, std::size_t N>
SVE_INLINE bool	horizontal_and (const VecSVEMask< T, N > &vec)
template<typename other_t, std::size_t N>
VecSVE< float, N >	to_float (const VecSVE< other_t, N > &vec)
template<typename other_t, std::size_t N>
VecSVE< double, N >	to_double (const VecSVE< other_t, N > &vec)
template<typename real_t, std::size_t N, typename integral_t = typename sve::type<real_t>::integral>
VecSVE< integral_t, N >	truncate_to_int (const VecSVE< real_t, N > &arg)
template<typename real_t, std::size_t N, typename integral_t = typename sve::type<real_t>::integral>
VecSVE< integral_t, N >	roundi (const VecSVE< real_t, N > &arg)
template<typename T, std::size_t N>
VecSVE< T, N >	floor (const VecSVE< T, N > &arg)
template<typename T, std::size_t N>
T	horizontal_add (const VecSVE< T, N > &vec)
template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v<U>>>
VecSVE< T, N >	operator+ (const U lhs, const VecSVE< T, N > &rhs)
template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v<U>>>
VecSVE< T, N >	operator* (const U lhs, const VecSVE< T, N > &rhs)
template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v<U>>>
VecSVE< T, N >	operator- (U lhs, const VecSVE< T, N > &rhs)
template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v<U>>>
VecSVE< T, N >	operator/ (U lhs, const VecSVE< T, N > &rhs)

Macro Definition Documentation

◆ _mm_prefetch

#define _mm_prefetch	(		addr,
			hint )

Value:

aarch64_do_prefetch<hint>(addr)

aarch64_do_prefetch

void SVE_INLINE aarch64_do_prefetch(void *addr)

Definition vectorclass_sve.hpp:43

Definition at line 72 of file vectorclass_sve.hpp.

◆ CACHE_LINE_SIZE

#define CACHE_LINE_SIZE (64)

Definition at line 76 of file vectorclass_sve.hpp.

◆ SVE_DISPATCH_1ARG

#define SVE_DISPATCH_1ARG	(		prefix,
			arg1 )

Value:

if constexpr (std::is_same_v<T, __fp16>) {                                                                          \
   return prefix##_f16(arg1);                                                                                       \
} else if constexpr (std::is_same_v<T, __bf16>) {                                                                   \
   return prefix##_bf16(arg1);                                                                                      \
} else if constexpr (std::is_same_v<T, float>) {                                                                    \
   return prefix##_f32(arg1);                                                                                       \
} else if constexpr (std::is_same_v<T, double>) {                                                                   \
   return prefix##_f64(arg1);                                                                                       \
} else if constexpr (std::is_same_v<T, int32_t>) {                                                                  \
   return prefix##_s32(arg1);                                                                                       \
} else if constexpr (std::is_same_v<T, int64_t>) {                                                                  \
   return prefix##_s64(arg1);                                                                                       \
} else {                                                                                                            \
   static_assert(false, "Unsupported type for SVE dispatching");                                                    \
}

Definition at line 79 of file vectorclass_sve.hpp.

◆ SVE_DISPATCH_1ARG_PREDICATED_NOSFX

#define SVE_DISPATCH_1ARG_PREDICATED_NOSFX	(	prefix,
		predicate,
		arg1 )

Value:

if constexpr (std::is_same_v<T, __fp16>) {                                                                          \
   return prefix##_f16(predicate, arg1);                                                                            \
} else if constexpr (std::is_same_v<T, __bf16>) {                                                                   \
   return prefix##_bf16(predicate, arg1);                                                                           \
} else if constexpr (std::is_same_v<T, float>) {                                                                    \
   return prefix##_f32(predicate, arg1);                                                                            \
} else if constexpr (std::is_same_v<T, double>) {                                                                   \
   return prefix##_f64(predicate, arg1);                                                                            \
} else if constexpr (std::is_same_v<T, int32_t>) {                                                                  \
   return prefix##_s32(predicate, arg1);                                                                            \
} else if constexpr (std::is_same_v<T, int64_t>) {                                                                  \
   return prefix##_s64(predicate, arg1);                                                                            \
} else {                                                                                                            \
   static_assert(false, "Unsupported type for SVE dispatching");                                                    \
}

Definition at line 130 of file vectorclass_sve.hpp.

◆ SVE_DISPATCH_1ARG_PREDICATED_SFX

#define SVE_DISPATCH_1ARG_PREDICATED_SFX	(	prefix,
		suffix,
		predicate,
		arg1 )

Value:

if constexpr (std::is_same_v<T, __fp16>) {                                                                          \
   return prefix##_f16##suffix(predicate, arg1);                                                                    \
} else if constexpr (std::is_same_v<T, __bf16>) {                                                                   \
   return prefix##_bf16##suffix(predicate, arg1);                                                                   \
} else if constexpr (std::is_same_v<T, float>) {                                                                    \
   return prefix##_f32##suffix(predicate, arg1);                                                                    \
} else if constexpr (std::is_same_v<T, double>) {                                                                   \
   return prefix##_f64##suffix(predicate, arg1);                                                                    \
} else if constexpr (std::is_same_v<T, int32_t>) {                                                                  \
   return prefix##_s32##suffix(predicate, arg1);                                                                    \
} else if constexpr (std::is_same_v<T, int64_t>) {                                                                  \
   return prefix##_s64##suffix(predicate, arg1);                                                                    \
} else {                                                                                                            \
   static_assert(false, "Unsupported type for SVE dispatching");                                                    \
}

Definition at line 96 of file vectorclass_sve.hpp.

◆ SVE_DISPATCH_2ARG_PREDICATED_NOSFX

#define SVE_DISPATCH_2ARG_PREDICATED_NOSFX	(	prefix,
		predicate,
		arg1,
		arg2 )

Value:

if constexpr (std::is_same_v<T, __fp16>) {                                                                          \
   return prefix##_f16(predicate, arg1, arg2);                                                                      \
} else if constexpr (std::is_same_v<T, __bf16>) {                                                                   \
   return prefix##_bf16(predicate, arg1, arg2);                                                                     \
} else if constexpr (std::is_same_v<T, float>) {                                                                    \
   return prefix##_f32(predicate, arg1, arg2);                                                                      \
} else if constexpr (std::is_same_v<T, double>) {                                                                   \
   return prefix##_f64(predicate, arg1, arg2);                                                                      \
} else if constexpr (std::is_same_v<T, int32_t>) {                                                                  \
   return prefix##_s32(predicate, arg1, arg2);                                                                      \
} else if constexpr (std::is_same_v<T, int64_t>) {                                                                  \
   return prefix##_s64(predicate, arg1, arg2);                                                                      \
} else {                                                                                                            \
   static_assert(false, "Unsupported type for SVE dispatching");                                                    \
}

Definition at line 147 of file vectorclass_sve.hpp.

◆ SVE_DISPATCH_2ARG_PREDICATED_SFX

#define SVE_DISPATCH_2ARG_PREDICATED_SFX	(	prefix,
		suffix,
		predicate,
		arg1,
		arg2 )

Value:

if constexpr (std::is_same_v<T, __fp16>) {                                                                          \
   return prefix##_f16##suffix(predicate, arg1, arg2);                                                              \
} else if constexpr (std::is_same_v<T, __bf16>) {                                                                   \
   return prefix##_bf16##suffix(predicate, arg1, arg2);                                                             \
} else if constexpr (std::is_same_v<T, float>) {                                                                    \
   return prefix##_f32##suffix(predicate, arg1, arg2);                                                              \
} else if constexpr (std::is_same_v<T, double>) {                                                                   \
   return prefix##_f64##suffix(predicate, arg1, arg2);                                                              \
} else if constexpr (std::is_same_v<T, int32_t>) {                                                                  \
   return prefix##_s32##suffix(predicate, arg1, arg2);                                                              \
} else if constexpr (std::is_same_v<T, int64_t>) {                                                                  \
   return prefix##_s64##suffix(predicate, arg1, arg2);                                                              \
} else {                                                                                                            \
   static_assert(false, "Unsupported type for SVE dispatching");                                                    \
}

Definition at line 113 of file vectorclass_sve.hpp.

◆ SVE_INLINE

#define SVE_INLINE __attribute__((always_inline))

Definition at line 35 of file vectorclass_sve.hpp.

Function Documentation

◆ aarch64_do_prefetch()

template<uint32_t hint>

void SVE_INLINE aarch64_do_prefetch ( void * addr )

Definition at line 43 of file vectorclass_sve.hpp.

◆ abs()

template<typename T, std::size_t N>

SVE_INLINE VecSVE< T, N > abs ( const VecSVE< T, N > & v )

Definition at line 966 of file vectorclass_sve.hpp.

◆ floor()

template<typename T, std::size_t N>

VecSVE< T, N > floor ( const VecSVE< T, N > & arg )

Definition at line 1022 of file vectorclass_sve.hpp.

◆ horizontal_add()

template<typename T, std::size_t N>

T horizontal_add ( const VecSVE< T, N > & vec )

Definition at line 1024 of file vectorclass_sve.hpp.

Here is the call graph for this function:

◆ horizontal_and()

template<typename T, std::size_t N>

SVE_INLINE bool horizontal_and ( const VecSVEMask< T, N > & vec )

Definition at line 1001 of file vectorclass_sve.hpp.

Here is the call graph for this function:

◆ horizontal_or()

template<typename T, std::size_t N>

SVE_INLINE bool horizontal_or ( const VecSVEMask< T, N > & vec )

Definition at line 999 of file vectorclass_sve.hpp.

Here is the call graph for this function:

◆ max()

template<typename T, std::size_t N>

SVE_INLINE VecSVE< T, N > max	(	const VecSVE< T, N > &	lhs,
		const VecSVE< T, N > &	rhs )

Definition at line 995 of file vectorclass_sve.hpp.

Here is the call graph for this function:

◆ min()

template<typename T, std::size_t N>

SVE_INLINE VecSVE< T, N > min	(	const VecSVE< T, N > &	lhs,
		const VecSVE< T, N > &	rhs )

Definition at line 991 of file vectorclass_sve.hpp.

Here is the call graph for this function:

◆ no_subnormals()

void no_subnormals ( )

static

Definition at line 555 of file vectorclass_sve.hpp.

◆ operator*()

template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v>>

VecSVE< T, N > operator*	(	const U	lhs,
		const VecSVE< T, N > &	rhs )

Definition at line 1033 of file vectorclass_sve.hpp.

◆ operator+()

template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v>>

VecSVE< T, N > operator+	(	const U	lhs,
		const VecSVE< T, N > &	rhs )

Definition at line 1028 of file vectorclass_sve.hpp.

◆ operator-()

template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v>>

VecSVE< T, N > operator-	(	U	lhs,
		const VecSVE< T, N > &	rhs )

Definition at line 1038 of file vectorclass_sve.hpp.

◆ operator/()

template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v>>

VecSVE< T, N > operator/	(	U	lhs,
		const VecSVE< T, N > &	rhs )

Definition at line 1043 of file vectorclass_sve.hpp.

◆ roundi()

template<typename real_t, std::size_t N, typename integral_t = typename sve::type<real_t>::integral>

VecSVE< integral_t, N > roundi ( const VecSVE< real_t, N > & arg )

Definition at line 1017 of file vectorclass_sve.hpp.

◆ select() [1/3]

template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v>>

SVE_INLINE VecSVE< T, N > select	(	const VecSVEMask< T, N > &	mask,
		const U	value,
		const VecSVE< T, N > &	v1 )

Definition at line 984 of file vectorclass_sve.hpp.

Here is the call graph for this function:

◆ select() [2/3]

template<typename T, std::size_t N, typename U, typename = std::enable_if_t<std::is_arithmetic_v>>

SVE_INLINE VecSVE< T, N > select	(	const VecSVEMask< T, N > &	mask,
		const VecSVE< T, N > &	v1,
		const U	value )

Definition at line 976 of file vectorclass_sve.hpp.

Here is the call graph for this function:

◆ select() [3/3]

template<typename T, std::size_t N>

SVE_INLINE VecSVE< T, N > select	(	const VecSVEMask< T, N > &	mask,
		const VecSVE< T, N > &	v1,
		const VecSVE< T, N > &	v2 )

Definition at line 971 of file vectorclass_sve.hpp.

Here is the call graph for this function:

◆ sqrt()

template<typename T, std::size_t N>

SVE_INLINE VecSVE< T, N > sqrt ( const VecSVE< T, N > & v )

Definition at line 968 of file vectorclass_sve.hpp.

◆ to_double()

template<typename other_t, std::size_t N>

VecSVE< double, N > to_double ( const VecSVE< other_t, N > & vec )

Definition at line 1007 of file vectorclass_sve.hpp.

◆ to_float()

template<typename other_t, std::size_t N>

VecSVE< float, N > to_float ( const VecSVE< other_t, N > & vec )

Definition at line 1003 of file vectorclass_sve.hpp.

◆ truncate_to_int()

template<typename real_t, std::size_t N, typename integral_t = typename sve::type<real_t>::integral>

VecSVE< integral_t, N > truncate_to_int ( const VecSVE< real_t, N > & arg )

Definition at line 1012 of file vectorclass_sve.hpp.

Classes

Namespaces

Macros

Functions

Macro Definition Documentation

◆ _mm_prefetch

◆ CACHE_LINE_SIZE

◆ SVE_DISPATCH_1ARG

◆ SVE_DISPATCH_1ARG_PREDICATED_NOSFX

◆ SVE_DISPATCH_1ARG_PREDICATED_SFX

◆ SVE_DISPATCH_2ARG_PREDICATED_NOSFX

◆ SVE_DISPATCH_2ARG_PREDICATED_SFX

◆ SVE_INLINE

Function Documentation

◆ aarch64_do_prefetch()

◆ abs()

◆ floor()

◆ horizontal_add()

◆ horizontal_and()

◆ horizontal_or()

◆ max()

◆ min()

◆ no_subnormals()

◆ operator*()

◆ operator+()

◆ operator-()

◆ operator/()

◆ roundi()

◆ select() [1/3]

◆ select() [2/3]

◆ select() [3/3]

◆ sqrt()

◆ to_double()

◆ to_float()

◆ truncate_to_int()