Grok 10.0.0
Classes | Typedefs | Functions | Variables
hwy::HWY_NAMESPACE::detail Namespace Reference

Classes

struct  BitCastFromInteger128
 
struct  BitCastFromInteger128< double >
 
struct  BitCastFromInteger128< float >
 
struct  BitCastFromInteger256
 
struct  BitCastFromInteger256< double >
 
struct  BitCastFromInteger256< float >
 
struct  BitCastFromInteger512
 
struct  BitCastFromInteger512< double >
 
struct  BitCastFromInteger512< float >
 
struct  CappedTagChecker
 
struct  Deduce1
 
struct  Deduce128
 
struct  DeduceD
 
struct  ExpandDFromV
 
struct  FixedTagChecker
 
struct  ForeachCappedR
 
struct  ForeachCappedR< T, 0, kMinArg, Test >
 
struct  KeyLane
 
struct  OrderAscending
 
struct  OrderDescending
 
struct  Raw128
 
struct  Raw128< bfloat16_t, 1 >
 
struct  Raw128< bfloat16_t, 2 >
 
struct  Raw128< bfloat16_t, 4 >
 
struct  Raw128< bfloat16_t, 8 >
 
struct  Raw128< double >
 
struct  Raw128< float >
 
struct  Raw128< float, 1 >
 
struct  Raw128< float, 2 >
 
struct  Raw128< float, 4 >
 
struct  Raw128< float16_t, 1 >
 
struct  Raw128< float16_t, 2 >
 
struct  Raw128< float16_t, 4 >
 
struct  Raw128< float16_t, 8 >
 
struct  Raw128< int16_t, 1 >
 
struct  Raw128< int16_t, 2 >
 
struct  Raw128< int16_t, 4 >
 
struct  Raw128< int16_t, 8 >
 
struct  Raw128< int32_t, 1 >
 
struct  Raw128< int32_t, 2 >
 
struct  Raw128< int32_t, 4 >
 
struct  Raw128< int64_t, 1 >
 
struct  Raw128< int64_t, 2 >
 
struct  Raw128< int8_t, 1 >
 
struct  Raw128< int8_t, 16 >
 
struct  Raw128< int8_t, 2 >
 
struct  Raw128< int8_t, 4 >
 
struct  Raw128< int8_t, 8 >
 
struct  Raw128< uint16_t, 1 >
 
struct  Raw128< uint16_t, 2 >
 
struct  Raw128< uint16_t, 4 >
 
struct  Raw128< uint16_t, 8 >
 
struct  Raw128< uint32_t, 1 >
 
struct  Raw128< uint32_t, 2 >
 
struct  Raw128< uint32_t, 4 >
 
struct  Raw128< uint64_t, 1 >
 
struct  Raw128< uint64_t, 2 >
 
struct  Raw128< uint8_t, 1 >
 
struct  Raw128< uint8_t, 16 >
 
struct  Raw128< uint8_t, 2 >
 
struct  Raw128< uint8_t, 4 >
 
struct  Raw128< uint8_t, 8 >
 
struct  Raw256
 
struct  Raw256< double >
 
struct  Raw256< float >
 
struct  Raw512
 
struct  Raw512< double >
 
struct  Raw512< float >
 
struct  RawMask128
 
struct  RawMask128< 1 >
 
struct  RawMask128< 2 >
 
struct  RawMask128< 4 >
 
struct  RawMask128< 8 >
 
struct  RawMask256
 
struct  RawMask256< 1 >
 
struct  RawMask256< 2 >
 
struct  RawMask256< 4 >
 
struct  RawMask256< 8 >
 
struct  RawMask512
 
struct  RawMask512< 1 >
 
struct  RawMask512< 2 >
 
struct  RawMask512< 4 >
 
struct  RawMask512< 8 >
 
struct  RotateRight
 
struct  RotateRight< 0 >
 
struct  ScalableTagChecker
 
struct  SharedTraits
 
struct  ShiftLeftBytesT
 
struct  ShiftLeftBytesT< 0 >
 
struct  ShiftLeftBytesT< 0xFF >
 
struct  ShiftRightBytesT
 
struct  ShiftRightBytesT< 0 >
 
struct  ShiftRightBytesT< 0xFF >
 
struct  TraitsLane
 
struct  Tuple2
 
struct  Tuple2< bfloat16_t, 8 >
 
struct  Tuple2< bfloat16_t, N >
 
struct  Tuple2< float16_t, 8 >
 
struct  Tuple2< float16_t, N >
 
struct  Tuple2< float32_t, 4 >
 
struct  Tuple2< float32_t, N >
 
struct  Tuple2< int16_t, 8 >
 
struct  Tuple2< int16_t, N >
 
struct  Tuple2< int32_t, 4 >
 
struct  Tuple2< int32_t, N >
 
struct  Tuple2< int64_t, 2 >
 
struct  Tuple2< int64_t, N >
 
struct  Tuple2< int8_t, 16 >
 
struct  Tuple2< int8_t, N >
 
struct  Tuple2< uint16_t, 8 >
 
struct  Tuple2< uint16_t, N >
 
struct  Tuple2< uint32_t, 4 >
 
struct  Tuple2< uint32_t, N >
 
struct  Tuple2< uint64_t, 2 >
 
struct  Tuple2< uint64_t, N >
 
struct  Tuple2< uint8_t, 16 >
 
struct  Tuple2< uint8_t, N >
 
struct  Tuple3
 
struct  Tuple3< bfloat16_t, 8 >
 
struct  Tuple3< bfloat16_t, N >
 
struct  Tuple3< float16_t, 8 >
 
struct  Tuple3< float16_t, N >
 
struct  Tuple3< float32_t, 4 >
 
struct  Tuple3< float32_t, N >
 
struct  Tuple3< int16_t, 8 >
 
struct  Tuple3< int16_t, N >
 
struct  Tuple3< int32_t, 4 >
 
struct  Tuple3< int32_t, N >
 
struct  Tuple3< int64_t, 2 >
 
struct  Tuple3< int64_t, N >
 
struct  Tuple3< int8_t, 16 >
 
struct  Tuple3< int8_t, N >
 
struct  Tuple3< uint16_t, 8 >
 
struct  Tuple3< uint16_t, N >
 
struct  Tuple3< uint32_t, 4 >
 
struct  Tuple3< uint32_t, N >
 
struct  Tuple3< uint64_t, 2 >
 
struct  Tuple3< uint64_t, N >
 
struct  Tuple3< uint8_t, 16 >
 
struct  Tuple3< uint8_t, N >
 
struct  Tuple4
 
struct  Tuple4< bfloat16_t, 8 >
 
struct  Tuple4< bfloat16_t, N >
 
struct  Tuple4< float16_t, 8 >
 
struct  Tuple4< float16_t, N >
 
struct  Tuple4< float32_t, 4 >
 
struct  Tuple4< float32_t, N >
 
struct  Tuple4< int16_t, 8 >
 
struct  Tuple4< int16_t, N >
 
struct  Tuple4< int32_t, 4 >
 
struct  Tuple4< int32_t, N >
 
struct  Tuple4< int64_t, 2 >
 
struct  Tuple4< int64_t, N >
 
struct  Tuple4< int8_t, 16 >
 
struct  Tuple4< int8_t, N >
 
struct  Tuple4< uint16_t, 8 >
 
struct  Tuple4< uint16_t, N >
 
struct  Tuple4< uint32_t, 4 >
 
struct  Tuple4< uint32_t, N >
 
struct  Tuple4< uint64_t, 2 >
 
struct  Tuple4< uint64_t, N >
 
struct  Tuple4< uint8_t, 16 >
 
struct  Tuple4< uint8_t, N >
 

Typedefs

using Constants = hwy::SortConstants
 

Functions

template<class Traits , typename T >
void SiftDown (Traits st, T *HWY_RESTRICT lanes, const size_t num_lanes, size_t start)
 
template<class Traits , typename T >
void HeapSort (Traits st, T *HWY_RESTRICT lanes, const size_t num_lanes)
 
template<size_t N>
HWY_INLINE Vec128< uint8_t, NBitCastToByte (Vec128< uint8_t, N > v)
 
 HWY_NEON_DEF_FUNCTION_ALL_FLOATS (BitCastToByte, vreinterpret, _u8_, HWY_CAST_TO_U8) template< size_t N > HWY_INLINE Vec128< uint8_t
 
NBitCastToByte (Vec128< float16_t, N > v)
 
template<size_t N>
HWY_INLINE Vec128< uint8_t, N *2 > BitCastToByte (Vec128< bfloat16_t, N > v)
 
template<size_t N>
HWY_INLINE Vec128< uint8_t, NBitCastFromByte (Simd< uint8_t, N, 0 >, Vec128< uint8_t, N > v)
 
template<size_t N, HWY_IF_LE64(int8_t, N) >
HWY_INLINE Vec128< int8_t, NBitCastFromByte (Simd< int8_t, N, 0 >, Vec128< uint8_t, N > v)
 
template<size_t N, HWY_IF_LE64(uint16_t, N) >
HWY_INLINE Vec128< uint16_t, NBitCastFromByte (Simd< uint16_t, N, 0 >, Vec128< uint8_t, N *2 > v)
 
template<size_t N, HWY_IF_LE64(int16_t, N) >
HWY_INLINE Vec128< int16_t, NBitCastFromByte (Simd< int16_t, N, 0 >, Vec128< uint8_t, N *2 > v)
 
template<size_t N, HWY_IF_LE64(uint32_t, N) >
HWY_INLINE Vec128< uint32_t, NBitCastFromByte (Simd< uint32_t, N, 0 >, Vec128< uint8_t, N *4 > v)
 
template<size_t N, HWY_IF_LE64(int32_t, N) >
HWY_INLINE Vec128< int32_t, NBitCastFromByte (Simd< int32_t, N, 0 >, Vec128< uint8_t, N *4 > v)
 
template<size_t N, HWY_IF_LE64(float, N) >
HWY_INLINE Vec128< float, NBitCastFromByte (Simd< float, N, 0 >, Vec128< uint8_t, N *4 > v)
 
HWY_INLINE Vec64< uint64_t > BitCastFromByte (Full64< uint64_t >, Vec128< uint8_t, 1 *8 > v)
 
HWY_INLINE Vec64< int64_t > BitCastFromByte (Full64< int64_t >, Vec128< uint8_t, 1 *8 > v)
 
HWY_INLINE Vec128< int8_t > BitCastFromByte (Full128< int8_t >, Vec128< uint8_t > v)
 
HWY_INLINE Vec128< uint16_t > BitCastFromByte (Full128< uint16_t >, Vec128< uint8_t > v)
 
HWY_INLINE Vec128< int16_t > BitCastFromByte (Full128< int16_t >, Vec128< uint8_t > v)
 
HWY_INLINE Vec128< uint32_t > BitCastFromByte (Full128< uint32_t >, Vec128< uint8_t > v)
 
HWY_INLINE Vec128< int32_t > BitCastFromByte (Full128< int32_t >, Vec128< uint8_t > v)
 
HWY_INLINE Vec128< float > BitCastFromByte (Full128< float >, Vec128< uint8_t > v)
 
HWY_INLINE Vec128< uint64_t > BitCastFromByte (Full128< uint64_t >, Vec128< uint8_t > v)
 
HWY_INLINE Vec128< int64_t > BitCastFromByte (Full128< int64_t >, Vec128< uint8_t > v)
 
template<size_t N>
HWY_INLINE Vec128< float16_t, NBitCastFromByte (Simd< float16_t, N, 0 >, Vec128< uint8_t, N *2 > v)
 
template<size_t N>
HWY_INLINE Vec128< bfloat16_t, NBitCastFromByte (Simd< bfloat16_t, N, 0 >, Vec128< uint8_t, N *2 > v)
 
HWY_INLINE Vec128< float > ReciprocalNewtonRaphsonStep (const Vec128< float > recip, const Vec128< float > divisor)
 
template<size_t N>
HWY_INLINE Vec128< float, NReciprocalNewtonRaphsonStep (const Vec128< float, N > recip, Vec128< float, N > divisor)
 
HWY_INLINE Vec128< float > ReciprocalSqrtStep (const Vec128< float > root, const Vec128< float > recip)
 
template<size_t N>
HWY_INLINE Vec128< float, NReciprocalSqrtStep (const Vec128< float, N > root, Vec128< float, N > recip)
 
template<typename T >
HWY_INLINE Vec128< T > PopulationCount (hwy::SizeTag< 1 >, Vec128< T > v)
 
template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE Vec128< T, NPopulationCount (hwy::SizeTag< 1 >, Vec128< T, N > v)
 
template<typename T >
HWY_INLINE Vec128< T > PopulationCount (hwy::SizeTag< 2 >, Vec128< T > v)
 
template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE Vec128< T, NPopulationCount (hwy::SizeTag< 2 >, Vec128< T, N > v)
 
template<typename T >
HWY_INLINE Vec128< T > PopulationCount (hwy::SizeTag< 4 >, Vec128< T > v)
 
template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE Vec128< T, NPopulationCount (hwy::SizeTag< 4 >, Vec128< T, N > v)
 
template<typename T >
HWY_INLINE Vec128< T > PopulationCount (hwy::SizeTag< 8 >, Vec128< T > v)
 
template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE Vec128< T, NPopulationCount (hwy::SizeTag< 8 >, Vec128< T, N > v)
 
template<size_t N>
HWY_INLINE Mask128< float, NUseInt (const Vec128< float, N > v)
 
HWY_API Vec128< uint64_t > InterleaveUpper (const Vec128< uint64_t > a, const Vec128< uint64_t > b)
 
HWY_API Vec128< int64_t > InterleaveUpper (Vec128< int64_t > a, Vec128< int64_t > b)
 
HWY_API Vec128< float > InterleaveUpper (Vec128< float > a, Vec128< float > b)
 
HWY_API Vec64< float > InterleaveUpper (const Vec64< float > a, const Vec64< float > b)
 
template<typename T >
HWY_INLINE Vec128< T, 1 > SumOfLanes (const Vec128< T, 1 > v)
 
template<typename T >
HWY_INLINE Vec128< T, 1 > MinOfLanes (hwy::SizeTag< sizeof(T)>, const Vec128< T, 1 > v)
 
template<typename T >
HWY_INLINE Vec128< T, 1 > MaxOfLanes (hwy::SizeTag< sizeof(T)>, const Vec128< T, 1 > v)
 
template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_INLINE Vec128< T, 2 > SumOfLanes (const Vec128< T, 2 > v10)
 
template<typename T >
HWY_INLINE Vec128< T, 2 > MinOfLanes (hwy::SizeTag< 4 >, const Vec128< T, 2 > v10)
 
template<typename T >
HWY_INLINE Vec128< T, 2 > MaxOfLanes (hwy::SizeTag< 4 >, const Vec128< T, 2 > v10)
 
HWY_INLINE Vec128< uint32_t > SumOfLanes (const Vec128< uint32_t > v)
 
HWY_INLINE Vec128< int32_t > SumOfLanes (const Vec128< int32_t > v)
 
HWY_INLINE Vec128< float > SumOfLanes (const Vec128< float > v)
 
HWY_INLINE Vec128< uint64_t > SumOfLanes (const Vec128< uint64_t > v)
 
HWY_INLINE Vec128< int64_t > SumOfLanes (const Vec128< int64_t > v)
 
