Grok 10.0.5
Classes | Typedefs | Functions
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  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

HWY_INLINE void UnpoisonIfMemorySanitizer (void *p, size_t bytes)
 
template<class D >
HWY_INLINE void MaybePrintVector (D d, const char *label, Vec< D > v, size_t start=0, size_t max_lanes=16)
 
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 (hwy::SizeTag< sizeof(T)>, 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 (hwy::SizeTag< 4 >, 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 (hwy::SizeTag< 4 >, const Vec128< uint32_t > v)
 
HWY_INLINE Vec128< int32_t > SumOfLanes (hwy::SizeTag< 4 >, const Vec128< int32_t > v)
 
HWY_INLINE Vec128< float > SumOfLanes (hwy::SizeTag< 4 >, const Vec128< float > v)
 
HWY_INLINE Vec128< uint64_t > SumOfLanes (hwy::SizeTag< 8 >, const Vec128< uint64_t > v)
 
HWY_INLINE Vec128< int64_t > SumOfLanes (hwy::SizeTag< 8 >, 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<size_t N, HWY_IF_GE32(uint16_t, N) >
HWY_API Vec128< uint16_t, NSumOfLanes (hwy::SizeTag< 2 >, Vec128< uint16_t, N > v)
 
template<size_t N, HWY_IF_GE32(int16_t, N) >
HWY_API Vec128< int16_t, NSumOfLanes (hwy::SizeTag< 2 >, Vec128< int16_t, N > v)
 
template<size_t N, HWY_IF_GE32(uint16_t, N) >
HWY_API Vec128< uint16_t, NMinOfLanes (hwy::SizeTag< 2 >, Vec128< uint16_t, N > v)
 
template<size_t N, HWY_IF_GE32(int16_t, N) >
HWY_API Vec128< int16_t, NMinOfLanes (hwy::SizeTag< 2 >, Vec128< int16_t, N > v)
 
template<size_t N, HWY_IF_GE32(uint16_t, N) >
HWY_API Vec128< uint16_t, NMaxOfLanes (hwy::SizeTag< 2 >, Vec128< uint16_t, N > v)
 
template<size_t N, HWY_IF_GE32(int16_t, N) >
HWY_API Vec128< int16_t, NMaxOfLanes (hwy::SizeTag< 2 >, Vec128< int16_t, N > v)
 
template<typename T , HWY_IF_SUM_REDUCTION(T) >
HWY_API Vec128< T, 2 > SumOfLanes (hwy::SizeTag< sizeof(T)>, const Vec128< T, 2 > v10)
 
template<typename T , HWY_IF_MINMAX_REDUCTION(T) >
HWY_API Vec128< T, 2 > MinOfLanes (hwy::SizeTag< sizeof(T)>, const Vec128< T, 2 > v10)
 
template<typename T , HWY_IF_MINMAX_REDUCTION(T) >
HWY_API Vec128< T, 2 > MaxOfLanes (hwy::SizeTag< sizeof(T)>, const Vec128< T, 2 > v10)
 
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_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)
 
template<class D >
HWY_INLINE svuint64_t Lt128Vec (D d, const svuint64_t a, const svuint64_t b)
 
template<class D >
HWY_INLINE svuint64_t Eq128Vec (D d, const svuint64_t a, const svuint64_t b)
 
template<class D >
HWY_INLINE svuint64_t Ne128Vec (D d, const svuint64_t a, const svuint64_t b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NAdd (hwy::NonFloatTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NSub (hwy::NonFloatTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NAdd (hwy::FloatTag, Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NSub (hwy::FloatTag, Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NAbs (SignedTag, Vec128< T, N > a)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NAbs (hwy::FloatTag, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NMin (hwy::NonFloatTag, Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NMax (hwy::NonFloatTag, Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NMin (hwy::FloatTag, Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NMax (hwy::FloatTag, Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_API Vec128< T, NNeg (hwy::NonFloatTag, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_API Vec128< T, NNeg (hwy::FloatTag, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NMul (hwy::FloatTag, Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NMul (SignedTag, Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NMul (UnsignedTag, Vec128< T, N > a, const Vec128< T, N > b)
 
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 FromT , typename ToT , size_t N>
HWY_API Vec128< ToT, NConvertTo (hwy::FloatTag, Simd< ToT, N, 0 >, Vec128< FromT, N > from)
 
template<typename FromT , typename ToT , size_t N>
HWY_API Vec128< ToT, NConvertTo (hwy::NonFloatTag, Simd< ToT, N, 0 >, Vec128< FromT, N > 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<size_t N, int kPow2, class DF32 = Simd<float, N, kPow2>, class VF32 = VFromD<DF32>, class DU16 = RepartitionToNarrow<RebindToUnsigned<Simd<float, N, kPow2>>>>
HWY_API VF32 ReorderWidenMulAccumulateBF16 (Simd< float, N, kPow2 > df32, VFromD< DU16 > a, VFromD< DU16 > b, const VF32 sum0, VF32 &sum1)
 
template<size_t N, int kPow2, hwy::EnableIf<(kPow2< 3)> * = nullptr, class D32 = Simd<int32_t, N, kPow2>, class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > ReorderWidenMulAccumulateI16 (Simd< int32_t, N, kPow2 > d32, VFromD< D16 > a, VFromD< D16 > b, const V32 sum0, V32 &sum1)
 
template<size_t N, class D32 = Simd<int32_t, N, 3>, class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > ReorderWidenMulAccumulateI16 (Simd< int32_t, N, 3 > d32, VFromD< D16 > a, VFromD< D16 > b, const V32 sum0, V32 &sum1)
 
static float Abs (float f)
 
static double Abs (double f)
 
static bool SignBit (float f)
 
static bool SignBit (double f)
 
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, 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<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 , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > Shuffle2301 (Vec256< T > a, const Vec256< T > b)
 
template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > Shuffle1230 (Vec256< T > a, const Vec256< T > b)
 
template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > Shuffle3012 (Vec256< T > a, const Vec256< T > b)
 
HWY_API Vec128< uint16_t > PromoteUpperTo (Full128< uint16_t >, const Vec128< uint8_t > v)
 
HWY_API Vec128< uint32_t > PromoteUpperTo (Full128< uint32_t >, const Vec128< uint8_t > v)
 
HWY_API Vec128< int16_t > PromoteUpperTo (Full128< int16_t >, const Vec128< uint8_t > v)
 
HWY_API Vec128< int32_t > PromoteUpperTo (Full128< int32_t >, const Vec128< uint8_t > v)
 
HWY_API Vec128< uint32_t > PromoteUpperTo (Full128< uint32_t >, const Vec128< uint16_t > v)
 
HWY_API Vec128< uint64_t > PromoteUpperTo (Full128< uint64_t >, const Vec128< uint32_t > v)
 
HWY_API Vec128< int32_t > PromoteUpperTo (Full128< int32_t >, const Vec128< uint16_t > v)
 
HWY_API Vec128< int16_t > PromoteUpperTo (Full128< int16_t >, const Vec128< int8_t > v)
 
HWY_API Vec128< int32_t > PromoteUpperTo (Full128< int32_t >, const Vec128< int8_t > v)
 
HWY_API Vec128< int32_t > PromoteUpperTo (Full128< int32_t >, const Vec128< int16_t > v)
 
HWY_API Vec128< int64_t > PromoteUpperTo (Full128< int64_t >, const Vec128< int32_t > v)
 
HWY_API Vec128< double > PromoteUpperTo (Full128< double > dd, const Vec128< int32_t > v)
 
HWY_API Vec128< float > PromoteUpperTo (Full128< float > df32, const Vec128< float16_t > v)
 
HWY_API Vec128< float > PromoteUpperTo (Full128< float > df32, const Vec128< bfloat16_t > v)
 
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 __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, NNeg (hwy::FloatTag, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, NNeg (hwy::NonFloatTag, const Vec128< T, N > v)
 
template<typename T >
HWY_INLINE void MaybeUnpoison (T *HWY_RESTRICT unaligned, size_t count)
 
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 , size_t N>
HWY_INLINE Mask128< T, NExclusiveNeither (hwy::SizeTag< 1 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NExclusiveNeither (hwy::SizeTag< 2 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NExclusiveNeither (hwy::SizeTag< 4 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, NExclusiveNeither (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<typename T >
HWY_INLINE Vec128< T > ZeroExtendVector (hwy::NonFloatTag, Full128< T >, Vec64< T > lo)
 
template<typename T >
HWY_INLINE Vec128< T > ZeroExtendVector (hwy::FloatTag, Full128< T > d, Vec64< T > lo)
 
template<size_t N>
HWY_API Vec128< uint16_t, NShl (hwy::UnsignedTag, Vec128< uint16_t, N > v, Vec128< uint16_t, N > bits)
 
HWY_API Vec128< uint16_t, 1 > Shl (hwy::UnsignedTag, Vec128< uint16_t, 1 > v, Vec128< uint16_t, 1 > bits)
 
template<size_t N>
HWY_API Vec128< uint32_t, NShl (hwy::UnsignedTag, Vec128< uint32_t, N > v, Vec128< uint32_t, N > bits)
 
HWY_API Vec128< uint32_t, 1 > Shl (hwy::UnsignedTag, Vec128< uint32_t, 1 > v, const Vec128< uint32_t, 1 > bits)
 
HWY_API Vec128< uint64_t > Shl (hwy::UnsignedTag, Vec128< uint64_t > v, Vec128< uint64_t > bits)
 
HWY_API Vec64< uint64_t > Shl (hwy::UnsignedTag, Vec64< uint64_t > v, Vec64< uint64_t > bits)
 
template<typename T , size_t N>
HWY_API Vec128< T, NShl (hwy::SignedTag, Vec128< T, N > v, Vec128< T, N > bits)
 
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_INLINE Mask128< T, NUseInt (const Vec128< T, N > v)
 
HWY_API Vec64< uint8_t > SumOfLanes (hwy::SizeTag< 1 >, Vec64< uint8_t > v)
 
HWY_API Vec128< uint8_t > SumOfLanes (hwy::SizeTag< 1 >, Vec128< uint8_t > v)
 
template<size_t N, HWY_IF_GE64(int8_t, N) >
HWY_API Vec128< int8_t, NSumOfLanes (hwy::SizeTag< 1 >, const Vec128< int8_t, N > v)
 
HWY_API Vec128< uint16_t > MinOfLanes (hwy::SizeTag< 2 >, Vec128< uint16_t > v)
 
HWY_API Vec64< uint8_t > MinOfLanes (hwy::SizeTag< 1 >, Vec64< uint8_t > v)
 
HWY_API Vec128< uint8_t > MinOfLanes (hwy::SizeTag< 1 > tag, Vec128< uint8_t > v)
 
HWY_API Vec128< uint16_t > MaxOfLanes (hwy::SizeTag< 2 > tag, Vec128< uint16_t > v)
 
HWY_API Vec64< uint8_t > MaxOfLanes (hwy::SizeTag< 1 > tag, Vec64< uint8_t > v)
 
HWY_API Vec128< uint8_t > MaxOfLanes (hwy::SizeTag< 1 > tag, Vec128< uint8_t > v)
 
template<size_t N, HWY_IF_GE64(int8_t, N) >
HWY_API Vec128< int8_t, NMinOfLanes (hwy::SizeTag< 1 > tag, const Vec128< int8_t, N > v)
 
template<size_t N, HWY_IF_GE64(int8_t, N) >
HWY_API Vec128< int8_t, NMaxOfLanes (hwy::SizeTag< 1 > tag, const Vec128< int8_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_INLINEEq128Vec (const D d, const V a, const V b)
 
template<class D , class V = VFromD<D>>
HWY_INLINENe128Vec (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)
 
template<class D , class V = VFromD<D>>
HWY_INLINEEq128UpperVec (const D d, const V a, const V b)
 
template<class D , class V = VFromD<D>>
HWY_INLINENe128UpperVec (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 > ExclusiveNeither (hwy::SizeTag< 1 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > ExclusiveNeither (hwy::SizeTag< 2 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > ExclusiveNeither (hwy::SizeTag< 4 >, const Mask256< T > a, const Mask256< T > b)
 
template<typename T >
HWY_INLINE Mask256< T > ExclusiveNeither (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 Vec256< T > Neg (hwy::FloatTag, const Vec256< T > v)
 
template<typename T >
HWY_INLINE Vec256< T > Neg (hwy::NonFloatTag, 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)
 
HWY_API Vec256< uint8_t > InterleaveUpper (const Vec256< uint8_t > a, const Vec256< uint8_t > b)
 
HWY_API Vec256< uint16_t > InterleaveUpper (const Vec256< uint16_t > a, const Vec256< uint16_t > b)
 
HWY_API Vec256< uint32_t > InterleaveUpper (const Vec256< uint32_t > a, const Vec256< uint32_t > b)
 
HWY_API Vec256< uint64_t > InterleaveUpper (const Vec256< uint64_t > a, const Vec256< uint64_t > b)
 
HWY_API Vec256< int8_t > InterleaveUpper (const Vec256< int8_t > a, const Vec256< int8_t > b)
 
HWY_API Vec256< int16_t > InterleaveUpper (const Vec256< int16_t > a, const Vec256< int16_t > b)
 
HWY_API Vec256< int32_t > InterleaveUpper (const Vec256< int32_t > a, const Vec256< int32_t > b)
 
HWY_API Vec256< int64_t > InterleaveUpper (const Vec256< int64_t > a, const Vec256< int64_t > b)
 
HWY_API Vec256< float > InterleaveUpper (const Vec256< float > a, const Vec256< float > b)
 
HWY_API Vec256< double > InterleaveUpper (const Vec256< double > a, const Vec256< double > 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)
 
HWY_INLINE Vec256< uint16_t > Shl (hwy::UnsignedTag, Vec256< uint16_t > v, Vec256< uint16_t > bits)
 
HWY_INLINE Vec256< uint32_t > Shl (hwy::UnsignedTag, Vec256< uint32_t > v, Vec256< uint32_t > bits)
 
HWY_INLINE Vec256< uint64_t > Shl (hwy::UnsignedTag, Vec256< uint64_t > v, Vec256< uint64_t > bits)
 
template<typename T >
HWY_INLINE Vec256< T > Shl (hwy::SignedTag, Vec256< T > v, Vec256< T > bits)
 
template<uint32_t LO, uint32_t HI, typename T >
HWY_INLINE Vec128< uint32_t > LookupAndConcatHalves (Vec256< T > v)
 
template<uint16_t LO, uint16_t HI, typename T >
HWY_INLINE Vec128< uint32_t, 2 > LookupAndConcatQuarters (Vec256< T > v)
 
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_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)
 
HWY_API Vec256< uint16_t > SumOfLanes (hwy::SizeTag< 2 >, Vec256< uint16_t > v)
 
HWY_API Vec256< int16_t > SumOfLanes (hwy::SizeTag< 2 >, Vec256< int16_t > v)
 
HWY_API Vec256< uint16_t > MinOfLanes (hwy::SizeTag< 2 >, Vec256< uint16_t > v)
 
HWY_API Vec256< int16_t > MinOfLanes (hwy::SizeTag< 2 >, Vec256< int16_t > v)
 
HWY_API Vec256< uint16_t > MaxOfLanes (hwy::SizeTag< 2 >, Vec256< uint16_t > v)
 
HWY_API Vec256< int16_t > MaxOfLanes (hwy::SizeTag< 2 >, Vec256< int16_t > v)
 
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 Mask512< T > ExclusiveNeither (hwy::SizeTag< 1 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > ExclusiveNeither (hwy::SizeTag< 2 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > ExclusiveNeither (hwy::SizeTag< 4 >, const Mask512< T > a, const Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > ExclusiveNeither (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<size_t N>
HWY_INLINE Vec128< uint8_t, NNativeCompress (const Vec128< uint8_t, N > v, const Mask128< uint8_t, N > mask)
 
HWY_INLINE Vec256< uint8_t > NativeCompress (const Vec256< uint8_t > v, const Mask256< uint8_t > mask)
 
HWY_INLINE Vec512< uint8_t > NativeCompress (const Vec512< uint8_t > v, const Mask512< uint8_t > mask)
 
template<size_t N>
HWY_INLINE Vec128< uint16_t, NNativeCompress (const Vec128< uint16_t, N > v, const Mask128< uint16_t, N > mask)
 
HWY_INLINE Vec256< uint16_t > NativeCompress (const Vec256< uint16_t > v, const Mask256< uint16_t > mask)
 
HWY_INLINE Vec512< uint16_t > NativeCompress (const Vec512< uint16_t > v, const Mask512< uint16_t > mask)
 
template<size_t N>
HWY_INLINE void NativeCompressStore (Vec128< uint8_t, N > v, Mask128< uint8_t, N > mask, Simd< uint8_t, N, 0 >, uint8_t *HWY_RESTRICT unaligned)
 
HWY_INLINE void NativeCompressStore (Vec256< uint8_t > v, Mask256< uint8_t > mask, Full256< uint8_t >, uint8_t *HWY_RESTRICT unaligned)
 
HWY_INLINE void NativeCompressStore (Vec512< uint8_t > v, Mask512< uint8_t > mask, Full512< uint8_t >, uint8_t *HWY_RESTRICT unaligned)
 
template<size_t N>
HWY_INLINE void NativeCompressStore (Vec128< uint16_t, N > v, Mask128< uint16_t, N > mask, Simd< uint16_t, N, 0 >, uint16_t *HWY_RESTRICT unaligned)
 
HWY_INLINE void NativeCompressStore (Vec256< uint16_t > v, Mask256< uint16_t > mask, Full256< uint16_t >, uint16_t *HWY_RESTRICT unaligned)
 
HWY_INLINE void NativeCompressStore (Vec512< uint16_t > v, Mask512< uint16_t > mask, Full512< uint16_t >, uint16_t *HWY_RESTRICT unaligned)
 
template<size_t N>
HWY_INLINE Vec128< uint32_t, NNativeCompress (const Vec128< uint32_t, N > v, const Mask128< uint32_t, N > mask)
 
HWY_INLINE Vec256< uint32_t > NativeCompress (Vec256< uint32_t > v, Mask256< uint32_t > mask)
 
HWY_INLINE Vec512< uint32_t > NativeCompress (Vec512< uint32_t > v, Mask512< uint32_t > mask)
 
template<size_t N>
HWY_INLINE void NativeCompressStore (Vec128< uint32_t, N > v, Mask128< uint32_t, N > mask, Simd< uint32_t, N, 0 >, uint32_t *HWY_RESTRICT unaligned)
 
HWY_INLINE void NativeCompressStore (Vec256< uint32_t > v, Mask256< uint32_t > mask, Full256< uint32_t >, uint32_t *HWY_RESTRICT unaligned)
 
HWY_INLINE void NativeCompressStore (Vec512< uint32_t > v, Mask512< uint32_t > mask, Full512< uint32_t >, uint32_t *HWY_RESTRICT unaligned)
 
template<size_t N>
HWY_INLINE void NativeCompressStore (Vec128< uint64_t, N > v, Mask128< uint64_t, N > mask, Simd< uint64_t, N, 0 >, uint64_t *HWY_RESTRICT unaligned)
 
HWY_INLINE void NativeCompressStore (Vec256< uint64_t > v, Mask256< uint64_t > mask, Full256< uint64_t >, uint64_t *HWY_RESTRICT unaligned)
 
HWY_INLINE void NativeCompressStore (Vec512< uint64_t > v, Mask512< uint64_t > mask, Full512< uint64_t >, uint64_t *HWY_RESTRICT unaligned)
 
template<size_t N>
HWY_INLINE Vec128< uint8_t, NEmuCompress (Vec128< uint8_t, N > v, Mask128< uint8_t, N > mask)
 
template<size_t N>
HWY_INLINE Vec128< uint16_t, NEmuCompress (Vec128< uint16_t, N > v, Mask128< uint16_t, N > mask)
 
HWY_INLINE Vec256< uint16_t > EmuCompress (Vec256< uint16_t > v, Mask256< uint16_t > mask)
 
template<typename T , size_t N>
HWY_INLINE void EmuCompressStore (Vec128< T, N > v, Mask128< T, N > mask, Simd< T, N, 0 > d, T *HWY_RESTRICT unaligned)
 
HWY_INLINE void EmuCompressStore (Vec256< uint16_t > v, Mask256< uint16_t > mask, Full256< uint16_t > d, uint16_t *HWY_RESTRICT unaligned)
 
HWY_INLINE void EmuCompressStore (Vec256< uint8_t > v, Mask256< uint8_t > mask, Full256< uint8_t > d, uint8_t *HWY_RESTRICT unaligned)
 
HWY_INLINE void EmuCompressStore (Vec512< uint8_t > v, Mask512< uint8_t > mask, Full512< uint8_t > d, uint8_t *HWY_RESTRICT unaligned)
 
HWY_INLINE void EmuCompressStore (Vec512< uint16_t > v, Mask512< uint16_t > mask, Full512< uint16_t > d, uint16_t *HWY_RESTRICT unaligned)
 
template<typename T >
HWY_INLINE Vec512< T > EmuCompress (Vec512< T > v, Mask512< T > mask)
 
HWY_INLINE Vec256< uint8_t > EmuCompress (Vec256< uint8_t > v, const Mask256< uint8_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)
 

Typedef Documentation

◆ Constants

Function Documentation

◆ Abs() [1/4]

static double hwy::HWY_NAMESPACE::detail::Abs ( double  f)
inlinestatic

◆ Abs() [2/4]

static float hwy::HWY_NAMESPACE::detail::Abs ( float  f)
inlinestatic

◆ Abs() [3/4]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::Abs ( hwy::FloatTag  ,
Vec128< T, N v 
)

◆ Abs() [4/4]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::Abs ( SignedTag  ,
Vec128< T, N a 
)

◆ Add() [1/2]

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

◆ Add() [2/2]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::Add ( hwy::NonFloatTag  ,
Vec128< T, N a,
Vec128< T, N b 
)

◆ 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 
)

◆ BitCastFromByte() [2/24]

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

◆ BitCastFromByte() [3/24]

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

◆ BitCastFromByte() [4/24]

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

◆ BitCastFromByte() [5/24]

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

◆ BitCastFromByte() [6/24]

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

◆ BitCastFromByte() [7/24]

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

◆ BitCastFromByte() [8/24]

HWY_INLINE Vec128< uint64_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full128< uint64_t >  ,
Vec128< uint8_t >  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 
)

◆ BitCastFromByte() [12/24]

HWY_INLINE Vec64< uint64_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( Full64< uint64_t >  ,
Vec128< uint8_t, 1 *8 >  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 
)

◆ 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 
)

◆ 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 
)

◆ 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 
)

◆ 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 
)

◆ 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 
)

◆ 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 
)

◆ 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)

◆ BitCastToInteger() [2/12]

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

◆ BitCastToInteger() [3/12]

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

◆ BitCastToInteger() [4/12]

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

◆ BitCastToInteger() [5/12]

HWY_INLINE __m128i hwy::HWY_NAMESPACE::detail::BitCastToInteger ( __m128i  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)

◆ 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/13]

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

References BitsFromMask().

◆ BitsFromMask() [2/13]

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

◆ BitsFromMask() [3/13]

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

◆ BitsFromMask() [4/13]

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() [5/13]

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

◆ BitsFromMask() [6/13]

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() [7/13]

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

◆ BitsFromMask() [8/13]

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

◆ BitsFromMask() [9/13]

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() [10/13]

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

◆ BitsFromMask() [11/13]

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

◆ BitsFromMask() [12/13]

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

◆ BitsFromMask() [13/13]

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()

template<size_t N>
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()

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 
)

◆ ConvertTo() [1/2]

template<typename FromT , typename ToT , size_t N>
HWY_API Vec128< ToT, N > hwy::HWY_NAMESPACE::detail::ConvertTo ( hwy::FloatTag  ,
Simd< ToT, N, 0 >  ,
Vec128< FromT, N from 
)

◆ ConvertTo() [2/2]

template<typename FromT , typename ToT , size_t N>
HWY_API Vec128< ToT, N > hwy::HWY_NAMESPACE::detail::ConvertTo ( hwy::NonFloatTag  ,
Simd< ToT, N, 0 >  ,
Vec128< FromT, N from 
)

◆ 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 
)

◆ EmuCompress() [1/5]

template<size_t N>
HWY_INLINE Vec128< uint16_t, N > hwy::HWY_NAMESPACE::detail::EmuCompress ( Vec128< uint16_t, N v,
Mask128< uint16_t, N mask 
)

◆ EmuCompress() [2/5]

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

◆ EmuCompress() [3/5]

HWY_INLINE Vec256< uint16_t > hwy::HWY_NAMESPACE::detail::EmuCompress ( Vec256< uint16_t >  v,
Mask256< uint16_t >  mask 
)

◆ EmuCompress() [4/5]

HWY_INLINE Vec256< uint8_t > hwy::HWY_NAMESPACE::detail::EmuCompress ( Vec256< uint8_t >  v,
const Mask256< uint8_t >  mask 
)

◆ EmuCompress() [5/5]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::EmuCompress ( Vec512< T >  v,
Mask512< T >  mask 
)

◆ EmuCompressStore() [1/5]

template<typename T , size_t N>
HWY_INLINE void hwy::HWY_NAMESPACE::detail::EmuCompressStore ( Vec128< T, N v,
Mask128< T, N mask,
Simd< T, N, 0 >  d,
T *HWY_RESTRICT  unaligned 
)

◆ EmuCompressStore() [2/5]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::EmuCompressStore ( Vec256< uint16_t >  v,
Mask256< uint16_t >  mask,
Full256< uint16_t >  d,
uint16_t *HWY_RESTRICT  unaligned 
)

◆ EmuCompressStore() [3/5]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::EmuCompressStore ( Vec256< uint8_t >  v,
Mask256< uint8_t >  mask,
Full256< uint8_t >  d,
uint8_t *HWY_RESTRICT  unaligned 
)

◆ EmuCompressStore() [4/5]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::EmuCompressStore ( Vec512< uint16_t >  v,
Mask512< uint16_t >  mask,
Full512< uint16_t >  d,
uint16_t *HWY_RESTRICT  unaligned 
)

◆ EmuCompressStore() [5/5]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::EmuCompressStore ( Vec512< uint8_t >  v,
Mask512< uint8_t >  mask,
Full512< uint8_t >  d,
uint8_t *HWY_RESTRICT  unaligned 
)

◆ Eq128UpperVec()

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

◆ Eq128Vec() [1/2]

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

◆ Eq128Vec() [2/2]

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

◆ ExclusiveNeither() [1/12]

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

◆ ExclusiveNeither() [2/12]

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

◆ ExclusiveNeither() [3/12]

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

◆ ExclusiveNeither() [4/12]

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

◆ ExclusiveNeither() [5/12]

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

◆ ExclusiveNeither() [6/12]

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

◆ ExclusiveNeither() [7/12]

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

◆ ExclusiveNeither() [8/12]

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

◆ ExclusiveNeither() [9/12]

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

◆ ExclusiveNeither() [10/12]

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

◆ ExclusiveNeither() [11/12]

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

◆ ExclusiveNeither() [12/12]

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

◆ 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   
)

◆ 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 
)

◆ 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 Vec256< float > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( const Vec256< float >  a,
const Vec256< float >  b 
)

◆ InterleaveUpper() [11/41]

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

◆ InterleaveUpper() [12/41]

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

◆ InterleaveUpper() [13/41]

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

◆ InterleaveUpper() [14/41]

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

◆ InterleaveUpper() [15/41]

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

◆ InterleaveUpper() [16/41]

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

◆ InterleaveUpper() [17/41]

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

◆ InterleaveUpper() [18/41]

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

◆ InterleaveUpper() [19/41]

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

◆ InterleaveUpper() [20/41]

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

◆ InterleaveUpper() [21/41]

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

◆ InterleaveUpper() [22/41]

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

◆ InterleaveUpper() [23/41]

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

◆ InterleaveUpper() [24/41]

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

◆ InterleaveUpper() [25/41]

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

◆ InterleaveUpper() [26/41]

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

◆ InterleaveUpper() [27/41]

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

◆ InterleaveUpper() [28/41]

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

◆ InterleaveUpper() [29/41]

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

◆ InterleaveUpper() [30/41]

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

◆ InterleaveUpper() [31/41]

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

◆ InterleaveUpper() [32/41]

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

◆ InterleaveUpper() [33/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() [34/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() [35/41]

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

◆ InterleaveUpper() [36/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() [37/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() [38/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() [39/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() [40/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() [41/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 
)

◆ 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 
)

◆ 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()

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 
)

◆ LookupAndConcatHalves()

template<uint32_t LO, uint32_t HI, typename T >
HWY_INLINE Vec128< uint32_t > hwy::HWY_NAMESPACE::detail::LookupAndConcatHalves ( Vec256< T >  v)

◆ LookupAndConcatQuarters()

template<uint16_t LO, uint16_t HI, typename T >
HWY_INLINE Vec128< uint32_t, 2 > hwy::HWY_NAMESPACE::detail::LookupAndConcatQuarters ( Vec256< T >  v)

◆ 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 >
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)

◆ Max() [1/2]

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

◆ Max() [2/2]

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

◆ MaxOfLanes() [1/15]

template<size_t N, HWY_IF_GE64(int8_t, N) >
HWY_API Vec128< int8_t, N > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 1 >  tag,
const Vec128< int8_t, N v 
)

◆ MaxOfLanes() [2/15]

HWY_API Vec128< uint8_t > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 1 >  tag,
Vec128< uint8_t >  v 
)

◆ MaxOfLanes() [3/15]

HWY_API Vec64< uint8_t > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 1 >  tag,
Vec64< uint8_t >  v 
)

◆ MaxOfLanes() [4/15]

HWY_API Vec128< uint16_t > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 2 >  tag,
Vec128< uint16_t >  v 
)

◆ MaxOfLanes() [5/15]

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

◆ MaxOfLanes() [6/15]

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

◆ MaxOfLanes() [7/15]

HWY_API Vec256< int16_t > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 2 >  ,
Vec256< int16_t >  v 
)

◆ MaxOfLanes() [8/15]

HWY_API Vec256< uint16_t > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< 2 >  ,
Vec256< uint16_t >  v 
)

◆ MaxOfLanes() [9/15]

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

◆ MaxOfLanes() [10/15]

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

◆ MaxOfLanes() [11/15]

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

◆ MaxOfLanes() [12/15]

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

◆ MaxOfLanes() [13/15]

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

◆ MaxOfLanes() [14/15]

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

◆ MaxOfLanes() [15/15]

template<typename T , HWY_IF_MINMAX_REDUCTION(T) >
HWY_API Vec128< T, 2 > hwy::HWY_NAMESPACE::detail::MaxOfLanes ( hwy::SizeTag< sizeof(T)>  ,
const Vec128< T, 2 >  v10 
)

◆ 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 
)

◆ MaybePrintVector()

template<class D >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::MaybePrintVector ( d,
const char *  label,
Vec< D >  v,
size_t  start = 0,
size_t  max_lanes = 16 
)

◆ MaybeUnpoison()

template<typename T >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::MaybeUnpoison ( T *HWY_RESTRICT  unaligned,
size_t  count 
)

◆ Min() [1/2]

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

◆ Min() [2/2]

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

◆ MinOfLanes() [1/15]

template<size_t N, HWY_IF_GE64(int8_t, N) >
HWY_API Vec128< int8_t, N > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 1 >  tag,
const Vec128< int8_t, N v 
)

◆ MinOfLanes() [2/15]

HWY_API Vec128< uint8_t > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 1 >  tag,
Vec128< uint8_t >  v 
)

◆ MinOfLanes() [3/15]

HWY_API Vec64< uint8_t > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 1 >  ,
Vec64< uint8_t >  v 
)

◆ MinOfLanes() [4/15]

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

◆ MinOfLanes() [5/15]

HWY_API Vec128< uint16_t > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 2 >  ,
Vec128< uint16_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ MinOfLanes() [6/15]

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

◆ MinOfLanes() [7/15]

HWY_API Vec256< int16_t > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 2 >  ,
Vec256< int16_t >  v 
)

◆ MinOfLanes() [8/15]

HWY_API Vec256< uint16_t > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< 2 >  ,
Vec256< uint16_t >  v 
)

◆ MinOfLanes() [9/15]

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

◆ MinOfLanes() [10/15]

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

◆ MinOfLanes() [11/15]

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

◆ MinOfLanes() [12/15]

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

◆ MinOfLanes() [13/15]

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

◆ MinOfLanes() [14/15]

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

◆ MinOfLanes() [15/15]

template<typename T , HWY_IF_MINMAX_REDUCTION(T) >
HWY_API Vec128< T, 2 > hwy::HWY_NAMESPACE::detail::MinOfLanes ( hwy::SizeTag< sizeof(T)>  ,
const Vec128< T, 2 >  v10 
)

◆ 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 
)

◆ Mul() [1/3]

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

◆ Mul() [2/3]

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

◆ Mul() [3/3]

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

◆ NativeCompress() [1/9]

template<size_t N>
HWY_INLINE Vec128< uint16_t, N > hwy::HWY_NAMESPACE::detail::NativeCompress ( const Vec128< uint16_t, N v,
const Mask128< uint16_t, N mask 
)

◆ NativeCompress() [2/9]

template<size_t N>
HWY_INLINE Vec128< uint32_t, N > hwy::HWY_NAMESPACE::detail::NativeCompress ( const Vec128< uint32_t, N v,
const Mask128< uint32_t, N mask 
)

◆ NativeCompress() [3/9]

template<size_t N>
HWY_INLINE Vec128< uint8_t, N > hwy::HWY_NAMESPACE::detail::NativeCompress ( const Vec128< uint8_t, N v,
const Mask128< uint8_t, N mask 
)

◆ NativeCompress() [4/9]

HWY_INLINE Vec256< uint16_t > hwy::HWY_NAMESPACE::detail::NativeCompress ( const Vec256< uint16_t >  v,
const Mask256< uint16_t >  mask 
)

◆ NativeCompress() [5/9]

HWY_INLINE Vec256< uint8_t > hwy::HWY_NAMESPACE::detail::NativeCompress ( const Vec256< uint8_t >  v,
const Mask256< uint8_t >  mask 
)

◆ NativeCompress() [6/9]

HWY_INLINE Vec512< uint16_t > hwy::HWY_NAMESPACE::detail::NativeCompress ( const Vec512< uint16_t >  v,
const Mask512< uint16_t >  mask 
)

◆ NativeCompress() [7/9]

HWY_INLINE Vec512< uint8_t > hwy::HWY_NAMESPACE::detail::NativeCompress ( const Vec512< uint8_t >  v,
const Mask512< uint8_t >  mask 
)

◆ NativeCompress() [8/9]

HWY_INLINE Vec256< uint32_t > hwy::HWY_NAMESPACE::detail::NativeCompress ( Vec256< uint32_t >  v,
Mask256< uint32_t >  mask 
)

◆ NativeCompress() [9/9]

HWY_INLINE Vec512< uint32_t > hwy::HWY_NAMESPACE::detail::NativeCompress ( Vec512< uint32_t >  v,
Mask512< uint32_t >  mask 
)

◆ NativeCompressStore() [1/12]

template<size_t N>
HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec128< uint16_t, N v,
Mask128< uint16_t, N mask,
Simd< uint16_t, N, 0 >  ,
uint16_t *HWY_RESTRICT  unaligned 
)

◆ NativeCompressStore() [2/12]

template<size_t N>
HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec128< uint32_t, N v,
Mask128< uint32_t, N mask,
Simd< uint32_t, N, 0 >  ,
uint32_t *HWY_RESTRICT  unaligned 
)

◆ NativeCompressStore() [3/12]

template<size_t N>
HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec128< uint64_t, N v,
Mask128< uint64_t, N mask,
Simd< uint64_t, N, 0 >  ,
uint64_t *HWY_RESTRICT  unaligned 
)

◆ NativeCompressStore() [4/12]

template<size_t N>
HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec128< uint8_t, N v,
Mask128< uint8_t, N mask,
Simd< uint8_t, N, 0 >  ,
uint8_t *HWY_RESTRICT  unaligned 
)

◆ NativeCompressStore() [5/12]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec256< uint16_t >  v,
Mask256< uint16_t >  mask,
Full256< uint16_t >  ,
uint16_t *HWY_RESTRICT  unaligned 
)

◆ NativeCompressStore() [6/12]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec256< uint32_t >  v,
Mask256< uint32_t >  mask,
Full256< uint32_t >  ,
uint32_t *HWY_RESTRICT  unaligned 
)

◆ NativeCompressStore() [7/12]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec256< uint64_t >  v,
Mask256< uint64_t >  mask,
Full256< uint64_t >  ,
uint64_t *HWY_RESTRICT  unaligned 
)

