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

Classes

struct  AddFunc
 
class  AdjustSimdTagToMinVecPow2_t
 
class  AdjustSimdTagToMinVecPow2_t< Simd< T, N, kPow2 > >
 
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  ClampNAndPow2
 
struct  FixedTagChecker
 
struct  ForeachCappedR
 
struct  ForeachCappedR< T, 0, kMinArg, Test, kPow2 >
 
struct  KeyLaneBase
 
struct  MaxFunc
 
struct  MinFunc
 
struct  NativeLaneTypeT
 
struct  NativeLaneTypeT< hwy::bfloat16_t >
 
struct  NativeLaneTypeT< hwy::float16_t >
 
struct  OrderAscending
 
struct  OrderDescending
 
struct  Raw128
 
struct  Raw128< bfloat16_t >
 
struct  Raw128< bfloat16_t, N >
 
struct  Raw128< double >
 
struct  Raw128< float >
 
struct  Raw128< float, 4 >
 
struct  Raw128< float, N >
 
struct  Raw128< float16_t >
 
struct  Raw128< float16_t, N >
 
struct  Raw128< int16_t, 8 >
 
struct  Raw128< int16_t, N >
 
struct  Raw128< int32_t, 4 >
 
struct  Raw128< int32_t, N >
 
struct  Raw128< int64_t, 1 >
 
struct  Raw128< int64_t, 2 >
 
struct  Raw128< int8_t, 16 >
 
struct  Raw128< int8_t, N >
 
struct  Raw128< uint16_t, 8 >
 
struct  Raw128< uint16_t, N >
 
struct  Raw128< uint32_t, 4 >
 
struct  Raw128< uint32_t, N >
 
struct  Raw128< uint64_t, 1 >
 
struct  Raw128< uint64_t, 2 >
 
struct  Raw128< uint8_t, 16 >
 
struct  Raw128< uint8_t, N >
 
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  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, N >
 
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, N >
 
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, N >
 
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 >
 
struct  Vec64ValsWrapper
 

Typedefs

using Constants = hwy::SortConstants
 
template<class D >
using F32ExpLzcntMinMaxRepartition = RebindToUnsigned<D>
 
template<class V >
using F32ExpLzcntMinMaxCmpV = VFromD<F32ExpLzcntMinMaxRepartition<DFromV<V>>>
 
template<class D >
using RebindToUnsignedIfNotFloat
 
template<class D >
using AdjustSimdTagToMinVecPow2
 
template<typename T >
using NativeLaneType = typename NativeLaneTypeT<T>::type
 

Functions

template<class D , HWY_IF_FLOAT_OR_SPECIAL_D(D) >
Vec< D > LargestSortValue (D d)
 
template<class D , HWY_IF_FLOAT_OR_SPECIAL_D(D) >
Vec< D > SmallestSortValue (D d)
 
template<class D , HWY_IF_FLOAT_OR_SPECIAL_D(D) >
Vec< D > LargerSortValue (D d, Vec< D > v)
 
template<class D , HWY_IF_FLOAT_OR_SPECIAL_D(D) >
Vec< D > SmallerSortValue (D d, Vec< D > v)
 
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<class Traits , typename T >
void HeapSelect (Traits st, T *HWY_RESTRICT lanes, const size_t num_lanes, const size_t select)
 
template<class Traits , typename T >
void HeapPartialSort (Traits st, T *HWY_RESTRICT lanes, const size_t num_lanes, const size_t select)
 
template<class D , class Traits , typename T , HWY_IF_FLOAT(T) >
HWY_INLINE size_t CountAndReplaceNaN (D d, Traits st, T *HWY_RESTRICT keys, size_t num)
 
template<class D , class Traits , typename T , HWY_IF_NOT_FLOAT(T) >
HWY_INLINE size_t CountAndReplaceNaN (D, Traits, T *HWY_RESTRICT, size_t)
 
template<class D , HWY_NEON_IF_EMULATED_D(D) >
HWY_API Vec128< TFromD< D >, MaxLanes(D())> NativeSet (D d, TFromD< D > t)
 
template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE VFromD< D > Iota0 (D d)
 
template<size_t N>
HWY_INLINE Vec128< uint8_t, N > BitCastToByte (Vec128< uint8_t, N > v)
 
 HWY_NEON_DEF_FUNCTION_ALL_FLOATS (BitCastToByte, vreinterpret, _u8_, HWY_CAST_TO_U8) HWY_NEON_DEF_FUNCTION_BFLOAT_16(BitCastToByte
 
template<size_t N>
HWY_CAST_TO_U8 HWY_INLINE Vec128< uint8_t, N *2 > BitCastToByte (Vec128< float16_t, N > v)
 
template<size_t N>
HWY_INLINE Vec128< uint8_t, N *2 > BitCastToByte (Vec128< bfloat16_t, N > v)
 
template<class D , HWY_IF_U8_D(D) >
HWY_INLINE VFromD< D > BitCastFromByte (D, VFromD< D > v)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_I8_D(D) >
HWY_INLINE VFromD< D > BitCastFromByte (D, VFromD< RebindToUnsigned< D > > v)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_U16_D(D) >
HWY_INLINE VFromD< D > BitCastFromByte (D, VFromD< Repartition< uint8_t, D > > v)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_U64_D(D) >
HWY_INLINE Vec64< uint64_t > BitCastFromByte (D, Vec64< uint8_t > v)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_I64_D(D) >
HWY_INLINE Vec64< int64_t > BitCastFromByte (D, Vec64< uint8_t > v)
 
template<class D , HWY_IF_I8_D(D) >
HWY_INLINE Vec128< int8_t > BitCastFromByte (D, Vec128< uint8_t > v)
 
template<class D , HWY_IF_U16_D(D) >
HWY_INLINE Vec128< uint16_t > BitCastFromByte (D, Vec128< uint8_t > v)
 
template<class D , HWY_IF_I16_D(D) >
HWY_INLINE Vec128< int16_t > BitCastFromByte (D, Vec128< uint8_t > v)
 
template<class D , HWY_IF_U32_D(D) >
HWY_INLINE Vec128< uint32_t > BitCastFromByte (D, Vec128< uint8_t > v)
 
template<class D , HWY_IF_I32_D(D) >
HWY_INLINE Vec128< int32_t > BitCastFromByte (D, Vec128< uint8_t > v)
 
template<class D , HWY_IF_U64_D(D) >
HWY_INLINE Vec128< uint64_t > BitCastFromByte (D, Vec128< uint8_t > v)
 
template<class D , HWY_IF_I64_D(D) >
HWY_INLINE Vec128< int64_t > BitCastFromByte (D, Vec128< uint8_t > v)
 
template<class D , HWY_IF_F32_D(D) >
HWY_INLINE Vec128< float > BitCastFromByte (D, Vec128< uint8_t > v)
 
template<class D , HWY_IF_F16_D(D) >
HWY_INLINE VFromD< D > BitCastFromByte (D, Vec128< uint8_t > v)
 
template<size_t kLane, class V , HWY_NEON_IF_EMULATED_D(DFromV< V >) >
static HWY_INLINE HWY_MAYBE_UNUSED TFromV< V > GetLane (V v)
 
template<size_t kLane, class V , class D = DFromV<V>, HWY_NEON_IF_EMULATED_D(D) >
HWY_APIInsertLane (const V v, TFromD< D > t)
 
template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > SumsOf2 (hwy::SignedTag, hwy::SizeTag< 1 >, V v)
 
template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > SumsOf2 (hwy::UnsignedTag, hwy::SizeTag< 1 >, V v)
 
template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > SumsOf2 (hwy::SignedTag, hwy::SizeTag< 2 >, V v)
 
template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > SumsOf2 (hwy::UnsignedTag, hwy::SizeTag< 2 >, V v)
 
template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > SumsOf2 (hwy::SignedTag, hwy::SizeTag< 4 >, V v)
 
template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > SumsOf2 (hwy::UnsignedTag, hwy::SizeTag< 4 >, V v)
 
template<size_t N>
HWY_API Vec128< float, N > MulAdd (Vec128< float, N > add, Vec128< float, N > mul, Vec128< float, N > x)
 
template<size_t N>
HWY_API Vec128< float, N > NegMulAdd (Vec128< float, N > add, Vec128< float, N > mul, Vec128< float, N > x)
 
template<typename T >
HWY_INLINE Vec128< T > PopulationCount (hwy::SizeTag< 1 >, Vec128< T > v)
 
template<typename T , size_t N, HWY_IF_V_SIZE_LE(T, N, 8) >
HWY_INLINE Vec128< T, N > PopulationCount (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_V_SIZE_LE(T, N, 8) >
HWY_INLINE Vec128< T, N > PopulationCount (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_V_SIZE_LE(T, N, 8) >
HWY_INLINE Vec128< T, N > PopulationCount (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_V_SIZE_LE(T, N, 8) >
HWY_INLINE Vec128< T, N > PopulationCount (hwy::SizeTag< 8 >, Vec128< T, N > v)
 
template<class D , HWY_IF_V_SIZE_D(D, 16) , HWY_IF_I32_D(D) >
HWY_INLINE Vec128< int32_t > ConvertFToI (D, Vec128< float > v)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_I32_D(D) >
HWY_INLINE VFromD< D > ConvertFToI (D, VFromD< RebindToFloat< D > > v)
 
template<class D , HWY_IF_V_SIZE_D(D, 16) , HWY_IF_U32_D(D) >
HWY_INLINE Vec128< uint32_t > ConvertFToU (D, Vec128< float > v)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_U32_D(D) >
HWY_INLINE VFromD< D > ConvertFToU (D, VFromD< RebindToFloat< D > > v)
 
template<size_t N>
HWY_INLINE Mask128< float, N > UseInt (const Vec128< float, N > v)
 
template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE VFromD< Repartition< uint8_t, D > > IndicesFromVecBroadcastLaneBytes (D d)
 
template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE VFromD< Repartition< uint8_t, D > > IndicesFromVecByteOffsets (D d)
 
template<typename T , HWY_IF_T_SIZE(T, 8) >
HWY_API Vec128< T > InterleaveUpper (Vec128< T > a, Vec128< T > b)
 
template<size_t kLaneSize, size_t kVectSize, class V , HWY_IF_LANES_GT_D(DFromV< V >, 4) >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< 0x88 >, hwy::SizeTag< kLaneSize >, hwy::SizeTag< kVectSize >, V v)
 
template<size_t kLaneSize, size_t kVectSize, class V , HWY_IF_LANES_GT_D(DFromV< V >, 4) >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< 0xDD >, hwy::SizeTag< kLaneSize >, hwy::SizeTag< kVectSize >, V v)
 
template<class V >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< 0xFA >, hwy::SizeTag< 2 >, hwy::SizeTag< 8 >, V v)
 
template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINESlideUpLanes (V v, size_t amt)
 
template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINESlideDownLanes (V v, size_t amt)
 
template<size_t N>
HWY_INLINE Vec128< float16_t, N > ConcatEven (Vec128< float16_t, N > hi, Vec128< float16_t, N > lo)
 
template<size_t N>
HWY_INLINE Vec128< float16_t, N > ConcatOdd (Vec128< float16_t, N > hi, Vec128< float16_t, N > lo)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 8) >
HWY_INLINE VFromD< D > Set64 (D, uint64_t mask_bits)
 
template<typename T >
HWY_INLINE Vec128< T > Set64 (Full128< T > d, uint64_t mask_bits)
 
template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE MFromD< D > LoadMaskBits (D d, uint64_t mask_bits)
 
template<class D , HWY_IF_V_SIZE_D(D, 16) >
HWY_INLINE uint64_t NibblesFromMask (D d, MFromD< D > mask)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 1 >, Mask128< T > mask)
 
template<typename T , size_t N, HWY_IF_V_SIZE_LE(T, N, 8) >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 1 >, Mask128< T, N > mask)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 2 >, Mask128< T > mask)
 
template<typename T , size_t N, HWY_IF_V_SIZE_LE(T, N, 8) >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 2 >, Mask128< T, N > mask)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 4 >, Mask128< T > mask)
 
template<typename T , size_t N, HWY_IF_V_SIZE_LE(T, N, 8) >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 4 >, Mask128< T, N > mask)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 8 >, Mask128< T > m)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 8 >, 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 (Mask128< T, N > mask)
 
template<typename T >
HWY_INLINE size_t CountTrue (hwy::SizeTag< 1 >, Mask128< T > mask)
 
template<typename T >
HWY_INLINE size_t CountTrue (hwy::SizeTag< 2 >, Mask128< T > mask)
 
template<typename T >
HWY_INLINE size_t CountTrue (hwy::SizeTag< 4 >, Mask128< T > mask)
 
template<typename T >
HWY_INLINE size_t CountTrue (hwy::SizeTag< 8 >, Mask128< T > mask)
 
template<class D , HWY_IF_V_SIZE_D(D, 16) >
HWY_INLINE Vec128< uint8_t > Load8Bytes (D, const uint8_t *bytes)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 8) >
HWY_INLINE VFromD< D > Load8Bytes (D d, const uint8_t *bytes)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IdxFromBits (hwy::SizeTag< 2 >, uint64_t mask_bits)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IdxFromNotBits (hwy::SizeTag< 2 >, uint64_t mask_bits)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IdxFromBits (hwy::SizeTag< 4 >, uint64_t mask_bits)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IdxFromNotBits (hwy::SizeTag< 4 >, uint64_t mask_bits)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Compress (Vec128< T, N > v, uint64_t mask_bits)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > CompressNot (Vec128< T, N > v, uint64_t mask_bits)
 
template<typename T , HWY_IF_T_SIZE(T, 1) >
HWY_INLINE size_t AllHardwareLanes ()
 
HWY_API svbool_t PFalse ()
 
template<class D >
svbool_t MakeMask (D d)
 
template<class V , HWY_SVE_IF_EMULATED_D(DFromV< V >) >
HWY_INLINE svuint8_t BitCastToByte (V v)
 
template<class D , HWY_SVE_IF_EMULATED_D(D) >
HWY_INLINE VFromD< D > BitCastFromByte (D d, svuint8_t v)
 
HWY_INLINE svint16_t SumsOf2 (hwy::SignedTag, hwy::SizeTag< 1 >, svint8_t v)
 
HWY_INLINE svuint16_t SumsOf2 (hwy::UnsignedTag, hwy::SizeTag< 1 >, svuint8_t v)
 
HWY_INLINE svint32_t SumsOf2 (hwy::SignedTag, hwy::SizeTag< 2 >, svint16_t v)
 
HWY_INLINE svuint32_t SumsOf2 (hwy::UnsignedTag, hwy::SizeTag< 2 >, svuint16_t v)
 
HWY_INLINE svint64_t SumsOf2 (hwy::SignedTag, hwy::SizeTag< 4 >, svint32_t v)
 
HWY_INLINE svuint64_t SumsOf2 (hwy::UnsignedTag, hwy::SizeTag< 4 >, svuint32_t v)
 
HWY_INLINE svint32_t SumsOf4 (hwy::SignedTag, hwy::SizeTag< 1 >, svint8_t v)
 
HWY_INLINE svuint32_t SumsOf4 (hwy::UnsignedTag, hwy::SizeTag< 1 >, svuint8_t v)
 
HWY_INLINE svint64_t SumsOf4 (hwy::SignedTag, hwy::SizeTag< 2 >, svint16_t v)
 
HWY_INLINE svuint64_t SumsOf4 (hwy::UnsignedTag, hwy::SizeTag< 2 >, svuint16_t v)
 
template<typename TN , class VU >
VU SaturateU (VU v)
 
template<typename TN , class VI >
VI SaturateI (VI v)
 
template<class V , HWY_IF_BF16_D(DFromV< V >) >
HWY_INLINESplice (V hi, V lo, svbool_t mask)
 
HWY_INLINE svuint32_t RoundF32ForDemoteToBF16 (svfloat32_t v)
 
template<class D , HWY_IF_T_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 > d)
 
template<class D >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::SignedTag, hwy::SizeTag< 2 >, hwy::SignedTag, D d_to, svint8_t v)
 
template<class D >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::SignedTag, hwy::SizeTag< 4 >, hwy::SignedTag, D d_to, svint16_t v)
 
template<class D >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::SignedTag, hwy::SizeTag< 8 >, hwy::SignedTag, D d_to, svint32_t v)
 
template<class D >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::FloatTag, hwy::SizeTag< 4 >, hwy::FloatTag, D d_to, svfloat16_t v)
 
template<class D >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::FloatTag, hwy::SizeTag< 8 >, hwy::FloatTag, D d_to, svfloat32_t v)
 
template<class D >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::FloatTag, hwy::SizeTag< 8 >, hwy::SignedTag, D d_to, svint32_t v)
 
template<class D >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::FloatTag, hwy::SizeTag< 8 >, hwy::UnsignedTag, D d_to, svuint32_t v)
 
template<class D >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::SignedTag, hwy::SizeTag< 8 >, hwy::FloatTag, D d_to, svfloat32_t v)
 
template<class D >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::UnsignedTag, hwy::SizeTag< 8 >, hwy::FloatTag, D d_to, svfloat32_t v)
 
template<class D >
HWY_INLINE VFromD< D > PromoteOddTo (hwy::FloatTag to_type_tag, hwy::SizeTag< 4 > to_lane_size_tag, hwy::FloatTag from_type_tag, D d_to, svfloat16_t v)
 
template<class FromTypeTag , class D , class V >
HWY_INLINE VFromD< D > PromoteOddTo (hwy::FloatTag to_type_tag, hwy::SizeTag< 8 > to_lane_size_tag, FromTypeTag from_type_tag, D d_to, V v)
 
template<class ToTypeTag , class D , HWY_IF_UI64_D(D) >
HWY_INLINE VFromD< D > PromoteOddTo (ToTypeTag to_type_tag, hwy::SizeTag< 8 > to_lane_size_tag, hwy::FloatTag from_type_tag, D d_to, svfloat32_t v)
 
template<class T , HWY_IF_T_SIZE(T, 1) >
HWY_INLINE svuint8_t BoolFromMask (svbool_t m)
 
HWY_INLINE svuint64_t BitsFromBool (svuint8_t x)
 
HWY_INLINE svuint8_t IndicesForExpandFromBits (uint64_t mask_bits)
 
template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE svuint8_t LaneIndicesFromByteIndices (D, svuint8_t idx)
 
template<class D , class DU = RebindToUnsigned<D>, HWY_IF_NOT_T_SIZE_D(D, 1) >
HWY_INLINE VFromD< DU > LaneIndicesFromByteIndices (D, svuint8_t idx)
 