template<typename T >
HWY_INLINE Vec128< T > MinOfLanes (hwy::SizeTag< 4 >, const Vec128< T > v3210)
 
template<typename T >
HWY_INLINE Vec128< T > MaxOfLanes (hwy::SizeTag< 4 >, const Vec128< T > v3210)
 
template<typename T >
HWY_INLINE Vec128< T > MinOfLanes (hwy::SizeTag< 8 >, const Vec128< T > v10)
 
template<typename T >
HWY_INLINE Vec128< T > MaxOfLanes (hwy::SizeTag< 8 >, const Vec128< T > v10)
 
template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 2) , HWY_IF_GE32(T, N) >
HWY_API Vec128< T, NMinOfLanes (hwy::SizeTag< 2 >, Vec128< T, N > v)
 
template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 2) , HWY_IF_GE32(T, N) >
HWY_API Vec128< T, NMaxOfLanes (hwy::SizeTag< 2 >, Vec128< T, N > v)
 
template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE Vec128< T, NSet64 (Simd< T, N, 0 >, uint64_t mask_bits)
 
template<typename T >
HWY_INLINE Vec128< T > Set64 (Full128< T > d, uint64_t mask_bits)
 
template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_INLINE Mask128< T, NLoadMaskBits (Simd< T, N, 0 > d, uint64_t mask_bits)
 
template<typename T >
HWY_INLINE uint64_t NibblesFromMask (const Full128< T > d, Mask128< T > mask)
 
template<typename T >
HWY_INLINE uint64_t NibblesFromMask (const Full64< T > d, Mask64< T > mask)
 
template<typename T , size_t N, HWY_IF_LE32(T, N) >
HWY_INLINE uint64_t NibblesFromMask (Simd< T, N, 0 >, Mask128< T, N > mask)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 1 >, const Mask128< T > mask)
 
template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 1 >, const Mask128< T, N > mask)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 2 >, const Mask128< T > mask)
 
template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 2 >, const Mask128< T, N > mask)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 4 >, const Mask128< T > mask)
 
template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 4 >, const Mask128< T, N > mask)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 8 >, const Mask128< T > m)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 8 >, const Mask128< T, 1 > m)
 
template<typename T , size_t N>
constexpr uint64_t OnlyActive (uint64_t bits)
 
template<typename T , size_t N>
HWY_INLINE uint64_t BitsFromMask (const Mask128< T, N > mask)
 
template<typename T >
HWY_INLINE size_t CountTrue (hwy::SizeTag< 1 >, const Mask128< T > mask)
 
template<typename T >
HWY_INLINE size_t CountTrue (hwy::SizeTag< 2 >, const Mask128< T > mask)
 
template<typename T >
HWY_INLINE size_t CountTrue (hwy::SizeTag< 4 >, const Mask128< T > mask)
 
template<typename T >
HWY_INLINE size_t CountTrue (hwy::SizeTag< 8 >, const Mask128< T > mask)
 
HWY_INLINE Vec128< uint8_t > Load8Bytes (Full128< uint8_t >, const uint8_t *bytes)
 
template<size_t N, HWY_IF_LE64(uint8_t, N) >
HWY_INLINE Vec128< uint8_t, NLoad8Bytes (Simd< uint8_t, N, 0 > d, const uint8_t *bytes)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIdxFromBits (hwy::SizeTag< 2 >, const uint64_t mask_bits)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIdxFromNotBits (hwy::SizeTag< 2 >, const uint64_t mask_bits)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIdxFromBits (hwy::SizeTag< 4 >, const uint64_t mask_bits)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIdxFromNotBits (hwy::SizeTag< 4 >, const uint64_t mask_bits)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NCompress (Vec128< T, N > v, const uint64_t mask_bits)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NCompressNot (Vec128< T, N > v, const uint64_t mask_bits)
 
HWY_INLINE size_t AllHardwareLanes (hwy::SizeTag< 1 >)
 
HWY_INLINE size_t AllHardwareLanes (hwy::SizeTag< 2 >)
 
HWY_INLINE size_t AllHardwareLanes (hwy::SizeTag< 4 >)
 
HWY_INLINE size_t AllHardwareLanes (hwy::SizeTag< 8 >)
 
 HWY_SVE_FOREACH (HWY_SVE_WRAP_PTRUE, PTrue, ptrue) HWY_API svbool_t PFalse()
 
template<class D >
svbool_t MakeMask (D d)
 
template<size_t N, int kPow2>
HWY_INLINE svuint16_t BitCastFromByte (Simd< bfloat16_t, N, kPow2 >, svuint8_t v)
 
template<size_t N, int kPow2>
HWY_API svfloat32_t PromoteUpperTo (Simd< float, N, kPow2 > df, svfloat16_t v)
 
template<typename TN , class VU >
VU SaturateU (VU v)
 
template<typename TN , class VI >
VI SaturateI (VI v)
 
template<class D , HWY_IF_LANE_SIZE_D(D, 1) >
svbool_t MaskLowerHalf (D d)
 
template<class D >
svbool_t MaskUpperHalf (D d)
 
template<typename T , size_t N, int kPow2>
constexpr size_t LanesPerBlock (Simd< T, N, kPow2 >)
 
template<class T , HWY_IF_LANE_SIZE(T, 1) >
HWY_INLINE svuint8_t BoolFromMask (svbool_t m)
 
HWY_INLINE svuint64_t BitsFromBool (svuint8_t x)
 
 HWY_SVE_FOREACH_U (HWY_SVE_DUP, DupEvenB, trn1) HWY_SVE_FOREACH_U(HWY_SVE_DUP
 
template<class D >
trn2 HWY_INLINE svuint64_t Lt128Vec (D d, const svuint64_t a, const svuint64_t b)
 
template<typename T , HWY_IF_FLOAT(T) >
HWY_INLINE constexpr T IncrementWithWraparound (T t)
 
HWY_INLINE void StoreU16ToF16 (const uint16_t val, hwy::float16_t *HWY_RESTRICT to)
 
HWY_INLINE uint16_t U16FromF16 (const hwy::float16_t *HWY_RESTRICT from)
 
template<typename T , size_t N, class V , HWY_IF_LE128(T, N) >
HWY_API void LoadTransposedBlocks3 (Simd< T, N, 0 > d, const T *HWY_RESTRICT unaligned, V &A, V &B, V &C)
 
template<typename T , size_t N, class V , HWY_IF_LE128(T, N) >
HWY_API void LoadTransposedBlocks4 (Simd< T, N, 0 > d, const T *HWY_RESTRICT unaligned, V &A, V &B, V &C, V &D)
 
template<typename T , size_t N, class V , HWY_IF_LE128(T, N) >
HWY_API void StoreTransposedBlocks2 (const V A, const V B, Simd< T, N, 0 > d, T *HWY_RESTRICT unaligned)
 
template<typename T , size_t N, class V , HWY_IF_LE128(T, N) >
HWY_API void StoreTransposedBlocks3 (const V A, const V B, const V C, Simd< T, N, 0 > d, T *HWY_RESTRICT unaligned)
 
template<typename T , size_t N, class V , HWY_IF_LE128(T, N) >
HWY_API void StoreTransposedBlocks4 (const V A, const V B, const V C, const V D, Simd< T, N, 0 > d, T *HWY_RESTRICT unaligned)
 
template<size_t N, int kPow2>
HWY_INLINE VFromD< Simd< uint16_t, N, kPow2 > > BitCastFromByte (Simd< bfloat16_t, N, kPow2 >, VFromD< Simd< uint8_t, N, kPow2 > > v)
 
template<class V , class DU = RebindToUnsigned<DFromV<V>>>
HWY_INLINE VFromD< DU > BitCastToUnsigned (V v)
 
template<class D , class DU = RebindToUnsigned<D>>
HWY_INLINE VFromD< DU > Iota0 (const D)
 
template<typename T , size_t N, int kPow2>
size_t LanesPerBlock (Simd< T, N, kPow2 > d)
 
template<class D , class V >
HWY_INLINEOffsetsOf128BitBlocks (const D d, const V iota0)
 
template<size_t kLanes, class D >
HWY_INLINE MFromD< D > FirstNPerBlock (D)
 
template<class D >
constexpr bool IsSupportedLMUL (D d)
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2 - 3 > > v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2 - 2 > > v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2 - 1 > > v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< decltype(d)> v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2+1 > > v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2+2 > > v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
HWY_INLINE auto ChangeLMUL (Simd< T, N, kPow2 > d, VFromD< Simd< T, N, kPow2+3 > > v) -> VFromD< decltype(d)>
 
template<typename T , size_t N, int kPow2>
constexpr bool IsFull (Simd< T, N, kPow2 >)
 
constexpr size_t ScaleByPower (size_t N, int pow2)
 
HWY_INLINE __v128_u BitCastToInteger (__v128_u v)
 
HWY_INLINE __v128_u BitCastToInteger (__f32x4 v)
 
HWY_INLINE __v128_u BitCastToInteger (__f64x2 v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< uint8_t, N *sizeof(T)> BitCastToByte (Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NBitCastFromByte (Simd< T, N, 0 >, Vec128< uint8_t, N *sizeof(T)> v)
 
template<size_t kLane, typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_INLINEExtractLane (const Vec128< T, N > v)
 
template<size_t kLane, size_t N>
HWY_INLINE float ExtractLane (const Vec128< float, N > v)
 
template<size_t kLane, typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_INLINE Vec128< T, NInsertLane (const Vec128< T, N > v, T t)
 
template<size_t kLane, size_t N>
HWY_INLINE Vec128< float, NInsertLane (const Vec128< float, N > v, float t)
 
template<size_t kLane, size_t N>
HWY_INLINE Vec128< double, NInsertLane (const Vec128< double, N > v, double t)
 
template<int kBytes, typename T , size_t N>
HWY_API __i8x16 ShrBytes (const Vec128< T, N > v)
 
template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, NShuffle2301 (const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, NShuffle1230 (const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, NShuffle3012 (const Vec128< T, N > a, const Vec128< T, N > b)
 
template<size_t N>
HWY_API Vec128< uint8_t, NInterleaveUpper (Vec128< uint8_t, N > a, Vec128< uint8_t, N > b)
 
template<size_t N>
HWY_API Vec128< uint16_t, NInterleaveUpper (Vec128< uint16_t, N > a, Vec128< uint16_t, N > b)
 
template<size_t N>
HWY_API Vec128< uint32_t, NInterleaveUpper (Vec128< uint32_t, N > a, Vec128< uint32_t, N > b)
 
template<size_t N>
HWY_API Vec128< uint64_t, NInterleaveUpper (Vec128< uint64_t, N > a, Vec128< uint64_t, N > b)
 
template<size_t N>
HWY_API Vec128< int8_t, NInterleaveUpper (Vec128< int8_t, N > a, Vec128< int8_t, N > b)
 
template<size_t N>
HWY_API Vec128< int16_t, NInterleaveUpper (Vec128< int16_t, N > a, Vec128< int16_t, N > b)
 
template<size_t N>
HWY_API Vec128< int32_t, NInterleaveUpper (Vec128< int32_t, N > a, Vec128< int32_t, N > b)
 
template<size_t N>
HWY_API Vec128< int64_t, NInterleaveUpper (Vec128< int64_t, N > a, Vec128< int64_t, N > b)
 
template<size_t N>
HWY_API Vec128< float, NInterleaveUpper (Vec128< float, N > a, Vec128< float, N > b)
 
template<size_t N>
HWY_API Vec128< double, NInterleaveUpper (Vec128< double, N > a, Vec128< double, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NOddEven (hwy::SizeTag< 1 >, const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NOddEven (hwy::SizeTag< 2 >, const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NOddEven (hwy::SizeTag< 4 >, const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NOddEven (hwy::SizeTag< 8 >, const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 1 >, const Mask128< T, 8 > mask)
 
template<typename T , size_t N>
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 2 >, const Mask128< T, N > mask)
 
template<typename T , size_t N>
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 4 >, const Mask128< T, N > mask)
 
template<typename T , size_t N>
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 8 >, const Mask128< T, N > mask)
 
template<size_t N>
constexpr __i8x16 BytesAbove ()
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 1 >, const Mask128< T > m)
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 2 >, const Mask128< T > m)
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 4 >, const Mask128< T > m)
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 8 >, const Mask128< T > m)
 
template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 2) >
HWY_INLINE Vec128< T, NIdxFromBits (const uint64_t mask_bits)
 
template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 2) >
HWY_INLINE Vec128< T, NIdxFromNotBits (const uint64_t mask_bits)
 
template<typename T >
HWY_INLINE Vec128< T, 1 > SumOfLanes (hwy::SizeTag< sizeof(T)>, const Vec128< T, 1 > v)
 
template<typename T >
HWY_INLINE Vec128< T, 2 > SumOfLanes (hwy::SizeTag< 4 >, const Vec128< T, 2 > v10)
 
template<typename T >
HWY_INLINE Vec128< T > SumOfLanes (hwy::SizeTag< 4 >, const Vec128< T > v3210)
 
template<typename T >
HWY_INLINE Vec128< T > SumOfLanes (hwy::SizeTag< 8 >, const Vec128< T > v10)
 
template<int kBytes, typename T >
HWY_API __i8x16 ShrBytes (const Vec256< T > v)
 
HWY_API Vec256< uint8_t > InterleaveUpper (Vec256< uint8_t > a, Vec256< uint8_t > b)
 
HWY_API Vec256< uint16_t > InterleaveUpper (Vec256< uint16_t > a, Vec256< uint16_t > b)
 
HWY_API Vec256< uint32_t > InterleaveUpper (Vec256< uint32_t > a, Vec256< uint32_t > b)
 
HWY_API Vec256< uint64_t > InterleaveUpper (Vec256< uint64_t > a, Vec256< uint64_t > b)
 
HWY_API Vec256< int8_t > InterleaveUpper (Vec256< int8_t > a, Vec256< int8_t > b)
 
HWY_API Vec256< int16_t > InterleaveUpper (Vec256< int16_t > a, Vec256< int16_t > b)
 
HWY_API Vec256< int32_t > InterleaveUpper (Vec256< int32_t > a, Vec256< int32_t > b)
 
HWY_API Vec256< int64_t > InterleaveUpper (Vec256< int64_t > a, Vec256< int64_t > b)
 
HWY_API Vec256< float > InterleaveUpper (Vec256< float > a, Vec256< float > b)
 
template<typename T >
HWY_INLINE Vec256< T > OddEven (hwy::SizeTag< 1 >, const Vec256< T > a, const Vec256< T > b)
 
template<typename T >
HWY_INLINE Vec256< T > OddEven (hwy::SizeTag< 2 >, const Vec256< T > a, const Vec256< T > b)
 
template<typename T >
HWY_INLINE Vec256< T > OddEven (hwy::SizeTag< 4 >, const Vec256< T > a, const Vec256< T > b)
 
template<typename T >
HWY_INLINE Vec256< T > OddEven (hwy::SizeTag< 8 >, const Vec256< T > a, const Vec256< T > b)
 
template<typename T , HWY_IF_LANE_SIZE(T, 1) >
HWY_INLINE Mask256< T > LoadMaskBits (Full256< T > d, uint64_t bits)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 2 >, const Mask256< T > mask)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 4 >, const Mask256< T > mask)
 
constexpr __i8x16 BytesAbove ()
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (const Mask256< T > mask)
 