◆ NativeCompressStore() [8/12]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec256< uint8_t >  v,
Mask256< uint8_t >  mask,
Full256< uint8_t >  ,
uint8_t *HWY_RESTRICT  unaligned 
)

◆ NativeCompressStore() [9/12]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec512< uint16_t >  v,
Mask512< uint16_t >  mask,
Full512< uint16_t >  ,
uint16_t *HWY_RESTRICT  unaligned 
)

◆ NativeCompressStore() [10/12]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec512< uint32_t >  v,
Mask512< uint32_t >  mask,
Full512< uint32_t >  ,
uint32_t *HWY_RESTRICT  unaligned 
)

◆ NativeCompressStore() [11/12]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec512< uint64_t >  v,
Mask512< uint64_t >  mask,
Full512< uint64_t >  ,
uint64_t *HWY_RESTRICT  unaligned 
)

◆ NativeCompressStore() [12/12]

HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeCompressStore ( Vec512< uint8_t >  v,
Mask512< uint8_t >  mask,
Full512< uint8_t >  ,
uint8_t *HWY_RESTRICT  unaligned 
)

◆ Ne128UpperVec()

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

◆ Ne128Vec() [1/2]

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

◆ Ne128Vec() [2/2]

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

◆ Neg() [1/6]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::Neg ( hwy::FloatTag  ,
const Vec128< T, N v 
)