template<class V >
HWY_INLINEExpandLoop (V v, svbool_t mask)
 
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<class FromSizeTag , class ToSizeTag , class DTo , class DFrom >
HWY_INLINE VFromD< DTo > ZeroExtendResizeBitCast (FromSizeTag, ToSizeTag, DTo d_to, DFrom, VFromD< DFrom > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Add (hwy::NonFloatTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Sub (hwy::NonFloatTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Add (hwy::FloatTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Sub (hwy::FloatTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Min (hwy::NonFloatTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Max (hwy::NonFloatTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Min (hwy::FloatTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Max (hwy::FloatTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_API Vec128< T, N > Neg (hwy::NonFloatTag, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_API Vec128< T, N > Neg (hwy::FloatTag, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_API Vec128< T, N > Neg (hwy::SpecialTag, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Mul (hwy::FloatTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Mul (SignedTag, Vec128< T, N > a, Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Mul (UnsignedTag, Vec128< T, N > a, Vec128< T, N > b)
 
static HWY_INLINE float ScalarSqrt (float v)
 
static HWY_INLINE double ScalarSqrt (double v)
 
template<class ToT , class FromT >
HWY_INLINE ToT CastValueForF2IConv (FromT val)
 
template<class ToT , class ToTypeTag , class FromT >
HWY_INLINE ToT CastValueForPromoteTo (ToTypeTag, FromT val)
 
template<class ToT >
HWY_INLINE ToT CastValueForPromoteTo (hwy::SignedTag, float val)
 
template<class ToT >
HWY_INLINE ToT CastValueForPromoteTo (hwy::UnsignedTag, float val)
 
template<class ToT , class FromT >
HWY_INLINE ToT CastValueForInRangeF2IConv (FromT val)
 
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 TFrom , typename DTo >
HWY_API VFromD< DTo > ConvertTo (hwy::FloatTag, DTo, Vec128< TFrom, HWY_MAX_LANES_D(DTo)> from)
 
template<typename TFrom , typename DTo >
HWY_API VFromD< DTo > ConvertTo (hwy::NonFloatTag, DTo, Vec128< TFrom, HWY_MAX_LANES_D(DTo)> from)
 
template<class D , class Func , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE VFromD< D > ReduceAcrossBlocks (D, Func, VFromD< D > v)
 
template<class D , class Func , HWY_IF_LANES_PER_BLOCK_D(D, 2) >
HWY_INLINE VFromD< D > ReduceWithinBlocks (D d, Func f, VFromD< D > v10)
 
template<class D , class Func , HWY_IF_LANES_PER_BLOCK_D(D, 16) , HWY_IF_U8_D(D) >
HWY_INLINE VFromD< D > ReduceWithinBlocks (D d, Func f, VFromD< D > v)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void LoadTransposedBlocks3 (D d, const TFromD< D > *HWY_RESTRICT unaligned, VFromD< D > &A, VFromD< D > &B, VFromD< D > &C)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void LoadTransposedBlocks4 (D d, const TFromD< D > *HWY_RESTRICT unaligned, VFromD< D > &vA, VFromD< D > &vB, VFromD< D > &vC, VFromD< D > &vD)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void StoreTransposedBlocks2 (VFromD< D > A, VFromD< D > B, D d, TFromD< D > *HWY_RESTRICT unaligned)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void StoreTransposedBlocks3 (VFromD< D > A, VFromD< D > B, VFromD< D > C, D d, TFromD< D > *HWY_RESTRICT unaligned)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void StoreTransposedBlocks4 (VFromD< D > vA, VFromD< D > vB, VFromD< D > vC, VFromD< D > vD, D d, TFromD< D > *HWY_RESTRICT unaligned)
 
template<class V , HWY_IF_F32(TFromV< V >) >
HWY_INLINE VFromD< RebindToUnsigned< DFromV< V > > > RoundF32ForDemoteToBF16 (V v)
 
template<class TypeTag , size_t kLaneSize, class V >
HWY_INLINE VFromD< RepartitionToWideX2< DFromV< V > > > SumsOf4 (TypeTag, hwy::SizeTag< kLaneSize >, V v)
 
template<class D , HWY_IF_U32_D(D) >
HWY_INLINE VFromD< D > UIntToF32BiasedExp (D d, VFromD< D > v)
 
template<class V , HWY_IF_U32_D(DFromV< V >) >
HWY_INLINEI32RangeU32ToF32BiasedExp (V v)
 
template<class D , HWY_IF_U16_D(D) , HWY_IF_LANES_LE_D(D, HWY_MAX_BYTES/4) >
HWY_INLINE VFromD< D > UIntToF32BiasedExp (D d, VFromD< D > v)
 
template<class V >
HWY_INLINE F32ExpLzcntMinMaxCmpV< V > F32ExpLzcntMinMaxBitCast (V v)
 
template<class V , HWY_IF_UNSIGNED_V(V) >
HWY_INLINEUIntToF32BiasedExp (V v)
 
template<class V , HWY_IF_UNSIGNED_V(V) , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)) >
HWY_INLINENormalizeForUIntTruncConvToF32 (V v)
 
template<class D , class V , HWY_IF_T_SIZE_D(D, sizeof(TFromV< V >)) >
HWY_INLINE Vec< D > IntDivConvFloatToInt (D di, V vf)
 
template<class D , class V , HWY_IF_T_SIZE_D(D, sizeof(TFromV< V >)) >
HWY_INLINE Vec< D > IntDivConvIntToFloat (D df, V vi)
 
template<size_t kOrigLaneSize, class V , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(V) , HWY_IF_T_SIZE_GT(TFromV< V >, kOrigLaneSize) >
HWY_INLINEIntDivUsingFloatDiv (V a, V b)
 
template<size_t kOrigLaneSize, class V , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(V) , HWY_IF_T_SIZE(TFromV< V >, kOrigLaneSize) , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 4)|(1<< 8)) >
HWY_INLINEIntDivUsingFloatDiv (V a, V b)
 
template<size_t kOrigLaneSize, class V , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)) , HWY_IF_V_SIZE_LE_V( V, HWY_MAX_BYTES/((!HWY_HAVE_FLOAT16 &&sizeof(TFromV< V >)==1) ? 4 :2)) >
HWY_INLINEIntDiv (V a, V b)
 
template<size_t kOrigLaneSize, class V , HWY_IF_T_SIZE_ONE_OF_V(V,(HWY_HAVE_FLOAT64 ? 0 :(1<< 4))|(1<< 8)) >
HWY_INLINEIntDiv (V a, V b)
 
template<size_t kOrigLaneSize, class V , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(V) , HWY_IF_T_SIZE_ONE_OF_V(V,((HWY_TARGET<=HWY_SSE2|| HWY_TARGET==HWY_WASM|| HWY_TARGET==HWY_WASM_EMU256) ? 0 :(1<< 1))|(1<< 2)|(1<< 4)|(1<< 8)) >
HWY_INLINEIntMod (V a, V b)
 
template<size_t N>
HWY_INLINE Vec128< uint8_t, N > IndicesForExpandFromBits (uint64_t mask_bits)
 
template<int kShiftAmt, int kShrResultMask, class V , HWY_IF_V_SIZE_GT_D(DFromV< V >, HWY_REVERSE_BITS_MIN_BYTES - 1) >
HWY_INLINEUI8ReverseBitsStep (V v)
 
template<class RawV >
static HWY_INLINE bool IsConstantRawAltivecVect (hwy::SizeTag< 1 >, RawV v)
 
template<class RawV >
static HWY_INLINE bool IsConstantRawAltivecVect (hwy::SizeTag< 2 >, RawV v)
 
template<class RawV >
static HWY_INLINE bool IsConstantRawAltivecVect (hwy::SizeTag< 4 >, RawV v)
 
template<class RawV >
static HWY_INLINE bool IsConstantRawAltivecVect (hwy::SizeTag< 8 >, RawV v)
 
template<class RawV >
static HWY_INLINE bool IsConstantRawAltivecVect (RawV v)
 
template<typename T , HWY_IF_T_SIZE(T, 1) >
HWY_API Vec32< T > ShuffleTwo2301 (Vec32< T > a, Vec32< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 2) >
HWY_API Vec64< T > ShuffleTwo2301 (Vec64< T > a, Vec64< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec128< T > ShuffleTwo2301 (Vec128< T > a, Vec128< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 1) >
HWY_API Vec32< T > ShuffleTwo1230 (Vec32< T > a, Vec32< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 2) >
HWY_API Vec64< T > ShuffleTwo1230 (Vec64< T > a, Vec64< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec128< T > ShuffleTwo1230 (Vec128< T > a, Vec128< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 1) >
HWY_API Vec32< T > ShuffleTwo3012 (Vec32< T > a, Vec32< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 2) >
HWY_API Vec64< T > ShuffleTwo3012 (Vec64< T > a, Vec64< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec128< T > ShuffleTwo3012 (Vec128< T > a, Vec128< T > b)
 
template<class D , HWY_IF_T_SIZE_D(D, 2) , HWY_IF_NOT_SPECIAL_FLOAT_D(D) >
HWY_INLINE VFromD< D > Iota0 (D d)
 
template<class D >
HWY_INLINE VFromD< D > Per4LaneBlkShufDupSet4xU32 (D d, const uint32_t x3, const uint32_t x2, const uint32_t x1, const uint32_t x0)
 
template<class D , typename FromT , HWY_IF_UNSIGNED_D(D) , HWY_IF_UNSIGNED(FromT) , HWY_IF_T_SIZE(FromT, sizeof(TFromD< D >) *2) , HWY_IF_LANES_GT_D(D, 1) >
HWY_API VFromD< D > Truncate2To (D, Vec128< FromT, Repartition< FromT, D >().MaxLanes()> lo, Vec128< FromT, Repartition< FromT, D >().MaxLanes()> hi)
 
template<typename T , size_t N>
HWY_API Vec128< T, N > Shl (hwy::UnsignedTag, Vec128< T, N > v, Vec128< T, N > bits)
 
template<typename T , size_t N>
HWY_API Vec128< T, N > Shl (hwy::SignedTag, Vec128< T, N > v, Vec128< T, N > bits)
 
template<typename T , size_t N>
HWY_API Vec128< T, N > Shr (hwy::UnsignedTag, Vec128< T, N > v, Vec128< T, N > bits)
 
template<typename T , size_t N>
HWY_API Vec128< T, N > Shr (hwy::SignedTag, Vec128< T, N > v, Vec128< T, N > bits)
 
template<class D , class V >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::FloatTag, hwy::SizeTag< 8 >, hwy::FloatTag, D, V v)
 
template<class D , class V , class FromTypeTag , HWY_IF_UI32(TFromV< V >) >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::FloatTag, hwy::SizeTag< 8 >, FromTypeTag, D d_to, V v)
 
template<class D , class V >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::SignedTag, hwy::SizeTag< 8 >, hwy::FloatTag, D d_to, V v)
 
template<class D , class V >
HWY_INLINE VFromD< D > PromoteEvenTo (hwy::UnsignedTag, hwy::SizeTag< 8 >, hwy::FloatTag, D d_to, V v)
 
template<class D , class V >
HWY_INLINE VFromD< D > PromoteOddTo (hwy::FloatTag, hwy::SizeTag< 8 >, hwy::FloatTag, D d_to, V v)
 
template<class D , class V , class FromTypeTag , HWY_IF_UI32(TFromV< V >) >
HWY_INLINE VFromD< D > PromoteOddTo (hwy::FloatTag, hwy::SizeTag< 8 >, FromTypeTag, D d_to, V v)
 
template<class D , class V >
HWY_INLINE VFromD< D > PromoteOddTo (hwy::SignedTag, hwy::SizeTag< 8 >, hwy::FloatTag, D d_to, V v)
 
template<class D , class V >
HWY_INLINE VFromD< D > PromoteOddTo (hwy::UnsignedTag, hwy::SizeTag< 8 >, hwy::FloatTag, D d_to, V v)
 
template<class DF32 , HWY_IF_F32_D(DF32) >
static HWY_INLINE VFromD< DF32 > DemoteToF32WithRoundToOdd (DF32 df32, VFromD< Rebind< double, DF32 > > v)
 
template<class V , HWY_IF_I64(TFromV< V >) >
HWY_INLINE VFromD< RebindToFloat< DFromV< V > > > ConvToF64WithRoundToOdd (V v)
 
template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE MFromD< D > LoadMaskBits128 (D, uint64_t mask_bits)
 
template<typename T , size_t N>
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 2 >, Mask128< T, N > mask)
 
template<typename T , size_t N>
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 4 >, Mask128< T, N > mask)
 
template<typename T , size_t N>
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 8 >, Mask128< T, N > mask)
 
template<class D , HWY_IF_T_SIZE_D(D, 2) >
HWY_INLINE VFromD< D > IndicesFromBits128 (D d, uint64_t mask_bits)
 
template<class D , HWY_IF_T_SIZE_D(D, 2) >
HWY_INLINE VFromD< D > IndicesFromNotBits128 (D d, uint64_t mask_bits)
 
template<typename T , size_t N, HWY_IF_NOT_T_SIZE(T, 1) >
HWY_API Vec128< T, N > CompressBits (Vec128< T, N > v, uint64_t mask_bits)
 
template<typename T , size_t N, HWY_IF_NOT_T_SIZE(T, 1) >
HWY_API Vec128< T, N > CompressNotBits (Vec128< T, N > v, uint64_t mask_bits)
 
template<class V , HWY_IF_T_SIZE_V(V, 1) >
HWY_INLINEPer64BitBlkRevLanesOnBe (V v)
 
template<class V >
HWY_INLINEPer128BitBlkRevLanesOnBe (V v)
 
template<class V >
HWY_INLINEI128Subtract (V a, V b)
 
template<class V >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > SumsOf2 (hwy::UnsignedTag, hwy::SizeTag< 2 >, V v)
 
template<class V >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > SumsOf2 (hwy::SignedTag, hwy::SizeTag< 2 >, V v)
 
template<class V >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > SumsOf2 (hwy::UnsignedTag, hwy::SizeTag< 4 >, V v)
 
template<class V >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > SumsOf2 (hwy::SignedTag, hwy::SizeTag< 4 >, V v)
 
template<class V >
HWY_INLINE VFromD< RepartitionToWideX2< DFromV< V > > > SumsOf4 (hwy::UnsignedTag, hwy::SizeTag< 1 >, V v)
 
template<class V >
HWY_INLINE VFromD< RepartitionToWideX2< DFromV< V > > > SumsOf4 (hwy::SignedTag, hwy::SizeTag< 1 >, V v)
 
template<class V >
HWY_INLINE VFromD< RepartitionToWideX2< DFromV< V > > > SumsOf4 (hwy::UnsignedTag, hwy::SizeTag< 2 >, V v)
 
template<class V >
HWY_INLINE VFromD< RepartitionToWideX2< DFromV< V > > > SumsOf4 (hwy::SignedTag, hwy::SizeTag< 2 >, V v)
 
template<class T , HWY_IF_NOT_FLOAT_NOR_SPECIAL(T) , HWY_IF_T_SIZE_ONE_OF(T,(1<< 4)|(1<< 8)) >
HWY_INLINE Vec128< T > SumOfU32OrU64LanesAsU128 (Vec128< T > v)
 
template<class D , class V = VFromD<D>>
HWY_INLINELt128Vec (D d, V a, V b)
 
template<class D , class V = VFromD<D>>
HWY_INLINEEq128Vec (D d, V a, V b)
 
template<class D , class V = VFromD<D>>
HWY_INLINENe128Vec (D d, V a, V b)
 
template<class D , class V = VFromD<D>>
HWY_INLINELt128UpperVec (D d, V a, V b)
 
template<class D , class V = VFromD<D>>
HWY_INLINEEq128UpperVec (D d, V a, V b)
 
template<class D , class V = VFromD<D>>
HWY_INLINENe128UpperVec (D d, V a, V b)
 
template<class D , HWY_RVV_IF_EMULATED_D(D) >
VFromD< D > Ext (D d, VFromD< Half< D > > v)
 
template<size_t N, int kPow2>
HWY_INLINE VFromD< Simd< uint16_t, N, kPow2 > > BitCastFromByte (Simd< hwy::float16_t, N, kPow2 >, VFromD< Simd< uint8_t, N, kPow2 > > v)
 
template<size_t N, int kPow2>
HWY_INLINE VFromD< Simd< int16_t, N, kPow2 > > BitCastFromByte (Simd< hwy::bfloat16_t, N, kPow2 >, VFromD< Simd< uint8_t, N, kPow2 > > v)
 
template<class D , HWY_RVV_IF_EMULATED_D(D) >
HWY_API void StoreN (size_t count, VFromD< D > v, D d, TFromD< D > *HWY_RESTRICT p)
 
template<typename T , size_t N, int kPow2>
HWY_INLINE 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<class D , HWY_IF_NOT_T_SIZE_D(D, 8) >
HWY_INLINE MFromD< D > IsEven (D d)
 
template<class D , HWY_IF_NOT_T_SIZE_D(D, 8) >
HWY_INLINE MFromD< D > IsOdd (D d)
 
template<class D >
HWY_INLINE VFromD< D > ChangeLMUL (D, VFromD< D > v)
 
template<class D , class V , HWY_IF_POW2_LE_D(DFromV< VFromD< D > >, DFromV< V >().Pow2() - 1) >
HWY_INLINE VFromD< D > ChangeLMUL (D d, V v)
 
template<class D , HWY_IF_T_SIZE_ONE_OF_D(D,(1<< 1)|(1<< 2)|(1<< 4)) , HWY_IF_POW2_GT_D(D, -3) >
HWY_API VFromD< D > InterleaveWhole (D d, VFromD< Half< D > > a, VFromD< Half< D > > b)
 
template<class D , class V , HWY_IF_POW2_LE_D(D, 2) >
HWY_INLINEInterleaveLowerBlocks (D d, const V a, const V b)
 
template<class D , class V , HWY_IF_POW2_LE_D(D, 2) >
HWY_INLINEInterleaveUpperBlocks (D d, const V a, const V b)
 
template<typename T , size_t N, int kPow2>
constexpr bool IsGE128 (Simd< T, N, kPow2 >)
 
template<typename T , size_t N, int kPow2>
constexpr bool IsLT128 (Simd< T, N, kPow2 >)
 
template<size_t N, int kPow2, class DF32 = Simd<float, N, kPow2>, class VF32 = VFromD<DF32>, class DBF16 = Repartition<hwy::bfloat16_t, Simd<float, N, kPow2>>>
HWY_API VF32 ReorderWidenMulAccumulateBF16 (Simd< float, N, kPow2 > df32, VFromD< DBF16 > a, VFromD< DBF16 > b, const VF32 sum0, VF32 &sum1)
 
template<class D32 , HWY_IF_POW2_LE_D(D32, 2) , class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > ReorderWidenMulAccumulateI16 (D32 d32, VFromD< D16 > a, VFromD< D16 > b, const V32 sum0, V32 &sum1)
 
template<class D32 , HWY_IF_POW2_LE_D(D32, 2) , class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > ReorderWidenMulAccumulateU16 (D32 d32, VFromD< D16 > a, VFromD< D16 > b, const V32 sum0, V32 &sum1)
 
template<class T >
HWY_INLINEReverseBitsOfEachByte (T val)
 
template<typename T , HWY_IF_NOT_SPECIAL_FLOAT(T) >
HWY_INLINE T * NativeLanePointer (T *p)
 
template<typename T , typename NT = NativeLaneType<RemoveConst<T>>, HWY_IF_F16(T) >
HWY_INLINE constexpr If< IsConst< T >(), const NT *, NT * > NativeLanePointer (T *p)
 
template<typename T , HWY_IF_SPECIAL_FLOAT(T) >
HWY_INLINE If< IsConst< T >(), const uint16_t *, uint16_t * > U16LanePointer (T *p)
 
constexpr size_t ScaleByPower (size_t N, int pow2)
 
template<typename T >
HWY_INLINE void MaybeUnpoison (T *HWY_RESTRICT unaligned, size_t count)
 
template<typename T , size_t N, int kPow2>
constexpr bool IsFull (Simd< T, N, kPow2 >)
 
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<class D >
HWY_INLINE VFromD< D > BitCastFromByte (D d, Vec128< uint8_t, d.MaxBytes()> v)
 
template<size_t kLane, typename T , size_t N, HWY_IF_T_SIZE(T, 1) >
HWY_INLINEExtractLane (const Vec128< T, N > v)
 
template<size_t kLane, typename T , size_t N, HWY_IF_T_SIZE(T, 2) , HWY_IF_NOT_SPECIAL_FLOAT(T) >
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, size_t N>
HWY_INLINE double ExtractLane (const Vec128< double, N > v)
 
template<size_t kLane, typename T , size_t N, HWY_IF_T_SIZE(T, 1) >
HWY_INLINE Vec128< T, N > InsertLane (const Vec128< T, N > v, T t)
 
template<size_t kLane, size_t N>
HWY_INLINE Vec128< float, N > InsertLane (const Vec128< float, N > v, float t)
 
template<size_t kLane, size_t N>
HWY_INLINE Vec128< double, N > InsertLane (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_T_SIZE(T, 1) >
HWY_API Vec128< T, N > ShuffleTwo2301 (const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N, HWY_IF_T_SIZE(T, 1) >
HWY_API Vec128< T, N > ShuffleTwo1230 (const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N, HWY_IF_T_SIZE(T, 1) >
HWY_API Vec128< T, N > ShuffleTwo3012 (const Vec128< T, N > a, const Vec128< T, N > b)
 
template<size_t N>
HWY_API Vec128< uint8_t, N > InterleaveUpper (Vec128< uint8_t, N > a, Vec128< uint8_t, N > b)
 
template<size_t N>
HWY_API Vec128< uint16_t, N > InterleaveUpper (Vec128< uint16_t, N > a, Vec128< uint16_t, N > b)
 
template<size_t N>
HWY_API Vec128< uint32_t, N > InterleaveUpper (Vec128< uint32_t, N > a, Vec128< uint32_t, N > b)
 
template<size_t N>
HWY_API Vec128< uint64_t, N > InterleaveUpper (Vec128< uint64_t, N > a, Vec128< uint64_t, N > b)
 
template<size_t N>
HWY_API Vec128< int8_t, N > InterleaveUpper (Vec128< int8_t, N > a, Vec128< int8_t, N > b)
 
template<size_t N>
HWY_API Vec128< int16_t, N > InterleaveUpper (Vec128< int16_t, N > a, Vec128< int16_t, N > b)
 
template<size_t N>
HWY_API Vec128< int32_t, N > InterleaveUpper (Vec128< int32_t, N > a, Vec128< int32_t, N > b)
 
template<size_t N>
HWY_API Vec128< int64_t, N > InterleaveUpper (Vec128< int64_t, N > a, Vec128< int64_t, N > b)
 
template<size_t N>
HWY_API Vec128< float, N > InterleaveUpper (Vec128< float, N > a, Vec128< float, N > b)
 
template<size_t N>
HWY_API Vec128< double, N > InterleaveUpper (Vec128< double, N > a, Vec128< double, N > b)
 
template<size_t kIdx3210, size_t kVectSize, class V , HWY_IF_LANES_LE(kVectSize, 16) >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 1 >, hwy::SizeTag< kVectSize >, V v)
 
template<size_t kIdx3210, size_t kVectSize, class V , HWY_IF_LANES_LE(kVectSize, 16) >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 2 >, hwy::SizeTag< kVectSize >, V v)
 
template<size_t kIdx3210, size_t kVectSize, class V , HWY_IF_LANES_LE(kVectSize, 16) >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 4 >, hwy::SizeTag< kVectSize >, V v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > OddEven (hwy::SizeTag< 1 >, const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > OddEven (hwy::SizeTag< 2 >, const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > OddEven (hwy::SizeTag< 4 >, const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > OddEven (hwy::SizeTag< 8 >, const Vec128< T, N > a, const Vec128< T, N > b)
 
template<class D , HWY_IF_UNSIGNED_D(D) >
HWY_INLINE VFromD< Rebind< uint64_t, D > > DemoteFromU64MaskOutResult (D, VFromD< Rebind< uint64_t, D > > v)
 
template<class D >
HWY_INLINE VFromD< Rebind< uint64_t, D > > DemoteFromU64Saturate (D dn, VFromD< Rebind< uint64_t, D > > v)
 
template<class D , class V >
HWY_INLINE VFromD< D > ReorderDemote2From64To32Combine (D dn, V a, V b)
 
template<class VW >
HWY_INLINE VFromD< Rebind< double, DFromV< VW > > > U64ToF64VecFast (VW w)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (hwy::SizeTag< 1 >, const Mask128< T, 8 > 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_T_SIZE(T, 2) >
HWY_INLINE Vec128< T, N > IdxFromBits (const uint64_t mask_bits)
 
template<typename T , size_t N, HWY_IF_T_SIZE(T, 2) >
HWY_INLINE Vec128< T, N > IdxFromNotBits (const uint64_t mask_bits)
 
template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec256< T > ShuffleTwo2301 (Vec256< T > a, const Vec256< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec256< T > ShuffleTwo1230 (Vec256< T > a, const Vec256< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec256< T > ShuffleTwo3012 (Vec256< T > a, const Vec256< T > b)
 
template<size_t kFromVectSize, class DTo , class DFrom , HWY_IF_LANES_LE(kFromVectSize, 8) >
HWY_INLINE VFromD< DTo > ZeroExtendResizeBitCast (hwy::SizeTag< kFromVectSize >, hwy::SizeTag< 32 >, DTo d_to, DFrom d_from, VFromD< DFrom > v)
 
template<size_t kIdx3210, class V >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 1 >, hwy::SizeTag< 32 >, V v)
 
template<size_t kIdx3210, class V >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 2 >, hwy::SizeTag< 32 >, V v)
 
template<size_t kIdx3210, class V >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 4 >, hwy::SizeTag< 32 >, V v)
 
template<size_t kIdx3210, class V >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 8 >, hwy::SizeTag< 32 >, V v)
 
template<class D , typename T = TFromD<D>>
HWY_API void LoadTransposedBlocks3 (D d, const T *HWY_RESTRICT unaligned, Vec256< T > &A, Vec256< T > &B, Vec256< T > &C)
 
template<class D , typename T = TFromD<D>>
HWY_API void LoadTransposedBlocks4 (D d, const T *HWY_RESTRICT unaligned, Vec256< T > &vA, Vec256< T > &vB, Vec256< T > &vC, Vec256< T > &vD)
 
template<class D , typename T = TFromD<D>>
HWY_API void StoreTransposedBlocks2 (Vec256< T > i, Vec256< T > j, D d, T *HWY_RESTRICT unaligned)
 
template<class D , typename T = TFromD<D>>
HWY_API void StoreTransposedBlocks3 (Vec256< T > i, Vec256< T > j, Vec256< T > k, D d, T *HWY_RESTRICT unaligned)
 
template<class D , typename T = TFromD<D>>
HWY_API void StoreTransposedBlocks4 (Vec256< T > i, Vec256< T > j, Vec256< T > k, Vec256< T > l, D d, T *HWY_RESTRICT unaligned)
 
HWY_INLINE __m128i BitCastToInteger (__m128i v)
 
HWY_INLINE __m128i BitCastToInteger (__m128 v)
 
HWY_INLINE __m128i BitCastToInteger (__m128d v)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE VFromD< D > BitCastFromByte (D, Vec128< uint8_t, D().MaxBytes()> v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > PopulationCount (hwy::SizeTag< 1 >, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > PopulationCount (hwy::SizeTag< 2 >, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > PopulationCount (hwy::SizeTag< 4 >, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > PopulationCount (hwy::SizeTag< 8 >, Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Neg (hwy::FloatTag, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Neg (hwy::SpecialTag, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > Neg (hwy::SignedTag, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > MaskFromVec (hwy::SizeTag< 1 >, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > MaskFromVec (hwy::SizeTag< 2 >, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > MaskFromVec (hwy::SizeTag< 4 >, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > MaskFromVec (hwy::SizeTag< 8 >, const Vec128< T, N > v)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IfThenElse (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, N > IfThenElse (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, N > IfThenElse (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, N > IfThenElse (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, N > IfThenElseZero (hwy::SizeTag< 1 >, Mask128< T, N > mask, Vec128< T, N > yes)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IfThenElseZero (hwy::SizeTag< 2 >, Mask128< T, N > mask, Vec128< T, N > yes)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IfThenElseZero (hwy::SizeTag< 4 >, Mask128< T, N > mask, Vec128< T, N > yes)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IfThenElseZero (hwy::SizeTag< 8 >, Mask128< T, N > mask, Vec128< T, N > yes)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IfThenZeroElse (hwy::SizeTag< 1 >, Mask128< T, N > mask, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IfThenZeroElse (hwy::SizeTag< 2 >, Mask128< T, N > mask, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IfThenZeroElse (hwy::SizeTag< 4 >, Mask128< T, N > mask, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Vec128< T, N > IfThenZeroElse (hwy::SizeTag< 8 >, Mask128< T, N > mask, Vec128< T, N > no)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > And (hwy::SizeTag< 1 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > And (hwy::SizeTag< 2 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > And (hwy::SizeTag< 4 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > And (hwy::SizeTag< 8 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > AndNot (hwy::SizeTag< 1 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > AndNot (hwy::SizeTag< 2 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > AndNot (hwy::SizeTag< 4 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > AndNot (hwy::SizeTag< 8 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > Or (hwy::SizeTag< 1 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > Or (hwy::SizeTag< 2 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > Or (hwy::SizeTag< 4 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > Or (hwy::SizeTag< 8 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > Xor (hwy::SizeTag< 1 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > Xor (hwy::SizeTag< 2 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > Xor (hwy::SizeTag< 4 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > Xor (hwy::SizeTag< 8 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > ExclusiveNeither (hwy::SizeTag< 1 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > ExclusiveNeither (hwy::SizeTag< 2 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > ExclusiveNeither (hwy::SizeTag< 4 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > ExclusiveNeither (hwy::SizeTag< 8 >, const Mask128< T, N > a, const Mask128< T, N > b)
 
template<typename T , size_t N, HWY_IF_T_SIZE(T, 1) >
HWY_INLINE Mask128< T, N > UnmaskedNot (const Mask128< T, N > m)
 
template<typename T >
HWY_INLINE Mask128< T > Not (hwy::SizeTag< 1 >, const Mask128< T > m)
 
template<typename T , size_t N, HWY_IF_LANES_LE(N, 8) >
HWY_INLINE Mask128< T, N > Not (hwy::SizeTag< 1 >, const Mask128< T, N > m)
 
template<typename T >
HWY_INLINE Mask128< T > Not (hwy::SizeTag< 2 >, const Mask128< T > m)
 
template<typename T , size_t N, HWY_IF_LANES_LE(N, 4) >
HWY_INLINE Mask128< T, N > Not (hwy::SizeTag< 2 >, const Mask128< T, N > m)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > Not (hwy::SizeTag< 4 >, const Mask128< T, N > m)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > Not (hwy::SizeTag< 8 >, const Mask128< T, N > m)
 
template<typename T , size_t N>
HWY_API Vec128< T, N > GaloisAffine (Vec128< T, N > v, VFromD< Repartition< uint64_t, Simd< T, N, 0 > > > matrix)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > TestBit (hwy::SizeTag< 1 >, const Vec128< T, N > v, const Vec128< T, N > bit)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > TestBit (hwy::SizeTag< 2 >, const Vec128< T, N > v, const Vec128< T, N > bit)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > TestBit (hwy::SizeTag< 4 >, const Vec128< T, N > v, const Vec128< T, N > bit)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > TestBit (hwy::SizeTag< 8 >, const Vec128< T, N > v, const Vec128< T, N > bit)
 
template<class D >
HWY_API void ScalarMaskedStore (VFromD< D > v, MFromD< D > m, D d, TFromD< D > *HWY_RESTRICT p)
 
template<size_t N>
HWY_INLINE Vec128< uint32_t,(N+3)/4 > SumsOf4 (hwy::UnsignedTag, hwy::SizeTag< 1 >, Vec128< uint8_t, N > v)
 
template<typename T , size_t N>
HWY_INLINE HWY_MAYBE_UNUSED Vec128< T, N > MinU (const Vec128< T, N > a, const Vec128< T, N > b)
 
template<typename T , size_t N>
HWY_INLINE HWY_MAYBE_UNUSED Vec128< T, N > MaxU (const Vec128< T, N > a, const Vec128< T, N > b)
 
template<int kScale, class D , class VI , HWY_IF_UI32_D(D) >
HWY_INLINE void NativeScatter128 (VFromD< D > v, D d, TFromD< D > *HWY_RESTRICT base, VI index)
 
template<int kScale, class D , class VI , HWY_IF_F32_D(D) >
HWY_INLINE void NativeScatter128 (VFromD< D > v, D d, float *HWY_RESTRICT base, VI index)
 
template<int kScale, class D , class VI , HWY_IF_F64_D(D) >
HWY_INLINE void NativeScatter128 (VFromD< D > v, D d, double *HWY_RESTRICT base, VI index)
 
template<int kScale, class D , class VI , HWY_IF_UI32_D(D) >
HWY_INLINE void NativeMaskedScatter128 (VFromD< D > v, MFromD< D > m, D d, TFromD< D > *HWY_RESTRICT base, VI index)
 
template<int kScale, class D , class VI , HWY_IF_F32_D(D) >
HWY_INLINE void NativeMaskedScatter128 (VFromD< D > v, MFromD< D > m, D d, float *HWY_RESTRICT base, VI index)
 
template<int kScale, class D , class VI , HWY_IF_F64_D(D) >
HWY_INLINE void NativeMaskedScatter128 (VFromD< D > v, MFromD< D > m, D d, double *HWY_RESTRICT base, VI index)
 
template<int kScale, typename T , size_t N, HWY_IF_UI32(T) >
HWY_INLINE Vec128< T, N > NativeGather128 (const T *HWY_RESTRICT base, Vec128< int32_t, N > indices)
 
template<int kScale, typename T , size_t N, HWY_IF_UI64(T) >
HWY_INLINE Vec128< T, N > NativeGather128 (const T *HWY_RESTRICT base, Vec128< int64_t, N > indices)
 
template<int kScale, size_t N>
HWY_INLINE Vec128< float, N > NativeGather128 (const float *HWY_RESTRICT base, Vec128< int32_t, N > indices)
 
template<int kScale, size_t N>
HWY_INLINE Vec128< double, N > NativeGather128 (const double *HWY_RESTRICT base, Vec128< int64_t, N > indices)
 
template<int kScale, typename T , size_t N, HWY_IF_UI32(T) >
HWY_INLINE Vec128< T, N > NativeMaskedGatherOr128 (Vec128< T, N > no, Mask128< T, N > m, const T *HWY_RESTRICT base, Vec128< int32_t, N > indices)
 
template<int kScale, typename T , size_t N, HWY_IF_UI64(T) >
HWY_INLINE Vec128< T, N > NativeMaskedGatherOr128 (Vec128< T, N > no, Mask128< T, N > m, const T *HWY_RESTRICT base, Vec128< int64_t, N > indices)
 
template<int kScale, size_t N>
HWY_INLINE Vec128< float, N > NativeMaskedGatherOr128 (Vec128< float, N > no, Mask128< float, N > m, const float *HWY_RESTRICT base, Vec128< int32_t, N > indices)
 
template<int kScale, size_t N>
HWY_INLINE Vec128< double, N > NativeMaskedGatherOr128 (Vec128< double, N > no, Mask128< double, N > m, const double *HWY_RESTRICT base, Vec128< int64_t, N > indices)
 
template<size_t kLane>
HWY_INLINE double ExtractLane (const Vec64< double > v)
 
template<size_t kLane>
HWY_INLINE double ExtractLane (const Vec128< double > v)
 
template<class V >
HWY_INLINEInsertLaneUsingBroadcastAndBlend (V v, size_t i, TFromV< V > t)
 
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)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE VFromD< D > Per4LaneBlkShufDupSet4xU32 (D d, const uint32_t x3, const uint32_t x2, const uint32_t x1, const uint32_t x0)
 
template<size_t kIdx3210, class V >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 2 >, hwy::SizeTag< 8 >, V v)
 
template<size_t kIdx3210, class V >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 2 >, hwy::SizeTag< 16 >, V v)
 
template<size_t kIdx3210, size_t kVectSize, class V >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 > idx_3210_tag, hwy::SizeTag< 1 >, hwy::SizeTag< 16 >, V v)
 
template<size_t kIdx3210, class V , HWY_IF_NOT_FLOAT(TFromV< V >) >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 4 >, hwy::SizeTag< 16 >, V v)
 
template<class V >
HWY_APIAVX2ShlU16Vec128 (V v, V bits)
 
template<size_t N>
HWY_API Vec128< uint16_t, N > Shl (hwy::UnsignedTag, Vec128< uint16_t, N > v, Vec128< uint16_t, N > bits)
 
template<class V >
HWY_INLINEAVX2ShlU8Vec128 (V v, V bits)
 
template<size_t N>
HWY_API Vec128< uint8_t, N > Shl (hwy::UnsignedTag tag, Vec128< uint8_t, N > v, Vec128< uint8_t, N > bits)
 
HWY_API Vec128< uint8_t, 1 > Shl (hwy::UnsignedTag, Vec128< uint8_t, 1 > v, Vec128< uint8_t, 1 > bits)
 
template<size_t N>
HWY_API Vec128< uint32_t, N > Shl (hwy::UnsignedTag, Vec128< uint32_t, N > v, Vec128< uint32_t, N > bits)
 
HWY_API Vec32< uint32_t > Shl (hwy::UnsignedTag, Vec32< uint32_t > v, const Vec32< uint32_t > 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<class V >
HWY_INLINEAVX2ShrU8Vec128 (V v, V bits)
 
template<class V >
HWY_INLINEAVX2ShrI8Vec128 (V v, V bits)
 
template<class V , HWY_IF_U64(TFromV< V >) >
static HWY_INLINESSE2Mul128 (V a, V b, V &mulH)
 
template<class D >
HWY_INLINE VFromD< D > ClampF64ToI32Max (D d, VFromD< D > v)
 
template<class DI >
HWY_INLINE VFromD< DI > FixConversionOverflow (DI di, VFromD< RebindToFloat< DI > > original, VFromD< DI > converted)
 
template<typename T , size_t N>
HWY_INLINE Mask128< T, N > UseInt (const Vec128< T, N > v)
 
template<size_t N>
HWY_INLINE Vec128< uint8_t, N > NativeExpand (Vec128< uint8_t, N > v, Mask128< uint8_t, N > mask)
 
template<size_t N>
HWY_INLINE Vec128< uint16_t, N > NativeExpand (Vec128< uint16_t, N > v, Mask128< uint16_t, N > mask)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 16) , HWY_IF_U8_D(D) >
HWY_INLINE VFromD< D > NativeLoadExpand (MFromD< D > mask, D, const uint8_t *HWY_RESTRICT unaligned)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 16) , HWY_IF_U16_D(D) >
HWY_INLINE VFromD< D > NativeLoadExpand (MFromD< D > mask, D, const uint16_t *HWY_RESTRICT unaligned)
 
template<size_t N>
HWY_INLINE Vec128< uint32_t, N > NativeExpand (Vec128< uint32_t, N > v, Mask128< uint32_t, N > mask)
 
template<size_t N>
HWY_INLINE Vec128< uint64_t, N > NativeExpand (Vec128< uint64_t, N > v, Mask128< uint64_t, N > mask)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 16) , HWY_IF_U32_D(D) >
HWY_INLINE VFromD< D > NativeLoadExpand (MFromD< D > mask, D, const uint32_t *HWY_RESTRICT unaligned)
 
template<class D , HWY_IF_V_SIZE_LE_D(D, 16) , HWY_IF_U64_D(D) >
HWY_INLINE VFromD< D > NativeLoadExpand (MFromD< D > mask, D, const uint64_t *HWY_RESTRICT unaligned)
 
template<class T , HWY_IF_LANES_LE(sizeof(T), 4) >
static HWY_INLINE uint32_t AVX3Blsi (T x)
 
template<class T , HWY_IF_T_SIZE(T, 8) >
static HWY_INLINE uint64_t AVX3Blsi (T x)
 
template<class T , HWY_IF_LANES_LE(sizeof(T), 4) >
static HWY_INLINE uint32_t AVX3Blsmsk (T x)
 
template<class T , HWY_IF_T_SIZE(T, 8) >
static HWY_INLINE uint64_t AVX3Blsmsk (T x)
 
template<class D , HWY_IF_U64_D(D) >
HWY_INLINE VFromD< D > Lt128Vec (const D d, VFromD< D > a, VFromD< D > b)
 
template<class D , HWY_IF_U64_D(D) >
HWY_INLINE VFromD< D > Eq128Vec (D d, VFromD< D > a, VFromD< D > b)
 
template<class D , HWY_IF_U64_D(D) >
HWY_INLINE VFromD< D > Ne128Vec (D d, VFromD< D > a, VFromD< D > b)
 
template<class D , HWY_IF_U64_D(D) >
HWY_INLINE VFromD< D > Lt128UpperVec (D d, VFromD< D > a, VFromD< D > b)
 
template<class D , HWY_IF_U64_D(D) >
HWY_INLINE VFromD< D > Eq128UpperVec (D d, VFromD< D > a, VFromD< D > b)
 
template<class D , HWY_IF_U64_D(D) >
HWY_INLINE VFromD< D > Ne128UpperVec (D d, VFromD< D > a, VFromD< D > b)
 
template<typename T >
HWY_INLINE uint64_t BitsFromMask (const Mask256< T > mask)
 
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<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_INLINE VFromD< D > BitCastFromByte (D, 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_IF_T_SIZE(T, 1) >
HWY_INLINE Mask256< T > UnmaskedNot (const Mask256< T > m)
 
template<typename T >
HWY_INLINE Mask256< T > Not (hwy::SizeTag< 1 >, const Mask256< T > m)
 
template<typename T >
HWY_INLINE Mask256< T > Not (hwy::SizeTag< 2 >, const Mask256< T > m)
 
template<typename T >
HWY_INLINE Mask256< T > Not (hwy::SizeTag< 4 >, const Mask256< T > m)
 
template<typename T >
HWY_INLINE Mask256< T > Not (hwy::SizeTag< 8 >, const Mask256< T > m)
 
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)
 
HWY_INLINE Vec256< uint32_t > SumsOf4 (hwy::UnsignedTag, hwy::SizeTag< 1 >, Vec256< uint8_t > v)
 
template<typename T >
HWY_API Vec256< T > GaloisAffine (Vec256< T > v, Vec256< uint64_t > matrix)
 
template<typename T >
HWY_INLINE Vec256< T > Neg (hwy::FloatTag, const Vec256< T > v)
 
template<typename T >
HWY_INLINE Vec256< T > Neg (hwy::SpecialTag, const Vec256< T > v)
 
template<typename T >
HWY_INLINE Vec256< T > Neg (hwy::SignedTag, const Vec256< T > v)
 
template<int kScale, typename T , HWY_IF_UI32(T) >
HWY_INLINE Vec256< T > NativeGather256 (const T *HWY_RESTRICT base, Vec256< int32_t > indices)
 
template<int kScale, typename T , HWY_IF_UI64(T) >
HWY_INLINE Vec256< T > NativeGather256 (const T *HWY_RESTRICT base, Vec256< int64_t > indices)
 
template<int kScale>
HWY_API Vec256< float > NativeGather256 (const float *HWY_RESTRICT base, Vec256< int32_t > indices)
 
template<int kScale>
HWY_API Vec256< double > NativeGather256 (const double *HWY_RESTRICT base, Vec256< int64_t > indices)
 
template<int kScale, typename T , HWY_IF_UI32(T) >
HWY_INLINE Vec256< T > NativeMaskedGatherOr256 (Vec256< T > no, Mask256< T > m, const T *HWY_RESTRICT base, Vec256< int32_t > indices)
 
template<int kScale, typename T , HWY_IF_UI64(T) >
HWY_INLINE Vec256< T > NativeMaskedGatherOr256 (Vec256< T > no, Mask256< T > m, const T *HWY_RESTRICT base, Vec256< int64_t > indices)
 
template<int kScale>
HWY_API Vec256< float > NativeMaskedGatherOr256 (Vec256< float > no, Mask256< float > m, const float *HWY_RESTRICT base, Vec256< int32_t > indices)
 
template<int kScale>
HWY_API Vec256< double > NativeMaskedGatherOr256 (Vec256< double > no, Mask256< double > m, const double *HWY_RESTRICT base, Vec256< int64_t > indices)
 
template<class DTo , class DFrom >
HWY_INLINE VFromD< DTo > ZeroExtendResizeBitCast (hwy::SizeTag< 8 >, hwy::SizeTag< 32 >, DTo d_to, DFrom d_from, VFromD< DFrom > v)
 
template<class T , HWY_IF_T_SIZE(T, 1) >
HWY_INLINE Vec256< T > BroadcastLane (hwy::SizeTag< 0 >, Vec256< T > v)
 
HWY_INLINE Vec256< float > BroadcastLane (hwy::SizeTag< 0 >, Vec256< float > v)
 
HWY_INLINE Vec256< double > BroadcastLane (hwy::SizeTag< 0 >, Vec256< double > v)
 
template<size_t kLaneIdx, class T , hwy::EnableIf< kLaneIdx !=0 > * = nullptr, HWY_IF_NOT_T_SIZE(T, 8) >
HWY_INLINE Vec256< T > BroadcastLane (hwy::SizeTag< kLaneIdx >, Vec256< T > v)
 
template<size_t kLaneIdx, hwy::EnableIf< kLaneIdx !=0 > * = nullptr>
HWY_INLINE Vec256< double > BroadcastLane (hwy::SizeTag< kLaneIdx >, Vec256< double > v)
 
template<size_t kIdx3210, class V , HWY_IF_NOT_FLOAT(TFromV< V >) >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 4 >, hwy::SizeTag< 32 >, V v)
 
template<class V >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< 0x44 >, hwy::SizeTag< 8 >, hwy::SizeTag< 32 >, V v)
 
template<class V >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< 0xEE >, hwy::SizeTag< 8 >, hwy::SizeTag< 32 >, V v)
 
template<size_t kIdx3210, class V , HWY_IF_NOT_FLOAT(TFromV< V >) >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 8 >, hwy::SizeTag< 32 >, V v)
 
template<int kI32Lanes, class V , HWY_IF_V_SIZE_V(V, 32) >
HWY_INLINECombineShiftRightI32Lanes (V hi, V lo)
 
template<int kI64Lanes, class V , HWY_IF_V_SIZE_V(V, 32) >
HWY_INLINECombineShiftRightI64Lanes (V hi, V lo)
 
template<int kI64Lanes, class V , HWY_IF_V_SIZE_V(V, 32) >
HWY_INLINESlideUpI64Lanes (V v)
 
template<class D , HWY_IF_V_SIZE_D(D, 32) , HWY_IF_T_SIZE_ONE_OF_D( D,(1<< 1)|((HWY_TARGET > HWY_AVX3) ?(1<< 2) :0)) >
HWY_INLINE VFromD< D > TableLookupSlideUpLanes (D d, VFromD< D > v, size_t amt)
 
template<int kI64Lanes, class V , HWY_IF_V_SIZE_V(V, 32) >
HWY_INLINESlideDownI64Lanes (V v)
 
template<class D , HWY_IF_V_SIZE_D(D, 32) , HWY_IF_T_SIZE_ONE_OF_D( D,(1<< 1)|((HWY_TARGET > HWY_AVX3) ?(1<< 2) :0)) >
HWY_INLINE VFromD< D > TableLookupSlideDownLanes (D d, VFromD< D > v, size_t amt)
 
HWY_INLINE Vec256< uint16_t > Shl (hwy::UnsignedTag, Vec256< uint16_t > v, Vec256< uint16_t > bits)
 
HWY_API Vec256< uint8_t > Shl (hwy::UnsignedTag tag, Vec256< uint8_t > v, Vec256< uint8_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)
 
HWY_INLINE Vec256< uint8_t > NativeExpand (Vec256< uint8_t > v, Mask256< uint8_t > mask)
 
HWY_INLINE Vec256< uint16_t > NativeExpand (Vec256< uint16_t > v, Mask256< uint16_t > mask)
 
HWY_INLINE Vec256< uint32_t > NativeExpand (Vec256< uint32_t > v, Mask256< uint32_t > mask)
 
HWY_INLINE Vec256< uint64_t > NativeExpand (Vec256< uint64_t > v, Mask256< uint64_t > mask)
 
template<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_API void LoadTransposedBlocks3 (D d, const TFromD< D > *HWY_RESTRICT unaligned, VFromD< D > &A, VFromD< D > &B, VFromD< D > &C)
 
template<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_API void LoadTransposedBlocks4 (D d, const TFromD< D > *HWY_RESTRICT unaligned, VFromD< D > &vA, VFromD< D > &vB, VFromD< D > &vC, VFromD< D > &vD)
 
template<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_API void StoreTransposedBlocks2 (VFromD< D > i, VFromD< D > j, D d, TFromD< D > *HWY_RESTRICT unaligned)
 
template<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_API void StoreTransposedBlocks3 (VFromD< D > i, VFromD< D > j, VFromD< D > k, D d, TFromD< D > *HWY_RESTRICT unaligned)
 
template<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_API void StoreTransposedBlocks4 (VFromD< D > i, VFromD< D > j, VFromD< D > k, VFromD< D > l, D d, TFromD< D > *HWY_RESTRICT unaligned)
 
HWY_INLINE __m512i BitCastToInteger (__m512i v)
 
HWY_INLINE __m512i BitCastToInteger (__m512 v)
 
HWY_INLINE __m512i BitCastToInteger (__m512d v)
 
template<typename T >
HWY_INLINE Vec512< uint8_t > BitCastToByte (Vec512< T > v)
 
template<class D , HWY_IF_V_SIZE_D(D, 64) >
HWY_INLINE VFromD< D > BitCastFromByte (D, 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)
 
HWY_INLINE Vec512< uint32_t > SumsOf4 (hwy::UnsignedTag, hwy::SizeTag< 1 >, Vec512< uint8_t > v)
 
template<typename T >
HWY_API Vec512< T > GaloisAffine (Vec512< T > v, Vec512< uint64_t > matrix)
 
template<typename T >
HWY_INLINE Mask512< T > TestBit (hwy::SizeTag< 1 >, Vec512< T > v, Vec512< T > bit)
 
template<typename T >
HWY_INLINE Mask512< T > TestBit (hwy::SizeTag< 2 >, Vec512< T > v, Vec512< T > bit)
 
template<typename T >
HWY_INLINE Mask512< T > TestBit (hwy::SizeTag< 4 >, Vec512< T > v, Vec512< T > bit)
 
template<typename T >
HWY_INLINE Mask512< T > TestBit (hwy::SizeTag< 8 >, Vec512< T > v, Vec512< T > bit)
 
template<typename T >
HWY_INLINE Mask512< T > MaskFromVec (hwy::SizeTag< 1 >, Vec512< T > v)
 
template<typename T >
HWY_INLINE Mask512< T > MaskFromVec (hwy::SizeTag< 2 >, Vec512< T > v)
 
template<typename T >
HWY_INLINE Mask512< T > MaskFromVec (hwy::SizeTag< 4 >, Vec512< T > v)
 
template<typename T >
HWY_INLINE Mask512< T > MaskFromVec (hwy::SizeTag< 8 >, Vec512< T > v)
 
template<typename T >
HWY_INLINE Mask512< T > Not (hwy::SizeTag< 1 >, Mask512< T > m)
 
template<typename T >
HWY_INLINE Mask512< T > Not (hwy::SizeTag< 2 >, Mask512< T > m)
 
template<typename T >
HWY_INLINE Mask512< T > Not (hwy::SizeTag< 4 >, Mask512< T > m)
 
template<typename T >
HWY_INLINE Mask512< T > Not (hwy::SizeTag< 8 >, Mask512< T > m)
 
template<typename T >
HWY_INLINE Mask512< T > And (hwy::SizeTag< 1 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > And (hwy::SizeTag< 2 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > And (hwy::SizeTag< 4 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > And (hwy::SizeTag< 8 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > AndNot (hwy::SizeTag< 1 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > AndNot (hwy::SizeTag< 2 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > AndNot (hwy::SizeTag< 4 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > AndNot (hwy::SizeTag< 8 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Or (hwy::SizeTag< 1 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Or (hwy::SizeTag< 2 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Or (hwy::SizeTag< 4 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Or (hwy::SizeTag< 8 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Xor (hwy::SizeTag< 1 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Xor (hwy::SizeTag< 2 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Xor (hwy::SizeTag< 4 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > Xor (hwy::SizeTag< 8 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > ExclusiveNeither (hwy::SizeTag< 1 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > ExclusiveNeither (hwy::SizeTag< 2 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > ExclusiveNeither (hwy::SizeTag< 4 >, Mask512< T > a, Mask512< T > b)
 
template<typename T >
HWY_INLINE Mask512< T > ExclusiveNeither (hwy::SizeTag< 8 >, Mask512< T > a, Mask512< T > b)
 
template<int kScale, typename T , HWY_IF_UI32(T) >
HWY_INLINE Vec512< T > NativeGather512 (const T *HWY_RESTRICT base, Vec512< int32_t > indices)
 
template<int kScale, typename T , HWY_IF_UI64(T) >
HWY_INLINE Vec512< T > NativeGather512 (const T *HWY_RESTRICT base, Vec512< int64_t > indices)
 
template<int kScale>
HWY_INLINE Vec512< float > NativeGather512 (const float *HWY_RESTRICT base, Vec512< int32_t > indices)
 
template<int kScale>
HWY_INLINE Vec512< double > NativeGather512 (const double *HWY_RESTRICT base, Vec512< int64_t > indices)
 
template<int kScale, typename T , HWY_IF_UI32(T) >
HWY_INLINE Vec512< T > NativeMaskedGatherOr512 (Vec512< T > no, Mask512< T > m, const T *HWY_RESTRICT base, Vec512< int32_t > indices)
 
template<int kScale, typename T , HWY_IF_UI64(T) >
HWY_INLINE Vec512< T > NativeMaskedGatherOr512 (Vec512< T > no, Mask512< T > m, const T *HWY_RESTRICT base, Vec512< int64_t > indices)
 
template<int kScale>
HWY_INLINE Vec512< float > NativeMaskedGatherOr512 (Vec512< float > no, Mask512< float > m, const float *HWY_RESTRICT base, Vec512< int32_t > indices)
 
template<int kScale>
HWY_INLINE Vec512< double > NativeMaskedGatherOr512 (Vec512< double > no, Mask512< double > m, const double *HWY_RESTRICT base, Vec512< int64_t > indices)
 
template<typename T >
HWY_INLINE Vec512< T > InsertBlock (hwy::SizeTag< 0 >, Vec512< T > v, Vec128< T > blk_to_insert)
 
template<size_t kBlockIdx, typename T >
HWY_INLINE Vec512< T > InsertBlock (hwy::SizeTag< kBlockIdx >, Vec512< T > v, Vec128< T > blk_to_insert)
 
template<size_t kBlockIdx, hwy::EnableIf< kBlockIdx !=0 > * = nullptr>
HWY_INLINE Vec512< float > InsertBlock (hwy::SizeTag< kBlockIdx >, Vec512< float > v, Vec128< float > blk_to_insert)
 
template<size_t kBlockIdx, hwy::EnableIf< kBlockIdx !=0 > * = nullptr>
HWY_INLINE Vec512< double > InsertBlock (hwy::SizeTag< kBlockIdx >, Vec512< double > v, Vec128< double > blk_to_insert)
 
template<class DTo , class DFrom , HWY_IF_NOT_FLOAT3264_D(DTo) >
HWY_INLINE VFromD< DTo > ZeroExtendResizeBitCast (hwy::SizeTag< 16 >, hwy::SizeTag< 64 >, DTo d_to, DFrom d_from, VFromD< DFrom > v)
 
template<class DTo , class DFrom , HWY_IF_F64_D(DTo) >
HWY_INLINE Vec512< double > ZeroExtendResizeBitCast (hwy::SizeTag< 16 >, hwy::SizeTag< 64 >, DTo d_to, DFrom d_from, VFromD< DFrom > v)
 
template<class DTo , class DFrom >
HWY_INLINE VFromD< DTo > ZeroExtendResizeBitCast (hwy::SizeTag< 8 >, hwy::SizeTag< 64 >, DTo d_to, DFrom d_from, VFromD< DFrom > v)
 
template<class T , HWY_IF_T_SIZE(T, 1) >
HWY_INLINE Vec512< T > BroadcastLane (hwy::SizeTag< 0 >, Vec512< T > v)
 
HWY_INLINE Vec512< float > BroadcastLane (hwy::SizeTag< 0 >, Vec512< float > v)
 
HWY_INLINE Vec512< double > BroadcastLane (hwy::SizeTag< 0 >, Vec512< double > v)
 
template<size_t kLaneIdx, class T , hwy::EnableIf< kLaneIdx !=0 > * = nullptr>
HWY_INLINE Vec512< T > BroadcastLane (hwy::SizeTag< kLaneIdx >, Vec512< T > v)
 
template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec512< T > ShuffleTwo2301 (const Vec512< T > a, const Vec512< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec512< T > ShuffleTwo1230 (const Vec512< T > a, const Vec512< T > b)
 
template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec512< T > ShuffleTwo3012 (const Vec512< T > a, const Vec512< T > b)
 
template<size_t kIdx3210, class V , HWY_IF_NOT_FLOAT(TFromV< V >) >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 4 >, hwy::SizeTag< 64 >, V v)
 
template<size_t kIdx3210, class V , HWY_IF_NOT_FLOAT(TFromV< V >) >
HWY_INLINEPer4LaneBlockShuffle (hwy::SizeTag< kIdx3210 >, hwy::SizeTag< 8 >, hwy::SizeTag< 64 >, V v)
 
template<int kI32Lanes, class V , HWY_IF_V_SIZE_V(V, 64) >
HWY_INLINESlideUpI32Lanes (V v)
 
template<int kI32Lanes, class V , HWY_IF_V_SIZE_V(V, 64) >
HWY_INLINESlideDownI32Lanes (V v)
 
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, N > NativeCompress (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, N > NativeCompress (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)
 
HWY_INLINE Vec512< uint8_t > NativeExpand (Vec512< uint8_t > v, Mask512< uint8_t > mask)
 
HWY_INLINE Vec512< uint16_t > NativeExpand (Vec512< uint16_t > v, Mask512< uint16_t > mask)
 
template<class D , HWY_IF_V_SIZE_D(D, 64) , HWY_IF_U8_D(D) >
HWY_INLINE VFromD< D > NativeLoadExpand (Mask512< uint8_t > mask, D, const uint8_t *HWY_RESTRICT unaligned)
 
template<class D , HWY_IF_V_SIZE_D(D, 64) , HWY_IF_U16_D(D) >
HWY_INLINE VFromD< D > NativeLoadExpand (Mask512< uint16_t > mask, D, const uint16_t *HWY_RESTRICT unaligned)
 
template<size_t N>
HWY_INLINE Vec128< uint32_t, N > NativeCompress (Vec128< uint32_t, N > v, 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)
 
HWY_INLINE Vec512< uint32_t > NativeExpand (Vec512< uint32_t > v, Mask512< uint32_t > mask)
 
HWY_INLINE Vec512< uint64_t > NativeExpand (Vec512< uint64_t > v, Mask512< uint64_t > mask)
 
template<class D , HWY_IF_V_SIZE_D(D, 64) , HWY_IF_U32_D(D) >
HWY_INLINE VFromD< D > NativeLoadExpand (Mask512< uint32_t > mask, D, const uint32_t *HWY_RESTRICT unaligned)
 
template<class D , HWY_IF_V_SIZE_D(D, 64) , HWY_IF_U64_D(D) >
HWY_INLINE VFromD< D > NativeLoadExpand (Mask512< uint64_t > mask, D, const uint64_t *HWY_RESTRICT unaligned)
 
template<size_t N>
HWY_INLINE Vec128< uint8_t, N > EmuCompress (Vec128< uint8_t, N > v, Mask128< uint8_t, N > mask)
 
template<size_t N>
HWY_INLINE Vec128< uint16_t, N > EmuCompress (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<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void EmuCompressStore (VFromD< D > v, MFromD< D > mask, D d, TFromD< D > *HWY_RESTRICT unaligned)
 
template<class D , HWY_IF_V_SIZE_D(D, 32) , HWY_IF_U16_D(D) >
HWY_INLINE void EmuCompressStore (VFromD< D > v, MFromD< D > mask, D d, TFromD< D > *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<class V , HWY_IF_UNSIGNED_V(V) , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)) , HWY_IF_LANES_LE_D(DFromV< V >, 16) >
HWY_INLINELzcnt32ForU8OrU16 (V v)
 
template<class V , HWY_IF_UNSIGNED_V(V) , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)) , HWY_IF_LANES_D(DFromV< V >, 32) >
HWY_INLINE VFromD< Rebind< uint16_t, DFromV< V > > > Lzcnt32ForU8OrU16AsU16 (V v)
 
HWY_INLINE Vec256< uint8_t > Lzcnt32ForU8OrU16 (Vec256< uint8_t > v)
 
HWY_INLINE Vec512< uint8_t > Lzcnt32ForU8OrU16 (Vec512< uint8_t > v)
 
HWY_INLINE Vec512< uint16_t > Lzcnt32ForU8OrU16 (Vec512< uint16_t > v)
 

Variables

 vreinterpret
 
 _u8_
 

Typedef Documentation

◆ AdjustSimdTagToMinVecPow2

Initial value:
typename AdjustSimdTagToMinVecPow2_t<RemoveConst<D>>::type

◆ Constants

◆ F32ExpLzcntMinMaxCmpV

◆ F32ExpLzcntMinMaxRepartition

◆ NativeLaneType

template<typename T >
using hwy::HWY_NAMESPACE::detail::NativeLaneType = typename NativeLaneTypeT<T>::type

◆ RebindToUnsignedIfNotFloat

Initial value:
hwy::If<(!hwy::IsFloat<TFromD<D>>() && !hwy::IsSpecialFloat<TFromD<D>>()),
RebindToUnsigned<D>, D>
typename IfT< Condition, Then, Else >::type If
Definition base.h:520
HWY_API constexpr bool IsSpecialFloat()
Definition base.h:832

Function Documentation

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

template<typename T , HWY_IF_T_SIZE(T, 1) >
HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::AllHardwareLanes ( )

◆ AllTrue() [1/12]

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

References hwy::HWY_NAMESPACE::m.

Referenced by HeapSelect(), and SiftDown().

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

References hwy::HWY_NAMESPACE::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 )

References hwy::HWY_NAMESPACE::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 )

References hwy::HWY_NAMESPACE::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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
Mask512< T > b )

◆ AVX2ShlU16Vec128()

template<class V >
HWY_API V hwy::HWY_NAMESPACE::detail::AVX2ShlU16Vec128 ( V v,
V bits )

◆ AVX2ShlU8Vec128()

template<class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::AVX2ShlU8Vec128 ( V v,
V bits )

◆ AVX2ShrI8Vec128()

template<class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::AVX2ShrI8Vec128 ( V v,
V bits )

◆ AVX2ShrU8Vec128()

template<class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::AVX2ShrU8Vec128 ( V v,
V bits )

◆ AVX3Blsi() [1/2]

template<class T , HWY_IF_LANES_LE(sizeof(T), 4) >
static HWY_INLINE uint32_t hwy::HWY_NAMESPACE::detail::AVX3Blsi ( T x)
static

◆ AVX3Blsi() [2/2]

template<class T , HWY_IF_T_SIZE(T, 8) >
static HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::AVX3Blsi ( T x)
static

References AVX3Blsi().

◆ AVX3Blsmsk() [1/2]

template<class T , HWY_IF_LANES_LE(sizeof(T), 4) >
static HWY_INLINE uint32_t hwy::HWY_NAMESPACE::detail::AVX3Blsmsk ( T x)
static

◆ AVX3Blsmsk() [2/2]

template<class T , HWY_IF_T_SIZE(T, 8) >
static HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::AVX3Blsmsk ( T x)
static

References AVX3Blsmsk().

◆ BitCastFromByte() [1/21]

template<class D , HWY_SVE_IF_EMULATED_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D d,
svuint8_t v )

◆ BitCastFromByte() [2/21]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D d,
Vec128< uint8_t, d.MaxBytes()> v )

◆ BitCastFromByte() [3/21]

template<class D , HWY_IF_I8_D(D) >
HWY_INLINE Vec128< int8_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec128< uint8_t > v )

◆ BitCastFromByte() [4/21]

template<class D , HWY_IF_U16_D(D) >
HWY_INLINE Vec128< uint16_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec128< uint8_t > v )

◆ BitCastFromByte() [5/21]

template<class D , HWY_IF_I16_D(D) >
HWY_INLINE Vec128< int16_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec128< uint8_t > v )

◆ BitCastFromByte() [6/21]

template<class D , HWY_IF_U32_D(D) >
HWY_INLINE Vec128< uint32_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec128< uint8_t > v )

◆ BitCastFromByte() [7/21]

template<class D , HWY_IF_I32_D(D) >
HWY_INLINE Vec128< int32_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec128< uint8_t > v )

◆ BitCastFromByte() [8/21]

template<class D , HWY_IF_U64_D(D) >
HWY_INLINE Vec128< uint64_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec128< uint8_t > v )

◆ BitCastFromByte() [9/21]

template<class D , HWY_IF_I64_D(D) >
HWY_INLINE Vec128< int64_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec128< uint8_t > v )

◆ BitCastFromByte() [10/21]

template<class D , HWY_IF_F32_D(D) >
HWY_INLINE Vec128< float > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec128< uint8_t > v )

◆ BitCastFromByte() [11/21]

template<class D , HWY_IF_F16_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec128< uint8_t > v )

◆ BitCastFromByte() [12/21]

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec128< uint8_t, D().MaxBytes()> v )

◆ BitCastFromByte() [13/21]

template<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec256< uint8_t > v )

◆ BitCastFromByte() [14/21]

template<class D , HWY_IF_V_SIZE_D(D, 64) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec512< uint8_t > v )

◆ BitCastFromByte() [15/21]

template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_U64_D(D) >
HWY_INLINE Vec64< uint64_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec64< uint8_t > v )

◆ BitCastFromByte() [16/21]

template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_I64_D(D) >
HWY_INLINE Vec64< int64_t > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
Vec64< uint8_t > v )

◆ BitCastFromByte() [17/21]

template<class D , HWY_IF_U8_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
VFromD< D > v )

◆ BitCastFromByte() [18/21]

template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_I8_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
VFromD< RebindToUnsigned< D > > v )

◆ BitCastFromByte() [19/21]

template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_U16_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::BitCastFromByte ( D ,
VFromD< Repartition< uint8_t, D > > v )

◆ BitCastFromByte() [20/21]

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

References BitCastFromByte().

◆ BitCastFromByte() [21/21]

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

References BitCastFromByte().

◆ BitCastToByte() [1/7]

template<class V , HWY_SVE_IF_EMULATED_D(DFromV< V >) >
HWY_INLINE svuint8_t hwy::HWY_NAMESPACE::detail::BitCastToByte ( V v)

◆ BitCastToByte() [2/7]

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

◆ BitCastToByte() [3/7]

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

◆ BitCastToByte() [4/7]

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

◆ BitCastToByte() [5/7]

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

◆ BitCastToByte() [6/7]

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

◆ BitCastToByte() [7/7]

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)

◆ BitCastToInteger() [7/12]

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

◆ BitCastToInteger() [8/12]

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

◆ BitCastToInteger() [9/12]

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

◆ BitCastToInteger() [10/12]

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

◆ BitCastToInteger() [11/12]

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

◆ BitCastToInteger() [12/12]

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

◆ BitsFromBool()

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

◆ BitsFromMask() [1/14]

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

◆ BitsFromMask() [2/14]

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

◆ BitsFromMask() [3/14]

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

◆ BitsFromMask() [4/14]

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

◆ BitsFromMask() [5/14]

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

◆ BitsFromMask() [6/14]

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

◆ BitsFromMask() [7/14]

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

◆ BitsFromMask() [8/14]

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

◆ BitsFromMask() [9/14]

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

◆ BitsFromMask() [10/14]

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

◆ BitsFromMask() [11/14]

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

◆ BitsFromMask() [12/14]

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

◆ BitsFromMask() [13/14]

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

◆ BitsFromMask() [14/14]

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

References BitsFromMask().

◆ BoolFromMask()

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

◆ BroadcastLane() [1/9]

HWY_INLINE Vec256< double > hwy::HWY_NAMESPACE::detail::BroadcastLane ( hwy::SizeTag< 0 > ,
Vec256< double > v )

◆ BroadcastLane() [2/9]

HWY_INLINE Vec256< float > hwy::HWY_NAMESPACE::detail::BroadcastLane ( hwy::SizeTag< 0 > ,
Vec256< float > v )

◆ BroadcastLane() [3/9]

template<class T , HWY_IF_T_SIZE(T, 1) >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::BroadcastLane ( hwy::SizeTag< 0 > ,
Vec256< T > v )

◆ BroadcastLane() [4/9]

HWY_INLINE Vec512< double > hwy::HWY_NAMESPACE::detail::BroadcastLane ( hwy::SizeTag< 0 > ,
Vec512< double > v )

◆ BroadcastLane() [5/9]

HWY_INLINE Vec512< float > hwy::HWY_NAMESPACE::detail::BroadcastLane ( hwy::SizeTag< 0 > ,
Vec512< float > v )

◆ BroadcastLane() [6/9]

template<class T , HWY_IF_T_SIZE(T, 1) >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::BroadcastLane ( hwy::SizeTag< 0 > ,
Vec512< T > v )

◆ BroadcastLane() [7/9]

template<size_t kLaneIdx, hwy::EnableIf< kLaneIdx !=0 > * = nullptr>
HWY_INLINE Vec256< double > hwy::HWY_NAMESPACE::detail::BroadcastLane ( hwy::SizeTag< kLaneIdx > ,
Vec256< double > v )

◆ BroadcastLane() [8/9]

template<size_t kLaneIdx, class T , hwy::EnableIf< kLaneIdx !=0 > * = nullptr, HWY_IF_NOT_T_SIZE(T, 8) >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::BroadcastLane ( hwy::SizeTag< kLaneIdx > ,
Vec256< T > v )

◆ BroadcastLane() [9/9]

template<size_t kLaneIdx, class T , hwy::EnableIf< kLaneIdx !=0 > * = nullptr>
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::BroadcastLane ( hwy::SizeTag< kLaneIdx > ,
Vec512< T > v )

◆ BytesAbove()

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

◆ CastValueForF2IConv()

template<class ToT , class FromT >
HWY_INLINE ToT hwy::HWY_NAMESPACE::detail::CastValueForF2IConv ( FromT val)

◆ CastValueForInRangeF2IConv()

template<class ToT , class FromT >
HWY_INLINE ToT hwy::HWY_NAMESPACE::detail::CastValueForInRangeF2IConv ( FromT val)

References HWY_MIN, and hwy::ScalarAbs().

◆ CastValueForPromoteTo() [1/3]

template<class ToT >
HWY_INLINE ToT hwy::HWY_NAMESPACE::detail::CastValueForPromoteTo ( hwy::SignedTag ,
float val )

◆ CastValueForPromoteTo() [2/3]

template<class ToT >
HWY_INLINE ToT hwy::HWY_NAMESPACE::detail::CastValueForPromoteTo ( hwy::UnsignedTag ,
float val )

◆ CastValueForPromoteTo() [3/3]

template<class ToT , class ToTypeTag , class FromT >
HWY_INLINE ToT hwy::HWY_NAMESPACE::detail::CastValueForPromoteTo ( ToTypeTag ,
FromT val )

◆ ChangeLMUL() [1/2]

template<class D , class V , HWY_IF_POW2_LE_D(DFromV< VFromD< D > >, DFromV< V >().Pow2() - 1) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::ChangeLMUL ( D d,
V v )

◆ ChangeLMUL() [2/2]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::ChangeLMUL ( D ,
VFromD< D > v )

References ChangeLMUL().

Referenced by ChangeLMUL(), and ChangeLMUL().

◆ ClampF64ToI32Max()

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::ClampF64ToI32Max ( D d,
VFromD< D > v )

◆ CombineShiftRightI32Lanes()

template<int kI32Lanes, class V , HWY_IF_V_SIZE_V(V, 32) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::CombineShiftRightI32Lanes ( V hi,
V lo )

◆ CombineShiftRightI64Lanes()

template<int kI64Lanes, class V , HWY_IF_V_SIZE_V(V, 32) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::CombineShiftRightI64Lanes ( V hi,
V lo )

◆ Compress()

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

◆ CompressBits()

template<typename T , size_t N, HWY_IF_NOT_T_SIZE(T, 1) >
HWY_API Vec128< T, N > hwy::HWY_NAMESPACE::detail::CompressBits ( Vec128< T, N > v,
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,
uint64_t mask_bits )

◆ CompressNotBits()

template<typename T , size_t N, HWY_IF_NOT_T_SIZE(T, 1) >
HWY_API Vec128< T, N > hwy::HWY_NAMESPACE::detail::CompressNotBits ( Vec128< T, N > v,
uint64_t mask_bits )

◆ ConcatEven()

template<size_t N>
HWY_INLINE Vec128< float16_t, N > hwy::HWY_NAMESPACE::detail::ConcatEven ( Vec128< float16_t, N > hi,
Vec128< float16_t, N > lo )

◆ ConcatOdd()

template<size_t N>
HWY_INLINE Vec128< float16_t, N > hwy::HWY_NAMESPACE::detail::ConcatOdd ( Vec128< float16_t, N > hi,
Vec128< float16_t, N > lo )

◆ ConvertFToI() [1/2]

template<class D , HWY_IF_V_SIZE_D(D, 16) , HWY_IF_I32_D(D) >
HWY_INLINE Vec128< int32_t > hwy::HWY_NAMESPACE::detail::ConvertFToI ( D ,
Vec128< float > v )

◆ ConvertFToI() [2/2]

template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_I32_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::ConvertFToI ( D ,
VFromD< RebindToFloat< D > > v )

References HWY_ARCH_ARM_A64.

◆ ConvertFToU() [1/2]

template<class D , HWY_IF_V_SIZE_D(D, 16) , HWY_IF_U32_D(D) >
HWY_INLINE Vec128< uint32_t > hwy::HWY_NAMESPACE::detail::ConvertFToU ( D ,
Vec128< float > v )

◆ ConvertFToU() [2/2]

template<class D , HWY_IF_V_SIZE_LE_D(D, 8) , HWY_IF_U32_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::ConvertFToU ( D ,
VFromD< RebindToFloat< D > > v )

References HWY_ARCH_ARM_A64.

◆ ConvertTo() [1/2]

template<typename TFrom , typename DTo >
HWY_API VFromD< DTo > hwy::HWY_NAMESPACE::detail::ConvertTo ( hwy::FloatTag ,
DTo ,
Vec128< TFrom, HWY_MAX_LANES_D(DTo)> from )

◆ ConvertTo() [2/2]

template<typename TFrom , typename DTo >
HWY_API VFromD< DTo > hwy::HWY_NAMESPACE::detail::ConvertTo ( hwy::NonFloatTag ,
DTo ,
Vec128< TFrom, HWY_MAX_LANES_D(DTo)> from )

References HWY_MAX_LANES_D.

◆ ConvToF64WithRoundToOdd()

template<class V , HWY_IF_I64(TFromV< V >) >
HWY_INLINE VFromD< RebindToFloat< DFromV< V > > > hwy::HWY_NAMESPACE::detail::ConvToF64WithRoundToOdd ( V v)

◆ CountAndReplaceNaN() [1/2]

template<class D , class Traits , typename T , HWY_IF_FLOAT(T) >
HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::CountAndReplaceNaN ( D d,
Traits st,
T *HWY_RESTRICT keys,
size_t num )

◆ CountAndReplaceNaN() [2/2]

template<class D , class Traits , typename T , HWY_IF_NOT_FLOAT(T) >
HWY_INLINE size_t hwy::HWY_NAMESPACE::detail::CountAndReplaceNaN ( D ,
Traits ,
T * HWY_RESTRICT,
size_t  )

◆ CountTrue() [1/4]

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

◆ CountTrue() [2/4]

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

◆ CountTrue() [3/4]

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

◆ CountTrue() [4/4]

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

◆ DemoteFromU64MaskOutResult()

template<class D , HWY_IF_UNSIGNED_D(D) >
HWY_INLINE VFromD< Rebind< uint64_t, D > > hwy::HWY_NAMESPACE::detail::DemoteFromU64MaskOutResult ( D ,
VFromD< Rebind< uint64_t, D > > v )

Referenced by DemoteFromU64Saturate().

◆ DemoteFromU64Saturate()

template<class D >
HWY_INLINE VFromD< Rebind< uint64_t, D > > hwy::HWY_NAMESPACE::detail::DemoteFromU64Saturate ( D dn,
VFromD< Rebind< uint64_t, D > > v )

◆ DemoteToF32WithRoundToOdd()

template<class DF32 , HWY_IF_F32_D(DF32) >
static HWY_INLINE VFromD< DF32 > hwy::HWY_NAMESPACE::detail::DemoteToF32WithRoundToOdd ( DF32 df32,
VFromD< Rebind< double, DF32 > > v )
static

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

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::EmuCompressStore ( VFromD< D > v,
MFromD< D > mask,
D d,
TFromD< D > *HWY_RESTRICT unaligned )

◆ EmuCompressStore() [2/2]

template<class D , HWY_IF_V_SIZE_D(D, 32) , HWY_IF_U16_D(D) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::EmuCompressStore ( VFromD< D > v,
MFromD< D > mask,
D d,
TFromD< D > *HWY_RESTRICT unaligned )

◆ Eq128UpperVec() [1/2]

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

◆ Eq128UpperVec() [2/2]

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

◆ Eq128Vec() [1/3]

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

◆ Eq128Vec() [2/3]

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

◆ Eq128Vec() [3/3]

template<class D , HWY_IF_U64_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::Eq128Vec ( D d,
VFromD< D > a,
VFromD< D > 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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
Mask512< T > b )

◆ ExpandLoop()

template<class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::ExpandLoop ( V v,
svbool_t mask )

◆ Ext()

template<class D , HWY_RVV_IF_EMULATED_D(D) >
VFromD< D > hwy::HWY_NAMESPACE::detail::Ext ( D d,
VFromD< Half< D > > v )

◆ ExtractLane() [1/6]

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

◆ ExtractLane() [2/6]

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

◆ ExtractLane() [3/6]

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

◆ ExtractLane() [4/6]

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

◆ ExtractLane() [5/6]

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

◆ ExtractLane() [6/6]

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

◆ F32ExpLzcntMinMaxBitCast()

template<class V >
HWY_INLINE F32ExpLzcntMinMaxCmpV< V > hwy::HWY_NAMESPACE::detail::F32ExpLzcntMinMaxBitCast ( V v)

◆ FirstNPerBlock()

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

◆ FixConversionOverflow()

template<class DI >
HWY_INLINE VFromD< DI > hwy::HWY_NAMESPACE::detail::FixConversionOverflow ( DI di,
VFromD< RebindToFloat< DI > > original,
VFromD< DI > converted )

◆ GaloisAffine() [1/3]

template<typename T , size_t N>
HWY_API Vec128< T, N > hwy::HWY_NAMESPACE::detail::GaloisAffine ( Vec128< T, N > v,
VFromD< Repartition< uint64_t, Simd< T, N, 0 > > > matrix )

◆ GaloisAffine() [2/3]

template<typename T >
HWY_API Vec256< T > hwy::HWY_NAMESPACE::detail::GaloisAffine ( Vec256< T > v,
Vec256< uint64_t > matrix )

◆ GaloisAffine() [3/3]

template<typename T >
HWY_API Vec512< T > hwy::HWY_NAMESPACE::detail::GaloisAffine ( Vec512< T > v,
Vec512< uint64_t > matrix )

◆ GetLane()

template<size_t kLane, class V , HWY_NEON_IF_EMULATED_D(DFromV< V >) >
static HWY_INLINE HWY_MAYBE_UNUSED TFromV< V > hwy::HWY_NAMESPACE::detail::GetLane ( V v)
static

◆ HeapPartialSort()

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

◆ HeapSelect()

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

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

◆ I128Subtract()

template<class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::I128Subtract ( V a,
V b )

◆ I32RangeU32ToF32BiasedExp()

template<class V , HWY_IF_U32_D(DFromV< V >) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::I32RangeU32ToF32BiasedExp ( V v)

◆ IdxFromBits() [1/3]

template<typename T , size_t N, HWY_IF_T_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 > ,
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 > ,
uint64_t mask_bits )

◆ IdxFromNotBits() [1/3]

template<typename T , size_t N, HWY_IF_T_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 > ,
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 > ,
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 )

◆ IndicesForExpandFromBits() [1/2]

HWY_INLINE svuint8_t hwy::HWY_NAMESPACE::detail::IndicesForExpandFromBits ( uint64_t mask_bits)

◆ IndicesForExpandFromBits() [2/2]

template<size_t N>
HWY_INLINE Vec128< uint8_t, N > hwy::HWY_NAMESPACE::detail::IndicesForExpandFromBits ( uint64_t mask_bits)

◆ IndicesFromBits128()

template<class D , HWY_IF_T_SIZE_D(D, 2) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::IndicesFromBits128 ( D d,
uint64_t mask_bits )

◆ IndicesFromNotBits128()

template<class D , HWY_IF_T_SIZE_D(D, 2) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::IndicesFromNotBits128 ( D d,
uint64_t mask_bits )

◆ IndicesFromVecBroadcastLaneBytes()

template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE VFromD< Repartition< uint8_t, D > > hwy::HWY_NAMESPACE::detail::IndicesFromVecBroadcastLaneBytes ( D d)

◆ IndicesFromVecByteOffsets()

template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE VFromD< Repartition< uint8_t, D > > hwy::HWY_NAMESPACE::detail::IndicesFromVecByteOffsets ( D d)

◆ InsertBlock() [1/4]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::InsertBlock ( hwy::SizeTag< 0 > ,
Vec512< T > v,
Vec128< T > blk_to_insert )

◆ InsertBlock() [2/4]

template<size_t kBlockIdx, hwy::EnableIf< kBlockIdx !=0 > * = nullptr>
HWY_INLINE Vec512< double > hwy::HWY_NAMESPACE::detail::InsertBlock ( hwy::SizeTag< kBlockIdx > ,
Vec512< double > v,
Vec128< double > blk_to_insert )

◆ InsertBlock() [3/4]

template<size_t kBlockIdx, hwy::EnableIf< kBlockIdx !=0 > * = nullptr>
HWY_INLINE Vec512< float > hwy::HWY_NAMESPACE::detail::InsertBlock ( hwy::SizeTag< kBlockIdx > ,
Vec512< float > v,
Vec128< float > blk_to_insert )

◆ InsertBlock() [4/4]

template<size_t kBlockIdx, typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::InsertBlock ( hwy::SizeTag< kBlockIdx > ,
Vec512< T > v,
Vec128< T > blk_to_insert )

◆ InsertLane() [1/6]

template<size_t kLane, class V , class D = DFromV<V>, HWY_NEON_IF_EMULATED_D(D) >
HWY_API V hwy::HWY_NAMESPACE::detail::InsertLane ( const V v,
TFromD< D > t )

◆ InsertLane() [2/6]

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

◆ InsertLane() [3/6]

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

◆ InsertLane() [4/6]

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

◆ InsertLane() [5/6]

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

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

◆ InsertLaneUsingBroadcastAndBlend()

template<class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::InsertLaneUsingBroadcastAndBlend ( V v,
size_t i,
TFromV< V > t )

◆ IntDiv() [1/2]

template<size_t kOrigLaneSize, class V , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)) , HWY_IF_V_SIZE_LE_V( V, HWY_MAX_BYTES/((!HWY_HAVE_FLOAT16 &&sizeof(TFromV< V >)==1) ? 4 :2)) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::IntDiv ( V a,
V b )

◆ IntDiv() [2/2]

template<size_t kOrigLaneSize, class V , HWY_IF_T_SIZE_ONE_OF_V(V,(HWY_HAVE_FLOAT64 ? 0 :(1<< 4))|(1<< 8)) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::IntDiv ( V a,
V b )

◆ IntDivConvFloatToInt()

template<class D , class V , HWY_IF_T_SIZE_D(D, sizeof(TFromV< V >)) >
HWY_INLINE Vec< D > hwy::HWY_NAMESPACE::detail::IntDivConvFloatToInt ( D di,
V vf )

◆ IntDivConvIntToFloat()

template<class D , class V , HWY_IF_T_SIZE_D(D, sizeof(TFromV< V >)) >
HWY_INLINE Vec< D > hwy::HWY_NAMESPACE::detail::IntDivConvIntToFloat ( D df,
V vi )

References ConvertTo().

Referenced by IntDivUsingFloatDiv().

◆ IntDivUsingFloatDiv() [1/2]

template<size_t kOrigLaneSize, class V , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(V) , HWY_IF_T_SIZE_GT(TFromV< V >, kOrigLaneSize) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::IntDivUsingFloatDiv ( V a,
V b )

◆ IntDivUsingFloatDiv() [2/2]

template<size_t kOrigLaneSize, class V , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(V) , HWY_IF_T_SIZE(TFromV< V >, kOrigLaneSize) , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 4)|(1<< 8)) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::IntDivUsingFloatDiv ( V a,
V b )

◆ InterleaveLowerBlocks()

template<class D , class V , HWY_IF_POW2_LE_D(D, 2) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::InterleaveLowerBlocks ( D d,
const V a,
const V b )

◆ InterleaveUpper() [1/11]

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

◆ InterleaveUpper() [2/11]

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

◆ InterleaveUpper() [3/11]

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

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

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

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

template<typename T , HWY_IF_T_SIZE(T, 8) >
HWY_API Vec128< T > hwy::HWY_NAMESPACE::detail::InterleaveUpper ( Vec128< T > a,
Vec128< T > b )

◆ InterleaveUpper() [8/11]

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

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

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

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 )

◆ InterleaveUpperBlocks()

template<class D , class V , HWY_IF_POW2_LE_D(D, 2) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::InterleaveUpperBlocks ( D d,
const V a,
const V b )

◆ InterleaveWhole()

template<class D , HWY_IF_T_SIZE_ONE_OF_D(D,(1<< 1)|(1<< 2)|(1<< 4)) , HWY_IF_POW2_GT_D(D, -3) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::detail::InterleaveWhole ( D d,
VFromD< Half< D > > a,
VFromD< Half< D > > b )

◆ IntMod()

template<size_t kOrigLaneSize, class V , HWY_IF_NOT_FLOAT_NOR_SPECIAL_V(V) , HWY_IF_T_SIZE_ONE_OF_V(V,((HWY_TARGET<=HWY_SSE2|| HWY_TARGET==HWY_WASM|| HWY_TARGET==HWY_WASM_EMU256) ? 0 :(1<< 1))|(1<< 2)|(1<< 4)|(1<< 8)) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::IntMod ( V a,
V b )

◆ Iota0() [1/2]

template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::Iota0 ( D d)

◆ Iota0() [2/2]

template<class D , HWY_IF_T_SIZE_D(D, 2) , HWY_IF_NOT_SPECIAL_FLOAT_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::Iota0 ( D d)

◆ IsConstantRawAltivecVect() [1/5]

template<class RawV >
static HWY_INLINE bool hwy::HWY_NAMESPACE::detail::IsConstantRawAltivecVect ( hwy::SizeTag< 1 > ,
RawV v )
static

◆ IsConstantRawAltivecVect() [2/5]

template<class RawV >
static HWY_INLINE bool hwy::HWY_NAMESPACE::detail::IsConstantRawAltivecVect ( hwy::SizeTag< 2 > ,
RawV v )
static

◆ IsConstantRawAltivecVect() [3/5]

template<class RawV >
static HWY_INLINE bool hwy::HWY_NAMESPACE::detail::IsConstantRawAltivecVect ( hwy::SizeTag< 4 > ,
RawV v )
static

◆ IsConstantRawAltivecVect() [4/5]

template<class RawV >
static HWY_INLINE bool hwy::HWY_NAMESPACE::detail::IsConstantRawAltivecVect ( hwy::SizeTag< 8 > ,
RawV v )
static

◆ IsConstantRawAltivecVect() [5/5]

template<class RawV >
static HWY_INLINE bool hwy::HWY_NAMESPACE::detail::IsConstantRawAltivecVect ( RawV v)
static

◆ IsEven()

template<class D , HWY_IF_NOT_T_SIZE_D(D, 8) >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::detail::IsEven ( D d)

◆ IsFull()

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

◆ IsGE128()

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

References IsGE128().

Referenced by IsGE128().

◆ IsLT128()

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

References IsLT128().

Referenced by IsLT128().

◆ IsOdd()

template<class D , HWY_IF_NOT_T_SIZE_D(D, 8) >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::detail::IsOdd ( D d)

◆ IsSupportedLMUL()

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

References hwy::HWY_NAMESPACE::d.

◆ LaneIndicesFromByteIndices() [1/2]

template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE svuint8_t hwy::HWY_NAMESPACE::detail::LaneIndicesFromByteIndices ( D ,
svuint8_t idx )

Referenced by ExpandLoop().

◆ LaneIndicesFromByteIndices() [2/2]

template<class D , class DU = RebindToUnsigned<D>, HWY_IF_NOT_T_SIZE_D(D, 1) >
HWY_INLINE VFromD< DU > hwy::HWY_NAMESPACE::detail::LaneIndicesFromByteIndices ( D ,
svuint8_t idx )

◆ LanesPerBlock() [1/2]

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

◆ LanesPerBlock() [2/2]

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

◆ LargerSortValue()

template<class D , HWY_IF_FLOAT_OR_SPECIAL_D(D) >
Vec< D > hwy::HWY_NAMESPACE::detail::LargerSortValue ( D d,
Vec< D > v )

◆ LargestSortValue()

template<class D , HWY_IF_FLOAT_OR_SPECIAL_D(D) >
Vec< D > hwy::HWY_NAMESPACE::detail::LargestSortValue ( D d)

◆ Load8Bytes() [1/2]

template<class D , HWY_IF_V_SIZE_LE_D(D, 8) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::Load8Bytes ( D d,
const uint8_t * bytes )

◆ Load8Bytes() [2/2]

template<class D , HWY_IF_V_SIZE_D(D, 16) >
HWY_INLINE Vec128< uint8_t > hwy::HWY_NAMESPACE::detail::Load8Bytes ( D ,
const uint8_t * bytes )

References HWY_RCAST_ALIGNED.

Referenced by IdxFromBits(), and IdxFromNotBits().

◆ LoadMaskBits()

template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::detail::LoadMaskBits ( D d,
uint64_t mask_bits )

◆ LoadMaskBits128()

template<class D , HWY_IF_T_SIZE_D(D, 1) >
HWY_INLINE MFromD< D > hwy::HWY_NAMESPACE::detail::LoadMaskBits128 ( D ,
uint64_t mask_bits )

◆ LoadTransposedBlocks3() [1/3]

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

◆ LoadTransposedBlocks3() [2/3]

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::LoadTransposedBlocks3 ( D d,
const TFromD< D > *HWY_RESTRICT unaligned,
VFromD< D > & A,
VFromD< D > & B,
VFromD< D > & C )

◆ LoadTransposedBlocks3() [3/3]

template<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_API void hwy::HWY_NAMESPACE::detail::LoadTransposedBlocks3 ( D d,
const TFromD< D > *HWY_RESTRICT unaligned,
VFromD< D > & A,
VFromD< D > & B,
VFromD< D > & C )

◆ LoadTransposedBlocks4() [1/3]

template<class D , typename T = TFromD<D>>
HWY_API void hwy::HWY_NAMESPACE::detail::LoadTransposedBlocks4 ( D d,
const T *HWY_RESTRICT unaligned,
Vec256< T > & vA,
Vec256< T > & vB,
Vec256< T > & vC,
Vec256< T > & vD )

◆ LoadTransposedBlocks4() [2/3]

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::LoadTransposedBlocks4 ( D d,
const TFromD< D > *HWY_RESTRICT unaligned,
VFromD< D > & vA,
VFromD< D > & vB,
VFromD< D > & vC,
VFromD< D > & vD )

◆ LoadTransposedBlocks4() [3/3]

template<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_API void hwy::HWY_NAMESPACE::detail::LoadTransposedBlocks4 ( D d,
const TFromD< D > *HWY_RESTRICT unaligned,
VFromD< D > & vA,
VFromD< D > & vB,
VFromD< D > & vC,
VFromD< D > & vD )

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

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

◆ Lt128UpperVec() [2/2]

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

◆ Lt128Vec() [1/3]

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

◆ Lt128Vec() [2/3]

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

◆ Lt128Vec() [3/3]

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

◆ Lzcnt32ForU8OrU16() [1/4]

template<class V , HWY_IF_UNSIGNED_V(V) , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)) , HWY_IF_LANES_LE_D(DFromV< V >, 16) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Lzcnt32ForU8OrU16 ( V v)

◆ Lzcnt32ForU8OrU16() [2/4]

HWY_INLINE Vec256< uint8_t > hwy::HWY_NAMESPACE::detail::Lzcnt32ForU8OrU16 ( Vec256< uint8_t > v)

◆ Lzcnt32ForU8OrU16() [3/4]

HWY_INLINE Vec512< uint16_t > hwy::HWY_NAMESPACE::detail::Lzcnt32ForU8OrU16 ( Vec512< uint16_t > v)

◆ Lzcnt32ForU8OrU16() [4/4]

HWY_INLINE Vec512< uint8_t > hwy::HWY_NAMESPACE::detail::Lzcnt32ForU8OrU16 ( Vec512< uint8_t > v)

◆ Lzcnt32ForU8OrU16AsU16()

template<class V , HWY_IF_UNSIGNED_V(V) , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)) , HWY_IF_LANES_D(DFromV< V >, 32) >
HWY_INLINE VFromD< Rebind< uint16_t, DFromV< V > > > hwy::HWY_NAMESPACE::detail::Lzcnt32ForU8OrU16AsU16 ( V v)

◆ MakeMask()

template<class D >
svbool_t hwy::HWY_NAMESPACE::detail::MakeMask ( D 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 )

◆ MaskFromVec() [3/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 1 > ,
Vec512< T > 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 )

◆ MaskFromVec() [5/12]

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

◆ MaskFromVec() [6/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 2 > ,
Vec512< T > 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 )

◆ MaskFromVec() [8/12]

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

◆ MaskFromVec() [9/12]

template<typename T >
HWY_INLINE Mask512< T > hwy::HWY_NAMESPACE::detail::MaskFromVec ( hwy::SizeTag< 4 > ,
Vec512< T > 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 )

◆ MaskFromVec() [11/12]

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

◆ MaskFromVec() [12/12]

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

◆ MaskLowerHalf()

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

◆ MaskUpperHalf()

template<class D >
svbool_t hwy::HWY_NAMESPACE::detail::MaskUpperHalf ( D 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,
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,
Vec128< T, N > b )

◆ 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 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,
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,
Vec128< T, N > b )

◆ 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,
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,
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,
Vec128< T, N > b )

◆ MulAdd()

template<size_t N>
HWY_API Vec128< float, N > hwy::HWY_NAMESPACE::detail::MulAdd ( Vec128< float, N > add,
Vec128< float, N > mul,
Vec128< float, N > x )

◆ 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< uint8_t, N > hwy::HWY_NAMESPACE::detail::NativeCompress ( const Vec128< uint8_t, N > v,
const Mask128< uint8_t, N > mask )

◆ NativeCompress() [3/9]

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

◆ NativeCompress() [4/9]

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

◆ NativeCompress() [5/9]

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

◆ NativeCompress() [6/9]

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

◆ NativeCompress() [7/9]

template<size_t N>
HWY_INLINE Vec128< uint32_t, N > hwy::HWY_NAMESPACE::detail::NativeCompress ( Vec128< uint32_t, N > v,
Mask128< uint32_t, N > 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 )

◆ NativeExpand() [1/12]

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

◆ NativeExpand() [2/12]

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

◆ NativeExpand() [3/12]

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

◆ NativeExpand() [4/12]

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

◆ NativeExpand() [5/12]

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

◆ NativeExpand() [6/12]

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

◆ NativeExpand() [7/12]

HWY_INLINE Vec256< uint64_t > hwy::HWY_NAMESPACE::detail::NativeExpand ( Vec256< uint64_t > v,
Mask256< uint64_t > mask )

◆ NativeExpand() [8/12]

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

◆ NativeExpand() [9/12]

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

◆ NativeExpand() [10/12]

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

◆ NativeExpand() [11/12]

HWY_INLINE Vec512< uint64_t > hwy::HWY_NAMESPACE::detail::NativeExpand ( Vec512< uint64_t > v,
Mask512< uint64_t > mask )

◆ NativeExpand() [12/12]

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

◆ NativeGather128() [1/4]

template<int kScale, size_t N>
HWY_INLINE Vec128< double, N > hwy::HWY_NAMESPACE::detail::NativeGather128 ( const double *HWY_RESTRICT base,
Vec128< int64_t, N > indices )

◆ NativeGather128() [2/4]

template<int kScale, size_t N>
HWY_INLINE Vec128< float, N > hwy::HWY_NAMESPACE::detail::NativeGather128 ( const float *HWY_RESTRICT base,
Vec128< int32_t, N > indices )

◆ NativeGather128() [3/4]

template<int kScale, typename T , size_t N, HWY_IF_UI32(T) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::NativeGather128 ( const T *HWY_RESTRICT base,
Vec128< int32_t, N > indices )

◆ NativeGather128() [4/4]

template<int kScale, typename T , size_t N, HWY_IF_UI64(T) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::NativeGather128 ( const T *HWY_RESTRICT base,
Vec128< int64_t, N > indices )

◆ NativeGather256() [1/4]

template<int kScale>
HWY_API Vec256< double > hwy::HWY_NAMESPACE::detail::NativeGather256 ( const double *HWY_RESTRICT base,
Vec256< int64_t > indices )

◆ NativeGather256() [2/4]

template<int kScale>
HWY_API Vec256< float > hwy::HWY_NAMESPACE::detail::NativeGather256 ( const float *HWY_RESTRICT base,
Vec256< int32_t > indices )

◆ NativeGather256() [3/4]

template<int kScale, typename T , HWY_IF_UI32(T) >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::NativeGather256 ( const T *HWY_RESTRICT base,
Vec256< int32_t > indices )

◆ NativeGather256() [4/4]

template<int kScale, typename T , HWY_IF_UI64(T) >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::NativeGather256 ( const T *HWY_RESTRICT base,
Vec256< int64_t > indices )

◆ NativeGather512() [1/4]

template<int kScale>
HWY_INLINE Vec512< double > hwy::HWY_NAMESPACE::detail::NativeGather512 ( const double *HWY_RESTRICT base,
Vec512< int64_t > indices )

◆ NativeGather512() [2/4]

template<int kScale>
HWY_INLINE Vec512< float > hwy::HWY_NAMESPACE::detail::NativeGather512 ( const float *HWY_RESTRICT base,
Vec512< int32_t > indices )

◆ NativeGather512() [3/4]

template<int kScale, typename T , HWY_IF_UI32(T) >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::NativeGather512 ( const T *HWY_RESTRICT base,
Vec512< int32_t > indices )

◆ NativeGather512() [4/4]

template<int kScale, typename T , HWY_IF_UI64(T) >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::NativeGather512 ( const T *HWY_RESTRICT base,
Vec512< int64_t > indices )

◆ NativeLanePointer() [1/2]

template<typename T , HWY_IF_NOT_SPECIAL_FLOAT(T) >
HWY_INLINE T * hwy::HWY_NAMESPACE::detail::NativeLanePointer ( T * p)

◆ NativeLanePointer() [2/2]

template<typename T , typename NT = NativeLaneType<RemoveConst<T>>, HWY_IF_F16(T) >
HWY_INLINE constexpr If< IsConst< T >(), const NT *, NT * > hwy::HWY_NAMESPACE::detail::NativeLanePointer ( T * p)
constexpr

◆ NativeLoadExpand() [1/8]

template<class D , HWY_IF_V_SIZE_D(D, 64) , HWY_IF_U16_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::NativeLoadExpand ( Mask512< uint16_t > mask,
D ,
const uint16_t *HWY_RESTRICT unaligned )

◆ NativeLoadExpand() [2/8]

template<class D , HWY_IF_V_SIZE_D(D, 64) , HWY_IF_U32_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::NativeLoadExpand ( Mask512< uint32_t > mask,
D ,
const uint32_t *HWY_RESTRICT unaligned )

◆ NativeLoadExpand() [3/8]

template<class D , HWY_IF_V_SIZE_D(D, 64) , HWY_IF_U64_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::NativeLoadExpand ( Mask512< uint64_t > mask,
D ,
const uint64_t *HWY_RESTRICT unaligned )

◆ NativeLoadExpand() [4/8]

template<class D , HWY_IF_V_SIZE_D(D, 64) , HWY_IF_U8_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::NativeLoadExpand ( Mask512< uint8_t > mask,
D ,
const uint8_t *HWY_RESTRICT unaligned )

◆ NativeLoadExpand() [5/8]

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) , HWY_IF_U16_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::NativeLoadExpand ( MFromD< D > mask,
D ,
const uint16_t *HWY_RESTRICT unaligned )

References NativeLoadExpand().

◆ NativeLoadExpand() [6/8]

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) , HWY_IF_U32_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::NativeLoadExpand ( MFromD< D > mask,
D ,
const uint32_t *HWY_RESTRICT unaligned )

References NativeLoadExpand().

◆ NativeLoadExpand() [7/8]

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) , HWY_IF_U64_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::NativeLoadExpand ( MFromD< D > mask,
D ,
const uint64_t *HWY_RESTRICT unaligned )

References NativeLoadExpand().

◆ NativeLoadExpand() [8/8]

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) , HWY_IF_U8_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::NativeLoadExpand ( MFromD< D > mask,
D ,
const uint8_t *HWY_RESTRICT unaligned )

◆ NativeMaskedGatherOr128() [1/4]

template<int kScale, size_t N>
HWY_INLINE Vec128< double, N > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr128 ( Vec128< double, N > no,
Mask128< double, N > m,
const double *HWY_RESTRICT base,
Vec128< int64_t, N > indices )

◆ NativeMaskedGatherOr128() [2/4]

template<int kScale, size_t N>
HWY_INLINE Vec128< float, N > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr128 ( Vec128< float, N > no,
Mask128< float, N > m,
const float *HWY_RESTRICT base,
Vec128< int32_t, N > indices )

◆ NativeMaskedGatherOr128() [3/4]

template<int kScale, typename T , size_t N, HWY_IF_UI32(T) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr128 ( Vec128< T, N > no,
Mask128< T, N > m,
const T *HWY_RESTRICT base,
Vec128< int32_t, N > indices )

◆ NativeMaskedGatherOr128() [4/4]

template<int kScale, typename T , size_t N, HWY_IF_UI64(T) >
HWY_INLINE Vec128< T, N > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr128 ( Vec128< T, N > no,
Mask128< T, N > m,
const T *HWY_RESTRICT base,
Vec128< int64_t, N > indices )

◆ NativeMaskedGatherOr256() [1/4]

template<int kScale>
HWY_API Vec256< double > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr256 ( Vec256< double > no,
Mask256< double > m,
const double *HWY_RESTRICT base,
Vec256< int64_t > indices )

◆ NativeMaskedGatherOr256() [2/4]

template<int kScale>
HWY_API Vec256< float > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr256 ( Vec256< float > no,
Mask256< float > m,
const float *HWY_RESTRICT base,
Vec256< int32_t > indices )

◆ NativeMaskedGatherOr256() [3/4]

template<int kScale, typename T , HWY_IF_UI32(T) >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr256 ( Vec256< T > no,
Mask256< T > m,
const T *HWY_RESTRICT base,
Vec256< int32_t > indices )

◆ NativeMaskedGatherOr256() [4/4]

template<int kScale, typename T , HWY_IF_UI64(T) >
HWY_INLINE Vec256< T > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr256 ( Vec256< T > no,
Mask256< T > m,
const T *HWY_RESTRICT base,
Vec256< int64_t > indices )

◆ NativeMaskedGatherOr512() [1/4]

template<int kScale>
HWY_INLINE Vec512< double > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr512 ( Vec512< double > no,
Mask512< double > m,
const double *HWY_RESTRICT base,
Vec512< int64_t > indices )

◆ NativeMaskedGatherOr512() [2/4]

template<int kScale>
HWY_INLINE Vec512< float > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr512 ( Vec512< float > no,
Mask512< float > m,
const float *HWY_RESTRICT base,
Vec512< int32_t > indices )

◆ NativeMaskedGatherOr512() [3/4]

template<int kScale, typename T , HWY_IF_UI32(T) >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr512 ( Vec512< T > no,
Mask512< T > m,
const T *HWY_RESTRICT base,
Vec512< int32_t > indices )

◆ NativeMaskedGatherOr512() [4/4]

template<int kScale, typename T , HWY_IF_UI64(T) >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::NativeMaskedGatherOr512 ( Vec512< T > no,
Mask512< T > m,
const T *HWY_RESTRICT base,
Vec512< int64_t > indices )

◆ NativeMaskedScatter128() [1/3]

template<int kScale, class D , class VI , HWY_IF_F64_D(D) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeMaskedScatter128 ( VFromD< D > v,
MFromD< D > m,
D d,
double *HWY_RESTRICT base,
VI index )

◆ NativeMaskedScatter128() [2/3]

template<int kScale, class D , class VI , HWY_IF_F32_D(D) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeMaskedScatter128 ( VFromD< D > v,
MFromD< D > m,
D d,
float *HWY_RESTRICT base,
VI index )

◆ NativeMaskedScatter128() [3/3]

template<int kScale, class D , class VI , HWY_IF_UI32_D(D) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeMaskedScatter128 ( VFromD< D > v,
MFromD< D > m,
D d,
TFromD< D > *HWY_RESTRICT base,
VI index )

◆ NativeScatter128() [1/3]

template<int kScale, class D , class VI , HWY_IF_F64_D(D) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeScatter128 ( VFromD< D > v,
D d,
double *HWY_RESTRICT base,
VI index )

◆ NativeScatter128() [2/3]

template<int kScale, class D , class VI , HWY_IF_F32_D(D) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeScatter128 ( VFromD< D > v,
D d,
float *HWY_RESTRICT base,
VI index )

◆ NativeScatter128() [3/3]

template<int kScale, class D , class VI , HWY_IF_UI32_D(D) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::NativeScatter128 ( VFromD< D > v,
D d,
TFromD< D > *HWY_RESTRICT base,
VI index )

◆ NativeSet()

template<class D , HWY_NEON_IF_EMULATED_D(D) >
HWY_API Vec128< TFromD< D >, MaxLanes(D())> hwy::HWY_NAMESPACE::detail::NativeSet ( D d,
TFromD< D > t )

◆ Ne128UpperVec() [1/2]

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

◆ Ne128UpperVec() [2/2]

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

◆ Ne128Vec() [1/3]

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

◆ Ne128Vec() [2/3]

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

◆ Ne128Vec() [3/3]

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

◆ Neg() [1/9]

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/9]

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

◆ Neg() [3/9]

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

◆ Neg() [4/9]

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

◆ Neg() [5/9]

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

◆ Neg() [6/9]

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

◆ Neg() [7/9]

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

◆ Neg() [8/9]

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

◆ Neg() [9/9]

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

◆ NegMulAdd()

template<size_t N>
HWY_API Vec128< float, N > hwy::HWY_NAMESPACE::detail::NegMulAdd ( Vec128< float, N > add,
Vec128< float, N > mul,
Vec128< float, N > x )

◆ NibblesFromMask()

template<class D , HWY_IF_V_SIZE_D(D, 16) >
HWY_INLINE uint64_t hwy::HWY_NAMESPACE::detail::NibblesFromMask ( D d,
MFromD< D > mask )

◆ NormalizeForUIntTruncConvToF32()

template<class V , HWY_IF_UNSIGNED_V(V) , HWY_IF_T_SIZE_ONE_OF_V(V,(1<< 1)|(1<< 2)) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::NormalizeForUIntTruncConvToF32 ( V v)

◆ Not() [1/14]

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

◆ Not() [2/14]

template<typename T , size_t N, HWY_IF_LANES_LE(N, 8) >
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::Not ( hwy::SizeTag< 1 > ,
const Mask128< T, N > m )

References AndNot(), and hwy::HWY_NAMESPACE::m.

◆ Not() [3/14]

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

◆ Not() [4/14]

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

◆ Not() [5/14]

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

◆ Not() [6/14]

template<typename T , size_t N, HWY_IF_LANES_LE(N, 4) >
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::Not ( hwy::SizeTag< 2 > ,
const Mask128< T, N > m )

References AndNot(), and hwy::HWY_NAMESPACE::m.

◆ Not() [7/14]

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

◆ Not() [8/14]

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

◆ Not() [9/14]

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

References AndNot(), and hwy::HWY_NAMESPACE::m.

◆ Not() [10/14]

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

◆ Not() [11/14]

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

References hwy::HWY_NAMESPACE::m.

◆ Not() [12/14]

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

References AndNot(), and hwy::HWY_NAMESPACE::m.

◆ Not() [13/14]

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

References AndNot(), and hwy::HWY_NAMESPACE::m.

◆ Not() [14/14]

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

References hwy::HWY_NAMESPACE::m.

◆ OddEven() [1/4]

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/4]

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

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

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 )

◆ 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

◆ 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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
Mask512< T > b )

◆ Per128BitBlkRevLanesOnBe()

template<class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per128BitBlkRevLanesOnBe ( V v)

◆ Per4LaneBlkShufDupSet4xU32() [1/2]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::Per4LaneBlkShufDupSet4xU32 ( D d,
const uint32_t x3,
const uint32_t x2,
const uint32_t x1,
const uint32_t x0 )

◆ Per4LaneBlkShufDupSet4xU32() [2/2]

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::Per4LaneBlkShufDupSet4xU32 ( D d,
const uint32_t x3,
const uint32_t x2,
const uint32_t x1,
const uint32_t x0 )

◆ Per4LaneBlockShuffle() [1/20]

template<class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< 0x44 > ,
hwy::SizeTag< 8 > ,
hwy::SizeTag< 32 > ,
V v )

◆ Per4LaneBlockShuffle() [2/20]

template<size_t kLaneSize, size_t kVectSize, class V , HWY_IF_LANES_GT_D(DFromV< V >, 4) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< 0x88 > ,
hwy::SizeTag< kLaneSize > ,
hwy::SizeTag< kVectSize > ,
V v )

◆ Per4LaneBlockShuffle() [3/20]

template<size_t kLaneSize, size_t kVectSize, class V , HWY_IF_LANES_GT_D(DFromV< V >, 4) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< 0xDD > ,
hwy::SizeTag< kLaneSize > ,
hwy::SizeTag< kVectSize > ,
V v )

◆ Per4LaneBlockShuffle() [4/20]

template<class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< 0xEE > ,
hwy::SizeTag< 8 > ,
hwy::SizeTag< 32 > ,
V v )

◆ Per4LaneBlockShuffle() [5/20]

template<class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< 0xFA > ,
hwy::SizeTag< 2 > ,
hwy::SizeTag< 8 > ,
V v )

◆ Per4LaneBlockShuffle() [6/20]

template<size_t kIdx3210, size_t kVectSize, class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > idx_3210_tag,
hwy::SizeTag< 1 > ,
hwy::SizeTag< 16 > ,
V v )

◆ Per4LaneBlockShuffle() [7/20]

template<size_t kIdx3210, class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 1 > ,
hwy::SizeTag< 32 > ,
V v )

References hwy::HWY_NAMESPACE::d.

◆ Per4LaneBlockShuffle() [8/20]

template<size_t kIdx3210, size_t kVectSize, class V , HWY_IF_LANES_LE(kVectSize, 16) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > idx_3210_tag,
hwy::SizeTag< 1 > ,
hwy::SizeTag< kVectSize > ,
V v )

