Grok 12.0.1
Classes | Namespaces | Macros | Typedefs | Functions | Variables
arm_sve-inl.h File Reference
#include <arm_sve.h>
#include "hwy/ops/shared-inl.h"

Go to the source code of this file.

Classes

struct  hwy::HWY_NAMESPACE::DFromV_t< V >
 
struct  hwy::HWY_NAMESPACE::CompressIsPartition< T >
 

Namespaces

namespace  hwy
 
namespace  hwy::HWY_NAMESPACE
 
namespace  hwy::HWY_NAMESPACE::detail
 

Macros

#define HWY_SVE_HAVE_2   1
 
#define HWY_SVE_HAVE_BF16_FEATURE   0
 
#define HWY_SVE_HAVE_BF16_VEC   0
 
#define HWY_SVE_HAVE_F32_TO_BF16C   0
 
#define HWY_SVE_FOREACH_U08(X_MACRO, NAME, OP)   X_MACRO(uint, u, 8, 8, NAME, OP)
 
#define HWY_SVE_FOREACH_U16(X_MACRO, NAME, OP)   X_MACRO(uint, u, 16, 8, NAME, OP)
 
#define HWY_SVE_FOREACH_U32(X_MACRO, NAME, OP)    X_MACRO(uint, u, 32, 16, NAME, OP)
 
#define HWY_SVE_FOREACH_U64(X_MACRO, NAME, OP)    X_MACRO(uint, u, 64, 32, NAME, OP)
 
#define HWY_SVE_FOREACH_I08(X_MACRO, NAME, OP)   X_MACRO(int, s, 8, 8, NAME, OP)
 
#define HWY_SVE_FOREACH_I16(X_MACRO, NAME, OP)   X_MACRO(int, s, 16, 8, NAME, OP)
 
#define HWY_SVE_FOREACH_I32(X_MACRO, NAME, OP)   X_MACRO(int, s, 32, 16, NAME, OP)
 
#define HWY_SVE_FOREACH_I64(X_MACRO, NAME, OP)   X_MACRO(int, s, 64, 32, NAME, OP)
 
#define HWY_SVE_FOREACH_F16(X_MACRO, NAME, OP)    X_MACRO(float, f, 16, 16, NAME, OP)
 
#define HWY_SVE_FOREACH_F32(X_MACRO, NAME, OP)    X_MACRO(float, f, 32, 16, NAME, OP)
 
#define HWY_SVE_FOREACH_F64(X_MACRO, NAME, OP)    X_MACRO(float, f, 64, 32, NAME, OP)
 
#define HWY_SVE_FOREACH_BF16_UNCONDITIONAL(X_MACRO, NAME, OP)    X_MACRO(bfloat, bf, 16, 16, NAME, OP)
 
#define HWY_SVE_FOREACH_BF16(X_MACRO, NAME, OP)
 
#define HWY_SVE_IF_EMULATED_D(D)   HWY_IF_BF16_D(D)
 
#define HWY_SVE_IF_NOT_EMULATED_D(D)   HWY_IF_NOT_BF16_D(D)
 
#define HWY_SVE_FOREACH_U(X_MACRO, NAME, OP)
 
#define HWY_SVE_FOREACH_I(X_MACRO, NAME, OP)
 
#define HWY_SVE_FOREACH_F3264(X_MACRO, NAME, OP)
 
#define HWY_SVE_FOREACH_F(X_MACRO, NAME, OP)
 
#define HWY_SVE_FOREACH_UI08(X_MACRO, NAME, OP)
 
#define HWY_SVE_FOREACH_UI16(X_MACRO, NAME, OP)
 
#define HWY_SVE_FOREACH_UI32(X_MACRO, NAME, OP)
 
#define HWY_SVE_FOREACH_UI64(X_MACRO, NAME, OP)
 
#define HWY_SVE_FOREACH_UIF3264(X_MACRO, NAME, OP)
 
#define HWY_SVE_FOREACH_UI(X_MACRO, NAME, OP)
 
#define HWY_SVE_FOREACH_IF(X_MACRO, NAME, OP)
 
#define HWY_SVE_FOREACH(X_MACRO, NAME, OP)
 
#define HWY_SVE_T(BASE, BITS)   BASE##BITS##_t
 
#define HWY_SVE_D(BASE, BITS, N, POW2)   Simd<HWY_SVE_T(BASE, BITS), N, POW2>
 
#define HWY_SVE_V(BASE, BITS)   sv##BASE##BITS##_t
 
#define HWY_SVE_TUPLE(BASE, BITS, MUL)   sv##BASE##BITS##x##MUL##_t
 
#define HWY_SPECIALIZE(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_RETV_ARGPV(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_RETV_ARGV(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_RETV_ARGPVN(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_RETV_ARGVN(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_RETV_ARGVV(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_RETV_ARGPVV(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_RETV_ARGMVV(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_RETV_ARGVVV(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_ALL_PTRUE(BITS)   svptrue_pat_b##BITS(SV_ALL)
 
#define HWY_SVE_PTRUE(BITS)   svptrue_pat_b##BITS(SV_POW2)
 
#define HWY_SVE_FIRSTN(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_WRAP_PTRUE(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_MASK_FALSE
 
#define HWY_SVE_SET(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_CAST_NOP(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_CAST(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_UNDEFINED(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_CREATE(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_GET(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_SET(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_RETV_ARGPVN_SWAP(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_RETV_ARGPVV_SWAP(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_POPCNT
 
#define HWY_SVE_POPCNT(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_SATURATED_NEG_8_16_32
 
#define HWY_NATIVE_SATURATED_NEG_64
 
#define HWY_NATIVE_SATURATED_ABS
 
#define HWY_NATIVE_OPERATOR_REPLACEMENTS
 
#define HWY_SVE_RETV_ARGPVN_MASK(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_I32_SATURATED_ADDSUB
 
#define HWY_NATIVE_U32_SATURATED_ADDSUB
 
#define HWY_NATIVE_I64_SATURATED_ADDSUB
 
#define HWY_NATIVE_U64_SATURATED_ADDSUB
 
#define HWY_NATIVE_INTEGER_ABS_DIFF
 
#define HWY_SVE_SHIFT_N(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_ROTATE_RIGHT_N(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_SHIFT(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_MUL_8
 
#define HWY_NATIVE_MUL_64
 
#define HWY_NATIVE_INT_DIV
 
#define HWY_NATIVE_F64_APPROX_RECIP
 
#define HWY_NATIVE_F64_APPROX_RSQRT
 
#define HWY_NATIVE_INT_FMA
 
#define HWY_SVE_FMA(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_COUNT_TRUE(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_COUNT_TRUE_FULL(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_IF_THEN_ELSE(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_PROMOTE_MASK_TO
 
#define HWY_NATIVE_DEMOTE_MASK_TO
 
#define HWY_NATIVE_LOWER_HALF_OF_MASK
 
#define HWY_NATIVE_MASKED_ARITH
 
#define HWY_SVE_COMPARE(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_COMPARE_N(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_IS_NEGATIVE
 
#define HWY_SVE_IF_VEC(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_BITWISE_IF_THEN_ELSE
 
#define HWY_NATIVE_ISINF
 
#define HWY_SVE_MEM(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_SCATTER
 
#define HWY_SVE_SCATTER_OFFSET(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_MASKED_SCATTER_INDEX(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_GATHER
 
#define HWY_SVE_GATHER_OFFSET(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_MASKED_GATHER_INDEX(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_LOAD_STORE_INTERLEAVED
 
#define HWY_SVE_LOAD2(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_LOAD3(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_LOAD4(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_STORE2(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_STORE3(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_STORE4(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_PROMOTE_TO(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_F16C
 
#define HWY_NATIVE_PROMOTE_F16_TO_F64
 
#define HWY_NATIVE_PROMOTE_UPPER_TO
 
#define HWY_IF_U2I_DEMOTE_FROM_LANE_SIZE_V(V)    hwy::EnableIf<!hwy::IsSame<V, V>()>* = nullptr
 
#define HWY_SVE_CONCAT_EVERY_SECOND(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_SPLICE(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_DEMOTE_F64_TO_F16
 
#define HWY_NATIVE_DEMOTE_F32_TO_BF16
 
#define HWY_SVE_CONVERT(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_IOTA(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_INTERLEAVE_WHOLE
 
#define HWY_SVE_EXT(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_REDUCE_SCALAR
 
#define HWY_SVE_REDUCE_ADD(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_REDUCE(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_IF_REDUCE_D(D)   hwy::EnableIf<HWY_MAX_LANES_D(D) != 1>* = nullptr
 
#define HWY_NATIVE_REDUCE_SUM_4_UI8
 
#define HWY_NATIVE_REDUCE_MINMAX_4_UI8
 
#define HWY_SVE_GET_LANE(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_ODD_EVEN(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_TABLE(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_TABLE2(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_REVERSE(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_REVERSE2_8
 
#define HWY_NATIVE_REVERSE_BITS_UI8
 
#define HWY_NATIVE_REVERSE_BITS_UI16_32_64
 
#define HWY_SVE_REVERSE_BITS(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_SLIDE1_UP_DOWN
 
#define HWY_SVE_COMPRESS(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_BROADCASTLANE
 
#define HWY_SVE_BROADCAST(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_ADDSUB_F(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_SVE_ADDSUB_UI(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_IF_ADDSUB_V(V)
 
#define HWY_IF_MULADDSUB_V(V)
 
#define HWY_NATIVE_EXPAND
 
#define HWY_SVE_MUL_EVEN(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_I16_SATWIDENMULACCUMFIXEDPOINT
 
#define HWY_NATIVE_I8_I8_SUMOFMULQUADACCUMULATE
 
#define HWY_NATIVE_U8_U8_SUMOFMULQUADACCUMULATE
 
#define HWY_NATIVE_U8_I8_SUMOFMULQUADACCUMULATE
 
#define HWY_NATIVE_I16_I16_SUMOFMULQUADACCUMULATE
 
#define HWY_NATIVE_U16_U16_SUMOFMULQUADACCUMULATE
 
#define HWY_SVE_DUP(BASE, CHAR, BITS, HALF, NAME, OP)
 
#define HWY_NATIVE_LEADING_ZERO_COUNT
 
#define HWY_SVE_LEADING_ZERO_COUNT(BASE, CHAR, BITS, HALF, NAME, OP)
 

Typedefs

using hwy::HWY_NAMESPACE::VBF16 = VFromD<ScalableTag<bfloat16_t>>
 
template<class D >
using hwy::HWY_NAMESPACE::Vec2 = decltype(Create2(D(), Zero(D()), Zero(D())))
 
template<class D >
using hwy::HWY_NAMESPACE::Vec3 = decltype(Create3(D(), Zero(D()), Zero(D()), Zero(D())))
 
template<class D >
using hwy::HWY_NAMESPACE::Vec4 = decltype(Create4(D(), Zero(D()), Zero(D()), Zero(D()), Zero(D())))
 

Functions

 HWY_BEFORE_NAMESPACE ()
 
template<typename T , HWY_IF_T_SIZE(T, 1) >
HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::AllHardwareLanes ()
 
template<class D , HWY_SVE_IF_EMULATED_D(D) >
svbool_t hwy::HWY_NAMESPACE::FirstN (D, size_t count)
 
HWY_API svbool_t hwy::HWY_NAMESPACE::detail::PFalse ()
 
template<class D >
svbool_t hwy::HWY_NAMESPACE::detail::MakeMask (D d)
 
template<class D >
HWY_API svbool_t hwy::HWY_NAMESPACE::MaskFalse (const D)
 
template<class D , HWY_IF_BF16_D(D) >
HWY_API svuint16_t hwy::HWY_NAMESPACE::Set (D d, bfloat16_t arg)
 
template<class D >
VFromD< D > hwy::HWY_NAMESPACE::Zero (D d)
 