◆ Neg() [2/6]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::Neg ( hwy::FloatTag  ,
const Vec256< T >  v 
)

◆ Neg() [3/6]

template<typename T , size_t N>
HWY_API Vec128< T, N > hwy::HWY_NAMESPACE::detail::Neg ( hwy::FloatTag  ,
Vec128< T, N v 
)

◆ Neg() [4/6]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::Neg ( hwy::NonFloatTag  ,
const Vec128< T, N v 
)

◆ Neg() [5/6]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::Neg ( hwy::NonFloatTag  ,
const Vec256< T >  v 
)

◆ Neg() [6/6]

template<typename T , size_t N>
HWY_API Vec128< T, N > hwy::HWY_NAMESPACE::detail::Neg ( hwy::NonFloatTag  ,
Vec128< T, N v 
)

◆ 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, and OnlyActive().

Referenced by OnlyActive().

◆ 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 
)

◆ PFalse()

HWY_API svbool_t hwy::HWY_NAMESPACE::detail::PFalse ( )

◆ 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() [1/15]

HWY_API Vec128< double > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< double >  dd,
const Vec128< int32_t >  v 
)

◆ PromoteUpperTo() [2/15]

HWY_API Vec128< float > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< float >  df32,
const Vec128< bfloat16_t v 
)