◆ Per4LaneBlockShuffle() [9/20]

template<size_t kIdx3210, class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 2 > ,
hwy::SizeTag< 16 > ,
V v )

◆ Per4LaneBlockShuffle() [10/20]

template<size_t kIdx3210, class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 2 > ,
hwy::SizeTag< 32 > ,
V v )

References hwy::HWY_NAMESPACE::d.

◆ Per4LaneBlockShuffle() [11/20]

template<size_t kIdx3210, class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 2 > ,
hwy::SizeTag< 8 > ,
V v )

◆ Per4LaneBlockShuffle() [12/20]

template<size_t kIdx3210, size_t kVectSize, class V , HWY_IF_LANES_LE(kVectSize, 16) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 2 > ,
hwy::SizeTag< kVectSize > ,
V v )

◆ Per4LaneBlockShuffle() [13/20]

template<size_t kIdx3210, class V , HWY_IF_NOT_FLOAT(TFromV< V >) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 4 > ,
hwy::SizeTag< 16 > ,
V v )

◆ Per4LaneBlockShuffle() [14/20]

template<size_t kIdx3210, class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 4 > ,
hwy::SizeTag< 32 > ,
V v )

References hwy::HWY_NAMESPACE::d.

◆ Per4LaneBlockShuffle() [15/20]