template<typename T >
HWY_INLINE Vec256< T > Idx16x8FromBits (const uint64_t mask_bits)
 
template<typename T >
HWY_INLINE Vec256< T > Idx32x4FromBits (const uint64_t mask_bits)
 
template<typename T >
HWY_INLINE Vec256< T > Compress (hwy::SizeTag< 2 >, Vec256< T > v, const uint64_t mask_bits)
 
template<typename T >
HWY_INLINE Vec256< T > Compress (hwy::SizeTag< 4 >, Vec256< T > v, const uint64_t mask_bits)
 
template<typename T >
HWY_INLINE Vec256< T > SumOfLanes (hwy::SizeTag< 4 >, const Vec256< T > v3210)
 
template<typename T >
HWY_INLINE Vec256< T > MinOfLanes (hwy::SizeTag< 4 >, const Vec256< T > v3210)
 
template<typename T >
HWY_INLINE Vec256< T > MaxOfLanes (hwy::SizeTag< 4 >, const Vec256< T > v3210)
 
template<typename T >
HWY_INLINE Vec256< T > SumOfLanes (hwy::SizeTag< 8 >, const Vec256< T > v10)
 
template<typename T >
HWY_INLINE Vec256< T > MinOfLanes (hwy::SizeTag< 8 >, const Vec256< T > v10)
 
template<typename T >
HWY_INLINE Vec256< T > MaxOfLanes (hwy::SizeTag< 8 >, const Vec256< T > v10)
 
template<typename T , HWY_IF_LANE_SIZE(T, 2) >
HWY_API Vec256< T > MinOfLanes (hwy::SizeTag< 2 >, Vec256< T > v)
 
template<typename T , HWY_IF_LANE_SIZE(T, 2) >
HWY_API Vec256< T > MaxOfLanes (hwy::SizeTag< 2 >, Vec256< T > v)
 
HWY_INLINE __m128i BitCastToInteger (__m128i v)
 
HWY_INLINE __m128i BitCastToInteger (__m128 v)
 