◆ PromoteUpperTo() [3/15]

HWY_API Vec128< float > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< float >  df32,
const Vec128< float16_t v 
)

◆ PromoteUpperTo() [4/15]

HWY_API Vec128< int16_t > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< int16_t >  ,
const Vec128< int8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo() [5/15]

HWY_API Vec128< int16_t > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< int16_t >  ,
const Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo() [6/15]

HWY_API Vec128< int32_t > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< int32_t >  ,
const Vec128< int16_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo() [7/15]

HWY_API Vec128< int32_t > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< int32_t >  ,
const Vec128< int8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo() [8/15]

HWY_API Vec128< int32_t > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< int32_t >  ,
const Vec128< uint16_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo() [9/15]

HWY_API Vec128< int32_t > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< int32_t >  ,
const Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo() [10/15]

HWY_API Vec128< int64_t > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< int64_t >  ,
const Vec128< int32_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo() [11/15]

HWY_API Vec128< uint16_t > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< uint16_t >  ,
const Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo() [12/15]

HWY_API Vec128< uint32_t > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< uint32_t >  ,
const Vec128< uint16_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo() [13/15]

HWY_API Vec128< uint32_t > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< uint32_t >  ,
const Vec128< uint8_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo() [14/15]

HWY_API Vec128< uint64_t > hwy::HWY_NAMESPACE::detail::PromoteUpperTo ( Full128< uint64_t >  ,
const Vec128< uint32_t >  v 
)