template<size_t kIdx3210, class V , HWY_IF_NOT_FLOAT(TFromV< V >) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 4 > ,
hwy::SizeTag< 32 > ,
V v )

◆ Per4LaneBlockShuffle() [16/20]

template<size_t kIdx3210, class V , HWY_IF_NOT_FLOAT(TFromV< V >) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 4 > ,
hwy::SizeTag< 64 > ,
V v )

◆ Per4LaneBlockShuffle() [17/20]

template<size_t kIdx3210, size_t kVectSize, class V , HWY_IF_LANES_LE(kVectSize, 16) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 4 > ,
hwy::SizeTag< kVectSize > ,
V v )

◆ Per4LaneBlockShuffle() [18/20]

template<size_t kIdx3210, class V >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 8 > ,
hwy::SizeTag< 32 > ,
V v )

References hwy::HWY_NAMESPACE::d.

◆ Per4LaneBlockShuffle() [19/20]

template<size_t kIdx3210, class V , HWY_IF_NOT_FLOAT(TFromV< V >) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 8 > ,
hwy::SizeTag< 32 > ,
V v )

◆ Per4LaneBlockShuffle() [20/20]

template<size_t kIdx3210, class V , HWY_IF_NOT_FLOAT(TFromV< V >) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per4LaneBlockShuffle ( hwy::SizeTag< kIdx3210 > ,
hwy::SizeTag< 8 > ,
hwy::SizeTag< 64 > ,
V v )