HWY_INLINE __m128i BitCastToInteger (__m128d v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NPopulationCount (hwy::SizeTag< 1 >, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NPopulationCount (hwy::SizeTag< 2 >, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NPopulationCount (hwy::SizeTag< 4 >, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NPopulationCount (hwy::SizeTag< 8 >, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenElse (hwy::SizeTag< 1 >, Mask128< T, N > mask, Vec128< T, N > yes, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenElse (hwy::SizeTag< 2 >, Mask128< T, N > mask, Vec128< T, N > yes, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenElse (hwy::SizeTag< 4 >, Mask128< T, N > mask, Vec128< T, N > yes, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenElse (hwy::SizeTag< 8 >, Mask128< T, N > mask, Vec128< T, N > yes, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenElseZero (hwy::SizeTag< 1 >, Mask128< T, N > mask, Vec128< T, N > yes)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenElseZero (hwy::SizeTag< 2 >, Mask128< T, N > mask, Vec128< T, N > yes)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenElseZero (hwy::SizeTag< 4 >, Mask128< T, N > mask, Vec128< T, N > yes)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenElseZero (hwy::SizeTag< 8 >, Mask128< T, N > mask, Vec128< T, N > yes)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenZeroElse (hwy::SizeTag< 1 >, Mask128< T, N > mask, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenZeroElse (hwy::SizeTag< 2 >, Mask128< T, N > mask, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenZeroElse (hwy::SizeTag< 4 >, Mask128< T, N > mask, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NIfThenZeroElse (hwy::SizeTag< 8 >, Mask128< T, N > mask, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NAnd (hwy::SizeTag< 1 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NAnd (hwy::SizeTag< 2 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NAnd (hwy::SizeTag< 4 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NAnd (hwy::SizeTag< 8 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NAndNot (hwy::SizeTag< 1 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NAndNot (hwy::SizeTag< 2 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NAndNot (hwy::SizeTag< 4 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NAndNot (hwy::SizeTag< 8 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NOr (hwy::SizeTag< 1 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NOr (hwy::SizeTag< 2 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NOr (hwy::SizeTag< 4 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NOr (hwy::SizeTag< 8 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NXor (hwy::SizeTag< 1 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NXor (hwy::SizeTag< 2 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NXor (hwy::SizeTag< 4 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NXor (hwy::SizeTag< 8 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, 4 > Shuffle2301 (const Vec128< T, 4 > a, const Vec128< T, 4 > b)
 
template<typename T , HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, 4 > Shuffle1230 (const Vec128< T, 4 > a, const Vec128< T, 4 > b)
 
template<typename T , HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, 4 > Shuffle3012 (const Vec128< T, 4 > a, const Vec128< T, 4 > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NTestBit (hwy::SizeTag< 1 >, const Vec128< T, N > v, const Vec128< T, N > bit)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NTestBit (hwy::SizeTag< 2 >, const Vec128< T, N > v, const Vec128< T, N > bit)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NTestBit (hwy::SizeTag< 4 >, const Vec128< T, N > v, const Vec128< T, N > bit)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NTestBit (hwy::SizeTag< 8 >, const Vec128< T, N > v, const Vec128< T, N > bit)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NMaskFromVec (hwy::SizeTag< 1 >, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NMaskFromVec (hwy::SizeTag< 2 >, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NMaskFromVec (hwy::SizeTag< 4 >, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NMaskFromVec (hwy::SizeTag< 8 >, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_API void ScalarMaskedStore (Vec128< T, N > v, Mask128< T, N > m, Simd< T, N, 0 > d, T *HWY_RESTRICT p)
 
template<typename T , size_t N>
HWY_INLINE HWY_MAYBE_UNUSED Vec128< T, NMinU (const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE HWY_MAYBE_UNUSED Vec128< T, NMaxU (const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE void ScatterOffset (hwy::SizeTag< 4 >, Vec128< T, N > v, Simd< T, N, 0 >, T *HWY_RESTRICT base, const Vec128< int32_t, N > offset)
 
template<typename T , size_t N>
HWY_INLINE void ScatterIndex (hwy::SizeTag< 4 >, Vec128< T, N > v, Simd< T, N, 0 >, T *HWY_RESTRICT base, const Vec128< int32_t, N > index)
 
template<typename T , size_t N>
HWY_INLINE void ScatterOffset (hwy::SizeTag< 8 >, Vec128< T, N > v, Simd< T, N, 0 >, T *HWY_RESTRICT base, const Vec128< int64_t, N > offset)
 
template<typename T , size_t N>
HWY_INLINE void ScatterIndex (hwy::SizeTag< 8 >, Vec128< T, N > v, Simd< T, N, 0 >, T *HWY_RESTRICT base, const Vec128< int64_t, N > index)
 
template<size_t kLane>
HWY_INLINE double ExtractLane (const Vec128< double, 1 > v)
 
template<size_t kLane>
HWY_INLINE double ExtractLane (const Vec128< double > v)
 
template<size_t kLane>
HWY_INLINE Vec128< double, 1 > InsertLane (const Vec128< double, 1 > v, double t)
 
template<size_t kLane>
HWY_INLINE Vec128< double > InsertLane (const Vec128< double > v, double t)
 
HWY_API Vec128< uint8_t > InterleaveUpper (const Vec128< uint8_t > a, const Vec128< uint8_t > b)
 
HWY_API Vec128< uint16_t > InterleaveUpper (const Vec128< uint16_t > a, const Vec128< uint16_t > b)
 
HWY_API Vec128< uint32_t > InterleaveUpper (const Vec128< uint32_t > a, const Vec128< uint32_t > b)
 
HWY_API Vec128< int8_t > InterleaveUpper (const Vec128< int8_t > a, const Vec128< int8_t > b)
 
HWY_API Vec128< int16_t > InterleaveUpper (const Vec128< int16_t > a, const Vec128< int16_t > b)
 
HWY_API Vec128< int32_t > InterleaveUpper (const Vec128< int32_t > a, const Vec128< int32_t > b)
 
HWY_API Vec128< double > InterleaveUpper (const Vec128< double > a, const Vec128< double > b)
 
template<size_t N>
HWY_INLINE auto ClampF64ToI32Max (Simd< double, N, 0 > d, decltype(Zero(d)) v) -> decltype(Zero(d))
 
template<class DI , class DF = RebindToFloat<DI>>
HWY_INLINE auto FixConversionOverflow (DI di, VFromD< DF > original, decltype(Zero(di).raw) converted_raw) -> VFromD< DI >
 
template<typename T , size_t N, HWY_IF_FLOAT(T) >
HWY_INLINE Mask128< T, NUseInt (const Vec128< T, N > v)
 
template<class D , class V = VFromD<D>>
HWY_INLINELt128Vec (const D d, const V a, const V b)
 
template<class D , class V = VFromD<D>>
HWY_INLINELt128UpperVec (const D d, const V a, const V b)
 
HWY_INLINE __m256i BitCastToInteger (__m256i v)
 
HWY_INLINE __m256i BitCastToInteger (__m256 v)
 
HWY_INLINE __m256i BitCastToInteger (__m256d v)
 
template<typename T >
HWY_INLINE Vec256< uint8_t > BitCastToByte (Vec256< T > v)
 
template<typename T >
HWY_INLINE Vec256< T > BitCastFromByte (Full256< T >, Vec256< uint8_t > v)
 
template<typename T >
HWY_INLINE Vec256< T > PopulationCount (hwy::SizeTag< 1 >, Vec256< T > v)
 
template<typename T >
HWY_INLINE Vec256< T > PopulationCount (hwy::SizeTag< 2 >, Vec256< T > v)
 
template<typename T >
HWY_INLINE Vec256< T > PopulationCount (hwy::SizeTag< 4 >, Vec256< T > v)
 
template<typename T >
HWY_INLINE Vec256< T > PopulationCount (hwy::SizeTag< 8 >, Vec256< T > v)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenElse (hwy::SizeTag< 1 >, Mask256< T > mask, Vec256< T > yes, Vec256< T > no)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenElse (hwy::SizeTag< 2 >, Mask256< T > mask, Vec256< T > yes, Vec256< T > no)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenElse (hwy::SizeTag< 4 >, Mask256< T > mask, Vec256< T > yes, Vec256< T > no)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenElse (hwy::SizeTag< 8 >, Mask256< T > mask, Vec256< T > yes, Vec256< T > no)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenElseZero (hwy::SizeTag< 1 >, Mask256< T > mask, Vec256< T > yes)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenElseZero (hwy::SizeTag< 2 >, Mask256< T > mask, Vec256< T > yes)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenElseZero (hwy::SizeTag< 4 >, Mask256< T > mask, Vec256< T > yes)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenElseZero (hwy::SizeTag< 8 >, Mask256< T > mask, Vec256< T > yes)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenZeroElse (hwy::SizeTag< 1 >, Mask256< T > mask, Vec256< T > no)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenZeroElse (hwy::SizeTag< 2 >, Mask256< T > mask, Vec256< T > no)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenZeroElse (hwy::SizeTag< 4 >, Mask256< T > mask, Vec256< T > no)
 
template<typename T >
HWY_INLINE Vec256< T > IfThenZeroElse (hwy::SizeTag< 8 >, Mask256< T > mask, Vec256< T > no)
 
template<typename T >
HWY_INLINE Mask256< T > And (hwy::SizeTag< 1 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > And (hwy::SizeTag< 2 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > And (hwy::SizeTag< 4 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > And (hwy::SizeTag< 8 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > AndNot (hwy::SizeTag< 1 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > AndNot (hwy::SizeTag< 2 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > AndNot (hwy::SizeTag< 4 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > AndNot (hwy::SizeTag< 8 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > Or (hwy::SizeTag< 1 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > Or (hwy::SizeTag< 2 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > Or (hwy::SizeTag< 4 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > Or (hwy::SizeTag< 8 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > Xor (hwy::SizeTag< 1 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > Xor (hwy::SizeTag< 2 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > Xor (hwy::SizeTag< 4 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > Xor (hwy::SizeTag< 8 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > TestBit (hwy::SizeTag< 1 >, const Vec256< T > v, const Vec256< T > bit)
 
template<typename T >
HWY_INLINE Mask256< T > TestBit (hwy::SizeTag< 2 >, const Vec256< T > v, const Vec256< T > bit)
 
template<typename T >
HWY_INLINE Mask256< T > TestBit (hwy::SizeTag< 4 >, const Vec256< T > v, const Vec256< T > bit)
 
template<typename T >
HWY_INLINE Mask256< T > TestBit (hwy::SizeTag< 8 >, const Vec256< T > v, const Vec256< T > bit)
 
template<typename T >
HWY_INLINE Mask256< T > MaskFromVec (hwy::SizeTag< 1 >, const Vec256< T > v)
 
template<typename T >
HWY_INLINE Mask256< T > MaskFromVec (hwy::SizeTag< 2 >, const Vec256< T > v)
 
template<typename T >
HWY_INLINE Mask256< T > MaskFromVec (hwy::SizeTag< 4 >, const Vec256< T > v)
 
template<typename T >
HWY_INLINE Mask256< T > MaskFromVec (hwy::SizeTag< 8 >, const Vec256< T > v)
 
template<typename T >
HWY_INLINE void ScatterOffset (hwy::SizeTag< 4 >, Vec256< T > v, Full256< T >, T *HWY_RESTRICT base, const Vec256< int32_t > offset)
 
template<typename T >
HWY_INLINE void ScatterIndex (hwy::SizeTag< 4 >, Vec256< T > v, Full256< T >, T *HWY_RESTRICT base, const Vec256< int32_t > index)
 
template<typename T >
HWY_INLINE void ScatterOffset (hwy::SizeTag< 8 >, Vec256< T > v, Full256< T >, T *HWY_RESTRICT base, const Vec256< int64_t > offset)
 
template<typename T >
HWY_INLINE void ScatterIndex (hwy::SizeTag< 8 >, Vec256< T > v, Full256< T >, T *HWY_RESTRICT base, const Vec256< int64_t > index)
 
template<typename T >
HWY_INLINE Vec256< T > GatherOffset (hwy::SizeTag< 4 >, Full256< T >, const T *HWY_RESTRICT base, const Vec256< int32_t > offset)
 
template<typename T >
HWY_INLINE Vec256< T > GatherIndex (hwy::SizeTag< 4 >, Full256< T >, const T *HWY_RESTRICT base, const Vec256< int32_t > index)
 
template<typename T >
HWY_INLINE Vec256< T > GatherOffset (hwy::SizeTag< 8 >, Full256< T >, const T *HWY_RESTRICT base, const Vec256< int64_t > offset)
 
template<typename T >
HWY_INLINE Vec256< T > GatherIndex (hwy::SizeTag< 8 >, Full256< T >, const T *HWY_RESTRICT base, const Vec256< int64_t > index)
 
template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > Shuffle2301 (const Vec256< T > a, const Vec256< T > b)
 
template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > Shuffle1230 (const Vec256< T > a, const Vec256< T > b)
 
template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > Shuffle3012 (const Vec256< T > a, const Vec256< T > b)
 
HWY_API Vec256< double > InterleaveUpper (const Vec256< double > a, const Vec256< double > b)
 
template<typename T >
HWY_INLINE bool AllFalse (hwy::SizeTag< 1 >, const Mask256< T > mask)
 
template<typename T >
HWY_INLINE bool AllFalse (hwy::SizeTag< 2 >, const Mask256< T > mask)
 
template<typename T >
HWY_INLINE bool AllFalse (hwy::SizeTag< 4 >, const Mask256< T > mask)
 
template<typename T >
HWY_INLINE bool AllFalse (hwy::SizeTag< 8 >, const Mask256< T > mask)
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 1 >, const Mask256< T > mask)
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 2 >, const Mask256< T > mask)
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 4 >, const Mask256< T > mask)
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 8 >, const Mask256< T > mask)
 
template<typename T >
HWY_API void LoadTransposedBlocks3 (Full256< T > d, const T *HWY_RESTRICT unaligned, Vec256< T > &A, Vec256< T > &B, Vec256< T > &C)
 
template<typename T >
HWY_API void LoadTransposedBlocks4 (Full256< T > d, const T *HWY_RESTRICT unaligned, Vec256< T > &A, Vec256< T > &B, Vec256< T > &C, Vec256< T > &D)
 
template<typename T >
HWY_API void StoreTransposedBlocks2 (const Vec256< T > i, const Vec256< T > j, const Full256< T > d, T *HWY_RESTRICT unaligned)
 
template<typename T >
HWY_API void StoreTransposedBlocks3 (const Vec256< T > i, const Vec256< T > j, const Vec256< T > k, Full256< T > d, T *HWY_RESTRICT unaligned)
 
template<typename T >
HWY_API void StoreTransposedBlocks4 (const Vec256< T > i, const Vec256< T > j, const Vec256< T > k, const Vec256< T > l, Full256< T > d, T *HWY_RESTRICT unaligned)
 
HWY_INLINE __m512i BitCastToInteger (__m512i v)
 
HWY_INLINE __m512i BitCastToInteger (__m512 v)
 
HWY_INLINE __m512i BitCastToInteger (__m512d v)
 
template<typename T >
HWY_INLINE Vec512< uint8_t > BitCastToByte (Vec512< T > v)
 
template<typename T >
HWY_INLINE Vec512< T > BitCastFromByte (Full512< T >, Vec512< uint8_t > v)
 
template<typename T >
HWY_INLINE Vec512< T > PopulationCount (hwy::SizeTag< 1 >, Vec512< T > v)
 
template<typename T >
HWY_INLINE Vec512< T > PopulationCount (hwy::SizeTag< 2 >, Vec512< T > v)
 
template<typename T >
HWY_INLINE Vec512< T > PopulationCount (hwy::SizeTag< 4 >, Vec512< T > v)
 
template<typename T >
HWY_INLINE Vec512< T > PopulationCount (hwy::SizeTag< 8 >, Vec512< T > v)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenElse (hwy::SizeTag< 1 >, const Mask512< T > mask, const Vec512< T > yes, const Vec512< T > no)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenElse (hwy::SizeTag< 2 >, const Mask512< T > mask, const Vec512< T > yes, const Vec512< T > no)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenElse (hwy::SizeTag< 4 >, const Mask512< T > mask, const Vec512< T > yes, const Vec512< T > no)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenElse (hwy::SizeTag< 8 >, const Mask512< T > mask, const Vec512< T > yes, const Vec512< T > no)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenElseZero (hwy::SizeTag< 1 >, const Mask512< T > mask, const Vec512< T > yes)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenElseZero (hwy::SizeTag< 2 >, const Mask512< T > mask, const Vec512< T > yes)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenElseZero (hwy::SizeTag< 4 >, const Mask512< T > mask, const Vec512< T > yes)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenElseZero (hwy::SizeTag< 8 >, const Mask512< T > mask, const Vec512< T > yes)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenZeroElse (hwy::SizeTag< 1 >, const Mask512< T > mask, const Vec512< T > no)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenZeroElse (hwy::SizeTag< 2 >, const Mask512< T > mask, const Vec512< T > no)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenZeroElse (hwy::SizeTag< 4 >, const Mask512< T > mask, const Vec512< T > no)
 
template<typename T >
HWY_INLINE Vec512< T > IfThenZeroElse (hwy::SizeTag< 8 >, const Mask512< T > mask, const Vec512< T > no)
 
template<typename T >
HWY_INLINE Mask512< T > TestBit (hwy::SizeTag< 1 >, const Vec512< T > v, const Vec512< T > bit)
 
template<typename T >
HWY_INLINE Mask512< T > TestBit (hwy::SizeTag< 2 >, const Vec512< T > v, const Vec512< T > bit)
 
template<typename T >
HWY_INLINE Mask512< T > TestBit (hwy::SizeTag< 4 >, const Vec512< T > v, const Vec512< T > bit)
 
template<typename T >
HWY_INLINE Mask512< T > TestBit (hwy::SizeTag< 8 >, const Vec512< T > v, const Vec512< T > bit)
 
template<typename T >
HWY_INLINE Mask512< T > MaskFromVec (hwy::SizeTag< 1 >, const Vec512< T > v)
 
template<typename T >
HWY_INLINE Mask512< T > MaskFromVec (hwy::SizeTag< 2 >, const Vec512< T > v)
 
template<typename T >
HWY_INLINE Mask512< T > MaskFromVec (hwy::SizeTag< 4 >, const Vec512< T > v)
 
template<typename T >
HWY_INLINE Mask512< T > MaskFromVec (hwy::SizeTag< 8 >, const Vec512< T > v)
 
template<typename T >
HWY_INLINE Mask512< T > Not (hwy::SizeTag< 1 >, const Mask512< T > m)
 
template<typename T >
HWY_INLINE Mask512< T > Not (hwy::SizeTag< 2 >, const Mask512< T > m)
 
template<typename T >
HWY_INLINE Mask512< T > Not (hwy::SizeTag< 4 >, const Mask512< T > m)
 
template<typename T >
HWY_INLINE Mask512< T > Not (hwy::SizeTag< 8 >, const Mask512< T > m)
 
template<typename T >
HWY_INLINE Mask512< T > And (hwy::SizeTag< 1 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > And (hwy::SizeTag< 2 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > And (hwy::SizeTag< 4 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > And (hwy::SizeTag< 8 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > AndNot (hwy::SizeTag< 1 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > AndNot (hwy::SizeTag< 2 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > AndNot (hwy::SizeTag< 4 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > AndNot (hwy::SizeTag< 8 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Or (hwy::SizeTag< 1 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Or (hwy::SizeTag< 2 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Or (hwy::SizeTag< 4 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Or (hwy::SizeTag< 8 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Xor (hwy::SizeTag< 1 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Xor (hwy::SizeTag< 2 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Xor (hwy::SizeTag< 4 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Xor (hwy::SizeTag< 8 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE void ScatterOffset (hwy::SizeTag< 4 >, Vec512< T > v, Full512< T >, T *HWY_RESTRICT base, const Vec512< int32_t > offset)
 
template<typename T >
HWY_INLINE void ScatterIndex (hwy::SizeTag< 4 >, Vec512< T > v, Full512< T >, T *HWY_RESTRICT base, const Vec512< int32_t > index)
 
template<typename T >
HWY_INLINE void ScatterOffset (hwy::SizeTag< 8 >, Vec512< T > v, Full512< T >, T *HWY_RESTRICT base, const Vec512< int64_t > offset)
 
template<typename T >
HWY_INLINE void ScatterIndex (hwy::SizeTag< 8 >, Vec512< T > v, Full512< T >, T *HWY_RESTRICT base, const Vec512< int64_t > index)
 
template<typename T >
HWY_INLINE Vec512< T > GatherOffset (hwy::SizeTag< 4 >, Full512< T >, const T *HWY_RESTRICT base, const Vec512< int32_t > offset)
 
template<typename T >
HWY_INLINE Vec512< T > GatherIndex (hwy::SizeTag< 4 >, Full512< T >, const T *HWY_RESTRICT base, const Vec512< int32_t > index)
 
template<typename T >
HWY_INLINE Vec512< T > GatherOffset (hwy::SizeTag< 8 >, Full512< T >, const T *HWY_RESTRICT base, const Vec512< int64_t > offset)
 
template<typename T >
HWY_INLINE Vec512< T > GatherIndex (hwy::SizeTag< 8 >, Full512< T >, const T *HWY_RESTRICT base, const Vec512< int64_t > index)
 
template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec512< T > Shuffle2301 (const Vec512< T > a, const Vec512< T > b)
 
template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec512< T > Shuffle1230 (const Vec512< T > a, const Vec512< T > b)
 
template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec512< T > Shuffle3012 (const Vec512< T > a, const Vec512< T > b)
 
HWY_API Vec512< uint8_t > InterleaveUpper (const Vec512< uint8_t > a, const Vec512< uint8_t > b)
 
HWY_API Vec512< uint16_t > InterleaveUpper (const Vec512< uint16_t > a, const Vec512< uint16_t > b)
 
HWY_API Vec512< uint32_t > InterleaveUpper (const Vec512< uint32_t > a, const Vec512< uint32_t > b)
 
HWY_API Vec512< uint64_t > InterleaveUpper (const Vec512< uint64_t > a, const Vec512< uint64_t > b)
 
HWY_API Vec512< int8_t > InterleaveUpper (const Vec512< int8_t > a, const Vec512< int8_t > b)
 
HWY_API Vec512< int16_t > InterleaveUpper (const Vec512< int16_t > a, const Vec512< int16_t > b)
 
HWY_API Vec512< int32_t > InterleaveUpper (const Vec512< int32_t > a, const Vec512< int32_t > b)
 
HWY_API Vec512< int64_t > InterleaveUpper (const Vec512< int64_t > a, const Vec512< int64_t > b)
 
HWY_API Vec512< float > InterleaveUpper (const Vec512< float > a, const Vec512< float > b)
 
HWY_API Vec512< double > InterleaveUpper (const Vec512< double > a, const Vec512< double > b)
 
template<typename T >
HWY_INLINE bool AllFalse (hwy::SizeTag< 1 >, const Mask512< T > mask)
 
template<typename T >
HWY_INLINE bool AllFalse (hwy::SizeTag< 2 >, const Mask512< T > mask)
 
template<typename T >
HWY_INLINE bool AllFalse (hwy::SizeTag< 4 >, const Mask512< T > mask)
 
template<typename T >
HWY_INLINE bool AllFalse (hwy::SizeTag< 8 >, const Mask512< T > mask)
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 1 >, const Mask512< T > mask)
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 2 >, const Mask512< T > mask)
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 4 >, const Mask512< T > mask)
 
template<typename T >
HWY_INLINE bool AllTrue (hwy::SizeTag< 8 >, const Mask512< T > mask)
 
template<_MM_PERM_ENUM kPerm, typename T >
Vec512< T > Shuffle128 (const Vec512< T > lo, const Vec512< T > hi)
 
template<_MM_PERM_ENUM kPerm>
Vec512< float > Shuffle128 (const Vec512< float > lo, const Vec512< float > hi)
 
template<_MM_PERM_ENUM kPerm>
Vec512< double > Shuffle128 (const Vec512< double > lo, const Vec512< double > hi)
 
template<typename T >
HWY_API void LoadTransposedBlocks3 (Full512< T > d, const T *HWY_RESTRICT unaligned, Vec512< T > &A, Vec512< T > &B, Vec512< T > &C)
 
template<typename T >
HWY_API void LoadTransposedBlocks4 (Full512< T > d, const T *HWY_RESTRICT unaligned, Vec512< T > &A, Vec512< T > &B, Vec512< T > &C, Vec512< T > &D)
 
template<typename T >
HWY_API void StoreTransposedBlocks2 (const Vec512< T > i, const Vec512< T > j, const Full512< T > d, T *HWY_RESTRICT unaligned)
 
template<typename T >
HWY_API void StoreTransposedBlocks3 (const Vec512< T > i, const Vec512< T > j, const Vec512< T > k, Full512< T > d, T *HWY_RESTRICT unaligned)
 
template<typename T >
HWY_API void StoreTransposedBlocks4 (const Vec512< T > i, const Vec512< T > j, const Vec512< T > k, const Vec512< T > l, Full512< T > d, T *HWY_RESTRICT unaligned)
 

Variables

 DupOddB
 

Typedef Documentation

◆ Constants

Function Documentation

◆ AllFalse() [1/8]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllFalse ( hwy::SizeTag< 1 >  ,
const Mask256< T >  mask 
)

◆ AllFalse() [2/8]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllFalse ( hwy::SizeTag< 1 >  ,
const Mask512< T >  mask 
)

◆ AllFalse() [3/8]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllFalse ( hwy::SizeTag< 2 >  ,
const Mask256< T >  mask 
)

◆ AllFalse() [4/8]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllFalse ( hwy::SizeTag< 2 >  ,
const Mask512< T >  mask 
)

◆ AllFalse() [5/8]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllFalse ( hwy::SizeTag< 4 >  ,
const Mask256< T >  mask 
)

◆ AllFalse() [6/8]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllFalse ( hwy::SizeTag< 4 >  ,
const Mask512< T >  mask 
)

◆ AllFalse() [7/8]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllFalse ( hwy::SizeTag< 8 >  ,
const Mask256< T >  mask 
)

◆ AllFalse() [8/8]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllFalse ( hwy::SizeTag< 8 >  ,
const Mask512< T >  mask 
)

◆ AllHardwareLanes() [1/4]

HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::AllHardwareLanes ( hwy::SizeTag< 1 >  )

◆ AllHardwareLanes() [2/4]

HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::AllHardwareLanes ( hwy::SizeTag< 2 >  )

◆ AllHardwareLanes() [3/4]

HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::AllHardwareLanes ( hwy::SizeTag< 4 >  )

◆ AllHardwareLanes() [4/4]

HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::AllHardwareLanes ( hwy::SizeTag< 8 >  )

◆ AllTrue() [1/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 1 >  ,
const Mask128< T >  m 
)

◆ AllTrue() [2/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 1 >  ,
const Mask256< T >  mask 
)

◆ AllTrue() [3/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 1 >  ,
const Mask512< T >  mask 
)

◆ AllTrue() [4/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 2 >  ,
const Mask128< T >  m 
)

◆ AllTrue() [5/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 2 >  ,
const Mask256< T >  mask 
)

◆ AllTrue() [6/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 2 >  ,
const Mask512< T >  mask 
)

◆ AllTrue() [7/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 4 >  ,
const Mask128< T >  m 
)

◆ AllTrue() [8/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 4 >  ,
const Mask256< T >  mask 
)

◆ AllTrue() [9/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 4 >  ,
const Mask512< T >  mask 
)

◆ AllTrue() [10/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 8 >  ,
const Mask128< T >  m 
)

◆ AllTrue() [11/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 8 >  ,
const Mask256< T >  mask 
)

◆ AllTrue() [12/12]

template<typename T >
HWY_INLINE bool hwy::HWY_NAMESPACE::detail::AllTrue ( hwy::SizeTag< 8 >  ,
const Mask512< T >  mask 
)

◆ And() [1/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 1 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ And() [2/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 1 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ And() [3/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 1 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ And() [4/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 2 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ And() [5/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 2 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ And() [6/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 2 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ And() [7/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 4 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ And() [8/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 4 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ And() [9/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 4 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ And() [10/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 8 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ And() [11/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 8 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ And() [12/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::And ( hwy::SizeTag< 8 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ AndNot() [1/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 1 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ AndNot() [2/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 1 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ AndNot() [3/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 1 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ AndNot() [4/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 2 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ AndNot() [5/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 2 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ AndNot() [6/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 2 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ AndNot() [7/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 4 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ AndNot() [8/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 4 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ AndNot() [9/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 4 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ AndNot() [10/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 8 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ AndNot() [11/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 8 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ AndNot() [12/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::AndNot ( hwy::SizeTag< 8 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ BitCastFromByte() [1/24]

HWY_INLINE Vec128< float > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full128< float >  ,
Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [2/24]

HWY_INLINE Vec128< int16_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full128< int16_t >  ,
Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [3/24]

HWY_INLINE Vec128< int32_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full128< int32_t >  ,
Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [4/24]

HWY_INLINE Vec128< int64_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full128< int64_t >  ,
Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [5/24]

HWY_INLINE Vec128< int8_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full128< int8_t >  ,
Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [6/24]

HWY_INLINE Vec128< uint16_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full128< uint16_t >  ,
Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [7/24]

HWY_INLINE Vec128< uint32_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full128< uint32_t >  ,
Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [8/24]

HWY_INLINE Vec128< uint64_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full128< uint64_t >  ,
Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [9/24]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full256< T >  ,
Vec256< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [10/24]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full512< T >  ,
Vec512< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [11/24]

HWY_INLINE Vec64< int64_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full64< int64_t >  ,
Vec128< uint8_t, 1 *8 >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [12/24]

HWY_INLINE Vec64< uint64_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full64< uint64_t >  ,
Vec128< uint8_t, 1 *8 >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [13/24]

template<size_t N>
HWY_INLINE Vec128< bfloat16_t, N > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< bfloat16_t, N, 0 >  ,
Vec128< uint8_t, N *2 >  v 
)

◆ BitCastFromByte() [14/24]

template<size_t N, int kPow2>
HWY_INLINE svuint16_t hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< bfloat16_t, N, kPow2 >  ,
svuint8_t  v 
)

◆ BitCastFromByte() [15/24]

template<size_t N, int kPow2>
HWY_INLINE VFromD< Simd< uint16_t, N, kPow2 > > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< bfloat16_t, N, kPow2 >  ,
VFromD< Simd< uint8_t, N, kPow2 > >  v 
)

◆ BitCastFromByte() [16/24]

template<size_t N, HWY_IF_LE64(float, N) >
HWY_INLINE Vec128< float, N > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< float, N, 0 >  ,
Vec128< uint8_t, N *4 >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [17/24]

template<size_t N>
HWY_INLINE Vec128< float16_t, N > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< float16_t, N, 0 >  ,
Vec128< uint8_t, N *2 >  v 
)

◆ BitCastFromByte() [18/24]

template<size_t N, HWY_IF_LE64(int16_t, N) >
HWY_INLINE Vec128< int16_t, N > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< int16_t, N, 0 >  ,
Vec128< uint8_t, N *2 >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [19/24]

template<size_t N, HWY_IF_LE64(int32_t, N) >
HWY_INLINE Vec128< int32_t, N > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< int32_t, N, 0 >  ,
Vec128< uint8_t, N *4 >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [20/24]

template<size_t N, HWY_IF_LE64(int8_t, N) >
HWY_INLINE Vec128< int8_t, N > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< int8_t, N, 0 >  ,
Vec128< uint8_t, N v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [21/24]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< T, N, 0 >  ,
Vec128< uint8_t, N *sizeof(T)>  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [22/24]

template<size_t N, HWY_IF_LE64(uint16_t, N) >
HWY_INLINE Vec128< uint16_t, N > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< uint16_t, N, 0 >  ,
Vec128< uint8_t, N *2 >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [23/24]

template<size_t N, HWY_IF_LE64(uint32_t, N) >
HWY_INLINE Vec128< uint32_t, N > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< uint32_t, N, 0 >  ,
Vec128< uint8_t, N *4 >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ BitCastFromByte() [24/24]

template<size_t N>
HWY_INLINE Vec128< uint8_t, N > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Simd< uint8_t, N, 0 >  ,
Vec128< uint8_t, N v 
)

◆ BitCastToByte() [1/6]

template<size_t N>
HWY_INLINE Vec128< uint8_t, N *2 > hwy::HWY_NAMESPACE::detail::BitCastToByte ( Vec128< bfloat16_t, N v)

◆ BitCastToByte() [2/6]

N * hwy::HWY_NAMESPACE::detail::BitCastToByte ( Vec128< float16_t, N v)

◆ BitCastToByte() [3/6]

template<typename T , size_t N>
HWY_INLINE Vec128< uint8_t, N *sizeof(T)> hwy::HWY_NAMESPACE::detail::BitCastToByte ( Vec128< T, N v)

◆ BitCastToByte() [4/6]

template<size_t N>
HWY_INLINE Vec128< uint8_t, N > hwy::HWY_NAMESPACE::detail::BitCastToByte ( Vec128< uint8_t, N v)

◆ BitCastToByte() [5/6]

template<typename T >
HWY_INLINE Vec256< uint8_t > hwy::HWY_NAMESPACE::detail::BitCastToByte ( Vec256< T >  v)

◆ BitCastToByte() [6/6]

template<typename T >
HWY_INLINE Vec512< uint8_t > hwy::HWY_NAMESPACE::detail::BitCastToByte ( Vec512< T >  v)

◆ BitCastToInteger() [1/12]

HWY_INLINE __v128_u hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __f32x4  v)

References hwy::HWY_NAMESPACE::v.

◆ BitCastToInteger() [2/12]

HWY_INLINE __v128_u hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __f64x2  v)

References hwy::HWY_NAMESPACE::v.

◆ BitCastToInteger() [3/12]

HWY_INLINE __m128i hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __m128  v)

References hwy::HWY_NAMESPACE::v.

◆ BitCastToInteger() [4/12]

HWY_INLINE __m128i hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __m128d  v)

References hwy::HWY_NAMESPACE::v.

◆ BitCastToInteger() [5/12]

HWY_INLINE __m128i hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __m128i  v)

References hwy::HWY_NAMESPACE::v.

◆ BitCastToInteger() [6/12]

HWY_INLINE __m256i hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __m256  v)

References hwy::HWY_NAMESPACE::v.

◆ BitCastToInteger() [7/12]

HWY_INLINE __m256i hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __m256d  v)

References hwy::HWY_NAMESPACE::v.

◆ BitCastToInteger() [8/12]

HWY_INLINE __m256i hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __m256i  v)

References hwy::HWY_NAMESPACE::v.

◆ BitCastToInteger() [9/12]

HWY_INLINE __m512i hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __m512  v)

References hwy::HWY_NAMESPACE::v.

◆ BitCastToInteger() [10/12]

HWY_INLINE __m512i hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __m512d  v)

References hwy::HWY_NAMESPACE::v.

◆ BitCastToInteger() [11/12]

HWY_INLINE __m512i hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __m512i  v)

References hwy::HWY_NAMESPACE::v.

◆ BitCastToInteger() [12/12]

HWY_INLINE __v128_u hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __v128_u  v)

References hwy::HWY_NAMESPACE::v.

Referenced by BitCastToByte().

◆ BitCastToUnsigned()

template<class V , class DU = RebindToUnsigned<DFromV<V>>>
HWY_INLINE VFromD< DU > hwy::HWY_NAMESPACE::detail::BitCastToUnsigned ( v)

◆ BitsFromBool()

HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::detail::BitsFromBool ( svuint8_t  x)

◆ BitsFromMask() [1/16]

template<typename T , size_t N>
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( const Mask128< T, N mask)

References BitsFromMask().

◆ BitsFromMask() [2/16]

template<typename T >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( const Mask256< T >  mask)

References BitsFromMask().

◆ BitsFromMask() [3/16]

template<typename T >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 1 >  ,
const Mask128< T >  mask 
)

◆ BitsFromMask() [4/16]

template<typename T >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 1 >  ,
const Mask128< T, 8 >  mask 
)

◆ BitsFromMask() [5/16]

template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 1 >  ,
const Mask128< T, N mask 
)

◆ BitsFromMask() [6/16]

template<typename T >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 2 >  ,
const Mask128< T >  mask 
)

◆ BitsFromMask() [7/16]

template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 2 >  ,
const Mask128< T, N mask 
)

◆ BitsFromMask() [8/16]

template<typename T , size_t N>
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 2 >  ,
const Mask128< T, N mask 
)

◆ BitsFromMask() [9/16]

template<typename T >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 2 >  ,
const Mask256< T >  mask 
)

◆ BitsFromMask() [10/16]

template<typename T >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 4 >  ,
const Mask128< T >  mask 
)

◆ BitsFromMask() [11/16]

template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 4 >  ,
const Mask128< T, N mask 
)

◆ BitsFromMask() [12/16]

template<typename T , size_t N>
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 4 >  ,
const Mask128< T, N mask 
)

◆ BitsFromMask() [13/16]

template<typename T >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 4 >  ,
const Mask256< T >  mask 
)

◆ BitsFromMask() [14/16]

template<typename T >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 8 >  ,
const Mask128< T >  m 
)

◆ BitsFromMask() [15/16]

template<typename T >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 8 >  ,
const Mask128< T, 1 >  m 
)

◆ BitsFromMask() [16/16]

template<typename T , size_t N>
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::BitsFromMask ( hwy::SizeTag< 8 >  ,
const Mask128< T, N mask 
)

◆ BoolFromMask()

template<class T , HWY_IF_LANE_SIZE(T, 1) >
HWY_INLINE svuint8_t hwy::HWY_NAMESPACE::detail::BoolFromMask ( svbool_t  m)

◆ BytesAbove() [1/2]

template<size_t N>
constexpr __i8x16 hwy::HWY_NAMESPACE::detail::BytesAbove ( )
constexpr

References hwy::HWY_NAMESPACE::N.

◆ BytesAbove() [2/2]

constexpr __i8x16 hwy::HWY_NAMESPACE::detail::BytesAbove ( )
constexpr

References hwy::HWY_NAMESPACE::N.

◆ ChangeLMUL() [1/7]

template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL ( Simd< T, N, kPow2 >  d,
VFromD< decltype(d)>  v 
) -> VFromD<decltype(d)>

References hwy::HWY_NAMESPACE::v.

◆ ChangeLMUL() [2/7]

template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL ( Simd< T, N, kPow2 >  d,
VFromD< Simd< T, N, kPow2 - 1 > >  v 
) -> VFromD<decltype(d)>

◆ ChangeLMUL() [3/7]

template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL ( Simd< T, N, kPow2 >  d,
VFromD< Simd< T, N, kPow2 - 2 > >  v 
) -> VFromD<decltype(d)>

◆ ChangeLMUL() [4/7]

template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL ( Simd< T, N, kPow2 >  d,
VFromD< Simd< T, N, kPow2 - 3 > >  v 
) -> VFromD<decltype(d)>

◆ ChangeLMUL() [5/7]

template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL ( Simd< T, N, kPow2 >  d,
VFromD< Simd< T, N, kPow2+1 > >  v 
) -> VFromD<decltype(d)>

◆ ChangeLMUL() [6/7]

template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL ( Simd< T, N, kPow2 >  d,
VFromD< Simd< T, N, kPow2+2 > >  v 
) -> VFromD<decltype(d)>

◆ ChangeLMUL() [7/7]

template<typename T , size_t N, int kPow2>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ChangeLMUL ( Simd< T, N, kPow2 >  d,
VFromD< Simd< T, N, kPow2+3 > >  v 
) -> VFromD<decltype(d)>

◆ ClampF64ToI32Max()

template<size_t N>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::ClampF64ToI32Max ( Simd< double, N, 0 >  d,
decltype(Zero(d))  v 
) -> decltype(Zero(d))

◆ Compress() [1/3]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::Compress ( hwy::SizeTag< 2 >  ,
Vec256< T >  v,
const uint64_t  mask_bits 
)

◆ Compress() [2/3]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::Compress ( hwy::SizeTag< 4 >  ,
Vec256< T >  v,
const uint64_t  mask_bits 
)

◆ Compress() [3/3]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::Compress ( Vec128< T, N v,
const uint64_t  mask_bits 
)

◆ CompressNot()

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::CompressNot ( Vec128< T, N v,
const uint64_t  mask_bits 
)

◆ CountTrue() [1/4]

template<typename T >
HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::CountTrue ( hwy::SizeTag< 1 >  tag,
const Mask128< T >  mask 
)

◆ CountTrue() [2/4]

template<typename T >
HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::CountTrue ( hwy::SizeTag< 2 >  tag,
const Mask128< T >  mask 
)

◆ CountTrue() [3/4]

template<typename T >
HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::CountTrue ( hwy::SizeTag< 4 >  ,
const Mask128< T >  mask 
)

◆ CountTrue() [4/4]

template<typename T >
HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::CountTrue ( hwy::SizeTag< 8 >  ,
const Mask128< T >  mask 
)

◆ ExtractLane() [1/4]

template<size_t kLane>
HWY_INLINE double hwy::HWY_NAMESPACE::detail::ExtractLane ( const Vec128< double >  v)

◆ ExtractLane() [2/4]

template<size_t kLane>
HWY_INLINE double hwy::HWY_NAMESPACE::detail::ExtractLane ( const Vec128< double, 1 >  v)

◆ ExtractLane() [3/4]

template<size_t kLane, size_t N>
HWY_INLINE float hwy::HWY_NAMESPACE::detail::ExtractLane ( const Vec128< float, N v)

References hwy::HWY_NAMESPACE::v.

◆ ExtractLane() [4/4]

template<size_t kLane, typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_INLINE T hwy::HWY_NAMESPACE::detail::ExtractLane ( const Vec128< T, N v)

References hwy::HWY_NAMESPACE::v.

◆ FirstNPerBlock()

template<size_t kLanes, class D >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::detail::FirstNPerBlock ( )

◆ FixConversionOverflow()

template<class DI , class DF = RebindToFloat<DI>>
HWY_INLINE auto hwy::HWY_NAMESPACE::detail::FixConversionOverflow ( DI  di,
VFromD< DF >  original,
decltype(Zero(di).raw)  converted_raw 
) -> VFromD<DI>

◆ GatherIndex() [1/4]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::GatherIndex ( hwy::SizeTag< 4 >  ,
Full256< T >  ,
const T *HWY_RESTRICT  base,
const Vec256< int32_t >  index 
)

◆ GatherIndex() [2/4]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::GatherIndex ( hwy::SizeTag< 4 >  ,
Full512< T >  ,
const T *HWY_RESTRICT  base,
const Vec512< int32_t >  index 
)

◆ GatherIndex() [3/4]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::GatherIndex ( hwy::SizeTag< 8 >  ,
Full256< T >  ,
const T *HWY_RESTRICT  base,
const Vec256< int64_t >  index 
)

◆ GatherIndex() [4/4]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::GatherIndex ( hwy::SizeTag< 8 >  ,
Full512< T >  ,
const T *HWY_RESTRICT  base,
const Vec512< int64_t >  index 
)

◆ GatherOffset() [1/4]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::GatherOffset ( hwy::SizeTag< 4 >  ,
Full256< T >  ,
const T *HWY_RESTRICT  base,
const Vec256< int32_t >  offset 
)

◆ GatherOffset() [2/4]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::GatherOffset ( hwy::SizeTag< 4 >  ,
Full512< T >  ,
const T *HWY_RESTRICT  base,
const Vec512< int32_t >  offset 
)

◆ GatherOffset() [3/4]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::GatherOffset ( hwy::SizeTag< 8 >  ,
Full256< T >  ,
const T *HWY_RESTRICT  base,
const Vec256< int64_t >  offset 
)

◆ GatherOffset() [4/4]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::GatherOffset ( hwy::SizeTag< 8 >  ,
Full512< T >  ,
const T *HWY_RESTRICT  base,
const Vec512< int64_t >  offset 
)

◆ HeapSort()

template<class Traits , typename T >
void hwy::HWY_NAMESPACE::detail::HeapSort ( Traits  st,
T *HWY_RESTRICT  lanes,
const size_t  num_lanes 
)

◆ HWY_NEON_DEF_FUNCTION_ALL_FLOATS()

hwy::HWY_NAMESPACE::detail::HWY_NEON_DEF_FUNCTION_ALL_FLOATS ( BitCastToByte  ,
vreinterpret  ,
_u8_  ,
HWY_CAST_TO_U8   
)

◆ HWY_SVE_FOREACH()

hwy::HWY_NAMESPACE::detail::HWY_SVE_FOREACH ( HWY_SVE_WRAP_PTRUE  ,
PTrue  ,
ptrue   
)

◆ HWY_SVE_FOREACH_U()

hwy::HWY_NAMESPACE::detail::HWY_SVE_FOREACH_U ( HWY_SVE_DUP  ,
DupEvenB  ,
trn1   
)

◆ Idx16x8FromBits()

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::Idx16x8FromBits ( const uint64_t  mask_bits)

◆ Idx32x4FromBits()

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::Idx32x4FromBits ( const uint64_t  mask_bits)

◆ IdxFromBits() [1/3]

template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 2) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IdxFromBits ( const uint64_t  mask_bits)

◆ IdxFromBits() [2/3]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IdxFromBits ( hwy::SizeTag< 2 >  ,
const uint64_t  mask_bits 
)

◆ IdxFromBits() [3/3]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IdxFromBits ( hwy::SizeTag< 4 >  ,
const uint64_t  mask_bits 
)

◆ IdxFromNotBits() [1/3]

template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 2) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IdxFromNotBits ( const uint64_t  mask_bits)

◆ IdxFromNotBits() [2/3]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IdxFromNotBits ( hwy::SizeTag< 2 >  ,
const uint64_t  mask_bits 
)

◆ IdxFromNotBits() [3/3]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IdxFromNotBits ( hwy::SizeTag< 4 >  ,
const uint64_t  mask_bits 
)

◆ IfThenElse() [1/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 1 >  ,
const Mask512< T >  mask,
const Vec512< T >  yes,
const Vec512< T >  no 
)

◆ IfThenElse() [2/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 1 >  ,
Mask128< T, N mask,
Vec128< T, N yes,
Vec128< T, N no 
)

◆ IfThenElse() [3/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 1 >  ,
Mask256< T >  mask,
Vec256< T >  yes,
Vec256< T >  no 
)

◆ IfThenElse() [4/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 2 >  ,
const Mask512< T >  mask,
const Vec512< T >  yes,
const Vec512< T >  no 
)

◆ IfThenElse() [5/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 2 >  ,
Mask128< T, N mask,
Vec128< T, N yes,
Vec128< T, N no 
)

◆ IfThenElse() [6/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 2 >  ,
Mask256< T >  mask,
Vec256< T >  yes,
Vec256< T >  no 
)

◆ IfThenElse() [7/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 4 >  ,
const Mask512< T >  mask,
const Vec512< T >  yes,
const Vec512< T >  no 
)

◆ IfThenElse() [8/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 4 >  ,
Mask128< T, N mask,
Vec128< T, N yes,
Vec128< T, N no 
)

◆ IfThenElse() [9/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 4 >  ,
Mask256< T >  mask,
Vec256< T >  yes,
Vec256< T >  no 
)

◆ IfThenElse() [10/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 8 >  ,
const Mask512< T >  mask,
const Vec512< T >  yes,
const Vec512< T >  no 
)

◆ IfThenElse() [11/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 8 >  ,
Mask128< T, N mask,
Vec128< T, N yes,
Vec128< T, N no 
)

◆ IfThenElse() [12/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenElse ( hwy::SizeTag< 8 >  ,
Mask256< T >  mask,
Vec256< T >  yes,
Vec256< T >  no 
)

◆ IfThenElseZero() [1/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 1 >  ,
const Mask512< T >  mask,
const Vec512< T >  yes 
)

◆ IfThenElseZero() [2/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 1 >  ,
Mask128< T, N mask,
Vec128< T, N yes 
)

◆ IfThenElseZero() [3/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 1 >  ,
Mask256< T >  mask,
Vec256< T >  yes 
)

◆ IfThenElseZero() [4/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 2 >  ,
const Mask512< T >  mask,
const Vec512< T >  yes 
)

◆ IfThenElseZero() [5/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 2 >  ,
Mask128< T, N mask,
Vec128< T, N yes 
)

◆ IfThenElseZero() [6/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 2 >  ,
Mask256< T >  mask,
Vec256< T >  yes 
)

◆ IfThenElseZero() [7/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 4 >  ,
const Mask512< T >  mask,
const Vec512< T >  yes 
)

◆ IfThenElseZero() [8/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 4 >  ,
Mask128< T, N mask,
Vec128< T, N yes 
)

◆ IfThenElseZero() [9/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 4 >  ,
Mask256< T >  mask,
Vec256< T >  yes 
)

◆ IfThenElseZero() [10/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 8 >  ,
const Mask512< T >  mask,
const Vec512< T >  yes 
)

◆ IfThenElseZero() [11/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 8 >  ,
Mask128< T, N mask,
Vec128< T, N yes 
)

◆ IfThenElseZero() [12/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenElseZero ( hwy::SizeTag< 8 >  ,
Mask256< T >  mask,
Vec256< T >  yes 
)

◆ IfThenZeroElse() [1/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 1 >  ,
const Mask512< T >  mask,
const Vec512< T >  no 
)

◆ IfThenZeroElse() [2/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 1 >  ,
Mask128< T, N mask,
Vec128< T, N no 
)

◆ IfThenZeroElse() [3/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 1 >  ,
Mask256< T >  mask,
Vec256< T >  no 
)

◆ IfThenZeroElse() [4/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 2 >  ,
const Mask512< T >  mask,
const Vec512< T >  no 
)

◆ IfThenZeroElse() [5/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 2 >  ,
Mask128< T, N mask,
Vec128< T, N no 
)

◆ IfThenZeroElse() [6/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 2 >  ,
Mask256< T >  mask,
Vec256< T >  no 
)

◆ IfThenZeroElse() [7/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 4 >  ,
const Mask512< T >  mask,
const Vec512< T >  no 
)

◆ IfThenZeroElse() [8/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 4 >  ,
Mask128< T, N mask,
Vec128< T, N no 
)

◆ IfThenZeroElse() [9/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 4 >  ,
Mask256< T >  mask,
Vec256< T >  no 
)

◆ IfThenZeroElse() [10/12]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 8 >  ,
const Mask512< T >  mask,
const Vec512< T >  no 
)

◆ IfThenZeroElse() [11/12]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 8 >  ,
Mask128< T, N mask,
Vec128< T, N no 
)

◆ IfThenZeroElse() [12/12]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::IfThenZeroElse ( hwy::SizeTag< 8 >  ,
Mask256< T >  mask,
Vec256< T >  no 
)

◆ IncrementWithWraparound()

template<typename T , HWY_IF_FLOAT(T) >
HWY_INLINE constexpr T hwy::HWY_NAMESPACE::detail::IncrementWithWraparound ( t)
constexpr

◆ InsertLane() [1/5]

template<size_t kLane>
HWY_INLINE Vec128< double > hwy::HWY_NAMESPACE::detail::InsertLane ( const Vec128< double >  v,
double  t 
)

◆ InsertLane() [2/5]

template<size_t kLane>
HWY_INLINE Vec128< double, 1 > hwy::HWY_NAMESPACE::detail::InsertLane ( const Vec128< double, 1 >  v,
double  t 
)

◆ InsertLane() [3/5]

template<size_t kLane, size_t N>
HWY_INLINE Vec128< double, N > hwy::HWY_NAMESPACE::detail::InsertLane ( const Vec128< double, N v,
double  t 
)

References hwy::HWY_NAMESPACE::v.

◆ InsertLane() [4/5]

template<size_t kLane, size_t N>
HWY_INLINE Vec128< float, N > hwy::HWY_NAMESPACE::detail::InsertLane ( const Vec128< float, N v,
float  t 
)

◆ InsertLane() [5/5]

template<size_t kLane, typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::InsertLane ( const Vec128< T, N v,
t 
)

◆ InterleaveUpper() [1/41]

HWY_API Vec128< double > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec128< double >  a,
const Vec128< double >  b 
)

◆ InterleaveUpper() [2/41]

HWY_API Vec128< int16_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec128< int16_t >  a,
const Vec128< int16_t >  b 
)

◆ InterleaveUpper() [3/41]

HWY_API Vec128< int32_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec128< int32_t >  a,
const Vec128< int32_t >  b 
)

◆ InterleaveUpper() [4/41]

HWY_API Vec128< int8_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec128< int8_t >  a,
const Vec128< int8_t >  b 
)

◆ InterleaveUpper() [5/41]

HWY_API Vec128< uint16_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec128< uint16_t >  a,
const Vec128< uint16_t >  b 
)

◆ InterleaveUpper() [6/41]

HWY_API Vec128< uint32_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec128< uint32_t >  a,
const Vec128< uint32_t >  b 
)

◆ InterleaveUpper() [7/41]

HWY_API Vec128< uint64_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec128< uint64_t >  a,
const Vec128< uint64_t >  b 
)

◆ InterleaveUpper() [8/41]

HWY_API Vec128< uint8_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec128< uint8_t >  a,
const Vec128< uint8_t >  b 
)

◆ InterleaveUpper() [9/41]

HWY_API Vec256< double > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec256< double >  a,
const Vec256< double >  b 
)

◆ InterleaveUpper() [10/41]

HWY_API Vec512< double > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec512< double >  a,
const Vec512< double >  b 
)

◆ InterleaveUpper() [11/41]

HWY_API Vec512< float > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec512< float >  a,
const Vec512< float >  b 
)

◆ InterleaveUpper() [12/41]

HWY_API Vec512< int16_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec512< int16_t >  a,
const Vec512< int16_t >  b 
)

◆ InterleaveUpper() [13/41]

HWY_API Vec512< int32_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec512< int32_t >  a,
const Vec512< int32_t >  b 
)

◆ InterleaveUpper() [14/41]

HWY_API Vec512< int64_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec512< int64_t >  a,
const Vec512< int64_t >  b 
)

◆ InterleaveUpper() [15/41]

HWY_API Vec512< int8_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec512< int8_t >  a,
const Vec512< int8_t >  b 
)

◆ InterleaveUpper() [16/41]

HWY_API Vec512< uint16_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec512< uint16_t >  a,
const Vec512< uint16_t >  b 
)

◆ InterleaveUpper() [17/41]

HWY_API Vec512< uint32_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec512< uint32_t >  a,
const Vec512< uint32_t >  b 
)

◆ InterleaveUpper() [18/41]

HWY_API Vec512< uint64_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec512< uint64_t >  a,
const Vec512< uint64_t >  b 
)

◆ InterleaveUpper() [19/41]

HWY_API Vec512< uint8_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec512< uint8_t >  a,
const Vec512< uint8_t >  b 
)

◆ InterleaveUpper() [20/41]

HWY_API Vec64< float > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec64< float >  a,
const Vec64< float >  b 
)

◆ InterleaveUpper() [21/41]

template<size_t N>
HWY_API Vec128< double, N > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< double, N a,
Vec128< double, N b 
)

◆ InterleaveUpper() [22/41]

HWY_API Vec128< float > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< float >  a,
Vec128< float >  b 
)

◆ InterleaveUpper() [23/41]

template<size_t N>
HWY_API Vec128< float, N > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< float, N a,
Vec128< float, N b 
)

◆ InterleaveUpper() [24/41]

template<size_t N>
HWY_API Vec128< int16_t, N > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< int16_t, N a,
Vec128< int16_t, N b 
)

◆ InterleaveUpper() [25/41]

template<size_t N>
HWY_API Vec128< int32_t, N > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< int32_t, N a,
Vec128< int32_t, N b 
)

◆ InterleaveUpper() [26/41]

HWY_API Vec128< int64_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< int64_t >  a,
Vec128< int64_t >  b 
)

◆ InterleaveUpper() [27/41]

template<size_t N>
HWY_API Vec128< int64_t, N > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< int64_t, N a,
Vec128< int64_t, N b 
)

◆ InterleaveUpper() [28/41]

template<size_t N>
HWY_API Vec128< int8_t, N > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< int8_t, N a,
Vec128< int8_t, N b 
)

◆ InterleaveUpper() [29/41]

template<size_t N>
HWY_API Vec128< uint16_t, N > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< uint16_t, N a,
Vec128< uint16_t, N b 
)

◆ InterleaveUpper() [30/41]

template<size_t N>
HWY_API Vec128< uint32_t, N > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< uint32_t, N a,
Vec128< uint32_t, N b 
)

◆ InterleaveUpper() [31/41]

template<size_t N>
HWY_API Vec128< uint64_t, N > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< uint64_t, N a,
Vec128< uint64_t, N b 
)

◆ InterleaveUpper() [32/41]

template<size_t N>
HWY_API Vec128< uint8_t, N > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< uint8_t, N a,
Vec128< uint8_t, N b 
)

◆ InterleaveUpper() [33/41]

HWY_API Vec256< float > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec256< float >  a,
Vec256< float >  b 
)

◆ InterleaveUpper() [34/41]

HWY_API Vec256< int16_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec256< int16_t >  a,
Vec256< int16_t >  b 
)

◆ InterleaveUpper() [35/41]

HWY_API Vec256< int32_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec256< int32_t >  a,
Vec256< int32_t >  b 
)

◆ InterleaveUpper() [36/41]

HWY_API Vec256< int64_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec256< int64_t >  a,
Vec256< int64_t >  b 
)

◆ InterleaveUpper() [37/41]

HWY_API Vec256< int8_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec256< int8_t >  a,
Vec256< int8_t >  b 
)

◆ InterleaveUpper() [38/41]

HWY_API Vec256< uint16_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec256< uint16_t >  a,
Vec256< uint16_t >  b 
)

◆ InterleaveUpper() [39/41]

HWY_API Vec256< uint32_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec256< uint32_t >  a,
Vec256< uint32_t >  b 
)

◆ InterleaveUpper() [40/41]

HWY_API Vec256< uint64_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec256< uint64_t >  a,
Vec256< uint64_t >  b 
)

◆ InterleaveUpper() [41/41]

HWY_API Vec256< uint8_t > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec256< uint8_t >  a,
Vec256< uint8_t >  b 
)

◆ Iota0()

template<class D , class DU = RebindToUnsigned<D>>
HWY_INLINE VFromD< DU > hwy::HWY_NAMESPACE::detail::Iota0 ( const  D)

◆ IsFull()

template<typename T , size_t N, int kPow2>
constexpr bool hwy::HWY_NAMESPACE::detail::IsFull ( Simd< T, N, kPow2 >  )
constexpr

◆ IsSupportedLMUL()

template<class D >
constexpr bool hwy::HWY_NAMESPACE::detail::IsSupportedLMUL ( d)
constexpr

◆ LanesPerBlock() [1/2]

template<typename T , size_t N, int kPow2>
size_t hwy::HWY_NAMESPACE::detail::LanesPerBlock ( Simd< T, N, kPow2 >  d)

◆ LanesPerBlock() [2/2]

template<typename T , size_t N, int kPow2>
constexpr size_t hwy::HWY_NAMESPACE::detail::LanesPerBlock ( Simd< T, N, kPow2 >  )
constexpr

◆ Load8Bytes() [1/2]

HWY_INLINE Vec128< uint8_t > hwy::HWY_NAMESPACE::detail::Load8Bytes ( Full128< uint8_t >  ,
const uint8_t *  bytes 
)

Referenced by IdxFromBits(), and IdxFromNotBits().

◆ Load8Bytes() [2/2]

template<size_t N, HWY_IF_LE64(uint8_t, N) >
HWY_INLINE Vec128< uint8_t, N > hwy::HWY_NAMESPACE::detail::Load8Bytes ( Simd< uint8_t, N, 0 >  d,
const uint8_t *  bytes 
)

◆ LoadMaskBits() [1/2]

template<typename T , HWY_IF_LANE_SIZE(T, 1) >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::LoadMaskBits ( Full256< T >  d,
uint64_t  bits 
)

◆ LoadMaskBits() [2/2]

template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::LoadMaskBits ( Simd< T, N, 0 >  d,
uint64_t  mask_bits 
)

◆ LoadTransposedBlocks3() [1/3]

template<typename T >
HWY_API void hwy::HWY_NAMESPACE::detail::LoadTransposedBlocks3 ( Full256< T >  d,
const T *HWY_RESTRICT  unaligned,
Vec256< T > &  A,
Vec256< T > &  B,
Vec256< T > &  C 
)

◆ LoadTransposedBlocks3() [2/3]

template<typename T >
HWY_API void hwy::HWY_NAMESPACE::detail::LoadTransposedBlocks3 ( Full512< T >  d,
const T *HWY_RESTRICT  unaligned,
Vec512< T > &  A,
Vec512< T > &  B,
Vec512< T > &  C 
)

◆ LoadTransposedBlocks3() [3/3]

template<typename T , size_t N, class V , HWY_IF_LE128(T, N) >
HWY_API void hwy::HWY_NAMESPACE::detail::LoadTransposedBlocks3 ( Simd< T, N, 0 >  d,
const T *HWY_RESTRICT  unaligned,
V &  A,
V &  B,
V &  C 
)

◆ LoadTransposedBlocks4() [1/3]

template<typename T >
HWY_API void hwy::HWY_NAMESPACE::detail::LoadTransposedBlocks4 ( Full256< T >  d,
const T *HWY_RESTRICT  unaligned,
Vec256< T > &  A,
Vec256< T > &  B,
Vec256< T > &  C,
Vec256< T > &  D 
)

◆ LoadTransposedBlocks4() [2/3]

template<typename T >
HWY_API void hwy::HWY_NAMESPACE::detail::LoadTransposedBlocks4 ( Full512< T >  d,
const T *HWY_RESTRICT  unaligned,
Vec512< T > &  A,
Vec512< T > &  B,
Vec512< T > &  C,
Vec512< T > &  D 
)

◆ LoadTransposedBlocks4() [3/3]

template<typename T , size_t N, class V , HWY_IF_LE128(T, N) >
HWY_API void hwy::HWY_NAMESPACE::detail::LoadTransposedBlocks4 ( Simd< T, N, 0 >  d,
const T *HWY_RESTRICT  unaligned,
V &  A,
V &  B,
V &  C,
V &  D 
)

◆ Lt128UpperVec()

template<class D , class V = VFromD<D>>
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Lt128UpperVec ( const D  d,
const V  a,
const V  b 
)

◆ Lt128Vec() [1/2]

template<class D , class V = VFromD<D>>
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Lt128Vec ( const D  d,
const V  a,
const V  b 
)

◆ Lt128Vec() [2/2]

template<class D >
trn2 HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::detail::Lt128Vec ( d,
const svuint64_t  a,
const svuint64_t  b 
)

◆ MakeMask()

template<class D >
svbool_t hwy::HWY_NAMESPACE::detail::MakeMask ( d)

◆ MaskFromVec() [1/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 1 >  ,
const Vec128< T, N v 
)

◆ MaskFromVec() [2/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 1 >  ,
const Vec256< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ MaskFromVec() [3/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 1 >  ,
const Vec512< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ MaskFromVec() [4/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 2 >  ,
const Vec128< T, N v 
)

References hwy::HWY_NAMESPACE::v.

◆ MaskFromVec() [5/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 2 >  ,
const Vec256< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ MaskFromVec() [6/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 2 >  ,
const Vec512< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ MaskFromVec() [7/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 4 >  ,
const Vec128< T, N v 
)

References hwy::HWY_NAMESPACE::v.

◆ MaskFromVec() [8/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 4 >  ,
const Vec256< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ MaskFromVec() [9/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 4 >  ,
const Vec512< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ MaskFromVec() [10/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 8 >  ,
const Vec128< T, N v 
)

References hwy::HWY_NAMESPACE::v.

◆ MaskFromVec() [11/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 8 >  ,
const Vec256< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ MaskFromVec() [12/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 8 >  ,
const Vec512< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ MaskLowerHalf()

template<class D , HWY_IF_LANE_SIZE_D(D, 1) >
svbool_t hwy::HWY_NAMESPACE::detail::MaskLowerHalf ( d)

◆ MaskUpperHalf()

template<class D >
svbool_t hwy::HWY_NAMESPACE::detail::MaskUpperHalf ( d)

◆ MaxOfLanes() [1/8]

template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 2) , HWY_IF_GE32(T, N) >
HWY_API Vec128< T, N > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 2 >  ,
Vec128< T, N v 
)

◆ MaxOfLanes() [2/8]

template<typename T , HWY_IF_LANE_SIZE(T, 2) >
HWY_API Vec256< T > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 2 >  ,
Vec256< T >  v 
)

◆ MaxOfLanes() [3/8]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 4 >  ,
const Vec128< T >  v3210 
)

◆ MaxOfLanes() [4/8]

template<typename T >
HWY_INLINE Vec128< T, 2 > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 4 >  ,
const Vec128< T, 2 >  v10 
)

◆ MaxOfLanes() [5/8]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 4 >  ,
const Vec256< T >  v3210 
)

◆ MaxOfLanes() [6/8]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 8 >  ,
const Vec128< T >  v10 
)

◆ MaxOfLanes() [7/8]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 8 >  ,
const Vec256< T >  v10 
)

◆ MaxOfLanes() [8/8]

template<typename T >
HWY_INLINE Vec128< T, 1 > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< sizeof(T)>  ,
const Vec128< T, 1 >  v 
)

◆ MaxU()

template<typename T , size_t N>
HWY_INLINE HWY_MAYBE_UNUSED Vec128< T, N > hwy::HWY_NAMESPACE::detail::MaxU ( const Vec128< T, N a,
const Vec128< T, N b 
)

◆ MinOfLanes() [1/8]

template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 2) , HWY_IF_GE32(T, N) >
HWY_API Vec128< T, N > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 2 >  ,
Vec128< T, N v 
)

◆ MinOfLanes() [2/8]

template<typename T , HWY_IF_LANE_SIZE(T, 2) >
HWY_API Vec256< T > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 2 >  ,
Vec256< T >  v 
)

◆ MinOfLanes() [3/8]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 4 >  ,
const Vec128< T >  v3210 
)

◆ MinOfLanes() [4/8]

template<typename T >
HWY_INLINE Vec128< T, 2 > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 4 >  ,
const Vec128< T, 2 >  v10 
)

◆ MinOfLanes() [5/8]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 4 >  ,
const Vec256< T >  v3210 
)

◆ MinOfLanes() [6/8]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 8 >  ,
const Vec128< T >  v10 
)

◆ MinOfLanes() [7/8]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 8 >  ,
const Vec256< T >  v10 
)

◆ MinOfLanes() [8/8]

template<typename T >
HWY_INLINE Vec128< T, 1 > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< sizeof(T)>  ,
const Vec128< T, 1 >  v 
)

◆ MinU()

template<typename T , size_t N>
HWY_INLINE HWY_MAYBE_UNUSED Vec128< T, N > hwy::HWY_NAMESPACE::detail::MinU ( const Vec128< T, N a,
const Vec128< T, N b 
)

◆ NibblesFromMask() [1/3]

template<typename T >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::NibblesFromMask ( const Full128< T >  d,
Mask128< T >  mask 
)

◆ NibblesFromMask() [2/3]

template<typename T >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::NibblesFromMask ( const Full64< T >  d,
Mask64< T >  mask 
)

◆ NibblesFromMask() [3/3]

template<typename T , size_t N, HWY_IF_LE32(T, N) >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::NibblesFromMask ( Simd< T, N, 0 >  ,
Mask128< T, N mask 
)

◆ Not() [1/4]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Not ( hwy::SizeTag< 1 >  ,
const Mask512< T >  m 
)

◆ Not() [2/4]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Not ( hwy::SizeTag< 2 >  ,
const Mask512< T >  m 
)

◆ Not() [3/4]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Not ( hwy::SizeTag< 4 >  ,
const Mask512< T >  m 
)

◆ Not() [4/4]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Not ( hwy::SizeTag< 8 >  ,
const Mask512< T >  m 
)

◆ OddEven() [1/8]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::OddEven ( hwy::SizeTag< 1 >  ,
const Vec128< T, N a,
const Vec128< T, N b 
)

◆ OddEven() [2/8]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::OddEven ( hwy::SizeTag< 1 >  ,
const Vec256< T >  a,
const Vec256< T >  b 
)

◆ OddEven() [3/8]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::OddEven ( hwy::SizeTag< 2 >  ,
const Vec128< T, N a,
const Vec128< T, N b 
)

◆ OddEven() [4/8]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::OddEven ( hwy::SizeTag< 2 >  ,
const Vec256< T >  a,
const Vec256< T >  b 
)

◆ OddEven() [5/8]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::OddEven ( hwy::SizeTag< 4 >  ,
const Vec128< T, N a,
const Vec128< T, N b 
)

◆ OddEven() [6/8]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::OddEven ( hwy::SizeTag< 4 >  ,
const Vec256< T >  a,
const Vec256< T >  b 
)

◆ OddEven() [7/8]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::OddEven ( hwy::SizeTag< 8 >  ,
const Vec128< T, N a,
const Vec128< T, N b 
)

◆ OddEven() [8/8]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::OddEven ( hwy::SizeTag< 8 >  ,
const Vec256< T >  a,
const Vec256< T >  b 
)

◆ OffsetsOf128BitBlocks()

template<class D , class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::OffsetsOf128BitBlocks ( const D  d,
const V  iota0 
)

◆ OnlyActive()

template<typename T , size_t N>
constexpr uint64_t hwy::HWY_NAMESPACE::detail::OnlyActive ( uint64_t  bits)
constexpr

References hwy::HWY_NAMESPACE::N.

◆ Or() [1/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 1 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ Or() [2/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 1 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ Or() [3/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 1 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ Or() [4/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 2 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ Or() [5/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 2 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ Or() [6/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 2 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ Or() [7/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 4 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ Or() [8/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 4 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ Or() [9/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 4 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ Or() [10/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 8 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ Or() [11/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 8 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ Or() [12/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Or ( hwy::SizeTag< 8 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ PopulationCount() [1/20]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 1 >  ,
Vec128< T >  v 
)

◆ PopulationCount() [2/20]

template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 1 >  ,
Vec128< T, N v 
)

◆ PopulationCount() [3/20]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 1 >  ,
Vec128< T, N v 
)

References hwy::HWY_NAMESPACE::v.

◆ PopulationCount() [4/20]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 1 >  ,
Vec256< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PopulationCount() [5/20]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 1 >  ,
Vec512< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PopulationCount() [6/20]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 2 >  ,
Vec128< T >  v 
)

◆ PopulationCount() [7/20]

template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 2 >  ,
Vec128< T, N v 
)

◆ PopulationCount() [8/20]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 2 >  ,
Vec128< T, N v 
)

References hwy::HWY_NAMESPACE::v.

◆ PopulationCount() [9/20]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 2 >  ,
Vec256< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PopulationCount() [10/20]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 2 >  ,
Vec512< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PopulationCount() [11/20]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 4 >  ,
Vec128< T >  v 
)

◆ PopulationCount() [12/20]

template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 4 >  ,
Vec128< T, N v 
)

◆ PopulationCount() [13/20]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 4 >  ,
Vec128< T, N v 
)

References hwy::HWY_NAMESPACE::v.

◆ PopulationCount() [14/20]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 4 >  ,
Vec256< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PopulationCount() [15/20]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 4 >  ,
Vec512< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PopulationCount() [16/20]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 8 >  ,
Vec128< T >  v 
)

◆ PopulationCount() [17/20]

template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 8 >  ,
Vec128< T, N v 
)

◆ PopulationCount() [18/20]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 8 >  ,
Vec128< T, N v 
)

References hwy::HWY_NAMESPACE::v.

◆ PopulationCount() [19/20]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 8 >  ,
Vec256< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PopulationCount() [20/20]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 8 >  ,
Vec512< T >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo()

template<size_t N, int kPow2>
HWY_API svfloat32_t hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Simd< float, N, kPow2 >  df,
svfloat16_t  v 
)

◆ ReciprocalNewtonRaphsonStep() [1/2]

HWY_INLINE Vec128< float > hwy::HWY_NAMESPACE::detail::ReciprocalNewtonRaphsonStep ( const Vec128< float >  recip,
const Vec128< float >  divisor 
)

◆ ReciprocalNewtonRaphsonStep() [2/2]

template<size_t N>
HWY_INLINE Vec128< float, N > hwy::HWY_NAMESPACE::detail::ReciprocalNewtonRaphsonStep ( const Vec128< float, N recip,
Vec128< float, N divisor 
)

◆ ReciprocalSqrtStep() [1/2]

HWY_INLINE Vec128< float > hwy::HWY_NAMESPACE::detail::ReciprocalSqrtStep ( const Vec128< float >  root,
const Vec128< float >  recip 
)

◆ ReciprocalSqrtStep() [2/2]

template<size_t N>
HWY_INLINE Vec128< float, N > hwy::HWY_NAMESPACE::detail::ReciprocalSqrtStep ( const Vec128< float, N root,
Vec128< float, N recip 
)

◆ SaturateI()

template<typename TN , class VI >
VI hwy::HWY_NAMESPACE::detail::SaturateI ( VI  v)

References hwy::HWY_NAMESPACE::v.

◆ SaturateU()

template<typename TN , class VU >
VU hwy::HWY_NAMESPACE::detail::SaturateU ( VU  v)

References hwy::HWY_NAMESPACE::v.

◆ ScalarMaskedStore()

template<typename T , size_t N>
HWY_API void hwy::HWY_NAMESPACE::detail::ScalarMaskedStore ( Vec128< T, N v,
Mask128< T, N m,
Simd< T, N, 0 >  d,
T *HWY_RESTRICT  p 
)

◆ ScaleByPower()

constexpr size_t hwy::HWY_NAMESPACE::detail::ScaleByPower ( size_t  N,
int  pow2 
)
constexpr

◆ ScatterIndex() [1/6]

template<typename T , size_t N>
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterIndex ( hwy::SizeTag< 4 >  ,
Vec128< T, N v,
Simd< T, N, 0 >  ,
T *HWY_RESTRICT  base,
const Vec128< int32_t, N index 
)

◆ ScatterIndex() [2/6]

template<typename T >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterIndex ( hwy::SizeTag< 4 >  ,
Vec256< T >  v,
Full256< T >  ,
T *HWY_RESTRICT  base,
const Vec256< int32_t >  index 
)

◆ ScatterIndex() [3/6]

template<typename T >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterIndex ( hwy::SizeTag< 4 >  ,
Vec512< T >  v,
Full512< T >  ,
T *HWY_RESTRICT  base,
const Vec512< int32_t >  index 
)

◆ ScatterIndex() [4/6]

template<typename T , size_t N>
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterIndex ( hwy::SizeTag< 8 >  ,
Vec128< T, N v,
Simd< T, N, 0 >  ,
T *HWY_RESTRICT  base,
const Vec128< int64_t, N index 
)

◆ ScatterIndex() [5/6]

template<typename T >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterIndex ( hwy::SizeTag< 8 >  ,
Vec256< T >  v,
Full256< T >  ,
T *HWY_RESTRICT  base,
const Vec256< int64_t >  index 
)

◆ ScatterIndex() [6/6]

template<typename T >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterIndex ( hwy::SizeTag< 8 >  ,
Vec512< T >  v,
Full512< T >  ,
T *HWY_RESTRICT  base,
const Vec512< int64_t >  index 
)

◆ ScatterOffset() [1/6]

template<typename T , size_t N>
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterOffset ( hwy::SizeTag< 4 >  ,
Vec128< T, N v,
Simd< T, N, 0 >  ,
T *HWY_RESTRICT  base,
const Vec128< int32_t, N offset 
)

◆ ScatterOffset() [2/6]

template<typename T >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterOffset ( hwy::SizeTag< 4 >  ,
Vec256< T >  v,
Full256< T >  ,
T *HWY_RESTRICT  base,
const Vec256< int32_t >  offset 
)

◆ ScatterOffset() [3/6]

template<typename T >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterOffset ( hwy::SizeTag< 4 >  ,
Vec512< T >  v,
Full512< T >  ,
T *HWY_RESTRICT  base,
const Vec512< int32_t >  offset 
)

◆ ScatterOffset() [4/6]

template<typename T , size_t N>
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterOffset ( hwy::SizeTag< 8 >  ,
Vec128< T, N v,
Simd< T, N, 0 >  ,
T *HWY_RESTRICT  base,
const Vec128< int64_t, N offset 
)

◆ ScatterOffset() [5/6]

template<typename T >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterOffset ( hwy::SizeTag< 8 >  ,
Vec256< T >  v,
Full256< T >  ,
T *HWY_RESTRICT  base,
const Vec256< int64_t >  offset 
)

◆ ScatterOffset() [6/6]

template<typename T >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::ScatterOffset ( hwy::SizeTag< 8 >  ,
Vec512< T >  v,
Full512< T >  ,
T *HWY_RESTRICT  base,
const Vec512< int64_t >  offset 
)

◆ Set64() [1/2]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::Set64 ( Full128< T >  d,
uint64_t  mask_bits 
)

◆ Set64() [2/2]

template<typename T , size_t N, HWY_IF_LE64(T, N) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::Set64 ( Simd< T, N, 0 >  ,
uint64_t  mask_bits 
)

References hwy::HWY_NAMESPACE::BitCast().

Referenced by LoadMaskBits().

◆ ShrBytes() [1/2]

template<int kBytes, typename T , size_t N>
HWY_API __i8x16 hwy::HWY_NAMESPACE::detail::ShrBytes ( const Vec128< T, N v)

References hwy::HWY_NAMESPACE::v.

◆ ShrBytes() [2/2]

template<int kBytes, typename T >
HWY_API __i8x16 hwy::HWY_NAMESPACE::detail::ShrBytes ( const Vec256< T >  v)

References hwy::HWY_NAMESPACE::v.

◆ Shuffle1230() [1/4]

template<typename T , HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, 4 > hwy::HWY_NAMESPACE::detail::Shuffle1230 ( const Vec128< T, 4 >  a,
const Vec128< T, 4 >  b 
)

◆ Shuffle1230() [2/4]

template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, N > hwy::HWY_NAMESPACE::detail::Shuffle1230 ( const Vec128< T, N a,
const Vec128< T, N b 
)

◆ Shuffle1230() [3/4]

template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > hwy::HWY_NAMESPACE::detail::Shuffle1230 ( const Vec256< T >  a,
const Vec256< T >  b 
)

◆ Shuffle1230() [4/4]

template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec512< T > hwy::HWY_NAMESPACE::detail::Shuffle1230 ( const Vec512< T >  a,
const Vec512< T >  b 
)

◆ Shuffle128() [1/3]

template<_MM_PERM_ENUM kPerm>
Vec512< double > hwy::HWY_NAMESPACE::detail::Shuffle128 ( const Vec512< double >  lo,
const Vec512< double >  hi 
)

◆ Shuffle128() [2/3]

template<_MM_PERM_ENUM kPerm>
Vec512< float > hwy::HWY_NAMESPACE::detail::Shuffle128 ( const Vec512< float >  lo,
const Vec512< float >  hi 
)

◆ Shuffle128() [3/3]

template<_MM_PERM_ENUM kPerm, typename T >
Vec512< T > hwy::HWY_NAMESPACE::detail::Shuffle128 ( const Vec512< T >  lo,
const Vec512< T >  hi 
)

◆ Shuffle2301() [1/4]

template<typename T , HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, 4 > hwy::HWY_NAMESPACE::detail::Shuffle2301 ( const Vec128< T, 4 >  a,
const Vec128< T, 4 >  b 
)

◆ Shuffle2301() [2/4]

template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, N > hwy::HWY_NAMESPACE::detail::Shuffle2301 ( const Vec128< T, N a,
const Vec128< T, N b 
)

◆ Shuffle2301() [3/4]

template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > hwy::HWY_NAMESPACE::detail::Shuffle2301 ( const Vec256< T >  a,
const Vec256< T >  b 
)

◆ Shuffle2301() [4/4]

template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec512< T > hwy::HWY_NAMESPACE::detail::Shuffle2301 ( const Vec512< T >  a,
const Vec512< T >  b 
)

◆ Shuffle3012() [1/4]

template<typename T , HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, 4 > hwy::HWY_NAMESPACE::detail::Shuffle3012 ( const Vec128< T, 4 >  a,
const Vec128< T, 4 >  b 
)

◆ Shuffle3012() [2/4]

template<typename T , size_t N, HWY_IF_LANE_SIZE(T, 1) >
HWY_API Vec128< T, N > hwy::HWY_NAMESPACE::detail::Shuffle3012 ( const Vec128< T, N a,
const Vec128< T, N b 
)

◆ Shuffle3012() [3/4]

template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > hwy::HWY_NAMESPACE::detail::Shuffle3012 ( const Vec256< T >  a,
const Vec256< T >  b 
)

◆ Shuffle3012() [4/4]

template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec512< T > hwy::HWY_NAMESPACE::detail::Shuffle3012 ( const Vec512< T >  a,
const Vec512< T >  b 
)

◆ SiftDown()

template<class Traits , typename T >
void hwy::HWY_NAMESPACE::detail::SiftDown ( Traits  st,
T *HWY_RESTRICT  lanes,
const size_t  num_lanes,
size_t  start 
)

References AllTrue(), and hwy::HWY_NAMESPACE::d.

Referenced by HeapSort().

◆ StoreTransposedBlocks2() [1/3]

template<typename T , size_t N, class V , HWY_IF_LE128(T, N) >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks2 ( const V  A,
const V  B,
Simd< T, N, 0 >  d,
T *HWY_RESTRICT  unaligned 
)

◆ StoreTransposedBlocks2() [2/3]

template<typename T >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks2 ( const Vec256< T >  i,
const Vec256< T >  j,
const Full256< T >  d,
T *HWY_RESTRICT  unaligned 
)

◆ StoreTransposedBlocks2() [3/3]

template<typename T >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks2 ( const Vec512< T >  i,
const Vec512< T >  j,
const Full512< T >  d,
T *HWY_RESTRICT  unaligned 
)

◆ StoreTransposedBlocks3() [1/3]

template<typename T , size_t N, class V , HWY_IF_LE128(T, N) >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks3 ( const V  A,
const V  B,
const V  C,
Simd< T, N, 0 >  d,
T *HWY_RESTRICT  unaligned 
)

◆ StoreTransposedBlocks3() [2/3]

template<typename T >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks3 ( const Vec256< T >  i,
const Vec256< T >  j,
const Vec256< T >  k,
Full256< T >  d,
T *HWY_RESTRICT  unaligned 
)

◆ StoreTransposedBlocks3() [3/3]

template<typename T >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks3 ( const Vec512< T >  i,
const Vec512< T >  j,
const Vec512< T >  k,
Full512< T >  d,
T *HWY_RESTRICT  unaligned 
)

◆ StoreTransposedBlocks4() [1/3]

template<typename T , size_t N, class V , HWY_IF_LE128(T, N) >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks4 ( const V  A,
const V  B,
const V  C,
const V  D,
Simd< T, N, 0 >  d,
T *HWY_RESTRICT  unaligned 
)

◆ StoreTransposedBlocks4() [2/3]

template<typename T >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks4 ( const Vec256< T >  i,
const Vec256< T >  j,
const Vec256< T >  k,
const Vec256< T >  l,
Full256< T >  d,
T *HWY_RESTRICT  unaligned 
)

◆ StoreTransposedBlocks4() [3/3]

template<typename T >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks4 ( const Vec512< T >  i,
const Vec512< T >  j,
const Vec512< T >  k,
const Vec512< T >  l,
Full512< T >  d,
T *HWY_RESTRICT  unaligned 
)

◆ StoreU16ToF16()

HWY_INLINE void hwy::HWY_NAMESPACE::detail::StoreU16ToF16 ( const uint16_t  val,
hwy::float16_t *HWY_RESTRICT  to 
)

◆ SumOfLanes() [1/13]

HWY_INLINE Vec128< float > hwy::HWY_NAMESPACE::detail::SumOfLanes ( const Vec128< float >  v)

References hwy::HWY_NAMESPACE::v.

◆ SumOfLanes() [2/13]

HWY_INLINE Vec128< int32_t > hwy::HWY_NAMESPACE::detail::SumOfLanes ( const Vec128< int32_t >  v)

References hwy::HWY_NAMESPACE::v.

◆ SumOfLanes() [3/13]

HWY_INLINE Vec128< int64_t > hwy::HWY_NAMESPACE::detail::SumOfLanes ( const Vec128< int64_t >  v)

◆ SumOfLanes() [4/13]

template<typename T >
HWY_INLINE Vec128< T, 1 > hwy::HWY_NAMESPACE::detail::SumOfLanes ( const Vec128< T, 1 >  v)

◆ SumOfLanes() [5/13]

template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_INLINE Vec128< T, 2 > hwy::HWY_NAMESPACE::detail::SumOfLanes ( const Vec128< T, 2 >  v10)

References Shuffle2301().

◆ SumOfLanes() [6/13]

HWY_INLINE Vec128< uint32_t > hwy::HWY_NAMESPACE::detail::SumOfLanes ( const Vec128< uint32_t >  v)

References hwy::HWY_NAMESPACE::v.

◆ SumOfLanes() [7/13]

HWY_INLINE Vec128< uint64_t > hwy::HWY_NAMESPACE::detail::SumOfLanes ( const Vec128< uint64_t >  v)

◆ SumOfLanes() [8/13]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 4 >  ,
const Vec128< T >  v3210 
)

◆ SumOfLanes() [9/13]

template<typename T >
HWY_INLINE Vec128< T, 2 > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 4 >  ,
const Vec128< T, 2 >  v10 
)

◆ SumOfLanes() [10/13]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 4 >  ,
const Vec256< T >  v3210 
)

◆ SumOfLanes() [11/13]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 8 >  ,
const Vec128< T >  v10 
)