References hwy::HWY_NAMESPACE::v.

◆ PromoteUpperTo() [15/15]

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 
)

◆ ReorderWidenMulAccumulateBF16()

template<size_t N, int kPow2, class DF32 = Simd<float, N, kPow2>, class VF32 = VFromD<DF32>, class DU16 = RepartitionToNarrow<RebindToUnsigned<Simd<float, N, kPow2>>>>
HWY_API VF32 hwy::HWY_NAMESPACE::detail::ReorderWidenMulAccumulateBF16 ( Simd< float, N, kPow2 >  df32,
VFromD< DU16 >  a,
VFromD< DU16 >  b,
const VF32  sum0,
VF32 &  sum1 
)

◆ ReorderWidenMulAccumulateI16() [1/2]

template<size_t N, class D32 = Simd<int32_t, N, 3>, class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > hwy::HWY_NAMESPACE::detail::ReorderWidenMulAccumulateI16 ( Simd< int32_t, N, 3 >  d32,
VFromD< D16 >  a,
VFromD< D16 >  b,
const V32  sum0,
V32 &  sum1 
)

◆ ReorderWidenMulAccumulateI16() [2/2]

template<size_t N, int kPow2, hwy::EnableIf<(kPow2< 3)> * = nullptr, class D32 = Simd<int32_t, N, kPow2>, class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > hwy::HWY_NAMESPACE::detail::ReorderWidenMulAccumulateI16 ( Simd< int32_t, N, kPow2 >  d32,
VFromD< D16 >  a,
VFromD< D16 >  b,
const V32  sum0,
V32 &  sum1 
)