◆ Per64BitBlkRevLanesOnBe()

template<class V , HWY_IF_T_SIZE_V(V, 1) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Per64BitBlkRevLanesOnBe ( V v)

◆ 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_V_SIZE_LE(T, N, 8) >
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 )

◆ PopulationCount() [4/20]

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

◆ PopulationCount() [5/20]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 1 > ,
Vec512< T > 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_V_SIZE_LE(T, N, 8) >
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 )

◆ PopulationCount() [9/20]

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

◆ PopulationCount() [10/20]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 2 > ,
Vec512< T > 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_V_SIZE_LE(T, N, 8) >
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 )

◆ PopulationCount() [14/20]

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

◆ PopulationCount() [15/20]

template<typename T >
HWY_INLINE Vec512< T > hwy::HWY_NAMESPACE::detail::PopulationCount ( hwy::SizeTag< 4 > ,
Vec512< T > 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_V_SIZE_LE(T, N, 8) >
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 )

◆ PopulationCount() [19/20]

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

◆ PopulationCount() [20/20]

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

◆ PromoteEvenTo() [1/13]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::FloatTag ,
hwy::SizeTag< 4 > ,
hwy::FloatTag ,
D d_to,
svfloat16_t v )

◆ PromoteEvenTo() [2/13]

template<class D , class V , class FromTypeTag , HWY_IF_UI32(TFromV< V >) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::FloatTag ,
hwy::SizeTag< 8 > ,
FromTypeTag ,
D d_to,
V v )