template<class V , HWY_SVE_IF_EMULATED_D(DFromV< V >) >
HWY_INLINE svuint8_t hwy::HWY_NAMESPACE::detail::BitCastToByte (V v)
 
template<class D , HWY_SVE_IF_EMULATED_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::BitCastFromByte (D d, svuint8_t v)
 
template<class D , class FromV >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::BitCast (D d, FromV v)
 
template<class D , HWY_SVE_IF_EMULATED_D(D) >
VFromD< D > hwy::HWY_NAMESPACE::Undefined (D d)
 
template<class D , class FromV >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::ResizeBitCast (D d, FromV v)
 
template<class D , HWY_IF_I8_D(D) >
HWY_API svint8_t hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3, TFromD< D > t4, TFromD< D > t5, TFromD< D > t6, TFromD< D > t7, TFromD< D > t8, TFromD< D > t9, TFromD< D > t10, TFromD< D > t11, TFromD< D > t12, TFromD< D > t13, TFromD< D > t14, TFromD< D > t15)
 
template<class D , HWY_IF_U8_D(D) >
HWY_API svuint8_t hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3, TFromD< D > t4, TFromD< D > t5, TFromD< D > t6, TFromD< D > t7, TFromD< D > t8, TFromD< D > t9, TFromD< D > t10, TFromD< D > t11, TFromD< D > t12, TFromD< D > t13, TFromD< D > t14, TFromD< D > t15)
 
template<class D , HWY_IF_I16_D(D) >
HWY_API svint16_t hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3, TFromD< D > t4, TFromD< D > t5, TFromD< D > t6, TFromD< D > t7)
 
template<class D , HWY_IF_U16_D(D) >
HWY_API svuint16_t hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3, TFromD< D > t4, TFromD< D > t5, TFromD< D > t6, TFromD< D > t7)
 
template<class D , HWY_IF_F16_D(D) >
HWY_API svfloat16_t hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3, TFromD< D > t4, TFromD< D > t5, TFromD< D > t6, TFromD< D > t7)
 
template<class D , HWY_IF_BF16_D(D) >
HWY_API VBF16 hwy::HWY_NAMESPACE::Dup128VecFromValues (D d, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3, TFromD< D > t4, TFromD< D > t5, TFromD< D > t6, TFromD< D > t7)
 
template<class D , HWY_IF_I32_D(D) >
HWY_API svint32_t hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3)
 
template<class D , HWY_IF_U32_D(D) >
HWY_API svuint32_t hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3)
 
template<class D , HWY_IF_F32_D(D) >
HWY_API svfloat32_t hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1, TFromD< D > t2, TFromD< D > t3)
 
template<class D , HWY_IF_I64_D(D) >
HWY_API svint64_t hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1)
 
template<class D , HWY_IF_U64_D(D) >
HWY_API svuint64_t hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1)
 
template<class D , HWY_IF_F64_D(D) >
HWY_API svfloat64_t hwy::HWY_NAMESPACE::Dup128VecFromValues (D, TFromD< D > t0, TFromD< D > t1)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::And (const V a, const V b)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::Or (const V a, const V b)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::Xor (const V a, const V b)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::AndNot (const V a, const V b)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::Xor3 (const V x1, const V x2, const V x3)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Or3 (V o1, V o2, V o3)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::OrAnd (const V o, const V a1, const V a2)
 
HWY_API VBF16 hwy::HWY_NAMESPACE::Neg (VBF16 v)
 
HWY_API svuint64_t hwy::HWY_NAMESPACE::SumsOf8 (const svuint8_t v)
 
HWY_API svint64_t hwy::HWY_NAMESPACE::SumsOf8 (const svint8_t v)
 
HWY_INLINE svint16_t hwy::HWY_NAMESPACE::detail::SumsOf2 (hwy::SignedTag, hwy::SizeTag< 1 >, svint8_t v)
 
HWY_INLINE svuint16_t hwy::HWY_NAMESPACE::detail::SumsOf2 (hwy::UnsignedTag, hwy::SizeTag< 1 >, svuint8_t v)
 
HWY_INLINE svint32_t hwy::HWY_NAMESPACE::detail::SumsOf2 (hwy::SignedTag, hwy::SizeTag< 2 >, svint16_t v)
 
HWY_INLINE svuint32_t hwy::HWY_NAMESPACE::detail::SumsOf2 (hwy::UnsignedTag, hwy::SizeTag< 2 >, svuint16_t v)
 
HWY_INLINE svint64_t hwy::HWY_NAMESPACE::detail::SumsOf2 (hwy::SignedTag, hwy::SizeTag< 4 >, svint32_t v)
 
HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::detail::SumsOf2 (hwy::UnsignedTag, hwy::SizeTag< 4 >, svuint32_t v)
 
HWY_INLINE svint32_t hwy::HWY_NAMESPACE::detail::SumsOf4 (hwy::SignedTag, hwy::SizeTag< 1 >, svint8_t v)
 
HWY_INLINE svuint32_t hwy::HWY_NAMESPACE::detail::SumsOf4 (hwy::UnsignedTag, hwy::SizeTag< 1 >, svuint8_t v)
 
HWY_INLINE svint64_t hwy::HWY_NAMESPACE::detail::SumsOf4 (hwy::SignedTag, hwy::SizeTag< 2 >, svint16_t v)
 
HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::detail::SumsOf4 (hwy::UnsignedTag, hwy::SizeTag< 2 >, svuint16_t v)
 
HWY_API svint16_t hwy::HWY_NAMESPACE::MulFixedPoint15 (svint16_t a, svint16_t b)
 
template<class D , typename MFrom >
HWY_API svbool_t hwy::HWY_NAMESPACE::RebindMask (const D, const MFrom mask)
 
HWY_API svbool_t hwy::HWY_NAMESPACE::Not (svbool_t m)
 
HWY_API svbool_t hwy::HWY_NAMESPACE::And (svbool_t a, svbool_t b)
 
HWY_API svbool_t hwy::HWY_NAMESPACE::AndNot (svbool_t a, svbool_t b)
 
HWY_API svbool_t hwy::HWY_NAMESPACE::Or (svbool_t a, svbool_t b)
 
HWY_API svbool_t hwy::HWY_NAMESPACE::Xor (svbool_t a, svbool_t b)
 
HWY_API svbool_t hwy::HWY_NAMESPACE::ExclusiveNeither (svbool_t a, svbool_t b)
 
template<class D >
HWY_API bool hwy::HWY_NAMESPACE::AllFalse (D d, svbool_t m)
 
template<class D >
HWY_API bool hwy::HWY_NAMESPACE::AllTrue (D d, svbool_t m)
 
template<class D >
HWY_API intptr_t hwy::HWY_NAMESPACE::FindFirstTrue (D d, svbool_t m)
 
template<class D >
HWY_API size_t hwy::HWY_NAMESPACE::FindKnownFirstTrue (D d, svbool_t m)
 
template<class V , class D = DFromV<V>, HWY_SVE_IF_EMULATED_D(D) >
HWY_APIhwy::HWY_NAMESPACE::IfThenElse (const svbool_t mask, V yes, V no)
 
template<class V , class D = DFromV<V>, HWY_SVE_IF_NOT_EMULATED_D(D) >
HWY_APIhwy::HWY_NAMESPACE::IfThenElseZero (const svbool_t mask, const V yes)
 
template<class V , class D = DFromV<V>, HWY_SVE_IF_NOT_EMULATED_D(D) >
HWY_APIhwy::HWY_NAMESPACE::IfThenZeroElse (const svbool_t mask, const V no)
 
HWY_API svbool_t hwy::HWY_NAMESPACE::SetBeforeFirst (svbool_t m)
 
HWY_API svbool_t hwy::HWY_NAMESPACE::SetAtOrBeforeFirst (svbool_t m)
 
HWY_API svbool_t hwy::HWY_NAMESPACE::SetOnlyFirst (svbool_t m)
 
HWY_API svbool_t hwy::HWY_NAMESPACE::SetAtOrAfterFirst (svbool_t m)
 
template<class DTo , class DFrom , HWY_IF_T_SIZE_D(DTo, sizeof(TFromD< DFrom >) *2) >
HWY_API svbool_t hwy::HWY_NAMESPACE::PromoteMaskTo (DTo, DFrom, svbool_t m)
 
template<class DTo , class DFrom , HWY_IF_T_SIZE_D(DTo, 1) , HWY_IF_T_SIZE_D(DFrom, 2) >
HWY_API svbool_t hwy::HWY_NAMESPACE::DemoteMaskTo (DTo, DFrom, svbool_t m)
 
template<class DTo , class DFrom , HWY_IF_T_SIZE_LE_D(DTo, sizeof(TFromD< DFrom >)/4) >
HWY_API svbool_t hwy::HWY_NAMESPACE::DemoteMaskTo (DTo d_to, DFrom d_from, svbool_t m)
 
template<class D >
HWY_API svbool_t hwy::HWY_NAMESPACE::LowerHalfOfMask (D, svbool_t m)
 
template<class V , class M >
HWY_APIhwy::HWY_NAMESPACE::MaskedMinOr (V no, M m, V a, V b)
 
template<class V , class M >
HWY_APIhwy::HWY_NAMESPACE::MaskedMaxOr (V no, M m, V a, V b)
 
template<class V , class M >
HWY_APIhwy::HWY_NAMESPACE::MaskedAddOr (V no, M m, V a, V b)
 
template<class V , class M >
HWY_APIhwy::HWY_NAMESPACE::MaskedSubOr (V no, M m, V a, V b)
 
template<class V , class M >
HWY_APIhwy::HWY_NAMESPACE::MaskedMulOr (V no, M m, V a, V b)
 
template<class V , class M , HWY_IF_T_SIZE_ONE_OF_V( V,(hwy::IsSame< TFromV< V >, hwy::float16_t >() ?(1<< 2) :0)|(1<< 4)|(1<< 8)) >
HWY_APIhwy::HWY_NAMESPACE::MaskedDivOr (V no, M m, V a, V b)
 
template<class V , class M >
HWY_APIhwy::HWY_NAMESPACE::MaskedSatAddOr (V no, M m, V a, V b)
 
template<class V , class M >
HWY_APIhwy::HWY_NAMESPACE::MaskedSatSubOr (V no, M m, V a, V b)
 
template<class V >
HWY_API svbool_t hwy::HWY_NAMESPACE::Gt (const V a, const V b)
 
template<class V >
HWY_API svbool_t hwy::HWY_NAMESPACE::Ge (const V a, const V b)
 
template<class V >
HWY_API svbool_t hwy::HWY_NAMESPACE::TestBit (const V a, const V bit)
 
template<class V >
HWY_API svbool_t hwy::HWY_NAMESPACE::MaskFromVec (const V v)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::VecFromMask (const D d, svbool_t mask)
 
template<class V , HWY_IF_NOT_UNSIGNED_V(V) >
HWY_API svbool_t hwy::HWY_NAMESPACE::IsNegative (V v)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::IfVecThenElse (const V mask, const V yes, const V no)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::BitwiseIfThenElse (V mask, V yes, V no)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::CopySign (const V magn, const V sign)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::CopySignToAbs (const V abs, const V sign)
 
template<class V >
HWY_API svbool_t hwy::HWY_NAMESPACE::IsNaN (const V v)
 
template<class V >
HWY_API svbool_t hwy::HWY_NAMESPACE::IsInf (const V v)
 
template<class V >
HWY_API svbool_t hwy::HWY_NAMESPACE::IsFinite (const V v)
 
template<class D , HWY_NEON_IF_EMULATED_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::LoadU (D d, const TFromD< D > *HWY_RESTRICT p)
 
template<class D , HWY_NEON_IF_EMULATED_D(D) >
HWY_API void hwy::HWY_NAMESPACE::StoreU (VFromD< D > v, D d, TFromD< D > *HWY_RESTRICT p)
 