◆ 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 
)

References hwy::HWY_NAMESPACE::v.

◆ 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 
)

References hwy::HWY_NAMESPACE::v.

◆ 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(), and Set64().

Referenced by LoadMaskBits(), Set64(), and Set64().

◆ Shl() [1/11]

template<typename T , size_t N>
HWY_API Vec128< T, N > hwy::HWY_NAMESPACE::detail::Shl ( hwy::SignedTag  ,
Vec128< T, N v,
Vec128< T, N bits 
)

◆ Shl() [2/11]

template<typename T >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::Shl ( hwy::SignedTag  ,
Vec256< T >  v,
Vec256< T >  bits 
)

◆ Shl() [3/11]

HWY_API Vec128< uint16_t, 1 > hwy::HWY_NAMESPACE::detail::Shl ( hwy::UnsignedTag  ,
Vec128< uint16_t, 1 >  v,
Vec128< uint16_t, 1 >  bits 
)

◆ Shl() [4/11]

template<size_t N>
HWY_API Vec128< uint16_t, N > hwy::HWY_NAMESPACE::detail::Shl ( hwy::UnsignedTag  ,
Vec128< uint16_t, N v,
Vec128< uint16_t, N bits 
)

◆ Shl() [5/11]

HWY_API Vec128< uint32_t, 1 > hwy::HWY_NAMESPACE::detail::Shl ( hwy::UnsignedTag  ,
Vec128< uint32_t, 1 >  v,
const Vec128< uint32_t, 1 >  bits 
)