References ConvertTo(), and PromoteEvenTo().

◆ PromoteEvenTo() [3/13]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::FloatTag ,
hwy::SizeTag< 8 > ,
hwy::FloatTag ,
D d_to,
svfloat32_t v )

◆ PromoteEvenTo() [4/13]

template<class D , class V >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::FloatTag ,
hwy::SizeTag< 8 > ,
hwy::FloatTag ,
D ,
V v )

◆ PromoteEvenTo() [5/13]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::FloatTag ,
hwy::SizeTag< 8 > ,
hwy::SignedTag ,
D d_to,
svint32_t v )

◆ PromoteEvenTo() [6/13]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::FloatTag ,
hwy::SizeTag< 8 > ,
hwy::UnsignedTag ,
D d_to,
svuint32_t v )

◆ PromoteEvenTo() [7/13]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::SignedTag ,
hwy::SizeTag< 2 > ,
hwy::SignedTag ,
D d_to,
svint8_t v )

◆ PromoteEvenTo() [8/13]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::SignedTag ,
hwy::SizeTag< 4 > ,
hwy::SignedTag ,
D d_to,
svint16_t v )

◆ PromoteEvenTo() [9/13]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::SignedTag ,
hwy::SizeTag< 8 > ,
hwy::FloatTag ,
D d_to,
svfloat32_t v )