template<class D , HWY_SVE_IF_EMULATED_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MaskedLoad (MFromD< D > m, D d, const TFromD< D > *HWY_RESTRICT p)
 
template<class D , HWY_SVE_IF_EMULATED_D(D) >
HWY_API void hwy::HWY_NAMESPACE::BlendedStore (VFromD< D > v, MFromD< D > m, D d, TFromD< D > *HWY_RESTRICT p)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::LoadDup128 (D d, const TFromD< D > *HWY_RESTRICT p)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Load (D d, const TFromD< D > *HWY_RESTRICT p)
 
template<class V , class D >
HWY_API void hwy::HWY_NAMESPACE::Store (const V v, D d, TFromD< D > *HWY_RESTRICT p)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MaskedLoadOr (VFromD< D > v, MFromD< D > m, D d, const TFromD< D > *HWY_RESTRICT aligned)
 
 hwy::HWY_NAMESPACE::HWY_SVE_FOREACH_UIF3264 (HWY_SVE_MASKED_SCATTER_INDEX, MaskedScatterIndex, st1_scatter) template< class D > HWY_API void ScatterIndex(VFromD< D > v
 
 hwy::HWY_NAMESPACE::HWY_SVE_FOREACH_UIF3264 (HWY_SVE_MASKED_GATHER_INDEX, MaskedGatherIndex, ld1_gather) template< class D > HWY_API VFromD< D > MaskedGatherIndexOr(VFromD< D > no
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::GatherIndex (D d, const TFromD< D > *HWY_RESTRICT p, VFromD< RebindToSigned< D > > indices)
 
template<size_t N, int kPow2>
HWY_API svuint32_t hwy::HWY_NAMESPACE::PromoteTo (Simd< uint32_t, N, kPow2 > dto, svuint8_t vfrom)
 
template<size_t N, int kPow2>
HWY_API svint32_t hwy::HWY_NAMESPACE::PromoteTo (Simd< int32_t, N, kPow2 > dto, svint8_t vfrom)
 
template<size_t N, int kPow2>
HWY_API svuint64_t hwy::HWY_NAMESPACE::PromoteTo (Simd< uint64_t, N, kPow2 > dto, svuint16_t vfrom)
 
template<size_t N, int kPow2>
HWY_API svint64_t hwy::HWY_NAMESPACE::PromoteTo (Simd< int64_t, N, kPow2 > dto, svint16_t vfrom)
 
template<size_t N, int kPow2>
HWY_API svuint64_t hwy::HWY_NAMESPACE::PromoteTo (Simd< uint64_t, N, kPow2 > dto, svuint8_t vfrom)
 
template<size_t N, int kPow2>
HWY_API svint64_t hwy::HWY_NAMESPACE::PromoteTo (Simd< int64_t, N, kPow2 > dto, svint8_t vfrom)
 
template<class D , class V , HWY_IF_SIGNED_D(D) , HWY_IF_UNSIGNED_V(V) , HWY_IF_LANES_GT(sizeof(TFromD< D >), sizeof(TFromV< V >)) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::PromoteTo (D di, V v)
 
template<size_t N, int kPow2>
HWY_API svfloat32_t hwy::HWY_NAMESPACE::PromoteTo (Simd< float32_t, N, kPow2 >, const svfloat16_t v)
 
template<size_t N, int kPow2>
HWY_API svfloat64_t hwy::HWY_NAMESPACE::PromoteTo (Simd< float64_t, N, kPow2 >, const svfloat16_t v)
 
template<size_t N, int kPow2>
HWY_API svfloat64_t hwy::HWY_NAMESPACE::PromoteTo (Simd< float64_t, N, kPow2 >, const svfloat32_t v)
 
template<size_t N, int kPow2>
HWY_API svfloat64_t hwy::HWY_NAMESPACE::PromoteTo (Simd< float64_t, N, kPow2 >, const svint32_t v)
 
template<size_t N, int kPow2>
HWY_API svfloat64_t hwy::HWY_NAMESPACE::PromoteTo (Simd< float64_t, N, kPow2 >, const svuint32_t v)
 
template<size_t N, int kPow2>
HWY_API svint64_t hwy::HWY_NAMESPACE::PromoteTo (Simd< int64_t, N, kPow2 >, const svfloat32_t v)
 
template<size_t N, int kPow2>
HWY_API svuint64_t hwy::HWY_NAMESPACE::PromoteTo (Simd< uint64_t, N, kPow2 >, const svfloat32_t v)
 
template<class D , class V , typename TD = TFromD<D>, typename TV = TFromV<V>, hwy::EnableIf< IsInteger< TD >() &&IsInteger< TV >() &&(IsSigned< TD >()==IsSigned< TV >())> * = nullptr>
HWY_API VFromD< D > hwy::HWY_NAMESPACE::PromoteUpperTo (D d, V v)
 
template<typename TN , class VU >
VU hwy::HWY_NAMESPACE::detail::SaturateU (VU v)
 
template<typename TN , class VI >
VI hwy::HWY_NAMESPACE::detail::SaturateI (VI v)
 
template<size_t N, int kPow2>
HWY_API svuint8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, kPow2 > dn, const svint16_t v)
 
template<size_t N, int kPow2>
HWY_API svuint16_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint16_t, N, kPow2 > dn, const svint32_t v)
 
template<size_t N, int kPow2>
HWY_API svuint8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, kPow2 > dn, const svint32_t v)
 
HWY_API svuint8_t hwy::HWY_NAMESPACE::U8FromU32 (const svuint32_t v)
 
template<size_t N, int kPow2>
HWY_API svuint8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, kPow2 > dn, const svuint16_t v)
 
template<size_t N, int kPow2>
HWY_API svuint16_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint16_t, N, kPow2 > dn, const svuint32_t v)
 
template<size_t N, int kPow2>
HWY_API svuint8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, kPow2 > dn, const svuint32_t v)
 
template<size_t N, int kPow2>
HWY_API svuint8_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, kPow2 >, const svuint64_t v)
 
template<size_t N, int kPow2>
HWY_API svuint16_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, kPow2 >, const svuint64_t v)
 
template<size_t N, int kPow2>
HWY_API svuint32_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint32_t, N, kPow2 >, const svuint64_t v)
 
template<size_t N, int kPow2>
HWY_API svuint8_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, kPow2 >, const svuint32_t v)
 
template<size_t N, int kPow2>
HWY_API svuint16_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint16_t, N, kPow2 >, const svuint32_t v)
 
template<size_t N, int kPow2>
HWY_API svuint8_t hwy::HWY_NAMESPACE::TruncateTo (Simd< uint8_t, N, kPow2 >, const svuint16_t v)
 
template<size_t N, int kPow2>
HWY_API svint8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, kPow2 > dn, const svint16_t v)
 
template<size_t N, int kPow2>
HWY_API svint16_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int16_t, N, kPow2 > dn, const svint32_t v)
 
template<size_t N, int kPow2>
HWY_API svint8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, kPow2 > dn, const svint32_t v)
 
template<size_t N, int kPow2>
HWY_API svint32_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, kPow2 > dn, const svint64_t v)
 
template<size_t N, int kPow2>
HWY_API svint16_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int16_t, N, kPow2 > dn, const svint64_t v)
 
template<size_t N, int kPow2>
HWY_API svint8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int8_t, N, kPow2 > dn, const svint64_t v)
 
template<size_t N, int kPow2>
HWY_API svuint32_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint32_t, N, kPow2 > dn, const svint64_t v)
 
template<size_t N, int kPow2>
HWY_API svuint16_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint16_t, N, kPow2 > dn, const svint64_t v)
 
template<size_t N, int kPow2>
HWY_API svuint8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, kPow2 > dn, const svint64_t v)
 
template<size_t N, int kPow2>
HWY_API svuint32_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint32_t, N, kPow2 > dn, const svuint64_t v)
 
template<size_t N, int kPow2>
HWY_API svuint16_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint16_t, N, kPow2 > dn, const svuint64_t v)
 
template<size_t N, int kPow2>
HWY_API svuint8_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint8_t, N, kPow2 > dn, const svuint64_t v)
 
template<class D , class V , HWY_IF_SIGNED_D(D) , HWY_IF_UNSIGNED_V(V) , HWY_IF_T_SIZE_LE_D(D, sizeof(TFromV< V >) - 1) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::DemoteTo (D dn, V v)
 
template<class V , HWY_IF_BF16_D(DFromV< V >) >
HWY_INLINEhwy::HWY_NAMESPACE::detail::Splice (V hi, V lo, svbool_t mask)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::ConcatOdd (D d, VFromD< D > hi, VFromD< D > lo)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::ConcatEven (D d, VFromD< D > hi, VFromD< D > lo)
 
template<size_t N, int kPow2>
HWY_API svfloat16_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float16_t, N, kPow2 > d, const svfloat32_t v)
 
template<size_t N, int kPow2>
HWY_API svfloat16_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float16_t, N, kPow2 > d, const svfloat64_t v)
 
HWY_INLINE svuint32_t hwy::HWY_NAMESPACE::detail::RoundF32ForDemoteToBF16 (svfloat32_t v)
 
template<size_t N, int kPow2>
HWY_API VBF16 hwy::HWY_NAMESPACE::DemoteTo (Simd< bfloat16_t, N, kPow2 > dbf16, svfloat32_t v)
 
template<size_t N, int kPow2>
HWY_API svfloat32_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float32_t, N, kPow2 > d, const svfloat64_t v)
 
template<size_t N, int kPow2>
HWY_API svint32_t hwy::HWY_NAMESPACE::DemoteTo (Simd< int32_t, N, kPow2 > d, const svfloat64_t v)
 
template<size_t N, int kPow2>
HWY_API svuint32_t hwy::HWY_NAMESPACE::DemoteTo (Simd< uint32_t, N, kPow2 > d, const svfloat64_t v)
 
template<size_t N, int kPow2>
HWY_API svfloat32_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, kPow2 > d, const svint64_t v)
 
template<size_t N, int kPow2>
HWY_API svfloat32_t hwy::HWY_NAMESPACE::DemoteTo (Simd< float, N, kPow2 > d, const svuint64_t v)
 
template<class VF , class DI = RebindToSigned<DFromV<VF>>>
HWY_API VFromD< DI > hwy::HWY_NAMESPACE::NearestInt (VF v)
 
template<class D , typename T2 , HWY_IF_FLOAT_D(D) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Iota (const D d, T2 first)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::InterleaveLower (D d, const V a, const V b)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::InterleaveLower (const V a, const V b)
 
template<class D , class V = VFromD<D>, hwy::EnableIf< detail::IsFull(D())> * = nullptr>
HWY_APIhwy::HWY_NAMESPACE::InterleaveUpper (D d, const V a, const V b)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::InterleaveWholeLower (D, VFromD< D > a, VFromD< D > b)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::InterleaveWholeUpper (D d, VFromD< D > a, VFromD< D > b)
 
template<size_t kLaneSize, size_t kVectSize, class V , HWY_IF_LANES_GT_D(DFromV< V >, 4) >
HWY_INLINEhwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle (hwy::SizeTag< 0x88 >, hwy::SizeTag< kLaneSize >, hwy::SizeTag< kVectSize >, V v)
 
template<size_t kLaneSize, size_t kVectSize, class V , HWY_IF_LANES_GT_D(DFromV< V >, 4) >
HWY_INLINEhwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle (hwy::SizeTag< 0xDD >, hwy::SizeTag< kLaneSize >, hwy::SizeTag< kVectSize >, V v)
 
template<class D , HWY_IF_T_SIZE_D(D, 1) >
svbool_t hwy::HWY_NAMESPACE::detail::MaskLowerHalf (D d)
 