◆ SumOfLanes() [12/13]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 8 >  ,
const Vec256< T >  v10 
)

◆ SumOfLanes() [13/13]

template<typename T >
HWY_INLINE Vec128< T, 1 > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< sizeof(T)>  ,
const Vec128< T, 1 >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ TestBit() [1/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 1 >  ,
const Vec128< T, N v,
const Vec128< T, N bit 
)

◆ TestBit() [2/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 1 >  ,
const Vec256< T >  v,
const Vec256< T >  bit 
)

◆ TestBit() [3/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 1 >  ,
const Vec512< T >  v,
const Vec512< T >  bit 
)

◆ TestBit() [4/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 2 >  ,
const Vec128< T, N v,
const Vec128< T, N bit 
)

◆ TestBit() [5/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 2 >  ,
const Vec256< T >  v,
const Vec256< T >  bit 
)

◆ TestBit() [6/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 2 >  ,
const Vec512< T >  v,
const Vec512< T >  bit 
)

◆ TestBit() [7/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 4 >  ,
const Vec128< T, N v,
const Vec128< T, N bit 
)

◆ TestBit() [8/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 4 >  ,
const Vec256< T >  v,
const Vec256< T >  bit 
)

◆ TestBit() [9/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 4 >  ,
const Vec512< T >  v,
const Vec512< T >  bit 
)