◆ PromoteEvenTo() [10/13]

template<class D , class V >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::SignedTag ,
hwy::SizeTag< 8 > ,
hwy::FloatTag ,
D d_to,
V v )

References ConvertTo(), and PromoteEvenTo().

◆ PromoteEvenTo() [11/13]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::SignedTag ,
hwy::SizeTag< 8 > ,
hwy::SignedTag ,
D d_to,
svint32_t v )

◆ PromoteEvenTo() [12/13]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::UnsignedTag ,
hwy::SizeTag< 8 > ,
hwy::FloatTag ,
D d_to,
svfloat32_t v )

◆ PromoteEvenTo() [13/13]

template<class D , class V >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteEvenTo ( hwy::UnsignedTag ,
hwy::SizeTag< 8 > ,
hwy::FloatTag ,
D d_to,
V v )

References ConvertTo(), and PromoteEvenTo().

◆ PromoteOddTo() [1/7]

template<class D >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteOddTo ( hwy::FloatTag to_type_tag,
hwy::SizeTag< 4 > to_lane_size_tag,
hwy::FloatTag from_type_tag,
D d_to,
svfloat16_t v )

◆ PromoteOddTo() [2/7]

template<class FromTypeTag , class D , class V >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteOddTo ( hwy::FloatTag to_type_tag,
hwy::SizeTag< 8 > to_lane_size_tag,
FromTypeTag from_type_tag,
D d_to,
V v )

◆ PromoteOddTo() [3/7]

template<class D , class V , class FromTypeTag , HWY_IF_UI32(TFromV< V >) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteOddTo ( hwy::FloatTag ,
hwy::SizeTag< 8 > ,
FromTypeTag ,
D d_to,
V v )

References ConvertTo(), and PromoteOddTo().

◆ PromoteOddTo() [4/7]

template<class D , class V >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteOddTo ( hwy::FloatTag ,
hwy::SizeTag< 8 > ,
hwy::FloatTag ,
D d_to,
V v )

References PromoteEvenTo().

◆ PromoteOddTo() [5/7]

template<class D , class V >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteOddTo ( hwy::SignedTag ,
hwy::SizeTag< 8 > ,
hwy::FloatTag ,
D d_to,
V v )

References ConvertTo(), and PromoteOddTo().

◆ PromoteOddTo() [6/7]

template<class D , class V >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteOddTo ( hwy::UnsignedTag ,
hwy::SizeTag< 8 > ,
hwy::FloatTag ,
D d_to,
V v )

References ConvertTo(), and PromoteOddTo().

◆ PromoteOddTo() [7/7]

template<class ToTypeTag , class D , HWY_IF_UI64_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::PromoteOddTo ( ToTypeTag to_type_tag,
hwy::SizeTag< 8 > to_lane_size_tag,
hwy::FloatTag from_type_tag,
D d_to,
svfloat32_t v )

◆ ReduceAcrossBlocks()

template<class D , class Func , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::ReduceAcrossBlocks ( D d,
Func f,
VFromD< D > v )

◆ ReduceWithinBlocks() [1/2]

template<class D , class Func , HWY_IF_LANES_PER_BLOCK_D(D, 16) , HWY_IF_U8_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::ReduceWithinBlocks ( D d,
Func f,
VFromD< D > v )

◆ ReduceWithinBlocks() [2/2]

template<class D , class Func , HWY_IF_LANES_PER_BLOCK_D(D, 2) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::ReduceWithinBlocks ( D d,
Func f,
VFromD< D > v10 )

◆ ReorderDemote2From64To32Combine()

template<class D , class V >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::ReorderDemote2From64To32Combine ( D dn,
V a,
V b )

◆ ReorderWidenMulAccumulateBF16()

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

◆ ReorderWidenMulAccumulateI16()

template<class D32 , HWY_IF_POW2_LE_D(D32, 2) , class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > hwy::HWY_NAMESPACE::detail::ReorderWidenMulAccumulateI16 ( D32 d32,
VFromD< D16 > a,
VFromD< D16 > b,
const V32 sum0,
V32 & sum1 )

◆ ReorderWidenMulAccumulateU16()

template<class D32 , HWY_IF_POW2_LE_D(D32, 2) , class V32 = VFromD<D32>, class D16 = RepartitionToNarrow<D32>>
HWY_API VFromD< D32 > hwy::HWY_NAMESPACE::detail::ReorderWidenMulAccumulateU16 ( D32 d32,
VFromD< D16 > a,
VFromD< D16 > b,
const V32 sum0,
V32 & sum1 )

◆ ReverseBitsOfEachByte()

template<class T >
HWY_INLINE T hwy::HWY_NAMESPACE::detail::ReverseBitsOfEachByte ( T val)

◆ RoundF32ForDemoteToBF16() [1/2]

HWY_INLINE svuint32_t hwy::HWY_NAMESPACE::detail::RoundF32ForDemoteToBF16 ( svfloat32_t v)

◆ RoundF32ForDemoteToBF16() [2/2]

template<class V , HWY_IF_F32(TFromV< V >) >
HWY_INLINE VFromD< RebindToUnsigned< DFromV< V > > > hwy::HWY_NAMESPACE::detail::RoundF32ForDemoteToBF16 ( V v)

◆ SaturateI()

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

◆ SaturateU()

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

◆ ScalarMaskedStore()