template<class D >
svbool_t hwy::HWY_NAMESPACE::detail::MaskUpperHalf (D d)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatUpperLower (const D d, const V hi, const V lo)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatLowerLower (const D d, const V hi, const V lo)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatLowerUpper (const D d, const V hi, const V lo)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::ConcatUpperUpper (const D d, const V hi, const V lo)
 
template<class D , class V2 >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Combine (const D d, const V2 hi, const V2 lo)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::ZeroExtendVector (const D d, const V lo)
 
template<class D2 , class V >
HWY_APIhwy::HWY_NAMESPACE::LowerHalf (D2, const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::LowerHalf (const V v)
 
template<class DH , class V >
HWY_APIhwy::HWY_NAMESPACE::UpperHalf (const DH dh, const V v)
 
template<class D , HWY_IF_REDUCE_D(D) >
HWY_API TFromD< D > hwy::HWY_NAMESPACE::ReduceSum (D d, VFromD< D > v)
 
template<class D , HWY_IF_REDUCE_D(D) >
HWY_API TFromD< D > hwy::HWY_NAMESPACE::ReduceMin (D d, VFromD< D > v)
 
template<class D , HWY_IF_REDUCE_D(D) >
HWY_API TFromD< D > hwy::HWY_NAMESPACE::ReduceMax (D d, VFromD< D > v)
 
template<class D , HWY_IF_LANES_GT_D(D, 1) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::SumOfLanes (D d, VFromD< D > v)
 
template<class D , HWY_IF_LANES_GT_D(D, 1) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MinOfLanes (D d, VFromD< D > v)
 
template<class D , HWY_IF_LANES_GT_D(D, 1) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::MaxOfLanes (D d, VFromD< D > v)
 
template<class V >
HWY_API TFromV< V > hwy::HWY_NAMESPACE::GetLane (const V v)
 
template<class V >
HWY_API TFromV< V > hwy::HWY_NAMESPACE::ExtractLane (V v, size_t i)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::InsertLane (const V v, size_t i, TFromV< V > t)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::DupEven (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::DupOdd (const V v)
 
template<class V , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::OddEven (const V odd, const V even)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::InterleaveEven (D, VFromD< D > a, VFromD< D > b)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::InterleaveOdd (D, VFromD< D > a, VFromD< D > b)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::OddEvenBlocks (const V odd, const V even)
 
template<class D , class VI >
HWY_API VFromD< RebindToUnsigned< D > > hwy::HWY_NAMESPACE::IndicesFromVec (D d, VI vec)
 
template<class D , typename TI >
HWY_API VFromD< RebindToUnsigned< D > > hwy::HWY_NAMESPACE::SetTableIndices (D d, const TI *idx)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::TwoTablesLookupLanes (D d, VFromD< D > a, VFromD< D > b, VFromD< RebindToUnsigned< D > > idx)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::TwoTablesLookupLanes (V a, V b, VFromD< RebindToUnsigned< DFromV< V > > > idx)
 
template<typename T , size_t N, int kPow2>
constexpr size_t hwy::HWY_NAMESPACE::detail::LanesPerBlock (Simd< T, N, kPow2 > d)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::SwapAdjacentBlocks (const V v)
 
template<class D , class V >
HWY_APIhwy::HWY_NAMESPACE::Reverse (D d, V v)
 
template<class D , HWY_IF_T_SIZE_D(D, 8) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Reverse2 (D d, VFromD< D > v)
 
template<class D , HWY_IF_T_SIZE_D(D, 4) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Reverse4 (D d, VFromD< D > v)
 
template<class D , HWY_IF_T_SIZE_D(D, 2) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Reverse8 (D d, VFromD< D > v)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::SlideUpLanes (D d, VFromD< D > v, size_t amt)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Slide1Up (D d, VFromD< D > v)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::SlideDownLanes (D d, VFromD< D > v, size_t amt)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::Slide1Down (D d, VFromD< D > v)
 
template<class V , HWY_IF_T_SIZE_V(V, 8) >
HWY_APIhwy::HWY_NAMESPACE::Compress (V v, svbool_t mask)
 
HWY_API svfloat16_t hwy::HWY_NAMESPACE::Compress (svfloat16_t v, svbool_t mask16)
 
template<class V , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 2)|(1<< 4)) >
HWY_APIhwy::HWY_NAMESPACE::CompressNot (V v, const svbool_t mask)
 
HWY_API svuint64_t hwy::HWY_NAMESPACE::CompressBlocksNot (svuint64_t v, svbool_t mask)
 
template<class V , class D , HWY_IF_NOT_T_SIZE_D(D, 1) >
HWY_API size_t hwy::HWY_NAMESPACE::CompressStore (const V v, const svbool_t mask, const D d, TFromD< D > *HWY_RESTRICT unaligned)
 
template<class V , class D , HWY_IF_NOT_T_SIZE_D(D, 1) >
HWY_API size_t hwy::HWY_NAMESPACE::CompressBlendedStore (const V v, const svbool_t mask, const D d, TFromD< D > *HWY_RESTRICT unaligned)
 
template<class D >
HWY_API size_t hwy::HWY_NAMESPACE::FindKnownLastTrue (D d, svbool_t m)
 
template<class D >
HWY_API intptr_t hwy::HWY_NAMESPACE::FindLastTrue (D d, svbool_t m)
 
template<size_t kBytes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::CombineShiftRightBytes (const D d, const V hi, const V lo)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle2301 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle2103 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle0321 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle1032 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle01 (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Shuffle0123 (const V v)
 
template<class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::ReverseBlocks (D d, V v)
 
template<class V , class VI >
HWY_API VI hwy::HWY_NAMESPACE::TableLookupBytes (const V v, const VI idx)
 
template<class V , class VI >
HWY_API VI hwy::HWY_NAMESPACE::TableLookupBytesOr0 (V bytes, VI from)
 
template<int kLane, class V >
HWY_APIhwy::HWY_NAMESPACE::Broadcast (const V v)
 
template<int kLane, class V >
HWY_APIhwy::HWY_NAMESPACE::BroadcastLane (const V v)
 
template<size_t kLanes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::ShiftLeftLanes (D d, const V v)
 
template<size_t kLanes, class V >
HWY_APIhwy::HWY_NAMESPACE::ShiftLeftLanes (const V v)
 
template<size_t kLanes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::ShiftRightLanes (D d, V v)
 
template<int kBytes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::ShiftLeftBytes (const D d, const V v)
 
template<int kBytes, class V >
HWY_APIhwy::HWY_NAMESPACE::ShiftLeftBytes (const V v)
 
template<int kBytes, class D , class V = VFromD<D>>
HWY_APIhwy::HWY_NAMESPACE::ShiftRightBytes (const D d, const V v)
 
template<class V , class DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > hwy::HWY_NAMESPACE::ZipLower (DW dw, V a, V b)
 
template<class V , class D = DFromV<V>, class DW = RepartitionToWide<D>>
HWY_API VFromD< DW > hwy::HWY_NAMESPACE::ZipLower (const V a, const V b)
 
template<class V , class DW = RepartitionToWide<DFromV<V>>>
HWY_API VFromD< DW > hwy::HWY_NAMESPACE::ZipUpper (DW dw, V a, V b)
 
template<class V , HWY_IF_LANES_GT_D(DFromV< V >, 1) , HWY_IF_FLOAT_V(V) >
HWY_APIhwy::HWY_NAMESPACE::MulAddSub (V mul, V x, V sub_or_add)
 
template<size_t N, int kPow2>
HWY_API svfloat32_t hwy::HWY_NAMESPACE::PromoteTo (Simd< float32_t, N, kPow2 > df32, VBF16 v)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo (hwy::SignedTag, hwy::SizeTag< 2 >, hwy::SignedTag, D d_to, svint8_t v)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo (hwy::SignedTag, hwy::SizeTag< 4 >, hwy::SignedTag, D d_to, svint16_t v)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo (hwy::SignedTag, hwy::SizeTag< 8 >, hwy::SignedTag, D d_to, svint32_t v)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo (hwy::FloatTag, hwy::SizeTag< 4 >, hwy::FloatTag, D d_to, svfloat16_t v)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo (hwy::FloatTag, hwy::SizeTag< 8 >, hwy::FloatTag, D d_to, svfloat32_t v)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo (hwy::FloatTag, hwy::SizeTag< 8 >, hwy::SignedTag, D d_to, svint32_t v)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo (hwy::FloatTag, hwy::SizeTag< 8 >, hwy::UnsignedTag, D d_to, svuint32_t v)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo (hwy::SignedTag, hwy::SizeTag< 8 >, hwy::FloatTag, D d_to, svfloat32_t v)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo (hwy::UnsignedTag, hwy::SizeTag< 8 >, hwy::FloatTag, D d_to, svfloat32_t v)
 
template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteOddTo (hwy::FloatTag to_type_tag, hwy::SizeTag< 4 > to_lane_size_tag, hwy::FloatTag from_type_tag, D d_to, svfloat16_t v)
 
template<class FromTypeTag , class D , class V >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteOddTo (hwy::FloatTag to_type_tag, hwy::SizeTag< 8 > to_lane_size_tag, FromTypeTag from_type_tag, D d_to, V v)
 
template<class ToTypeTag , class D , HWY_IF_UI64_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteOddTo (ToTypeTag to_type_tag, hwy::SizeTag< 8 > to_lane_size_tag, hwy::FloatTag from_type_tag, D d_to, svfloat32_t v)
 
template<size_t N, int kPow2>
HWY_API VBF16 hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< bfloat16_t, N, kPow2 > dbf16, svfloat32_t a, svfloat32_t b)
 
template<size_t N, int kPow2>
HWY_API svint16_t hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< int16_t, N, kPow2 > d16, svint32_t a, svint32_t b)
 
template<size_t N, int kPow2>
HWY_API svuint16_t hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< uint16_t, N, kPow2 > d16, svint32_t a, svint32_t b)
 
template<size_t N, int kPow2>
HWY_API svuint16_t hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< uint16_t, N, kPow2 > d16, svuint32_t a, svuint32_t b)
 
template<size_t N, int kPow2>
HWY_API svint8_t hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< int8_t, N, kPow2 > d8, svint16_t a, svint16_t b)
 
template<size_t N, int kPow2>
HWY_API svuint8_t hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< uint8_t, N, kPow2 > d8, svint16_t a, svint16_t b)
 
template<size_t N, int kPow2>
HWY_API svuint8_t hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< uint8_t, N, kPow2 > d8, svuint16_t a, svuint16_t b)
 
template<size_t N, int kPow2>
HWY_API svint32_t hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< int32_t, N, kPow2 > d32, svint64_t a, svint64_t b)
 
template<size_t N, int kPow2>
HWY_API svuint32_t hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< uint32_t, N, kPow2 > d32, svint64_t a, svint64_t b)
 
template<size_t N, int kPow2>
HWY_API svuint32_t hwy::HWY_NAMESPACE::ReorderDemote2To (Simd< uint32_t, N, kPow2 > d32, svuint64_t a, svuint64_t b)
 
template<class D , class V , HWY_IF_SIGNED_D(D) , HWY_IF_UNSIGNED_V(V) , HWY_IF_T_SIZE_D(D, sizeof(TFromV< V >)/2) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::ReorderDemote2To (D dn, V a, V b)
 
template<class D , class V , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(V) , HWY_IF_NOT_FLOAT_NOR_SPECIAL(TFromD< D >) , HWY_IF_LANES_D(D, HWY_MAX_LANES_D(DFromV< V >) *2) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::OrderedDemote2To (D d, V a, V b)
 
template<size_t N, int kPow2>
HWY_API VBF16 hwy::HWY_NAMESPACE::OrderedDemote2To (Simd< bfloat16_t, N, kPow2 > dbf16, svfloat32_t a, svfloat32_t b)
 