◆ TestBit() [10/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 8 >  ,
const Vec128< T, N v,
const Vec128< T, N bit 
)

◆ TestBit() [11/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 8 >  ,
const Vec256< T >  v,
const Vec256< T >  bit 
)

◆ TestBit() [12/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::TestBit ( hwy::SizeTag< 8 >  ,
const Vec512< T >  v,
const Vec512< T >  bit 
)

◆ U16FromF16()

HWY_INLINE uint16_t hwy::HWY_NAMESPACE::detail::U16FromF16 ( const hwy::float16_t *HWY_RESTRICT  from)

◆ UseInt() [1/2]

template<size_t N>
HWY_INLINE Mask128< float, N > hwy::HWY_NAMESPACE::detail::UseInt ( const Vec128< float, N v)

◆ UseInt() [2/2]

template<typename T , size_t N, HWY_IF_FLOAT(T) >
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::UseInt ( const Vec128< T, N v)

◆ Xor() [1/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 1 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ Xor() [2/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 1 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ Xor() [3/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 1 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ Xor() [4/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 2 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ Xor() [5/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 2 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ Xor() [6/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 2 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ Xor() [7/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 4 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ Xor() [8/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 4 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ Xor() [9/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 4 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

◆ Xor() [10/12]

template<typename T , size_t N>
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 8 >  ,
const Mask128< T, N a,
const Mask128< T, N b 
)

◆ Xor() [11/12]

template<typename T >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 8 >  ,
const Mask256< T >  a,
const Mask256< T >  b 
)

◆ Xor() [12/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::Xor ( hwy::SizeTag< 8 >  ,
const Mask512< T >  a,
const Mask512< T >  b 
)

Variable Documentation

◆ DupOddB

hwy::HWY_NAMESPACE::detail::DupOddB