◆ Shl() [6/11]

template<size_t N>
HWY_API Vec128< uint32_t, N > hwy::HWY_NAMESPACE::detail::Shl ( hwy::UnsignedTag  ,
Vec128< uint32_t, N v,
Vec128< uint32_t, N bits 
)

◆ Shl() [7/11]

HWY_API Vec128< uint64_t > hwy::HWY_NAMESPACE::detail::Shl ( hwy::UnsignedTag  ,
Vec128< uint64_t >  v,
Vec128< uint64_t >  bits 
)

◆ Shl() [8/11]

HWY_INLINE Vec256< uint16_t > hwy::HWY_NAMESPACE::detail::Shl ( hwy::UnsignedTag  ,
Vec256< uint16_t >  v,
Vec256< uint16_t >  bits 
)

◆ Shl() [9/11]

HWY_INLINE Vec256< uint32_t > hwy::HWY_NAMESPACE::detail::Shl ( hwy::UnsignedTag  ,
Vec256< uint32_t >  v,
Vec256< uint32_t >  bits 
)

◆ Shl() [10/11]

HWY_INLINE Vec256< uint64_t > hwy::HWY_NAMESPACE::detail::Shl ( hwy::UnsignedTag  ,
Vec256< uint64_t >  v,
Vec256< uint64_t >  bits 
)