template<class V , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(V) , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)) >
HWY_APIhwy::HWY_NAMESPACE::Div (V a, V b)
 
template<class V , class M , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)) , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(V) >
HWY_APIhwy::HWY_NAMESPACE::MaskedDivOr (V no, M m, V a, V b)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::Mod (V a, V b)
 
template<class V , class M >
HWY_APIhwy::HWY_NAMESPACE::MaskedModOr (V no, M m, V a, V b)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::BroadcastSignBit (const V v)
 
template<class V >
HWY_APIhwy::HWY_NAMESPACE::IfNegativeThenElse (V v, V yes, V no)
 
template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE svbool_t hwy::HWY_NAMESPACE::LoadMaskBits (D d, const uint8_t *HWY_RESTRICT bits)
 
template<class D , HWY_IF_T_SIZE_D(D, 1) , HWY_IF_V_SIZE_LE_D(D, 8) >
HWY_API MFromD< D > hwy::HWY_NAMESPACE::Dup128MaskFromMaskBits (D d, unsigned mask_bits)
 
template<class D , HWY_IF_T_SIZE_D(D, 2) >
HWY_API MFromD< D > hwy::HWY_NAMESPACE::Dup128MaskFromMaskBits (D d, unsigned mask_bits)
 
template<class T , HWY_IF_T_SIZE(T, 1) >
HWY_INLINE svuint8_t hwy::HWY_NAMESPACE::detail::BoolFromMask (svbool_t m)
 
HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::detail::BitsFromBool (svuint8_t x)
 
template<class D >
HWY_API size_t hwy::HWY_NAMESPACE::StoreMaskBits (D d, svbool_t m, uint8_t *bits)
 
template<class V , HWY_IF_NOT_T_SIZE_V(V, 1) >
HWY_INLINEhwy::HWY_NAMESPACE::CompressBits (V v, const uint8_t *HWY_RESTRICT bits)
 
template<class D , HWY_IF_NOT_T_SIZE_D(D, 1) >
HWY_API size_t hwy::HWY_NAMESPACE::CompressBitsStore (VFromD< D > v, const uint8_t *HWY_RESTRICT bits, D d, TFromD< D > *HWY_RESTRICT unaligned)
 
HWY_INLINE svuint8_t hwy::HWY_NAMESPACE::detail::IndicesForExpandFromBits (uint64_t mask_bits)
 
template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE svuint8_t hwy::HWY_NAMESPACE::detail::LaneIndicesFromByteIndices (D, svuint8_t idx)
 
template<class D , class DU = RebindToUnsigned<D>, HWY_IF_NOT_T_SIZE_D(D, 1) >
HWY_INLINE VFromD< DU > hwy::HWY_NAMESPACE::detail::LaneIndicesFromByteIndices (D, svuint8_t idx)
 
template<class V >
HWY_INLINEhwy::HWY_NAMESPACE::detail::ExpandLoop (V v, svbool_t mask)
 
template<class V , HWY_IF_T_SIZE_V(V, 1) >
HWY_APIhwy::HWY_NAMESPACE::Expand (V v, svbool_t mask)
 
template<class D >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::LoadExpand (MFromD< D > mask, D d, const TFromD< D > *HWY_RESTRICT unaligned)
 
template<class V , class DW = RepartitionToWide<DFromV<V>>, HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)|(1<< 4)) >
HWY_API VFromD< DW > hwy::HWY_NAMESPACE::MulEven (const V a, const V b)
 
template<class V , class DW = RepartitionToWide<DFromV<V>>, HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)|(1<< 4)) >
HWY_API VFromD< DW > hwy::HWY_NAMESPACE::MulOdd (const V a, const V b)
 
HWY_API svint64_t hwy::HWY_NAMESPACE::MulEven (const svint64_t a, const svint64_t b)
 
HWY_API svuint64_t hwy::HWY_NAMESPACE::MulEven (const svuint64_t a, const svuint64_t b)
 
HWY_API svint64_t hwy::HWY_NAMESPACE::MulOdd (const svint64_t a, const svint64_t b)
 
HWY_API svuint64_t hwy::HWY_NAMESPACE::MulOdd (const svuint64_t a, const svuint64_t b)
 
template<size_t N, int kPow2>
HWY_API svfloat32_t hwy::HWY_NAMESPACE::WidenMulPairwiseAdd (Simd< float, N, kPow2 > df32, VBF16 a, VBF16 b)
 
template<size_t N, int kPow2>
HWY_API svint32_t hwy::HWY_NAMESPACE::WidenMulPairwiseAdd (Simd< int32_t, N, kPow2 > d32, svint16_t a, svint16_t b)
 
template<size_t N, int kPow2>
HWY_API svuint32_t hwy::HWY_NAMESPACE::WidenMulPairwiseAdd (Simd< uint32_t, N, kPow2 > d32, svuint16_t a, svuint16_t b)
 
template<class DI32 , HWY_IF_I32_D(DI32) >
HWY_API VFromD< DI32 > hwy::HWY_NAMESPACE::SatWidenMulAccumFixedPoint (DI32, VFromD< Rebind< int16_t, DI32 > > a, VFromD< Rebind< int16_t, DI32 > > b, VFromD< DI32 > sum)
 
template<size_t N, int kPow2>
HWY_API svfloat32_t hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< float, N, kPow2 > df32, VBF16 a, VBF16 b, const svfloat32_t sum0, svfloat32_t &sum1)
 
template<size_t N, int kPow2>
HWY_API svint32_t hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< int32_t, N, kPow2 > d32, svint16_t a, svint16_t b, const svint32_t sum0, svint32_t &sum1)
 
template<size_t N, int kPow2>
HWY_API svuint32_t hwy::HWY_NAMESPACE::ReorderWidenMulAccumulate (Simd< uint32_t, N, kPow2 > d32, svuint16_t a, svuint16_t b, const svuint32_t sum0, svuint32_t &sum1)
 
template<class VW >
HWY_API VW hwy::HWY_NAMESPACE::RearrangeToOddPlusEven (const VW sum0, const VW sum1)
 
template<class DI32 , HWY_IF_I32_D(DI32) >
HWY_API VFromD< DI32 > hwy::HWY_NAMESPACE::SumOfMulQuadAccumulate (DI32, svint8_t a, svint8_t b, svint32_t sum)
 
template<class DU32 , HWY_IF_U32_D(DU32) >
HWY_API VFromD< DU32 > hwy::HWY_NAMESPACE::SumOfMulQuadAccumulate (DU32, svuint8_t a, svuint8_t b, svuint32_t sum)
 
template<class DI32 , HWY_IF_I32_D(DI32) >
HWY_API VFromD< DI32 > hwy::HWY_NAMESPACE::SumOfMulQuadAccumulate (DI32 di32, svuint8_t a_u, svint8_t b_i, svint32_t sum)
 
template<class DI64 , HWY_IF_I64_D(DI64) >
HWY_API VFromD< DI64 > hwy::HWY_NAMESPACE::SumOfMulQuadAccumulate (DI64, svint16_t a, svint16_t b, svint64_t sum)
 
template<class DU64 , HWY_IF_U64_D(DU64) >
HWY_API VFromD< DU64 > hwy::HWY_NAMESPACE::SumOfMulQuadAccumulate (DU64, svuint16_t a, svuint16_t b, svuint64_t sum)
 
template<class D >
HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::detail::Lt128Vec (D d, const svuint64_t a, const svuint64_t b)
 
template<class D >
HWY_INLINE svbool_t hwy::HWY_NAMESPACE::Lt128 (D d, const svuint64_t a, const svuint64_t b)
 
template<class D >
HWY_INLINE svbool_t hwy::HWY_NAMESPACE::Lt128Upper (D d, svuint64_t a, svuint64_t b)
 
template<class D >
HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::detail::Eq128Vec (D d, const svuint64_t a, const svuint64_t b)
 
template<class D >
HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::detail::Ne128Vec (D d, const svuint64_t a, const svuint64_t b)
 
template<class D >
HWY_INLINE svbool_t hwy::HWY_NAMESPACE::Eq128 (D d, const svuint64_t a, const svuint64_t b)
 
template<class D >
HWY_INLINE svbool_t hwy::HWY_NAMESPACE::Ne128 (D d, const svuint64_t a, const svuint64_t b)
 
template<class D >
HWY_INLINE svbool_t hwy::HWY_NAMESPACE::Eq128Upper (D d, svuint64_t a, svuint64_t b)
 
template<class D >
HWY_INLINE svbool_t hwy::HWY_NAMESPACE::Ne128Upper (D d, svuint64_t a, svuint64_t b)
 
template<class D >
HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::Min128 (D d, const svuint64_t a, const svuint64_t b)
 
template<class D >
HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::Max128 (D d, const svuint64_t a, const svuint64_t b)
 
template<class D >
HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::Min128Upper (D d, const svuint64_t a, const svuint64_t b)
 
template<class D >
HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::Max128Upper (D d, const svuint64_t a, const svuint64_t b)
 
template<class V , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(V) >
HWY_APIhwy::HWY_NAMESPACE::TrailingZeroCount (V v)
 
template<class V , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(V) >
HWY_APIhwy::HWY_NAMESPACE::HighestSetBitIndex (V v)
 
 HWY_AFTER_NAMESPACE ()
 

Variables

hwy::HWY_NAMESPACE::d
 
D TFromD< D > *HWY_RESTRICT hwy::HWY_NAMESPACE::p
 
D TFromD< D > *HWY_RESTRICT VFromD< RebindToSigned< D > > hwy::HWY_NAMESPACE::indices
 
svbool_t hwy::HWY_NAMESPACE::m
 

Macro Definition Documentation

◆ HWY_IF_ADDSUB_V

#define HWY_IF_ADDSUB_V ( V)
Value:
HWY_IF_LANES_GT_D(DFromV<V>, 1), \
hwy::EnableIf<!hwy::IsSame<V, V>()>* = nullptr
#define HWY_IF_LANES_GT_D(D, lanes)
Definition ops/shared-inl.h:562

◆ HWY_IF_MULADDSUB_V

#define HWY_IF_MULADDSUB_V ( V)
Value:
HWY_IF_LANES_GT_D(DFromV<V>, 1), \
hwy::EnableIf<!hwy::IsSame<V, V>()>* = nullptr

◆ HWY_IF_REDUCE_D

#define HWY_IF_REDUCE_D ( D)    hwy::EnableIf<HWY_MAX_LANES_D(D) != 1>* = nullptr

◆ HWY_IF_U2I_DEMOTE_FROM_LANE_SIZE_V

#define HWY_IF_U2I_DEMOTE_FROM_LANE_SIZE_V ( V)     hwy::EnableIf<!hwy::IsSame<V, V>()>* = nullptr

◆ HWY_NATIVE_BITWISE_IF_THEN_ELSE

#define HWY_NATIVE_BITWISE_IF_THEN_ELSE

◆ HWY_NATIVE_BROADCASTLANE

#define HWY_NATIVE_BROADCASTLANE

◆ HWY_NATIVE_DEMOTE_F32_TO_BF16

#define HWY_NATIVE_DEMOTE_F32_TO_BF16

◆ HWY_NATIVE_DEMOTE_F64_TO_F16

#define HWY_NATIVE_DEMOTE_F64_TO_F16

◆ HWY_NATIVE_DEMOTE_MASK_TO

#define HWY_NATIVE_DEMOTE_MASK_TO

◆ HWY_NATIVE_EXPAND

#define HWY_NATIVE_EXPAND

◆ HWY_NATIVE_F16C

#define HWY_NATIVE_F16C

◆ HWY_NATIVE_F64_APPROX_RECIP

#define HWY_NATIVE_F64_APPROX_RECIP

◆ HWY_NATIVE_F64_APPROX_RSQRT

#define HWY_NATIVE_F64_APPROX_RSQRT