template<class D >
HWY_API void hwy::HWY_NAMESPACE::detail::ScalarMaskedStore ( VFromD< D > v,
MFromD< D > m,
D d,
TFromD< D > *HWY_RESTRICT p )

◆ ScalarSqrt() [1/2]

static HWY_INLINE double hwy::HWY_NAMESPACE::detail::ScalarSqrt ( double v)
static

◆ ScalarSqrt() [2/2]

static HWY_INLINE float hwy::HWY_NAMESPACE::detail::ScalarSqrt ( float v)
static

◆ ScaleByPower()

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

◆ Set64() [1/2]

template<class D , HWY_IF_V_SIZE_LE_D(D, 8) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::Set64 ( D ,
uint64_t mask_bits )

References hwy::HWY_NAMESPACE::BitCast().

Referenced by LoadMaskBits().

◆ Set64() [2/2]

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

◆ Shl() [1/14]

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/14]

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

◆ Shl() [3/14]

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

◆ Shl() [4/14]

HWY_API Vec256< uint8_t > hwy::HWY_NAMESPACE::detail::Shl ( hwy::UnsignedTag tag,
Vec256< uint8_t > v,
Vec256< uint8_t > bits )

◆ Shl() [5/14]

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

◆ Shl() [6/14]

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

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

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

◆ Shl() [9/14]

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

◆ Shl() [10/14]

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

◆ Shl() [11/14]

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

◆ Shl() [12/14]

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

◆ Shl() [13/14]

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

◆ Shl() [14/14]

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

◆ Shr() [1/2]

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

◆ Shr() [2/2]

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

◆ ShrBytes()

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

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

◆ ShuffleTwo1230() [1/6]

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

◆ ShuffleTwo1230() [2/6]

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

◆ ShuffleTwo1230() [3/6]

template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec128< T > hwy::HWY_NAMESPACE::detail::ShuffleTwo1230 ( Vec128< T > a,
Vec128< T > b )

◆ ShuffleTwo1230() [4/6]

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

◆ ShuffleTwo1230() [5/6]

template<typename T , HWY_IF_T_SIZE(T, 1) >
HWY_API Vec32< T > hwy::HWY_NAMESPACE::detail::ShuffleTwo1230 ( Vec32< T > a,
Vec32< T > b )

◆ ShuffleTwo1230() [6/6]

template<typename T , HWY_IF_T_SIZE(T, 2) >
HWY_API Vec64< T > hwy::HWY_NAMESPACE::detail::ShuffleTwo1230 ( Vec64< T > a,
Vec64< T > b )

◆ ShuffleTwo2301() [1/6]

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

◆ ShuffleTwo2301() [2/6]

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

◆ ShuffleTwo2301() [3/6]

template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec128< T > hwy::HWY_NAMESPACE::detail::ShuffleTwo2301 ( Vec128< T > a,
Vec128< T > b )

◆ ShuffleTwo2301() [4/6]

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

◆ ShuffleTwo2301() [5/6]

template<typename T , HWY_IF_T_SIZE(T, 1) >
HWY_API Vec32< T > hwy::HWY_NAMESPACE::detail::ShuffleTwo2301 ( Vec32< T > a,
Vec32< T > b )

◆ ShuffleTwo2301() [6/6]

template<typename T , HWY_IF_T_SIZE(T, 2) >
HWY_API Vec64< T > hwy::HWY_NAMESPACE::detail::ShuffleTwo2301 ( Vec64< T > a,
Vec64< T > b )

◆ ShuffleTwo3012() [1/6]

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

◆ ShuffleTwo3012() [2/6]

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

◆ ShuffleTwo3012() [3/6]

template<typename T , HWY_IF_T_SIZE(T, 4) >
HWY_API Vec128< T > hwy::HWY_NAMESPACE::detail::ShuffleTwo3012 ( Vec128< T > a,
Vec128< T > b )

◆ ShuffleTwo3012() [4/6]

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

◆ ShuffleTwo3012() [5/6]

template<typename T , HWY_IF_T_SIZE(T, 1) >
HWY_API Vec32< T > hwy::HWY_NAMESPACE::detail::ShuffleTwo3012 ( Vec32< T > a,
Vec32< T > b )

◆ ShuffleTwo3012() [6/6]

template<typename T , HWY_IF_T_SIZE(T, 2) >
HWY_API Vec64< T > hwy::HWY_NAMESPACE::detail::ShuffleTwo3012 ( Vec64< T > a,
Vec64< 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 HeapSelect(), and HeapSort().

◆ SlideDownI32Lanes()

template<int kI32Lanes, class V , HWY_IF_V_SIZE_V(V, 64) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::SlideDownI32Lanes ( V v)

◆ SlideDownI64Lanes()

template<int kI64Lanes, class V , HWY_IF_V_SIZE_V(V, 32) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::SlideDownI64Lanes ( V v)

◆ SlideDownLanes()

template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::SlideDownLanes ( V v,
size_t amt )

◆ SlideUpI32Lanes()

template<int kI32Lanes, class V , HWY_IF_V_SIZE_V(V, 64) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::SlideUpI32Lanes ( V v)

◆ SlideUpI64Lanes()

template<int kI64Lanes, class V , HWY_IF_V_SIZE_V(V, 32) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::SlideUpI64Lanes ( V v)

◆ SlideUpLanes()

template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::SlideUpLanes ( V v,
size_t amt )

◆ SmallerSortValue()

template<class D , HWY_IF_FLOAT_OR_SPECIAL_D(D) >
Vec< D > hwy::HWY_NAMESPACE::detail::SmallerSortValue ( D d,
Vec< D > v )

◆ SmallestSortValue()

template<class D , HWY_IF_FLOAT_OR_SPECIAL_D(D) >
Vec< D > hwy::HWY_NAMESPACE::detail::SmallestSortValue ( D d)

◆ Splice()

template<class V , HWY_IF_BF16_D(DFromV< V >) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::Splice ( V hi,
V lo,
svbool_t mask )

◆ SSE2Mul128()

template<class V , HWY_IF_U64(TFromV< V >) >
static HWY_INLINE V hwy::HWY_NAMESPACE::detail::SSE2Mul128 ( V a,
V b,
V & mulH )
static

◆ StoreN()

template<class D , HWY_RVV_IF_EMULATED_D(D) >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreN ( size_t count,
VFromD< D > v,
D d,
TFromD< D > *HWY_RESTRICT p )

◆ StoreTransposedBlocks2() [1/3]

template<class D , typename T = TFromD<D>>
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks2 ( Vec256< T > i,
Vec256< T > j,
D d,
T *HWY_RESTRICT unaligned )

◆ StoreTransposedBlocks2() [2/3]

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks2 ( VFromD< D > A,
VFromD< D > B,
D d,
TFromD< D > *HWY_RESTRICT unaligned )

◆ StoreTransposedBlocks2() [3/3]

template<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks2 ( VFromD< D > i,
VFromD< D > j,
D d,
TFromD< D > *HWY_RESTRICT unaligned )

◆ StoreTransposedBlocks3() [1/3]

template<class D , typename T = TFromD<D>>
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks3 ( Vec256< T > i,
Vec256< T > j,
Vec256< T > k,
D d,
T *HWY_RESTRICT unaligned )

◆ StoreTransposedBlocks3() [2/3]

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks3 ( VFromD< D > A,
VFromD< D > B,
VFromD< D > C,
D d,
TFromD< D > *HWY_RESTRICT unaligned )

◆ StoreTransposedBlocks3() [3/3]

template<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks3 ( VFromD< D > i,
VFromD< D > j,
VFromD< D > k,
D d,
TFromD< D > *HWY_RESTRICT unaligned )

◆ StoreTransposedBlocks4() [1/3]

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

◆ StoreTransposedBlocks4() [2/3]

template<class D , HWY_IF_V_SIZE_D(D, 32) >
HWY_API void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks4 ( VFromD< D > i,
VFromD< D > j,
VFromD< D > k,
VFromD< D > l,
D d,
TFromD< D > *HWY_RESTRICT unaligned )

◆ StoreTransposedBlocks4() [3/3]

template<class D , HWY_IF_V_SIZE_LE_D(D, 16) >
HWY_INLINE void hwy::HWY_NAMESPACE::detail::StoreTransposedBlocks4 ( VFromD< D > vA,
VFromD< D > vB,
VFromD< D > vC,
VFromD< D > vD,
D d,
TFromD< D > *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,
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 )

◆ SumOfU32OrU64LanesAsU128()

template<class T , HWY_IF_NOT_FLOAT_NOR_SPECIAL(T) , HWY_IF_T_SIZE_ONE_OF(T,(1<< 4)|(1<< 8)) >
HWY_INLINE Vec128< T > hwy::HWY_NAMESPACE::detail::SumOfU32OrU64LanesAsU128 ( Vec128< T > v)

◆ SumsOf2() [1/16]

HWY_INLINE svint16_t hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::SignedTag ,
hwy::SizeTag< 1 > ,
svint8_t v )

◆ SumsOf2() [2/16]

template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::SignedTag ,
hwy::SizeTag< 1 > ,
V v )

◆ SumsOf2() [3/16]

HWY_INLINE svint32_t hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::SignedTag ,
hwy::SizeTag< 2 > ,
svint16_t v )

◆ SumsOf2() [4/16]

template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::SignedTag ,
hwy::SizeTag< 2 > ,
V v )

◆ SumsOf2() [5/16]

template<class V >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::SignedTag ,
hwy::SizeTag< 2 > ,
V v )

◆ SumsOf2() [6/16]

HWY_INLINE svint64_t hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::SignedTag ,
hwy::SizeTag< 4 > ,
svint32_t v )

◆ SumsOf2() [7/16]

template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::SignedTag ,
hwy::SizeTag< 4 > ,
V v )

◆ SumsOf2() [8/16]

template<class V >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::SignedTag ,
hwy::SizeTag< 4 > ,
V v )

◆ SumsOf2() [9/16]

HWY_INLINE svuint16_t hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::UnsignedTag ,
hwy::SizeTag< 1 > ,
svuint8_t v )

◆ SumsOf2() [10/16]

template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::UnsignedTag ,
hwy::SizeTag< 1 > ,
V v )

◆ SumsOf2() [11/16]

HWY_INLINE svuint32_t hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::UnsignedTag ,
hwy::SizeTag< 2 > ,
svuint16_t v )

◆ SumsOf2() [12/16]

template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::UnsignedTag ,
hwy::SizeTag< 2 > ,
V v )

◆ SumsOf2() [13/16]

template<class V >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::UnsignedTag ,
hwy::SizeTag< 2 > ,
V v )

◆ SumsOf2() [14/16]

HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::UnsignedTag ,
hwy::SizeTag< 4 > ,
svuint32_t v )

◆ SumsOf2() [15/16]

template<class V , HWY_IF_V_SIZE_LE_V(V, 8) >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::UnsignedTag ,
hwy::SizeTag< 4 > ,
V v )

◆ SumsOf2() [16/16]

template<class V >
HWY_INLINE VFromD< RepartitionToWide< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf2 ( hwy::UnsignedTag ,
hwy::SizeTag< 4 > ,
V v )

◆ SumsOf4() [1/12]

HWY_INLINE svint32_t hwy::HWY_NAMESPACE::detail::SumsOf4 ( hwy::SignedTag ,
hwy::SizeTag< 1 > ,
svint8_t v )

◆ SumsOf4() [2/12]

template<class V >
HWY_INLINE VFromD< RepartitionToWideX2< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf4 ( hwy::SignedTag ,
hwy::SizeTag< 1 > ,
V v )

◆ SumsOf4() [3/12]

HWY_INLINE svint64_t hwy::HWY_NAMESPACE::detail::SumsOf4 ( hwy::SignedTag ,
hwy::SizeTag< 2 > ,
svint16_t v )

◆ SumsOf4() [4/12]

template<class V >
HWY_INLINE VFromD< RepartitionToWideX2< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf4 ( hwy::SignedTag ,
hwy::SizeTag< 2 > ,
V v )

◆ SumsOf4() [5/12]

HWY_INLINE svuint32_t hwy::HWY_NAMESPACE::detail::SumsOf4 ( hwy::UnsignedTag ,
hwy::SizeTag< 1 > ,
svuint8_t v )

◆ SumsOf4() [6/12]

template<class V >
HWY_INLINE VFromD< RepartitionToWideX2< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf4 ( hwy::UnsignedTag ,
hwy::SizeTag< 1 > ,
V v )

◆ SumsOf4() [7/12]

template<size_t N>
HWY_INLINE Vec128< uint32_t,(N+3)/4 > hwy::HWY_NAMESPACE::detail::SumsOf4 ( hwy::UnsignedTag ,
hwy::SizeTag< 1 > ,
Vec128< uint8_t, N > v )

◆ SumsOf4() [8/12]

HWY_INLINE Vec256< uint32_t > hwy::HWY_NAMESPACE::detail::SumsOf4 ( hwy::UnsignedTag ,
hwy::SizeTag< 1 > ,
Vec256< uint8_t > v )

◆ SumsOf4() [9/12]

HWY_INLINE Vec512< uint32_t > hwy::HWY_NAMESPACE::detail::SumsOf4 ( hwy::UnsignedTag ,
hwy::SizeTag< 1 > ,
Vec512< uint8_t > v )

◆ SumsOf4() [10/12]

HWY_INLINE svuint64_t hwy::HWY_NAMESPACE::detail::SumsOf4 ( hwy::UnsignedTag ,
hwy::SizeTag< 2 > ,
svuint16_t v )

◆ SumsOf4() [11/12]

template<class V >
HWY_INLINE VFromD< RepartitionToWideX2< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf4 ( hwy::UnsignedTag ,
hwy::SizeTag< 2 > ,
V v )

◆ SumsOf4() [12/12]

template<class TypeTag , size_t kLaneSize, class V >
HWY_INLINE VFromD< RepartitionToWideX2< DFromV< V > > > hwy::HWY_NAMESPACE::detail::SumsOf4 ( TypeTag ,
hwy::SizeTag< kLaneSize > ,
V v )

◆ TableLookupSlideDownLanes()

template<class D , HWY_IF_V_SIZE_D(D, 32) , HWY_IF_T_SIZE_ONE_OF_D( D,(1<< 1)|((HWY_TARGET > HWY_AVX3) ?(1<< 2) :0)) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::TableLookupSlideDownLanes ( D d,
VFromD< D > v,
size_t amt )

◆ TableLookupSlideUpLanes()

template<class D , HWY_IF_V_SIZE_D(D, 32) , HWY_IF_T_SIZE_ONE_OF_D( D,(1<< 1)|((HWY_TARGET > HWY_AVX3) ?(1<< 2) :0)) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::TableLookupSlideUpLanes ( D d,
VFromD< D > v,
size_t amt )

◆ 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 > ,
Vec512< T > v,
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 > ,
Vec512< T > v,
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 > ,
Vec512< T > v,
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 > ,
Vec512< T > v,
Vec512< T > bit )

◆ Truncate2To()

template<class D , typename FromT , HWY_IF_UNSIGNED_D(D) , HWY_IF_UNSIGNED(FromT) , HWY_IF_T_SIZE(FromT, sizeof(TFromD< D >) *2) , HWY_IF_LANES_GT_D(D, 1) >
HWY_API VFromD< D > hwy::HWY_NAMESPACE::detail::Truncate2To ( D ,
Vec128< FromT, Repartition< FromT, D >().MaxLanes()> lo,
Vec128< FromT, Repartition< FromT, D >().MaxLanes()> hi )

◆ U16FromF16()

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

References hwy::CopySameSize().

◆ U16LanePointer()

template<typename T , HWY_IF_SPECIAL_FLOAT(T) >
HWY_INLINE If< IsConst< T >(), const uint16_t *, uint16_t * > hwy::HWY_NAMESPACE::detail::U16LanePointer ( T * p)

◆ U64ToF64VecFast()

template<class VW >
HWY_INLINE VFromD< Rebind< double, DFromV< VW > > > hwy::HWY_NAMESPACE::detail::U64ToF64VecFast ( VW w)

◆ UI8ReverseBitsStep()

template<int kShiftAmt, int kShrResultMask, class V , HWY_IF_V_SIZE_GT_D(DFromV< V >, HWY_REVERSE_BITS_MIN_BYTES - 1) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::UI8ReverseBitsStep ( V v)

◆ UIntToF32BiasedExp() [1/3]

template<class D , HWY_IF_U32_D(D) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::UIntToF32BiasedExp ( D d,
VFromD< D > v )

◆ UIntToF32BiasedExp() [2/3]

template<class D , HWY_IF_U16_D(D) , HWY_IF_LANES_LE_D(D, HWY_MAX_BYTES/4) >
HWY_INLINE VFromD< D > hwy::HWY_NAMESPACE::detail::UIntToF32BiasedExp ( D d,
VFromD< D > v )

◆ UIntToF32BiasedExp() [3/3]

template<class V , HWY_IF_UNSIGNED_V(V) >
HWY_INLINE V hwy::HWY_NAMESPACE::detail::UIntToF32BiasedExp ( V v)

◆ UnmaskedNot() [1/2]

template<typename T , size_t N, HWY_IF_T_SIZE(T, 1) >
HWY_INLINE Mask128< T, N > hwy::HWY_NAMESPACE::detail::UnmaskedNot ( const Mask128< T, N > m)

References hwy::HWY_NAMESPACE::m.

Referenced by Not(), Not(), Not(), Not(), and Not().

◆ UnmaskedNot() [2/2]

template<typename T , HWY_IF_T_SIZE(T, 1) >
HWY_INLINE Mask256< T > hwy::HWY_NAMESPACE::detail::UnmaskedNot ( const Mask256< T > m)

References hwy::HWY_NAMESPACE::m.

◆ 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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
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 > ,
Mask512< T > a,
Mask512< T > b )

◆ ZeroExtendResizeBitCast() [1/6]

template<class FromSizeTag , class ToSizeTag , class DTo , class DFrom >
HWY_INLINE VFromD< DTo > hwy::HWY_NAMESPACE::detail::ZeroExtendResizeBitCast ( FromSizeTag ,
ToSizeTag ,
DTo d_to,
DFrom ,
VFromD< DFrom > v )

◆ ZeroExtendResizeBitCast() [2/6]

template<class DTo , class DFrom , HWY_IF_NOT_FLOAT3264_D(DTo) >
HWY_INLINE VFromD< DTo > hwy::HWY_NAMESPACE::detail::ZeroExtendResizeBitCast ( hwy::SizeTag< 16 > ,
hwy::SizeTag< 64 > ,
DTo d_to,
DFrom d_from,
VFromD< DFrom > v )

◆ ZeroExtendResizeBitCast() [3/6]

template<class DTo , class DFrom , HWY_IF_F64_D(DTo) >
HWY_INLINE Vec512< double > hwy::HWY_NAMESPACE::detail::ZeroExtendResizeBitCast ( hwy::SizeTag< 16 > ,
hwy::SizeTag< 64 > ,
DTo d_to,
DFrom d_from,
VFromD< DFrom > v )

◆ ZeroExtendResizeBitCast() [4/6]

template<class DTo , class DFrom >
HWY_INLINE VFromD< DTo > hwy::HWY_NAMESPACE::detail::ZeroExtendResizeBitCast ( hwy::SizeTag< 8 > ,
hwy::SizeTag< 32 > ,
DTo d_to,
DFrom d_from,
VFromD< DFrom > v )

◆ ZeroExtendResizeBitCast() [5/6]

template<class DTo , class DFrom >
HWY_INLINE VFromD< DTo > hwy::HWY_NAMESPACE::detail::ZeroExtendResizeBitCast ( hwy::SizeTag< 8 > ,
hwy::SizeTag< 64 > ,
DTo d_to,
DFrom d_from,
VFromD< DFrom > v )

◆ ZeroExtendResizeBitCast() [6/6]

template<size_t kFromVectSize, class DTo , class DFrom , HWY_IF_LANES_LE(kFromVectSize, 8) >
HWY_INLINE VFromD< DTo > hwy::HWY_NAMESPACE::detail::ZeroExtendResizeBitCast ( hwy::SizeTag< kFromVectSize > ,
hwy::SizeTag< 32 > ,
DTo d_to,
DFrom d_from,
VFromD< DFrom > v )

Variable Documentation

◆ _u8_

hwy::HWY_NAMESPACE::detail::_u8_

◆ vreinterpret

hwy::HWY_NAMESPACE::detail::vreinterpret