◆ Shl() [11/11]

HWY_API Vec64< uint64_t > hwy::HWY_NAMESPACE::detail::Shl ( hwy::UnsignedTag  ,
Vec64< uint64_t >  v,
Vec64< uint64_t >  bits 
)

◆ ShrBytes()

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.

◆ 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 Vec512< T > hwy::HWY_NAMESPACE::detail::Shuffle1230 ( const Vec512< T >  a,
const Vec512< T >  b 
)

◆ Shuffle1230() [4/4]

template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > hwy::HWY_NAMESPACE::detail::Shuffle1230 ( Vec256< T >  a,
const Vec256< 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 Vec512< T > hwy::HWY_NAMESPACE::detail::Shuffle2301 ( const Vec512< T >  a,
const Vec512< T >  b 
)

◆ Shuffle2301() [4/4]

template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > hwy::HWY_NAMESPACE::detail::Shuffle2301 ( Vec256< T >  a,
const Vec256< 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 Vec512< T > hwy::HWY_NAMESPACE::detail::Shuffle3012 ( const Vec512< T >  a,
const Vec512< T >  b 
)

◆ Shuffle3012() [4/4]

template<typename T , HWY_IF_LANE_SIZE(T, 4) >
HWY_API Vec256< T > hwy::HWY_NAMESPACE::detail::Shuffle3012 ( Vec256< T >  a,
const Vec256< 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().

◆ SignBit() [1/2]

static bool hwy::HWY_NAMESPACE::detail::SignBit ( double  f)
inlinestatic

◆ SignBit() [2/2]

static bool hwy::HWY_NAMESPACE::detail::SignBit ( float  f)
inlinestatic

◆ 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 
)

References hwy::CopySameSize().

◆ Sub() [1/2]

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

◆ Sub() [2/2]

template<typename T , size_t N>
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::Sub ( hwy::NonFloatTag  ,
Vec128< T, N a,
Vec128< T, N b 
)

◆ SumOfLanes() [1/20]

template<size_t N, HWY_IF_GE64(int8_t, N) >
HWY_API Vec128< int8_t, N > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 1 >  ,
const Vec128< int8_t, N v 
)

◆ SumOfLanes() [2/20]

HWY_API Vec128< uint8_t > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 1 >  ,
Vec128< uint8_t >  v 
)

◆ SumOfLanes() [3/20]

HWY_API Vec64< uint8_t > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 1 >  ,
Vec64< uint8_t >  v 
)

◆ SumOfLanes() [4/20]

template<size_t N, HWY_IF_GE32(int16_t, N) >
HWY_API Vec128< int16_t, N > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 2 >  ,
Vec128< int16_t, N v 
)

◆ SumOfLanes() [5/20]

template<size_t N, HWY_IF_GE32(uint16_t, N) >
HWY_API Vec128< uint16_t, N > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 2 >  ,
Vec128< uint16_t, N v 
)

◆ SumOfLanes() [6/20]

HWY_API Vec256< int16_t > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 2 >  ,
Vec256< int16_t >  v 
)

◆ SumOfLanes() [7/20]

HWY_API Vec256< uint16_t > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< 2 >  ,
Vec256< uint16_t >  v 
)

◆ SumOfLanes() [8/20]

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

◆ SumOfLanes() [9/20]

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

◆ SumOfLanes() [10/20]

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

◆ SumOfLanes() [11/20]

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

◆ SumOfLanes() [12/20]

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

◆ SumOfLanes() [13/20]

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

◆ SumOfLanes() [14/20]

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

◆ SumOfLanes() [15/20]

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

◆ SumOfLanes() [16/20]

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

◆ SumOfLanes() [17/20]

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

◆ SumOfLanes() [18/20]

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

◆ SumOfLanes() [19/20]

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

◆ SumOfLanes() [20/20]

template<typename T , HWY_IF_SUM_REDUCTION(T) >
HWY_API Vec128< T, 2 > hwy::HWY_NAMESPACE::detail::SumOfLanes ( hwy::SizeTag< sizeof(T)>  ,
const Vec128< T, 2 >  v10 
)

◆ 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)

References hwy::CopySameSize().

◆ UnpoisonIfMemorySanitizer()

HWY_INLINE void hwy::HWY_NAMESPACE::detail::UnpoisonIfMemorySanitizer ( void *  p,
size_t  bytes 
)

◆ 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_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 
)

◆ ZeroExtendVector() [1/2]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::ZeroExtendVector ( hwy::FloatTag  ,
Full128< T >  d,
Vec64< T >  lo 
)

◆ ZeroExtendVector() [2/2]

template<typename T >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::ZeroExtendVector ( hwy::NonFloatTag  ,
Full128< T >  ,
Vec64< T >  lo 
)