◆ HWY_NATIVE_GATHER

#define HWY_NATIVE_GATHER

◆ HWY_NATIVE_I16_I16_SUMOFMULQUADACCUMULATE

#define HWY_NATIVE_I16_I16_SUMOFMULQUADACCUMULATE

◆ HWY_NATIVE_I16_SATWIDENMULACCUMFIXEDPOINT

#define HWY_NATIVE_I16_SATWIDENMULACCUMFIXEDPOINT

◆ HWY_NATIVE_I32_SATURATED_ADDSUB

#define HWY_NATIVE_I32_SATURATED_ADDSUB

◆ HWY_NATIVE_I64_SATURATED_ADDSUB

#define HWY_NATIVE_I64_SATURATED_ADDSUB

◆ HWY_NATIVE_I8_I8_SUMOFMULQUADACCUMULATE

#define HWY_NATIVE_I8_I8_SUMOFMULQUADACCUMULATE

◆ HWY_NATIVE_INT_DIV

#define HWY_NATIVE_INT_DIV

◆ HWY_NATIVE_INT_FMA

#define HWY_NATIVE_INT_FMA

◆ HWY_NATIVE_INTEGER_ABS_DIFF

#define HWY_NATIVE_INTEGER_ABS_DIFF

◆ HWY_NATIVE_INTERLEAVE_WHOLE

#define HWY_NATIVE_INTERLEAVE_WHOLE

◆ HWY_NATIVE_IS_NEGATIVE

#define HWY_NATIVE_IS_NEGATIVE

◆ HWY_NATIVE_ISINF

#define HWY_NATIVE_ISINF

◆ HWY_NATIVE_LEADING_ZERO_COUNT

#define HWY_NATIVE_LEADING_ZERO_COUNT

◆ HWY_NATIVE_LOAD_STORE_INTERLEAVED

#define HWY_NATIVE_LOAD_STORE_INTERLEAVED

◆ HWY_NATIVE_LOWER_HALF_OF_MASK

#define HWY_NATIVE_LOWER_HALF_OF_MASK

◆ HWY_NATIVE_MASK_FALSE

#define HWY_NATIVE_MASK_FALSE

◆ HWY_NATIVE_MASKED_ARITH

#define HWY_NATIVE_MASKED_ARITH

◆ HWY_NATIVE_MUL_64

#define HWY_NATIVE_MUL_64

◆ HWY_NATIVE_MUL_8

#define HWY_NATIVE_MUL_8

◆ HWY_NATIVE_OPERATOR_REPLACEMENTS

#define HWY_NATIVE_OPERATOR_REPLACEMENTS

◆ HWY_NATIVE_POPCNT

#define HWY_NATIVE_POPCNT

◆ HWY_NATIVE_PROMOTE_F16_TO_F64

#define HWY_NATIVE_PROMOTE_F16_TO_F64

◆ HWY_NATIVE_PROMOTE_MASK_TO

#define HWY_NATIVE_PROMOTE_MASK_TO

◆ HWY_NATIVE_PROMOTE_UPPER_TO

#define HWY_NATIVE_PROMOTE_UPPER_TO

◆ HWY_NATIVE_REDUCE_MINMAX_4_UI8

#define HWY_NATIVE_REDUCE_MINMAX_4_UI8

◆ HWY_NATIVE_REDUCE_SCALAR

#define HWY_NATIVE_REDUCE_SCALAR

◆ HWY_NATIVE_REDUCE_SUM_4_UI8

#define HWY_NATIVE_REDUCE_SUM_4_UI8

◆ HWY_NATIVE_REVERSE2_8

#define HWY_NATIVE_REVERSE2_8

◆ HWY_NATIVE_REVERSE_BITS_UI16_32_64

#define HWY_NATIVE_REVERSE_BITS_UI16_32_64

◆ HWY_NATIVE_REVERSE_BITS_UI8

#define HWY_NATIVE_REVERSE_BITS_UI8

◆ HWY_NATIVE_SATURATED_ABS

#define HWY_NATIVE_SATURATED_ABS

◆ HWY_NATIVE_SATURATED_NEG_64

#define HWY_NATIVE_SATURATED_NEG_64

◆ HWY_NATIVE_SATURATED_NEG_8_16_32

#define HWY_NATIVE_SATURATED_NEG_8_16_32

◆ HWY_NATIVE_SCATTER

#define HWY_NATIVE_SCATTER

◆ HWY_NATIVE_SLIDE1_UP_DOWN

#define HWY_NATIVE_SLIDE1_UP_DOWN

◆ HWY_NATIVE_U16_U16_SUMOFMULQUADACCUMULATE

#define HWY_NATIVE_U16_U16_SUMOFMULQUADACCUMULATE

◆ HWY_NATIVE_U32_SATURATED_ADDSUB

#define HWY_NATIVE_U32_SATURATED_ADDSUB

◆ HWY_NATIVE_U64_SATURATED_ADDSUB

#define HWY_NATIVE_U64_SATURATED_ADDSUB

◆ HWY_NATIVE_U8_I8_SUMOFMULQUADACCUMULATE

#define HWY_NATIVE_U8_I8_SUMOFMULQUADACCUMULATE

◆ HWY_NATIVE_U8_U8_SUMOFMULQUADACCUMULATE

#define HWY_NATIVE_U8_U8_SUMOFMULQUADACCUMULATE

◆ HWY_SPECIALIZE

#define HWY_SPECIALIZE ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <> \
struct DFromV_t<HWY_SVE_V(BASE, BITS)> { \
using type = ScalableTag<HWY_SVE_T(BASE, BITS)>; \
};
#define HWY_SVE_V(BASE, BITS)
Definition arm_sve-inl.h:190
#define HWY_SVE_T(BASE, BITS)
Definition arm_sve-inl.h:188

◆ HWY_SVE_ADDSUB_F

#define HWY_SVE_ADDSUB_F ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
const DFromV<decltype(b)> d; \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), a, Reverse2(d, b), \
90); \
}
#define HWY_SVE_PTRUE(BITS)
Definition arm_sve-inl.h:289
#define HWY_API
Definition base.h:171

◆ HWY_SVE_ADDSUB_UI

#define HWY_SVE_ADDSUB_UI ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
const DFromV<decltype(b)> d; \
return sv##OP##_##CHAR##BITS(a, Reverse2(d, b), 90); \
}

◆ HWY_SVE_ALL_PTRUE

#define HWY_SVE_ALL_PTRUE ( BITS)    svptrue_pat_b##BITS(SV_ALL)

◆ HWY_SVE_BROADCAST

#define HWY_SVE_BROADCAST ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <int kLane> \
HWY_INLINE HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS(v, kLane); \
}
#define HWY_INLINE
Definition base.h:101

◆ HWY_SVE_CAST

#define HWY_SVE_CAST ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_INLINE svuint8_t BitCastToByte(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_u8_##CHAR##BITS(v); \
} \
template <size_t N, int kPow2> \
HWY_INLINE HWY_SVE_V(BASE, BITS) \
BitCastFromByte(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, svuint8_t v) { \
return sv##OP##_##CHAR##BITS##_u8(v); \
}
#define HWY_SVE_D(BASE, BITS, N, POW2)
Definition arm_sve-inl.h:189

◆ HWY_SVE_CAST_NOP

#define HWY_SVE_CAST_NOP ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) BitCastToByte(HWY_SVE_V(BASE, BITS) v) { \
return v; \
} \
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) BitCastFromByte( \
HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, HWY_SVE_V(BASE, BITS) v) { \
return v; \
}

◆ HWY_SVE_COMPARE

#define HWY_SVE_COMPARE ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API svbool_t NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS(HWY_SVE_PTRUE(BITS), a, b); \
}

◆ HWY_SVE_COMPARE_N

#define HWY_SVE_COMPARE_N ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API svbool_t NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_T(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS(HWY_SVE_PTRUE(BITS), a, b); \
}

◆ HWY_SVE_COMPRESS

#define HWY_SVE_COMPRESS ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v, svbool_t mask) { \
return sv##OP##_##CHAR##BITS(mask, v); \
}

◆ HWY_SVE_CONCAT_EVERY_SECOND

#define HWY_SVE_CONCAT_EVERY_SECOND ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_INLINE HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) hi, HWY_SVE_V(BASE, BITS) lo) { \
return sv##OP##_##CHAR##BITS(lo, hi); \
}

◆ HWY_SVE_CONVERT

#define HWY_SVE_CONVERT ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
/* signed integers */ \
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, HWY_SVE_V(int, BITS) v) { \
return sv##OP##_##CHAR##BITS##_s##BITS##_x(HWY_SVE_PTRUE(BITS), v); \
} \
/* unsigned integers */ \
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, HWY_SVE_V(uint, BITS) v) { \
return sv##OP##_##CHAR##BITS##_u##BITS##_x(HWY_SVE_PTRUE(BITS), v); \
} \
/* Truncates (rounds toward zero). */ \
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(int, BITS) \
NAME(HWY_SVE_D(int, BITS, N, kPow2) /* d */, HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_s##BITS##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v); \
} \
/* Truncates to unsigned (rounds toward zero). */ \
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(uint, BITS) \
NAME(HWY_SVE_D(uint, BITS, N, kPow2) /* d */, HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_u##BITS##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v); \
}

◆ HWY_SVE_COUNT_TRUE

#define HWY_SVE_COUNT_TRUE ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API size_t NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, svbool_t m) { \
return sv##OP##_b##BITS(detail::MakeMask(d), m); \
}

◆ HWY_SVE_COUNT_TRUE_FULL

#define HWY_SVE_COUNT_TRUE_FULL ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API size_t NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, svbool_t m) { \
return sv##OP##_b##BITS(svptrue_b##BITS(), m); \
}

◆ HWY_SVE_CREATE

#define HWY_SVE_CREATE ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_TUPLE(BASE, BITS, 2) \
NAME##2(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, \
HWY_SVE_V(BASE, BITS) v0, HWY_SVE_V(BASE, BITS) v1) { \
return sv##OP##2_##CHAR##BITS(v0, v1); \
} \
template <size_t N, int kPow2> \
HWY_API HWY_SVE_TUPLE(BASE, BITS, 3) NAME##3( \
HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, HWY_SVE_V(BASE, BITS) v0, \
HWY_SVE_V(BASE, BITS) v1, HWY_SVE_V(BASE, BITS) v2) { \
return sv##OP##3_##CHAR##BITS(v0, v1, v2); \
} \
template <size_t N, int kPow2> \
HWY_API HWY_SVE_TUPLE(BASE, BITS, 4) \
NAME##4(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, \
HWY_SVE_V(BASE, BITS) v0, HWY_SVE_V(BASE, BITS) v1, \
HWY_SVE_V(BASE, BITS) v2, HWY_SVE_V(BASE, BITS) v3) { \
return sv##OP##4_##CHAR##BITS(v0, v1, v2, v3); \
}
#define HWY_SVE_TUPLE(BASE, BITS, MUL)
Definition arm_sve-inl.h:191

◆ HWY_SVE_D

#define HWY_SVE_D ( BASE,
BITS,
N,
POW2 )   Simd<HWY_SVE_T(BASE, BITS), N, POW2>

◆ HWY_SVE_DUP

#define HWY_SVE_DUP ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API svbool_t NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /*d*/, svbool_t m) { \
return sv##OP##_b##BITS(m, m); \
}

◆ HWY_SVE_EXT

#define HWY_SVE_EXT ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t kIndex> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) hi, HWY_SVE_V(BASE, BITS) lo) { \
return sv##OP##_##CHAR##BITS(lo, hi, kIndex); \
}

◆ HWY_SVE_FIRSTN

#define HWY_SVE_FIRSTN ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API svbool_t NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, size_t count) { \
const size_t limit = detail::IsFull(d) ? count : HWY_MIN(Lanes(d), count); \
return sv##OP##_b##BITS##_u32(uint32_t{0}, static_cast<uint32_t>(limit)); \
}
#define HWY_MIN(a, b)
Definition base.h:176

◆ HWY_SVE_FMA

#define HWY_SVE_FMA ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) mul, HWY_SVE_V(BASE, BITS) x, \
HWY_SVE_V(BASE, BITS) add) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), x, mul, add); \
}

◆ HWY_SVE_FOREACH

#define HWY_SVE_FOREACH ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_U(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_F(X_MACRO, NAME, OP)
#define HWY_SVE_FOREACH_U(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:128

◆ HWY_SVE_FOREACH_BF16

#define HWY_SVE_FOREACH_BF16 ( X_MACRO,
NAME,
OP )

◆ HWY_SVE_FOREACH_BF16_UNCONDITIONAL

#define HWY_SVE_FOREACH_BF16_UNCONDITIONAL ( X_MACRO,
NAME,
OP )    X_MACRO(bfloat, bf, 16, 16, NAME, OP)

◆ HWY_SVE_FOREACH_F

#define HWY_SVE_FOREACH_F ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_F16(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_F3264(X_MACRO, NAME, OP)
#define HWY_SVE_FOREACH_F16(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:99

◆ HWY_SVE_FOREACH_F16

#define HWY_SVE_FOREACH_F16 ( X_MACRO,
NAME,
OP )    X_MACRO(float, f, 16, 16, NAME, OP)

◆ HWY_SVE_FOREACH_F32

#define HWY_SVE_FOREACH_F32 ( X_MACRO,
NAME,
OP )    X_MACRO(float, f, 32, 16, NAME, OP)

◆ HWY_SVE_FOREACH_F3264

#define HWY_SVE_FOREACH_F3264 ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_F32(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_F64(X_MACRO, NAME, OP)
#define HWY_SVE_FOREACH_F32(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:101

◆ HWY_SVE_FOREACH_F64

#define HWY_SVE_FOREACH_F64 ( X_MACRO,
NAME,
OP )    X_MACRO(float, f, 64, 32, NAME, OP)

◆ HWY_SVE_FOREACH_I

#define HWY_SVE_FOREACH_I ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_I08(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I16(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I32(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I64(X_MACRO, NAME, OP)
#define HWY_SVE_FOREACH_I08(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:93

◆ HWY_SVE_FOREACH_I08

#define HWY_SVE_FOREACH_I08 ( X_MACRO,
NAME,
OP )   X_MACRO(int, s, 8, 8, NAME, OP)

◆ HWY_SVE_FOREACH_I16

#define HWY_SVE_FOREACH_I16 ( X_MACRO,
NAME,
OP )   X_MACRO(int, s, 16, 8, NAME, OP)

◆ HWY_SVE_FOREACH_I32

#define HWY_SVE_FOREACH_I32 ( X_MACRO,
NAME,
OP )   X_MACRO(int, s, 32, 16, NAME, OP)

◆ HWY_SVE_FOREACH_I64

#define HWY_SVE_FOREACH_I64 ( X_MACRO,
NAME,
OP )   X_MACRO(int, s, 64, 32, NAME, OP)

◆ HWY_SVE_FOREACH_IF

#define HWY_SVE_FOREACH_IF ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_I(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_F(X_MACRO, NAME, OP)
#define HWY_SVE_FOREACH_I(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:134

◆ HWY_SVE_FOREACH_U

#define HWY_SVE_FOREACH_U ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_U08(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_U16(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_U32(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_U64(X_MACRO, NAME, OP)
#define HWY_SVE_FOREACH_U08(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:85

◆ HWY_SVE_FOREACH_U08

#define HWY_SVE_FOREACH_U08 ( X_MACRO,
NAME,
OP )   X_MACRO(uint, u, 8, 8, NAME, OP)

◆ HWY_SVE_FOREACH_U16

#define HWY_SVE_FOREACH_U16 ( X_MACRO,
NAME,
OP )   X_MACRO(uint, u, 16, 8, NAME, OP)

◆ HWY_SVE_FOREACH_U32

#define HWY_SVE_FOREACH_U32 ( X_MACRO,
NAME,
OP )    X_MACRO(uint, u, 32, 16, NAME, OP)

◆ HWY_SVE_FOREACH_U64

#define HWY_SVE_FOREACH_U64 ( X_MACRO,
NAME,
OP )    X_MACRO(uint, u, 64, 32, NAME, OP)

◆ HWY_SVE_FOREACH_UI

#define HWY_SVE_FOREACH_UI ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_U(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I(X_MACRO, NAME, OP)

◆ HWY_SVE_FOREACH_UI08

#define HWY_SVE_FOREACH_UI08 ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_U08(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I08(X_MACRO, NAME, OP)

◆ HWY_SVE_FOREACH_UI16

#define HWY_SVE_FOREACH_UI16 ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_U16(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I16(X_MACRO, NAME, OP)
#define HWY_SVE_FOREACH_U16(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:86

◆ HWY_SVE_FOREACH_UI32

#define HWY_SVE_FOREACH_UI32 ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_U32(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I32(X_MACRO, NAME, OP)
#define HWY_SVE_FOREACH_U32(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:87

◆ HWY_SVE_FOREACH_UI64

#define HWY_SVE_FOREACH_UI64 ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_U64(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_I64(X_MACRO, NAME, OP)
#define HWY_SVE_FOREACH_U64(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:89

◆ HWY_SVE_FOREACH_UIF3264

#define HWY_SVE_FOREACH_UIF3264 ( X_MACRO,
NAME,
OP )
Value:
HWY_SVE_FOREACH_UI32(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_UI64(X_MACRO, NAME, OP) \
HWY_SVE_FOREACH_F3264(X_MACRO, NAME, OP)
#define HWY_SVE_FOREACH_UI32(X_MACRO, NAME, OP)
Definition arm_sve-inl.h:160

◆ HWY_SVE_GATHER_OFFSET

#define HWY_SVE_GATHER_OFFSET ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT base, \
HWY_SVE_V(int, BITS) offset) { \
return sv##OP##_s##BITS##offset_##CHAR##BITS(detail::MakeMask(d), base, \
offset); \
}
#define HWY_RESTRICT
Definition base.h:95

◆ HWY_SVE_GET

#define HWY_SVE_GET ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t kIndex> \
HWY_API HWY_SVE_V(BASE, BITS) NAME##2(HWY_SVE_TUPLE(BASE, BITS, 2) tuple) { \
return sv##OP##2_##CHAR##BITS(tuple, kIndex); \
} \
template <size_t kIndex> \
HWY_API HWY_SVE_V(BASE, BITS) NAME##3(HWY_SVE_TUPLE(BASE, BITS, 3) tuple) { \
return sv##OP##3_##CHAR##BITS(tuple, kIndex); \
} \
template <size_t kIndex> \
HWY_API HWY_SVE_V(BASE, BITS) NAME##4(HWY_SVE_TUPLE(BASE, BITS, 4) tuple) { \
return sv##OP##4_##CHAR##BITS(tuple, kIndex); \
}

◆ HWY_SVE_GET_LANE

#define HWY_SVE_GET_LANE ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_INLINE HWY_SVE_T(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) v, svbool_t mask) { \
return sv##OP##_##CHAR##BITS(mask, v); \
}

◆ HWY_SVE_HAVE_2

#define HWY_SVE_HAVE_2   1

◆ HWY_SVE_HAVE_BF16_FEATURE

#define HWY_SVE_HAVE_BF16_FEATURE   0

◆ HWY_SVE_HAVE_BF16_VEC

#define HWY_SVE_HAVE_BF16_VEC   0

◆ HWY_SVE_HAVE_F32_TO_BF16C

#define HWY_SVE_HAVE_F32_TO_BF16C   0

◆ HWY_SVE_IF_EMULATED_D

#define HWY_SVE_IF_EMULATED_D ( D)    HWY_IF_BF16_D(D)

◆ HWY_SVE_IF_NOT_EMULATED_D

#define HWY_SVE_IF_NOT_EMULATED_D ( D)    HWY_IF_NOT_BF16_D(D)

◆ HWY_SVE_IF_THEN_ELSE

#define HWY_SVE_IF_THEN_ELSE ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(svbool_t m, HWY_SVE_V(BASE, BITS) yes, HWY_SVE_V(BASE, BITS) no) { \
return sv##OP##_##CHAR##BITS(m, yes, no); \
}

◆ HWY_SVE_IF_VEC

#define HWY_SVE_IF_VEC ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) mask, HWY_SVE_V(BASE, BITS) yes, \
HWY_SVE_V(BASE, BITS) no) { \
return sv##OP##_##CHAR##BITS(yes, no, mask); \
}

◆ HWY_SVE_IOTA

#define HWY_SVE_IOTA ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2, typename T2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, T2 first) { \
return sv##OP##_##CHAR##BITS( \
ConvertScalarTo<HWY_SVE_T(BASE, BITS)>(first), 1); \
}

◆ HWY_SVE_LEADING_ZERO_COUNT

#define HWY_SVE_LEADING_ZERO_COUNT ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
const DFromV<decltype(v)> d; \
return BitCast(d, sv##OP##_##CHAR##BITS##_x(detail::PTrue(d), v)); \
}

◆ HWY_SVE_LOAD2

#define HWY_SVE_LOAD2 ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned, \
HWY_SVE_V(BASE, BITS) & v0, HWY_SVE_V(BASE, BITS) & v1) { \
const HWY_SVE_TUPLE(BASE, BITS, 2) tuple = sv##OP##_##CHAR##BITS( \
detail::MakeMask(d), detail::NativeLanePointer(unaligned)); \
v0 = svget2(tuple, 0); \
v1 = svget2(tuple, 1); \
}

◆ HWY_SVE_LOAD3

#define HWY_SVE_LOAD3 ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned, \
HWY_SVE_V(BASE, BITS) & v0, HWY_SVE_V(BASE, BITS) & v1, \
HWY_SVE_V(BASE, BITS) & v2) { \
const HWY_SVE_TUPLE(BASE, BITS, 3) tuple = sv##OP##_##CHAR##BITS( \
detail::MakeMask(d), detail::NativeLanePointer(unaligned)); \
v0 = svget3(tuple, 0); \
v1 = svget3(tuple, 1); \
v2 = svget3(tuple, 2); \
}

◆ HWY_SVE_LOAD4

#define HWY_SVE_LOAD4 ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_D(BASE, BITS, N, kPow2) d, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned, \
HWY_SVE_V(BASE, BITS) & v0, HWY_SVE_V(BASE, BITS) & v1, \
HWY_SVE_V(BASE, BITS) & v2, HWY_SVE_V(BASE, BITS) & v3) { \
const HWY_SVE_TUPLE(BASE, BITS, 4) tuple = sv##OP##_##CHAR##BITS( \
detail::MakeMask(d), detail::NativeLanePointer(unaligned)); \
v0 = svget4(tuple, 0); \
v1 = svget4(tuple, 1); \
v2 = svget4(tuple, 2); \
v3 = svget4(tuple, 3); \
}

◆ HWY_SVE_MASKED_GATHER_INDEX

#define HWY_SVE_MASKED_GATHER_INDEX ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(svbool_t m, HWY_SVE_D(BASE, BITS, N, kPow2) d, \
const HWY_SVE_T(BASE, BITS) * HWY_RESTRICT base, \
HWY_SVE_V(int, BITS) indices) { \
const RebindToSigned<decltype(d)> di; \
(void)di; /* for HWY_DASSERT */ \
HWY_DASSERT(AllFalse(di, Lt(indices, Zero(di)))); \
return sv##OP##_s##BITS##index_##CHAR##BITS(m, base, indices); \
}

◆ HWY_SVE_MASKED_SCATTER_INDEX

#define HWY_SVE_MASKED_SCATTER_INDEX ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_V(BASE, BITS) v, svbool_t m, \
HWY_SVE_D(BASE, BITS, N, kPow2) /*d*/, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT base, \
HWY_SVE_V(int, BITS) indices) { \
sv##OP##_s##BITS##index_##CHAR##BITS(m, base, indices, v); \
}

◆ HWY_SVE_MEM

#define HWY_SVE_MEM ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )

◆ HWY_SVE_MUL_EVEN

#define HWY_SVE_MUL_EVEN ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, HALF) a, HWY_SVE_V(BASE, HALF) b) { \
return sv##OP##_##CHAR##BITS(a, b); \
}

◆ HWY_SVE_ODD_EVEN

#define HWY_SVE_ODD_EVEN ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) odd, HWY_SVE_V(BASE, BITS) even) { \
return sv##OP##_##CHAR##BITS(even, odd, /*xor=*/0); \
}

◆ HWY_SVE_POPCNT

#define HWY_SVE_POPCNT ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return BitCast(DFromV<decltype(v)>(), \
sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v)); \
}

◆ HWY_SVE_PROMOTE_TO

#define HWY_SVE_PROMOTE_TO ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) NAME( \
HWY_SVE_D(BASE, BITS, N, kPow2) /* tag */, HWY_SVE_V(BASE, HALF) v) { \
return sv##OP##_##CHAR##BITS(v); \
}

◆ HWY_SVE_PTRUE

#define HWY_SVE_PTRUE ( BITS)    svptrue_pat_b##BITS(SV_POW2)

◆ HWY_SVE_REDUCE

#define HWY_SVE_REDUCE ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_T(BASE, BITS) NAME(svbool_t pg, HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS(pg, v); \
}

◆ HWY_SVE_REDUCE_ADD

#define HWY_SVE_REDUCE_ADD ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_T(BASE, BITS) NAME(svbool_t pg, HWY_SVE_V(BASE, BITS) v) { \
/* The intrinsic returns [u]int64_t; truncate to T so we can broadcast. */ \
using T = HWY_SVE_T(BASE, BITS); \
using TU = MakeUnsigned<T>; \
constexpr uint64_t kMask = LimitsMax<TU>(); \
return static_cast<T>(static_cast<TU>( \
static_cast<uint64_t>(sv##OP##_##CHAR##BITS(pg, v)) & kMask)); \
}

◆ HWY_SVE_RETV_ARGMVV

#define HWY_SVE_RETV_ARGMVV ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(svbool_t m, HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS##_x(m, a, b); \
}

◆ HWY_SVE_RETV_ARGPV

#define HWY_SVE_RETV_ARGPV ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v); \
}

◆ HWY_SVE_RETV_ARGPVN

#define HWY_SVE_RETV_ARGPVN ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_T(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), a, b); \
}

◆ HWY_SVE_RETV_ARGPVN_MASK

#define HWY_SVE_RETV_ARGPVN_MASK ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(svbool_t pg, HWY_SVE_V(BASE, BITS) a, HWY_SVE_T(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS##_z(pg, a, b); \
}

◆ HWY_SVE_RETV_ARGPVN_SWAP

#define HWY_SVE_RETV_ARGPVN_SWAP ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_T(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), b, a); \
}

◆ HWY_SVE_RETV_ARGPVV

#define HWY_SVE_RETV_ARGPVV ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), a, b); \
}

◆ HWY_SVE_RETV_ARGPVV_SWAP

#define HWY_SVE_RETV_ARGPVV_SWAP ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), b, a); \
}

◆ HWY_SVE_RETV_ARGV

#define HWY_SVE_RETV_ARGV ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS(v); \
}

◆ HWY_SVE_RETV_ARGVN

#define HWY_SVE_RETV_ARGVN ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_T(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS(a, b); \
}

◆ HWY_SVE_RETV_ARGVV

#define HWY_SVE_RETV_ARGVV ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b) { \
return sv##OP##_##CHAR##BITS(a, b); \
}

◆ HWY_SVE_RETV_ARGVVV

#define HWY_SVE_RETV_ARGVVV ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) a, HWY_SVE_V(BASE, BITS) b, \
HWY_SVE_V(BASE, BITS) c) { \
return sv##OP##_##CHAR##BITS(a, b, c); \
}

◆ HWY_SVE_REVERSE

#define HWY_SVE_REVERSE ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS(v); \
}

◆ HWY_SVE_REVERSE_BITS

#define HWY_SVE_REVERSE_BITS ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
const DFromV<decltype(v)> d; \
return sv##OP##_##CHAR##BITS##_x(detail::PTrue(d), v); \
}

◆ HWY_SVE_ROTATE_RIGHT_N

#define HWY_SVE_ROTATE_RIGHT_N ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <int kBits> \
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
if (kBits == 0) return v; \
return sv##OP##_##CHAR##BITS(v, Zero(DFromV<decltype(v)>()), \
HWY_MAX(kBits, 1)); \
}

◆ HWY_SVE_SCATTER_OFFSET

#define HWY_SVE_SCATTER_OFFSET ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_V(BASE, BITS) v, \
HWY_SVE_D(BASE, BITS, N, kPow2) d, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT base, \
HWY_SVE_V(int, BITS) offset) { \
sv##OP##_s##BITS##offset_##CHAR##BITS(detail::MakeMask(d), base, offset, \
v); \
}

◆ HWY_SVE_SET [1/2]

#define HWY_SVE_SET ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */, \
HWY_SVE_T(BASE, BITS) arg) { \
return sv##OP##_##CHAR##BITS(arg); \
}

◆ HWY_SVE_SET [2/2]

#define HWY_SVE_SET ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t kIndex> \
HWY_API HWY_SVE_TUPLE(BASE, BITS, 2) \
NAME##2(HWY_SVE_TUPLE(BASE, BITS, 2) tuple, HWY_SVE_V(BASE, BITS) vec) { \
return sv##OP##2_##CHAR##BITS(tuple, kIndex, vec); \
} \
template <size_t kIndex> \
HWY_API HWY_SVE_TUPLE(BASE, BITS, 3) \
NAME##3(HWY_SVE_TUPLE(BASE, BITS, 3) tuple, HWY_SVE_V(BASE, BITS) vec) { \
return sv##OP##3_##CHAR##BITS(tuple, kIndex, vec); \
} \
template <size_t kIndex> \
HWY_API HWY_SVE_TUPLE(BASE, BITS, 4) \
NAME##4(HWY_SVE_TUPLE(BASE, BITS, 4) tuple, HWY_SVE_V(BASE, BITS) vec) { \
return sv##OP##4_##CHAR##BITS(tuple, kIndex, vec); \
}

◆ HWY_SVE_SHIFT

#define HWY_SVE_SHIFT ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) v, HWY_SVE_V(BASE, BITS) bits) { \
const RebindToUnsigned<DFromV<decltype(v)>> du; \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v, \
BitCast(du, bits)); \
}

◆ HWY_SVE_SHIFT_N

#define HWY_SVE_SHIFT_N ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <int kBits> \
HWY_API HWY_SVE_V(BASE, BITS) NAME(HWY_SVE_V(BASE, BITS) v) { \
return sv##OP##_##CHAR##BITS##_x(HWY_SVE_PTRUE(BITS), v, kBits); \
} \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME##Same(HWY_SVE_V(BASE, BITS) v, int bits) { \
return sv##OP##_##CHAR##BITS##_x( \
HWY_SVE_PTRUE(BITS), v, static_cast<HWY_SVE_T(uint, BITS)>(bits)); \
}

◆ HWY_SVE_SPLICE

#define HWY_SVE_SPLICE ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) NAME( \
HWY_SVE_V(BASE, BITS) hi, HWY_SVE_V(BASE, BITS) lo, svbool_t mask) { \
return sv##OP##_##CHAR##BITS(mask, lo, hi); \
}

◆ HWY_SVE_STORE2

#define HWY_SVE_STORE2 ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_V(BASE, BITS) v0, HWY_SVE_V(BASE, BITS) v1, \
HWY_SVE_D(BASE, BITS, N, kPow2) d, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned) { \
sv##OP##_##CHAR##BITS(detail::MakeMask(d), \
detail::NativeLanePointer(unaligned), \
Create2(d, v0, v1)); \
}
HWY_API Vec2< D > Create2(D, VFromD< D > v0, VFromD< D > v1)
Definition tuple-inl.h:52

◆ HWY_SVE_STORE3

#define HWY_SVE_STORE3 ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_V(BASE, BITS) v0, HWY_SVE_V(BASE, BITS) v1, \
HWY_SVE_V(BASE, BITS) v2, \
HWY_SVE_D(BASE, BITS, N, kPow2) d, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned) { \
sv##OP##_##CHAR##BITS(detail::MakeMask(d), \
detail::NativeLanePointer(unaligned), \
Create3(d, v0, v1, v2)); \
}
HWY_API Vec3< D > Create3(D, VFromD< D > v0, VFromD< D > v1, VFromD< D > v2)
Definition tuple-inl.h:57

◆ HWY_SVE_STORE4

#define HWY_SVE_STORE4 ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API void NAME(HWY_SVE_V(BASE, BITS) v0, HWY_SVE_V(BASE, BITS) v1, \
HWY_SVE_V(BASE, BITS) v2, HWY_SVE_V(BASE, BITS) v3, \
HWY_SVE_D(BASE, BITS, N, kPow2) d, \
HWY_SVE_T(BASE, BITS) * HWY_RESTRICT unaligned) { \
sv##OP##_##CHAR##BITS(detail::MakeMask(d), \
detail::NativeLanePointer(unaligned), \
Create4(d, v0, v1, v2, v3)); \
}
HWY_API Vec4< D > Create4(D, VFromD< D > v0, VFromD< D > v1, VFromD< D > v2, VFromD< D > v3)
Definition tuple-inl.h:62

◆ HWY_SVE_T

#define HWY_SVE_T ( BASE,
BITS )   BASE##BITS##_t

◆ HWY_SVE_TABLE

#define HWY_SVE_TABLE ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_V(BASE, BITS) v, HWY_SVE_V(uint, BITS) idx) { \
return sv##OP##_##CHAR##BITS(v, idx); \
}

◆ HWY_SVE_TABLE2

#define HWY_SVE_TABLE2 ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_TUPLE(BASE, BITS, 2) tuple, HWY_SVE_V(uint, BITS) idx) { \
return sv##OP##_##CHAR##BITS(tuple, idx); \
}

◆ HWY_SVE_TUPLE

#define HWY_SVE_TUPLE ( BASE,
BITS,
MUL )   sv##BASE##BITS##x##MUL##_t

◆ HWY_SVE_UNDEFINED

#define HWY_SVE_UNDEFINED ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API HWY_SVE_V(BASE, BITS) \
NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */) { \
return sv##OP##_##CHAR##BITS(); \
}

◆ HWY_SVE_V

#define HWY_SVE_V ( BASE,
BITS )   sv##BASE##BITS##_t

◆ HWY_SVE_WRAP_PTRUE

#define HWY_SVE_WRAP_PTRUE ( BASE,
CHAR,
BITS,
HALF,
NAME,
OP )
Value:
template <size_t N, int kPow2> \
HWY_API svbool_t NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */) { \
return HWY_SVE_PTRUE(BITS); \
} \
template <size_t N, int kPow2> \
HWY_API svbool_t All##NAME(HWY_SVE_D(BASE, BITS, N, kPow2) /* d */) { \
return HWY_SVE_ALL_PTRUE(BITS); \
}
#define HWY_SVE_ALL_PTRUE(BITS)
Definition arm_sve-inl.h:288

Function Documentation

◆ HWY_AFTER_NAMESPACE()

HWY_AFTER_NAMESPACE ( )

◆ HWY_BEFORE_NAMESPACE()

HWY_BEFORE_NAMESPACE ( )