Grok 12.0.1
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
hwy Namespace Reference

Namespaces

namespace  detail
 
namespace  HWY_NAMESPACE
 
namespace  platform
 
namespace  robust_statistics
 

Classes

struct  AlignedAllocator
 
class  AlignedDeleter
 
class  AlignedFreer
 
class  AlignedNDArray
 
struct  bfloat16_t
 
class  Bins
 
struct  ChosenTarget
 
class  DeclValT
 
class  Divisor
 
struct  EnableIfT
 
struct  EnableIfT< true >
 
struct  float16_t
 
struct  FunctionCache
 
struct  IfT
 
struct  IfT< false, Then, Else >
 
class  Image
 
class  Image3
 
struct  ImageBase
 
class  InputStats
 
struct  IsArrayT
 
struct  IsArrayT< T[]>
 
struct  IsArrayT< T[N]>
 
class  IsAssignableT
 
struct  IsConstT
 
struct  IsConstT< const T >
 
class  IsConvertibleT
 
struct  IsSameT
 
struct  IsSameT< T, T >
 
class  IsStaticCastableT
 
struct  K32V32
 
struct  K64V64
 
struct  MakeLaneTypeIfIntegerT
 
struct  MakeLaneTypeIfIntegerT< T, true >
 
class  ParallelFor
 
struct  Params
 
class  PoolBarrier
 
class  PoolCommands
 
struct  PoolMem
 
class  PoolMemOwner
 
class  PoolTasks
 
class  PoolWorker
 
class  RandomState
 
class  Rect
 
struct  RemoveConstT
 
struct  RemoveConstT< const T >
 
struct  RemovePtrT
 
struct  RemovePtrT< const T * >
 
struct  RemovePtrT< const volatile T * >
 
struct  RemovePtrT< T * >
 
struct  RemovePtrT< volatile T * >
 
struct  RemoveRefT
 
struct  RemoveRefT< T & >
 
struct  RemoveRefT< T && >
 
struct  RemoveVolatileT
 
struct  RemoveVolatileT< volatile T >
 
struct  Result
 
class  ShuffledIota
 
struct  SizeTag
 
struct  SortAscending
 
struct  SortConstants
 
struct  SortDescending
 
class  Sorter
 
class  Span
 
class  Stats
 
class  TestWithParamTarget
 
class  TestWithParamTargetAndT
 
class  ThreadPool
 
struct  Timestamp
 
struct  uint128_t
 
struct  WrapMirror
 
class  WrapRowMirror
 
struct  WrapRowUnchanged
 
struct  WrapUnchanged
 

Typedefs

typedef void(* AbortFunc) (const char *file, int line, const char *formatted_err)
 
using AllocPtr = void* (*)(void* opaque, size_t bytes)
 
using FreePtr = void (*)(void* opaque, void* memory)
 
template<typename T >
using AlignedUniquePtr = std::unique_ptr<T, AlignedDeleter>
 
template<class T >
using AlignedVector = std::vector<T, AlignedAllocator<T>>
 
template<typename T >
using AlignedFreeUniquePtr = std::unique_ptr<T, AlignedFreer>
 
using float32_t = float
 
using float64_t = double
 
template<bool Condition>
using EnableIf = typename EnableIfT<Condition>::type
 
template<bool Condition, typename Then , typename Else >
using If = typename IfT<Condition, Then, Else>::type
 
template<class T >
using RemoveConst = typename RemoveConstT<T>::type
 
template<class T >
using RemoveVolatile = typename RemoveVolatileT<T>::type
 
template<class T >
using RemoveRef = typename RemoveRefT<T>::type
 
template<class T >
using RemoveCvRef = RemoveConst<RemoveVolatile<RemoveRef<T>>>
 
template<class T >
using RemovePtr = typename RemovePtrT<T>::type
 
template<typename T >
using MakeUnsigned = typename detail::Relations<T>::Unsigned
 
template<typename T >
using MakeSigned = typename detail::Relations<T>::Signed
 
template<typename T >
using MakeFloat = typename detail::Relations<T>::Float
 
template<typename T >
using MakeWide = typename detail::Relations<T>::Wide
 
template<typename T >
using MakeNarrow = typename detail::Relations<T>::Narrow
 
template<size_t N>
using UnsignedFromSize = typename detail::TypeFromSize<N>::Unsigned
 
template<size_t N>
using SignedFromSize = typename detail::TypeFromSize<N>::Signed
 
template<size_t N>
using FloatFromSize = typename detail::TypeFromSize<N>::Float
 
using UnsignedTag = SizeTag<0>
 
using SignedTag = SizeTag<0x100>
 
using FloatTag = SizeTag<0x200>
 
using SpecialTag = SizeTag<0x300>
 
using NonFloatTag = SizeTag<0x400>
 
template<typename T >
using MakeLaneTypeIfInteger = typename MakeLaneTypeIfIntegerT<T>::type
 
using ImageF = Image<float>
 
using Image3F = Image3<float>
 
using FuncInput = size_t
 
using FuncOutput = uint64_t
 
using Func = FuncOutput (*)(const void*, FuncInput)
 
template<typename T1 , typename T2 >
using LargestType
 

Enumerations

enum class  Dist { kUniform8 , kUniform16 , kUniform32 }
 
enum class  Algo {
  kStdSort , kStdSelect , kStdPartialSort , kVQSort ,
  kVQPartialSort , kVQSelect , kHeapSort , kHeapPartialSort ,
  kHeapSelect
}
 
enum class  PoolWaitMode : uint32_t { kBlock , kSpin }
 

Functions

AbortFuncGetAbortFunc ()
 
AbortFunc SetAbortFunc (AbortFunc func)
 
template<typename T >
HWY_API constexpr bool IsAligned (T *ptr, size_t align=HWY_ALIGNMENT)
 
HWY_DLLEXPORT void * AllocateAlignedBytes (size_t payload_size, AllocPtr alloc_ptr=nullptr, void *opaque_ptr=nullptr)
 
HWY_DLLEXPORT void FreeAlignedBytes (const void *aligned_pointer, FreePtr free_ptr, void *opaque_ptr)
 
template<typename T , typename... Args>
AlignedUniquePtr< T > MakeUniqueAlignedWithAlloc (AllocPtr alloc, FreePtr free, void *opaque, Args &&... args)
 
template<typename T , typename... Args>
AlignedUniquePtr< T > MakeUniqueAligned (Args &&... args)
 
template<class T , class V >
constexpr bool operator== (const AlignedAllocator< T > &, const AlignedAllocator< V > &) noexcept
 
template<class T , class V >
constexpr bool operator!= (const AlignedAllocator< T > &, const AlignedAllocator< V > &) noexcept
 
template<typename T , typename... Args>
AlignedUniquePtr< T[]> MakeUniqueAlignedArrayWithAlloc (size_t items, AllocPtr alloc, FreePtr free, void *opaque, Args &&... args)
 
template<typename T , typename... Args>
AlignedUniquePtr< T[]> MakeUniqueAlignedArray (size_t items, Args &&... args)
 
template<typename T >
AlignedFreeUniquePtr< T[]> AllocateAligned (const size_t items, AllocPtr alloc, FreePtr free, void *opaque)
 
template<typename T >
AlignedFreeUniquePtr< T[]> AllocateAligned (const size_t items)
 
HWY_DLLEXPORT HWY_NORETURN void HWY_FORMAT (3, 4) Abort(const char *file
 
template<size_t kBytes, typename From , typename To >
HWY_API void CopyBytes (const From *from, To *to)
 
HWY_API void CopyBytes (const void *HWY_RESTRICT from, void *HWY_RESTRICT to, size_t num_of_bytes_to_copy)
 
template<typename From , typename To >
HWY_API void CopySameSize (const From *HWY_RESTRICT from, To *HWY_RESTRICT to)
 
template<size_t kBytes, typename To >
HWY_API void ZeroBytes (To *to)
 
HWY_API void ZeroBytes (void *to, size_t num_bytes)
 
static HWY_MAYBE_UNUSED bool operator< (const uint128_t &a, const uint128_t &b)
 
static HWY_MAYBE_UNUSED bool operator> (const uint128_t &a, const uint128_t &b)
 
static HWY_MAYBE_UNUSED bool operator== (const uint128_t &a, const uint128_t &b)
 
static HWY_MAYBE_UNUSED bool operator< (const K64V64 &a, const K64V64 &b)
 
static HWY_MAYBE_UNUSED bool operator> (const K64V64 &a, const K64V64 &b)
 
static HWY_MAYBE_UNUSED bool operator== (const K64V64 &a, const K64V64 &b)
 
static HWY_MAYBE_UNUSED bool operator< (const K32V32 &a, const K32V32 &b)
 
static HWY_MAYBE_UNUSED bool operator> (const K32V32 &a, const K32V32 &b)
 
static HWY_MAYBE_UNUSED bool operator== (const K32V32 &a, const K32V32 &b)
 
template<typename T , typename U >
HWY_API constexpr bool IsSame ()
 
template<typename T , typename U1 , typename U2 >
HWY_API constexpr bool IsSameEither ()
 
template<typename T >
HWY_API constexpr bool IsConst ()
 
template<class T >
HWY_API DeclValT< T >::type DeclVal () noexcept
 
template<class T >
static constexpr bool IsArray ()
 
template<class From , class To >
HWY_API constexpr bool IsConvertible ()
 
template<class From , class To >
static constexpr bool IsStaticCastable ()
 
template<class T , class From >
static constexpr bool IsAssignable ()
 
template<typename T >
HWY_API constexpr bool IsSpecialFloat ()
 
template<class T >
HWY_API constexpr bool IsIntegerLaneType ()
 
template<>
HWY_INLINE constexpr bool IsIntegerLaneType< int8_t > ()
 
template<>
HWY_INLINE constexpr bool IsIntegerLaneType< uint8_t > ()
 
template<>
HWY_INLINE constexpr bool IsIntegerLaneType< int16_t > ()
 
template<>
HWY_INLINE constexpr bool IsIntegerLaneType< uint16_t > ()
 
template<>
HWY_INLINE constexpr bool IsIntegerLaneType< int32_t > ()
 
template<>
HWY_INLINE constexpr bool IsIntegerLaneType< uint32_t > ()
 
template<>
HWY_INLINE constexpr bool IsIntegerLaneType< int64_t > ()
 
template<>
HWY_INLINE constexpr bool IsIntegerLaneType< uint64_t > ()
 
template<class T >
HWY_API constexpr bool IsInteger ()
 
template<>
HWY_INLINE constexpr bool IsInteger< bool > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< char > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< signed char > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< unsigned char > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< short > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< unsigned short > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< int > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< unsigned > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< long > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< unsigned long > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< long long > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< unsigned long long > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< char16_t > ()
 
template<>
HWY_INLINE constexpr bool IsInteger< char32_t > ()
 
template<class To , class From >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR To BitCastScalar (const From &val)
 
HWY_API HWY_F16_CONSTEXPR float F32FromF16 (float16_t f16)
 
HWY_API HWY_F16_CONSTEXPR float16_t F16FromF32 (float f32)
 
HWY_API HWY_F16_CONSTEXPR float16_t F16FromF64 (double f64)
 
HWY_F16_CONSTEXPR bool operator== (float16_t lhs, float16_t rhs) noexcept
 
HWY_F16_CONSTEXPR bool operator!= (float16_t lhs, float16_t rhs) noexcept
 
HWY_F16_CONSTEXPR bool operator< (float16_t lhs, float16_t rhs) noexcept
 
HWY_F16_CONSTEXPR bool operator<= (float16_t lhs, float16_t rhs) noexcept
 
HWY_F16_CONSTEXPR bool operator> (float16_t lhs, float16_t rhs) noexcept
 
HWY_F16_CONSTEXPR bool operator>= (float16_t lhs, float16_t rhs) noexcept
 
HWY_API HWY_BF16_CONSTEXPR float F32FromBF16 (bfloat16_t bf)
 
HWY_API HWY_BF16_CONSTEXPR bfloat16_t BF16FromF32 (float f)
 
HWY_API HWY_BF16_CONSTEXPR bfloat16_t BF16FromF64 (double f64)
 
HWY_BF16_CONSTEXPR bool operator== (bfloat16_t lhs, bfloat16_t rhs) noexcept
 
HWY_BF16_CONSTEXPR bool operator!= (bfloat16_t lhs, bfloat16_t rhs) noexcept
 
HWY_BF16_CONSTEXPR bool operator< (bfloat16_t lhs, bfloat16_t rhs) noexcept
 
HWY_BF16_CONSTEXPR bool operator<= (bfloat16_t lhs, bfloat16_t rhs) noexcept
 
HWY_BF16_CONSTEXPR bool operator> (bfloat16_t lhs, bfloat16_t rhs) noexcept
 
HWY_BF16_CONSTEXPR bool operator>= (bfloat16_t lhs, bfloat16_t rhs) noexcept
 
template<typename T , class R = detail::Relations<T>>
constexpr auto TypeTag () -> hwy::SizeTag<((R::is_signed+R::is_float+R::is_bf16)<< 8)>
 
template<typename T , class R = detail::Relations<T>>
constexpr auto IsFloatTag () -> hwy::SizeTag<(R::is_float ? 0x200 :0x400)>
 
template<typename T >
HWY_API constexpr bool IsFloat3264 ()
 
template<typename T >
HWY_API constexpr bool IsFloat ()
 
template<typename T >
HWY_API constexpr bool IsSigned ()
 
template<>
constexpr bool IsSigned< float16_t > ()
 
template<>
constexpr bool IsSigned< bfloat16_t > ()
 
template<>
constexpr bool IsSigned< hwy::uint128_t > ()
 
template<>
constexpr bool IsSigned< hwy::K64V64 > ()
 
template<>
constexpr bool IsSigned< hwy::K32V32 > ()
 
template<typename T >
HWY_API constexpr T LimitsMax ()
 
template<typename T >
HWY_API constexpr T LimitsMin ()
 
template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPRLowestValue ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR bfloat16_t LowestValue< bfloat16_t > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR float16_t LowestValue< float16_t > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR float LowestValue< float > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR double LowestValue< double > ()
 
template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPRHighestValue ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR bfloat16_t HighestValue< bfloat16_t > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR float16_t HighestValue< float16_t > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR float HighestValue< float > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR double HighestValue< double > ()
 
template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPREpsilon ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR bfloat16_t Epsilon< bfloat16_t > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR float16_t Epsilon< float16_t > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR float Epsilon< float > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR double Epsilon< double > ()
 
template<typename T >
constexpr int MantissaBits ()
 
template<>
constexpr int MantissaBits< bfloat16_t > ()
 
template<>
constexpr int MantissaBits< float16_t > ()
 
template<>
constexpr int MantissaBits< float > ()
 
template<>
constexpr int MantissaBits< double > ()
 
template<typename T >
constexpr MakeSigned< T > MaxExponentTimes2 ()
 
template<typename T >
constexpr MakeUnsigned< T > SignMask ()
 
template<typename T >
constexpr MakeUnsigned< T > ExponentMask ()
 
template<typename T >
constexpr MakeUnsigned< T > MantissaMask ()
 
template<typename T >
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPRMantissaEnd ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR bfloat16_t MantissaEnd< bfloat16_t > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR float16_t MantissaEnd< float16_t > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR float MantissaEnd< float > ()
 
template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR double MantissaEnd< double > ()
 
template<typename T >
constexpr int ExponentBits ()
 
template<typename T >
constexpr MakeSigned< T > MaxExponentField ()
 
HWY_API float F32FromF16Mem (const void *ptr)
 
HWY_API float F32FromBF16Mem (const void *ptr)
 
template<typename TTo , typename TFrom , HWY_IF_NOT_SPECIAL_FLOAT(TTo) , HWY_IF_NOT_SPECIAL_FLOAT(TFrom) , HWY_IF_NOT_SAME(TTo, TFrom) >
HWY_API constexpr TTo ConvertScalarTo (const TFrom in)
 
template<typename TTo , HWY_IF_F16(TTo) >
HWY_API HWY_BF16_TO_F16_CONSTEXPR TTo ConvertScalarTo (const hwy::bfloat16_t in)
 
template<typename TTo , HWY_IF_F16(TTo) >
HWY_API HWY_F16_CONSTEXPR TTo ConvertScalarTo (const double in)
 
template<typename TTo , typename TFrom , HWY_IF_BF16(TTo) , HWY_IF_NOT_SPECIAL_FLOAT(TFrom) , HWY_IF_NOT_SAME(TFrom, double) >
HWY_API HWY_BF16_CONSTEXPR TTo ConvertScalarTo (const TFrom in)
 
template<typename TTo , HWY_IF_BF16(TTo) >
HWY_API HWY_BF16_TO_F16_CONSTEXPR TTo ConvertScalarTo (const hwy::float16_t in)
 
template<typename TTo , HWY_IF_BF16(TTo) >
HWY_API HWY_BF16_CONSTEXPR TTo ConvertScalarTo (const double in)
 
template<typename TTo , typename TFrom , HWY_IF_F16(TFrom) , HWY_IF_NOT_SPECIAL_FLOAT(TTo) >
HWY_API HWY_F16_CONSTEXPR TTo ConvertScalarTo (const TFrom in)
 
template<typename TTo , typename TFrom , HWY_IF_BF16(TFrom) , HWY_IF_NOT_SPECIAL_FLOAT(TTo) >
HWY_API HWY_BF16_CONSTEXPR TTo ConvertScalarTo (TFrom in)
 
template<typename TTo >
HWY_API constexpr TTo ConvertScalarTo (TTo in)
 
template<typename T1 , typename T2 >
constexpr T1 DivCeil (T1 a, T2 b)
 
constexpr size_t RoundUpTo (size_t what, size_t align)
 
constexpr size_t RoundDownTo (size_t what, size_t align)
 
template<class T , HWY_IF_INTEGER(RemoveCvRef< T >) >
HWY_API constexpr RemoveCvRef< T > ScalarShr (T val, int shift_amt)
 
HWY_API size_t Num0BitsBelowLS1Bit_Nonzero32 (const uint32_t x)
 
HWY_API size_t Num0BitsBelowLS1Bit_Nonzero64 (const uint64_t x)
 
HWY_API size_t Num0BitsAboveMS1Bit_Nonzero32 (const uint32_t x)
 
HWY_API size_t Num0BitsAboveMS1Bit_Nonzero64 (const uint64_t x)
 
template<class T , HWY_IF_INTEGER(RemoveCvRef< T >) , HWY_IF_T_SIZE_ONE_OF(RemoveCvRef< T >,(1<< 1)|(1<< 2)|(1<< 4)) >
HWY_API size_t PopCount (T x)
 
template<typename TI >
constexpr size_t FloorLog2 (TI x)
 
template<typename TI >
constexpr size_t CeilLog2 (TI x)
 
template<typename T , typename T2 , HWY_IF_FLOAT(T) , HWY_IF_NOT_SPECIAL_FLOAT(T) >
HWY_INLINE constexpr T AddWithWraparound (T t, T2 increment)
 
template<typename T , typename T2 , HWY_IF_SPECIAL_FLOAT(T) >
HWY_INLINE constexpr T AddWithWraparound (T t, T2 increment)
 
HWY_API uint64_t Mul128 (uint64_t a, uint64_t b, uint64_t *HWY_RESTRICT upper)
 
HWY_API int64_t Mul128 (int64_t a, int64_t b, int64_t *HWY_RESTRICT upper)
 
template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR RemoveCvRef< T > ScalarAbs (T val)
 
template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR bool ScalarIsNaN (T val)
 
template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR bool ScalarIsInf (T val)
 
template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR bool ScalarIsFinite (T val)
 
template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR RemoveCvRef< T > ScalarCopySign (T magn, T sign)
 
template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR bool ScalarSignBit (T val)
 
template<class T >
HWY_API void PreventElision (T &&output)
 
HWY_INLINE HWY_ATTR_CACHE void LoadFence ()
 
HWY_INLINE HWY_ATTR_CACHE void FlushStream ()
 
template<typename T >
HWY_INLINE HWY_ATTR_CACHE void Prefetch (const T *p)
 
HWY_INLINE HWY_ATTR_CACHE void FlushCacheline (const void *p)
 
HWY_INLINE HWY_ATTR_CACHE void Pause ()
 
template<class Image1 , class Image2 >
HWY_MAYBE_UNUSED bool SameSize (const Image1 &image1, const Image2 &image2)
 
static HWY_INLINE HWY_MAYBE_UNUSED size_t Mirror (int64_t x, const int64_t xsize)
 
static std::vector< DistAllDist ()
 
static const char * DistName (Dist dist)
 
static const char * AlgoName (Algo algo)
 
static double SummarizeMeasurements (std::vector< double > &seconds)
 
HWY_CONTRIB_DLLEXPORT void VQSort (uint16_t *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (uint16_t *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (uint32_t *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (uint32_t *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (uint64_t *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (uint64_t *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (int16_t *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (int16_t *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (int32_t *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (int32_t *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (int64_t *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (int64_t *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (float16_t *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (float16_t *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (float *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (float *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (double *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (double *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (uint128_t *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (uint128_t *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (K64V64 *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (K64V64 *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (K32V32 *HWY_RESTRICT keys, const size_t n, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSort (K32V32 *HWY_RESTRICT keys, const size_t n, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (uint16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (uint16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (uint32_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (uint32_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (uint64_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (uint64_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (int16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (int16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (int32_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (int32_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (int64_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (int64_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (float16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (float16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (float *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (float *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (double *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (double *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (uint128_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (uint128_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (K64V64 *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (K64V64 *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (K32V32 *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQPartialSort (K32V32 *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (uint16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (uint16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (uint32_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (uint32_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (uint64_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (uint64_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (int16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (int16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (int32_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (int32_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (int64_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (int64_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (float16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (float16_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (float *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (float *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (double *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (double *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (uint128_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (uint128_t *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (K64V64 *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (K64V64 *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (K32V32 *HWY_RESTRICT keys, const size_t n, const size_t k, SortAscending)
 
HWY_CONTRIB_DLLEXPORT void VQSelect (K32V32 *HWY_RESTRICT keys, const size_t n, const size_t k, SortDescending)
 
HWY_CONTRIB_DLLEXPORT bool Fill16BytesSecure (void *bytes)
 
HWY_CONTRIB_DLLEXPORT uint64_t * GetGeneratorState ()
 
static uint32_t BlockUntilDifferent (const uint32_t prev, const std::atomic< uint32_t > &current)
 
static void WakeAll (std::atomic< uint32_t > &current)
 
static void SetThreadName (const char *format, int thread)
 
template<typename RetType , typename... Args>
FunctionCache< RetType, Args... > DeduceFunctionCache (RetType(*)(Args...))
 
HWY_DLLEXPORT int Unpredictable1 ()
 
HWY_DLLEXPORT size_t Measure (Func func, const uint8_t *arg, const FuncInput *inputs, size_t num_inputs, Result *results, const Params &p=Params())
 
template<class Closure >
static FuncOutput CallClosure (const Closure *f, const FuncInput input)
 
template<class Closure >
static size_t MeasureClosure (const Closure &closure, const FuncInput *inputs, const size_t num_inputs, Result *results, const Params &p=Params())
 
HWY_DLLEXPORT int64_t DispatchedTarget ()
 
HWY_DLLEXPORT size_t VectorBytes ()
 
HWY_DLLEXPORT bool HaveFloat16 ()
 
HWY_DLLEXPORT bool HaveFloat64 ()
 
template<typename T >
HWY_NOINLINE void PrintValue (T value)
 
template<typename T >
HWY_NOINLINE void PrintArray (const T *value, size_t count)
 
HWY_DLLEXPORT int64_t SupportedTargets ()
 
HWY_DLLEXPORT void DisableTargets (int64_t disabled_targets)
 
HWY_DLLEXPORT void SetSupportedTargetsForTest (int64_t targets)
 
HWY_INLINE std::vector< int64_t > SupportedAndGeneratedTargets ()
 
static HWY_MAYBE_UNUSED const char * TargetName (int64_t target)
 
HWY_DLLEXPORT ChosenTargetGetChosenTarget ()
 
static std::string TestParamTargetName (const testing::TestParamInfo< int64_t > &info)
 
template<typename T >
std::string TestParamTargetNameAndT (const testing::TestParamInfo< std::tuple< int64_t, T > > &info)
 
static HWY_INLINE uint32_t Random32 (RandomState *rng)
 
static HWY_INLINE uint64_t Random64 (RandomState *rng)
 
template<class T , HWY_IF_FLOAT_OR_SPECIAL(T) >
static HWY_INLINERandomFiniteValue (RandomState *rng)
 
HWY_TEST_DLLEXPORT bool BytesEqual (const void *p1, const void *p2, size_t size, size_t *pos=nullptr)
 
void AssertStringEqual (const char *expected, const char *actual, const char *target_name, const char *filename, int line)
 
template<typename T >
std::string TypeName (T, size_t N)
 
template<typename TTo , typename T , HWY_IF_NOT_FLOAT_NOR_SPECIAL(TTo) , HWY_IF_T_SIZE_LE(TTo, 4) >
WrapTo (T value)
 
template<typename TTo , typename T , HWY_IF_FLOAT_OR_SPECIAL(TTo) >
WrapTo (T value)
 
template<typename TExpected , typename TActual >
HWY_INLINE bool IsEqual (const TExpected texpected, const TActual actual)
 
template<typename TExpected , typename TActual >
HWY_INLINE void AssertEqual (const TExpected texpected, const TActual actual, const char *target_name, const char *filename, int line, size_t lane=0)
 
template<typename T >
HWY_INLINE void AssertArrayEqual (const T *expected, const T *actual, size_t count, const char *target_name, const char *filename, int line)
 
template<typename T >
HWY_INLINE void AssertArraySimilar (const T *expected, const T *actual, size_t count, const char *target_name, const char *filename, int line)
 
static double SecondsSince (const Timestamp &t0)
 

Variables

HWY_DLLEXPORT HWY_NORETURN void int line
 
HWY_DLLEXPORT HWY_NORETURN void int const char * format
 
static constexpr HWY_MAYBE_UNUSED size_t kMaxVectorSize = 16
 
HWY_MAYBE_UNUSED constexpr size_t kTestMaxVectorSize = 64
 

Typedef Documentation

◆ AbortFunc

typedef void(* hwy::AbortFunc) (const char *file, int line, const char *formatted_err)

◆ AlignedFreeUniquePtr

template<typename T >
using hwy::AlignedFreeUniquePtr = std::unique_ptr<T, AlignedFreer>

◆ AlignedUniquePtr

template<typename T >
using hwy::AlignedUniquePtr = std::unique_ptr<T, AlignedDeleter>

◆ AlignedVector

template<class T >
using hwy::AlignedVector = std::vector<T, AlignedAllocator<T>>

◆ AllocPtr

using hwy::AllocPtr = void* (*)(void* opaque, size_t bytes)

◆ EnableIf

template<bool Condition>
using hwy::EnableIf = typename EnableIfT<Condition>::type

◆ float32_t

using hwy::float32_t = float

◆ float64_t

using hwy::float64_t = double

◆ FloatFromSize

template<size_t N>
using hwy::FloatFromSize = typename detail::TypeFromSize<N>::Float

◆ FloatTag

using hwy::FloatTag = SizeTag<0x200>

◆ FreePtr

using hwy::FreePtr = void (*)(void* opaque, void* memory)

◆ Func

using hwy::Func = FuncOutput (*)(const void*, FuncInput)

◆ FuncInput

using hwy::FuncInput = size_t

◆ FuncOutput

using hwy::FuncOutput = uint64_t

◆ If

template<bool Condition, typename Then , typename Else >
using hwy::If = typename IfT<Condition, Then, Else>::type

◆ Image3F

using hwy::Image3F = Image3<float>

◆ ImageF

using hwy::ImageF = Image<float>

◆ LargestType

template<typename T1 , typename T2 >
using hwy::LargestType
Initial value:
If<IsFloat<T1>() || IsFloat<T2>(),
FloatFromSize<HWY_MAX(sizeof(T1), sizeof(T2))>,
If<IsSigned<T1>() || IsSigned<T2>(),
SignedFromSize<HWY_MAX(sizeof(T1), sizeof(T2))>,
UnsignedFromSize<HWY_MAX(sizeof(T1), sizeof(T2))>>>
#define HWY_MAX(a, b)
Definition base.h:177
typename detail::TypeFromSize< N >::Unsigned UnsignedFromSize
Definition base.h:2092
typename detail::TypeFromSize< N >::Signed SignedFromSize
Definition base.h:2094
typename detail::TypeFromSize< N >::Float FloatFromSize
Definition base.h:2096

◆ MakeFloat

template<typename T >
using hwy::MakeFloat = typename detail::Relations<T>::Float

◆ MakeLaneTypeIfInteger

template<typename T >
using hwy::MakeLaneTypeIfInteger = typename MakeLaneTypeIfIntegerT<T>::type

◆ MakeNarrow

template<typename T >
using hwy::MakeNarrow = typename detail::Relations<T>::Narrow

◆ MakeSigned

template<typename T >
using hwy::MakeSigned = typename detail::Relations<T>::Signed

◆ MakeUnsigned

template<typename T >
using hwy::MakeUnsigned = typename detail::Relations<T>::Unsigned

◆ MakeWide

template<typename T >
using hwy::MakeWide = typename detail::Relations<T>::Wide

◆ NonFloatTag

using hwy::NonFloatTag = SizeTag<0x400>

◆ RemoveConst

template<class T >
using hwy::RemoveConst = typename RemoveConstT<T>::type

◆ RemoveCvRef

template<class T >
using hwy::RemoveCvRef = RemoveConst<RemoveVolatile<RemoveRef<T>>>

◆ RemovePtr

template<class T >
using hwy::RemovePtr = typename RemovePtrT<T>::type

◆ RemoveRef

template<class T >
using hwy::RemoveRef = typename RemoveRefT<T>::type

◆ RemoveVolatile

template<class T >
using hwy::RemoveVolatile = typename RemoveVolatileT<T>::type

◆ SignedFromSize

template<size_t N>
using hwy::SignedFromSize = typename detail::TypeFromSize<N>::Signed

◆ SignedTag

using hwy::SignedTag = SizeTag<0x100>

◆ SpecialTag

using hwy::SpecialTag = SizeTag<0x300>

◆ UnsignedFromSize

template<size_t N>
using hwy::UnsignedFromSize = typename detail::TypeFromSize<N>::Unsigned

◆ UnsignedTag

Enumeration Type Documentation

◆ Algo

enum class hwy::Algo
strong
Enumerator
kStdSort 
kStdSelect 
kStdPartialSort 
kVQSort 
kVQPartialSort 
kVQSelect 
kHeapSort 
kHeapPartialSort 
kHeapSelect 

◆ Dist

enum class hwy::Dist
strong
Enumerator
kUniform8 
kUniform16 
kUniform32 

◆ PoolWaitMode

enum class hwy::PoolWaitMode : uint32_t
strong
Enumerator
kBlock 
kSpin 

Function Documentation

◆ AddWithWraparound() [1/2]

template<typename T , typename T2 , HWY_IF_FLOAT(T) , HWY_IF_NOT_SPECIAL_FLOAT(T) >
HWY_INLINE constexpr T hwy::AddWithWraparound ( T t,
T2 increment )
constexpr

References AddWithWraparound().

Referenced by AddWithWraparound().

◆ AddWithWraparound() [2/2]

template<typename T , typename T2 , HWY_IF_SPECIAL_FLOAT(T) >
HWY_INLINE constexpr T hwy::AddWithWraparound ( T t,
T2 increment )
constexpr

References AddWithWraparound().

◆ AlgoName()

static const char * hwy::AlgoName ( Algo algo)
inlinestatic

◆ AllDist()

static std::vector< Dist > hwy::AllDist ( )
inlinestatic

References kUniform32.

◆ AllocateAligned() [1/2]

template<typename T >
AlignedFreeUniquePtr< T[]> hwy::AllocateAligned ( const size_t items)

◆ AllocateAligned() [2/2]

template<typename T >
AlignedFreeUniquePtr< T[]> hwy::AllocateAligned ( const size_t items,
AllocPtr alloc,
FreePtr free,
void * opaque )

◆ AllocateAlignedBytes()

HWY_DLLEXPORT void * hwy::AllocateAlignedBytes ( size_t payload_size,
AllocPtr alloc_ptr = nullptr,
void * opaque_ptr = nullptr )

◆ AssertArrayEqual()

template<typename T >
HWY_INLINE void hwy::AssertArrayEqual ( const T * expected,
const T * actual,
size_t count,
const char * target_name,
const char * filename,
int line )

◆ AssertArraySimilar()

template<typename T >
HWY_INLINE void hwy::AssertArraySimilar ( const T * expected,
const T * actual,
size_t count,
const char * target_name,
const char * filename,
int line )

References HWY_ABORT, line, ScalarAbs(), and TypeName().

◆ AssertEqual()

template<typename TExpected , typename TActual >
HWY_INLINE void hwy::AssertEqual ( const TExpected texpected,
const TActual actual,
const char * target_name,
const char * filename,
int line,
size_t lane = 0 )

◆ AssertStringEqual()

void hwy::AssertStringEqual ( const char * expected,
const char * actual,
const char * target_name,
const char * filename,
int line )

◆ BF16FromF32()

HWY_API HWY_BF16_CONSTEXPR bfloat16_t hwy::BF16FromF32 ( float f)

◆ BF16FromF64()

HWY_API HWY_BF16_CONSTEXPR bfloat16_t hwy::BF16FromF64 ( double f64)

References BF16FromF32(), and BF16FromF64().

Referenced by BF16FromF64(), and ConvertScalarTo().

◆ BitCastScalar()

template<class To , class From >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR To hwy::BitCastScalar ( const From & val)

References BitCastScalar(), and CopySameSize().

Referenced by BitCastScalar().

◆ BlockUntilDifferent()

static uint32_t hwy::BlockUntilDifferent ( const uint32_t prev,
const std::atomic< uint32_t > & current )
inlinestatic

◆ BytesEqual()

HWY_TEST_DLLEXPORT bool hwy::BytesEqual ( const void * p1,
const void * p2,
size_t size,
size_t * pos = nullptr )

◆ CallClosure()

template<class Closure >
static FuncOutput hwy::CallClosure ( const Closure * f,
const FuncInput input )
static

◆ CeilLog2()

template<typename TI >
constexpr size_t hwy::CeilLog2 ( TI x)
constexpr

◆ ConvertScalarTo() [1/9]

template<typename TTo , HWY_IF_F16(TTo) >
HWY_API HWY_F16_CONSTEXPR TTo hwy::ConvertScalarTo ( const double in)

References ConvertScalarTo(), and F16FromF64().

◆ ConvertScalarTo() [2/9]

template<typename TTo , HWY_IF_BF16(TTo) >
HWY_API HWY_BF16_CONSTEXPR TTo hwy::ConvertScalarTo ( const double in)

References BF16FromF64(), and ConvertScalarTo().

◆ ConvertScalarTo() [3/9]

template<typename TTo , HWY_IF_F16(TTo) >
HWY_API HWY_BF16_TO_F16_CONSTEXPR TTo hwy::ConvertScalarTo ( const hwy::bfloat16_t in)

◆ ConvertScalarTo() [4/9]

template<typename TTo , HWY_IF_BF16(TTo) >
HWY_API HWY_BF16_TO_F16_CONSTEXPR TTo hwy::ConvertScalarTo ( const hwy::float16_t in)

◆ ConvertScalarTo() [5/9]

template<typename TTo , typename TFrom , HWY_IF_NOT_SPECIAL_FLOAT(TTo) , HWY_IF_NOT_SPECIAL_FLOAT(TFrom) , HWY_IF_NOT_SAME(TTo, TFrom) >
HWY_API constexpr TTo hwy::ConvertScalarTo ( const TFrom in)
constexpr

◆ ConvertScalarTo() [6/9]

template<typename TTo , typename TFrom , HWY_IF_BF16(TTo) , HWY_IF_NOT_SPECIAL_FLOAT(TFrom) , HWY_IF_NOT_SAME(TFrom, double) >
HWY_API HWY_BF16_CONSTEXPR TTo hwy::ConvertScalarTo ( const TFrom in)

References BF16FromF32(), and ConvertScalarTo().

◆ ConvertScalarTo() [7/9]

template<typename TTo , typename TFrom , HWY_IF_F16(TFrom) , HWY_IF_NOT_SPECIAL_FLOAT(TTo) >
HWY_API HWY_F16_CONSTEXPR TTo hwy::ConvertScalarTo ( const TFrom in)

References ConvertScalarTo(), and F32FromF16().

◆ ConvertScalarTo() [8/9]

template<typename TTo , typename TFrom , HWY_IF_BF16(TFrom) , HWY_IF_NOT_SPECIAL_FLOAT(TTo) >
HWY_API HWY_BF16_CONSTEXPR TTo hwy::ConvertScalarTo ( TFrom in)

References ConvertScalarTo(), and F32FromBF16().

◆ ConvertScalarTo() [9/9]

template<typename TTo >
HWY_API constexpr TTo hwy::ConvertScalarTo ( TTo in)
constexpr

References ConvertScalarTo().

◆ CopyBytes() [1/2]

template<size_t kBytes, typename From , typename To >
HWY_API void hwy::CopyBytes ( const From * from,
To * to )

◆ CopyBytes() [2/2]

HWY_API void hwy::CopyBytes ( const void *HWY_RESTRICT from,
void *HWY_RESTRICT to,
size_t num_of_bytes_to_copy )

◆ CopySameSize()

template<typename From , typename To >
HWY_API void hwy::CopySameSize ( const From *HWY_RESTRICT from,
To *HWY_RESTRICT to )

◆ DeclVal()

template<class T >
HWY_API DeclValT< T >::type hwy::DeclVal ( )
noexcept

◆ DeduceFunctionCache()

template<typename RetType , typename... Args>
FunctionCache< RetType, Args... > hwy::DeduceFunctionCache ( RetType(*)(Args...) )

◆ DisableTargets()

HWY_DLLEXPORT void hwy::DisableTargets ( int64_t disabled_targets)

◆ DispatchedTarget()

HWY_DLLEXPORT int64_t hwy::DispatchedTarget ( )

◆ DistName()

static const char * hwy::DistName ( Dist dist)
inlinestatic

◆ DivCeil()

template<typename T1 , typename T2 >
constexpr T1 hwy::DivCeil ( T1 a,
T2 b )
inlineconstexpr

References DivCeil().

Referenced by DivCeil(), and RoundUpTo().

◆ Epsilon()

template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR T hwy::Epsilon ( )

References Epsilon().

Referenced by Epsilon().

◆ Epsilon< bfloat16_t >()

◆ Epsilon< double >()

template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR double hwy::Epsilon< double > ( )

◆ Epsilon< float >()

template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR float hwy::Epsilon< float > ( )

◆ Epsilon< float16_t >()

◆ ExponentBits()

template<typename T >
constexpr int hwy::ExponentBits ( )
constexpr

References ExponentBits().

Referenced by ExponentBits().

◆ ExponentMask()

template<typename T >
constexpr MakeUnsigned< T > hwy::ExponentMask ( )
constexpr

References ExponentMask().

Referenced by ExponentMask().

◆ F16FromF32()

HWY_API HWY_F16_CONSTEXPR float16_t hwy::F16FromF32 ( float f32)

◆ F16FromF64()

HWY_API HWY_F16_CONSTEXPR float16_t hwy::F16FromF64 ( double f64)

References F16FromF32(), and F16FromF64().

Referenced by ConvertScalarTo(), and F16FromF64().

◆ F32FromBF16()

HWY_API HWY_BF16_CONSTEXPR float hwy::F32FromBF16 ( bfloat16_t bf)

◆ F32FromBF16Mem()

HWY_API float hwy::F32FromBF16Mem ( const void * ptr)

◆ F32FromF16()

HWY_API HWY_F16_CONSTEXPR float hwy::F32FromF16 ( float16_t f16)

◆ F32FromF16Mem()

HWY_API float hwy::F32FromF16Mem ( const void * ptr)

◆ Fill16BytesSecure()

HWY_CONTRIB_DLLEXPORT bool hwy::Fill16BytesSecure ( void * bytes)

◆ FloorLog2()

template<typename TI >
constexpr size_t hwy::FloorLog2 ( TI x)
constexpr

References FloorLog2().

Referenced by CeilLog2(), and FloorLog2().

◆ FlushCacheline()

HWY_INLINE HWY_ATTR_CACHE void hwy::FlushCacheline ( const void * p)

◆ FlushStream()

HWY_INLINE HWY_ATTR_CACHE void hwy::FlushStream ( )

◆ FreeAlignedBytes()

HWY_DLLEXPORT void hwy::FreeAlignedBytes ( const void * aligned_pointer,
FreePtr free_ptr,
void * opaque_ptr )

◆ GetAbortFunc()

AbortFunc & hwy::GetAbortFunc ( )

◆ GetChosenTarget()

HWY_DLLEXPORT ChosenTarget & hwy::GetChosenTarget ( )

◆ GetGeneratorState()

HWY_CONTRIB_DLLEXPORT uint64_t * hwy::GetGeneratorState ( )

◆ HaveFloat16()

HWY_DLLEXPORT bool hwy::HaveFloat16 ( )

◆ HaveFloat64()

HWY_DLLEXPORT bool hwy::HaveFloat64 ( )

◆ HighestValue()

template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR T hwy::HighestValue ( )

◆ HighestValue< bfloat16_t >()

◆ HighestValue< double >()

template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR double hwy::HighestValue< double > ( )

◆ HighestValue< float >()

◆ HighestValue< float16_t >()

◆ HWY_FORMAT()

HWY_DLLEXPORT HWY_NORETURN void hwy::HWY_FORMAT ( 3 ,
4  ) const

◆ IsAligned()

template<typename T >
HWY_API constexpr bool hwy::IsAligned ( T * ptr,
size_t align = HWY_ALIGNMENT )
constexpr

◆ IsArray()

template<class T >
static constexpr bool hwy::IsArray ( )
staticconstexpr

◆ IsAssignable()

template<class T , class From >
static constexpr bool hwy::IsAssignable ( )
staticconstexpr

References IsAssignable().

Referenced by IsAssignable().

◆ IsConst()

template<typename T >
HWY_API constexpr bool hwy::IsConst ( )
constexpr

◆ IsConvertible()

template<class From , class To >
HWY_API constexpr bool hwy::IsConvertible ( )
constexpr

References IsConvertible().

Referenced by IsConvertible().

◆ IsEqual()

template<typename TExpected , typename TActual >
HWY_INLINE bool hwy::IsEqual ( const TExpected texpected,
const TActual actual )

◆ IsFloat()

template<typename T >
HWY_API constexpr bool hwy::IsFloat ( )
constexpr

References IsFloat().

Referenced by IsFloat().

◆ IsFloat3264()

template<typename T >
HWY_API constexpr bool hwy::IsFloat3264 ( )
constexpr

References IsFloat3264().

Referenced by IsFloat3264().

◆ IsFloatTag()

template<typename T , class R = detail::Relations<T>>
constexpr auto hwy::IsFloatTag ( ) -> hwy::SizeTag<(R::is_float ? 0x200 : 0x400)>
constexpr

References IsFloatTag().

Referenced by IsFloatTag().

◆ IsInteger()

template<class T >
HWY_API constexpr bool hwy::IsInteger ( )
constexpr

References IsInteger(), and IsSameEither().

Referenced by IsInteger().

◆ IsInteger< bool >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< bool > ( )
constexpr

◆ IsInteger< char >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< char > ( )
constexpr

◆ IsInteger< char16_t >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< char16_t > ( )
constexpr

◆ IsInteger< char32_t >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< char32_t > ( )
constexpr

◆ IsInteger< int >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< int > ( )
constexpr

◆ IsInteger< long >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< long > ( )
constexpr

◆ IsInteger< long long >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< long long > ( )
constexpr

◆ IsInteger< short >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< short > ( )
constexpr

◆ IsInteger< signed char >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< signed char > ( )
constexpr

◆ IsInteger< unsigned >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< unsigned > ( )
constexpr

◆ IsInteger< unsigned char >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< unsigned char > ( )
constexpr

◆ IsInteger< unsigned long >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< unsigned long > ( )
constexpr

◆ IsInteger< unsigned long long >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< unsigned long long > ( )
constexpr

◆ IsInteger< unsigned short >()

template<>
HWY_INLINE constexpr bool hwy::IsInteger< unsigned short > ( )
constexpr

◆ IsIntegerLaneType()

template<class T >
HWY_API constexpr bool hwy::IsIntegerLaneType ( )
constexpr

References IsIntegerLaneType().

Referenced by IsIntegerLaneType().

◆ IsIntegerLaneType< int16_t >()

template<>
HWY_INLINE constexpr bool hwy::IsIntegerLaneType< int16_t > ( )
constexpr

◆ IsIntegerLaneType< int32_t >()

template<>
HWY_INLINE constexpr bool hwy::IsIntegerLaneType< int32_t > ( )
constexpr

◆ IsIntegerLaneType< int64_t >()

template<>
HWY_INLINE constexpr bool hwy::IsIntegerLaneType< int64_t > ( )
constexpr

◆ IsIntegerLaneType< int8_t >()

template<>
HWY_INLINE constexpr bool hwy::IsIntegerLaneType< int8_t > ( )
constexpr

◆ IsIntegerLaneType< uint16_t >()

template<>
HWY_INLINE constexpr bool hwy::IsIntegerLaneType< uint16_t > ( )
constexpr

◆ IsIntegerLaneType< uint32_t >()

template<>
HWY_INLINE constexpr bool hwy::IsIntegerLaneType< uint32_t > ( )
constexpr

◆ IsIntegerLaneType< uint64_t >()

template<>
HWY_INLINE constexpr bool hwy::IsIntegerLaneType< uint64_t > ( )
constexpr

◆ IsIntegerLaneType< uint8_t >()

template<>
HWY_INLINE constexpr bool hwy::IsIntegerLaneType< uint8_t > ( )
constexpr

◆ IsSame()

template<typename T , typename U >
HWY_API constexpr bool hwy::IsSame ( )
constexpr

◆ IsSameEither()

template<typename T , typename U1 , typename U2 >
HWY_API constexpr bool hwy::IsSameEither ( )
constexpr

Referenced by IsInteger().

◆ IsSigned()

template<typename T >
HWY_API constexpr bool hwy::IsSigned ( )
constexpr

◆ IsSigned< bfloat16_t >()

template<>
constexpr bool hwy::IsSigned< bfloat16_t > ( )
constexpr

◆ IsSigned< float16_t >()

template<>
constexpr bool hwy::IsSigned< float16_t > ( )
constexpr

◆ IsSigned< hwy::K32V32 >()

template<>
constexpr bool hwy::IsSigned< hwy::K32V32 > ( )
constexpr

◆ IsSigned< hwy::K64V64 >()

template<>
constexpr bool hwy::IsSigned< hwy::K64V64 > ( )
constexpr

◆ IsSigned< hwy::uint128_t >()

template<>
constexpr bool hwy::IsSigned< hwy::uint128_t > ( )
constexpr

◆ IsSpecialFloat()

template<typename T >
HWY_API constexpr bool hwy::IsSpecialFloat ( )
constexpr

References IsSpecialFloat().

Referenced by IsSpecialFloat().

◆ IsStaticCastable()

template<class From , class To >
static constexpr bool hwy::IsStaticCastable ( )
staticconstexpr

References IsStaticCastable().

Referenced by IsStaticCastable().

◆ LimitsMax()

template<typename T >
HWY_API constexpr T hwy::LimitsMax ( )
constexpr

References LimitsMax().

Referenced by LimitsMax(), and hwy::HWY_NAMESPACE::NaN().

◆ LimitsMin()

template<typename T >
HWY_API constexpr T hwy::LimitsMin ( )
constexpr

References LimitsMin().

Referenced by LimitsMin().

◆ LoadFence()

HWY_INLINE HWY_ATTR_CACHE void hwy::LoadFence ( )

◆ LowestValue()

template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR T hwy::LowestValue ( )

References LowestValue().

Referenced by LowestValue().

◆ LowestValue< bfloat16_t >()

◆ LowestValue< double >()

template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR double hwy::LowestValue< double > ( )

◆ LowestValue< float >()

◆ LowestValue< float16_t >()

◆ MakeUniqueAligned()

template<typename T , typename... Args>
AlignedUniquePtr< T > hwy::MakeUniqueAligned ( Args &&... args)

◆ MakeUniqueAlignedArray()

template<typename T , typename... Args>
AlignedUniquePtr< T[]> hwy::MakeUniqueAlignedArray ( size_t items,
Args &&... args )

◆ MakeUniqueAlignedArrayWithAlloc()

template<typename T , typename... Args>
AlignedUniquePtr< T[]> hwy::MakeUniqueAlignedArrayWithAlloc ( size_t items,
AllocPtr alloc,
FreePtr free,
void * opaque,
Args &&... args )

Referenced by MakeUniqueAlignedArray().

◆ MakeUniqueAlignedWithAlloc()

template<typename T , typename... Args>
AlignedUniquePtr< T > hwy::MakeUniqueAlignedWithAlloc ( AllocPtr alloc,
FreePtr free,
void * opaque,
Args &&... args )

◆ MantissaBits()

template<typename T >
constexpr int hwy::MantissaBits ( )
constexpr

References MantissaBits().

Referenced by MantissaBits().

◆ MantissaBits< bfloat16_t >()

template<>
constexpr int hwy::MantissaBits< bfloat16_t > ( )
constexpr

◆ MantissaBits< double >()

template<>
constexpr int hwy::MantissaBits< double > ( )
constexpr

◆ MantissaBits< float >()

template<>
constexpr int hwy::MantissaBits< float > ( )
constexpr

◆ MantissaBits< float16_t >()

template<>
constexpr int hwy::MantissaBits< float16_t > ( )
constexpr

◆ MantissaEnd()

template<typename T >
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR T hwy::MantissaEnd ( )

References MantissaEnd().

Referenced by MantissaEnd().

◆ MantissaEnd< bfloat16_t >()

◆ MantissaEnd< double >()

template<>
HWY_INLINE HWY_BITCASTSCALAR_CONSTEXPR double hwy::MantissaEnd< double > ( )

◆ MantissaEnd< float >()

◆ MantissaEnd< float16_t >()

◆ MantissaMask()

template<typename T >
constexpr MakeUnsigned< T > hwy::MantissaMask ( )
constexpr

References MantissaMask().

Referenced by MantissaMask().

◆ MaxExponentField()

template<typename T >
constexpr MakeSigned< T > hwy::MaxExponentField ( )
constexpr

References MaxExponentField().

Referenced by MaxExponentField().

◆ MaxExponentTimes2()

template<typename T >
constexpr MakeSigned< T > hwy::MaxExponentTimes2 ( )
constexpr

References MaxExponentTimes2().

Referenced by MaxExponentTimes2().

◆ Measure()

HWY_DLLEXPORT size_t hwy::Measure ( Func func,
const uint8_t * arg,
const FuncInput * inputs,
size_t num_inputs,
Result * results,
const Params & p = Params() )

Referenced by MeasureClosure().

◆ MeasureClosure()

template<class Closure >
static size_t hwy::MeasureClosure ( const Closure & closure,
const FuncInput * inputs,
const size_t num_inputs,
Result * results,
const Params & p = Params() )
inlinestatic

References Measure().

◆ Mirror()

static HWY_INLINE HWY_MAYBE_UNUSED size_t hwy::Mirror ( int64_t x,
const int64_t xsize )
static

References HWY_DASSERT.

Referenced by hwy::WrapMirror::operator()().

◆ Mul128() [1/2]

HWY_API int64_t hwy::Mul128 ( int64_t a,
int64_t b,
int64_t *HWY_RESTRICT upper )

References Mul128().

◆ Mul128() [2/2]

HWY_API uint64_t hwy::Mul128 ( uint64_t a,
uint64_t b,
uint64_t *HWY_RESTRICT upper )

◆ Num0BitsAboveMS1Bit_Nonzero32()

HWY_API size_t hwy::Num0BitsAboveMS1Bit_Nonzero32 ( const uint32_t x)

◆ Num0BitsAboveMS1Bit_Nonzero64()

HWY_API size_t hwy::Num0BitsAboveMS1Bit_Nonzero64 ( const uint64_t x)

◆ Num0BitsBelowLS1Bit_Nonzero32()

HWY_API size_t hwy::Num0BitsBelowLS1Bit_Nonzero32 ( const uint32_t x)

◆ Num0BitsBelowLS1Bit_Nonzero64()

HWY_API size_t hwy::Num0BitsBelowLS1Bit_Nonzero64 ( const uint64_t x)

◆ operator!=() [1/3]

HWY_BF16_CONSTEXPR bool hwy::operator!= ( bfloat16_t lhs,
bfloat16_t rhs )
inlinenoexcept

References F32FromBF16(), and operator!=().

◆ operator!=() [2/3]

template<class T , class V >
constexpr bool hwy::operator!= ( const AlignedAllocator< T > & ,
const AlignedAllocator< V > &  )
constexprnoexcept

Referenced by operator!=(), and operator!=().

◆ operator!=() [3/3]

HWY_F16_CONSTEXPR bool hwy::operator!= ( float16_t lhs,
float16_t rhs )
inlinenoexcept

References F32FromF16(), and operator!=().

◆ operator<() [1/5]

HWY_BF16_CONSTEXPR bool hwy::operator< ( bfloat16_t lhs,
bfloat16_t rhs )
inlinenoexcept

References F32FromBF16(), and operator<().

◆ operator<() [2/5]

static HWY_MAYBE_UNUSED bool hwy::operator< ( const K32V32 & a,
const K32V32 & b )
inlinestatic

References hwy::K32V32::key.

◆ operator<() [3/5]

static HWY_MAYBE_UNUSED bool hwy::operator< ( const K64V64 & a,
const K64V64 & b )
inlinestatic

References hwy::K64V64::key.

◆ operator<() [4/5]

static HWY_MAYBE_UNUSED bool hwy::operator< ( const uint128_t & a,
const uint128_t & b )
inlinestatic

References hwy::uint128_t::hi, and hwy::uint128_t::lo.

Referenced by operator<(), and operator<().

◆ operator<() [5/5]

HWY_F16_CONSTEXPR bool hwy::operator< ( float16_t lhs,
float16_t rhs )
inlinenoexcept

References F32FromF16(), and operator<().

◆ operator<=() [1/2]

HWY_BF16_CONSTEXPR bool hwy::operator<= ( bfloat16_t lhs,
bfloat16_t rhs )
inlinenoexcept

References F32FromBF16(), and operator<=().

◆ operator<=() [2/2]

HWY_F16_CONSTEXPR bool hwy::operator<= ( float16_t lhs,
float16_t rhs )
inlinenoexcept

References F32FromF16(), and operator<=().

Referenced by operator<=(), and operator<=().

◆ operator==() [1/6]

HWY_BF16_CONSTEXPR bool hwy::operator== ( bfloat16_t lhs,
bfloat16_t rhs )
inlinenoexcept

References F32FromBF16(), and operator==().

◆ operator==() [2/6]

template<class T , class V >
constexpr bool hwy::operator== ( const AlignedAllocator< T > & ,
const AlignedAllocator< V > &  )
constexprnoexcept

Referenced by operator==(), and operator==().

◆ operator==() [3/6]

static HWY_MAYBE_UNUSED bool hwy::operator== ( const K32V32 & a,
const K32V32 & b )
inlinestatic

References hwy::K32V32::key.

◆ operator==() [4/6]

static HWY_MAYBE_UNUSED bool hwy::operator== ( const K64V64 & a,
const K64V64 & b )
inlinestatic

References hwy::K64V64::key.

◆ operator==() [5/6]

static HWY_MAYBE_UNUSED bool hwy::operator== ( const uint128_t & a,
const uint128_t & b )
inlinestatic

◆ operator==() [6/6]

HWY_F16_CONSTEXPR bool hwy::operator== ( float16_t lhs,
float16_t rhs )
inlinenoexcept

References F32FromF16(), and operator==().

◆ operator>() [1/5]

HWY_BF16_CONSTEXPR bool hwy::operator> ( bfloat16_t lhs,
bfloat16_t rhs )
inlinenoexcept

References F32FromBF16(), and operator>().

◆ operator>() [2/5]

static HWY_MAYBE_UNUSED bool hwy::operator> ( const K32V32 & a,
const K32V32 & b )
inlinestatic

◆ operator>() [3/5]

static HWY_MAYBE_UNUSED bool hwy::operator> ( const K64V64 & a,
const K64V64 & b )
inlinestatic

◆ operator>() [4/5]

static HWY_MAYBE_UNUSED bool hwy::operator> ( const uint128_t & a,
const uint128_t & b )
inlinestatic

Referenced by operator>(), and operator>().

◆ operator>() [5/5]

HWY_F16_CONSTEXPR bool hwy::operator> ( float16_t lhs,
float16_t rhs )
inlinenoexcept

References F32FromF16(), and operator>().

◆ operator>=() [1/2]

HWY_BF16_CONSTEXPR bool hwy::operator>= ( bfloat16_t lhs,
bfloat16_t rhs )
inlinenoexcept

References F32FromBF16(), and operator>=().

◆ operator>=() [2/2]

HWY_F16_CONSTEXPR bool hwy::operator>= ( float16_t lhs,
float16_t rhs )
inlinenoexcept

References F32FromF16(), and operator>=().

Referenced by operator>=(), and operator>=().

◆ Pause()

HWY_INLINE HWY_ATTR_CACHE void hwy::Pause ( )

◆ PopCount()

template<class T , HWY_IF_INTEGER(RemoveCvRef< T >) , HWY_IF_T_SIZE_ONE_OF(RemoveCvRef< T >,(1<< 1)|(1<< 2)|(1<< 4)) >
HWY_API size_t hwy::PopCount ( T x)

◆ Prefetch()

template<typename T >
HWY_INLINE HWY_ATTR_CACHE void hwy::Prefetch ( const T * p)

◆ PreventElision()

template<class T >
HWY_API void hwy::PreventElision ( T && output)

References PreventElision().

Referenced by PreventElision().

◆ PrintArray()

template<typename T >
HWY_NOINLINE void hwy::PrintArray ( const T * value,
size_t count )

◆ PrintValue()

template<typename T >
HWY_NOINLINE void hwy::PrintValue ( T value)

◆ Random32()

static HWY_INLINE uint32_t hwy::Random32 ( RandomState * rng)
static

◆ Random64()

static HWY_INLINE uint64_t hwy::Random64 ( RandomState * rng)
static

Referenced by RandomFiniteValue().

◆ RandomFiniteValue()

template<class T , HWY_IF_FLOAT_OR_SPECIAL(T) >
static HWY_INLINE T hwy::RandomFiniteValue ( RandomState * rng)
static

References HWY_MAX, HWY_MIN, and Random64().

◆ RoundDownTo()

constexpr size_t hwy::RoundDownTo ( size_t what,
size_t align )
inlineconstexpr

References RoundDownTo().

Referenced by RoundDownTo().

◆ RoundUpTo()

constexpr size_t hwy::RoundUpTo ( size_t what,
size_t align )
inlineconstexpr

◆ SameSize()

template<class Image1 , class Image2 >
HWY_MAYBE_UNUSED bool hwy::SameSize ( const Image1 & image1,
const Image2 & image2 )

◆ ScalarAbs()

template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR RemoveCvRef< T > hwy::ScalarAbs ( T val)

◆ ScalarCopySign()

template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR RemoveCvRef< T > hwy::ScalarCopySign ( T magn,
T sign )

References ScalarCopySign().

Referenced by ScalarCopySign().

◆ ScalarIsFinite()

template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR bool hwy::ScalarIsFinite ( T val)

◆ ScalarIsInf()

template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR bool hwy::ScalarIsInf ( T val)

◆ ScalarIsNaN()

template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR bool hwy::ScalarIsNaN ( T val)

◆ ScalarShr()

template<class T , HWY_IF_INTEGER(RemoveCvRef< T >) >
HWY_API constexpr RemoveCvRef< T > hwy::ScalarShr ( T val,
int shift_amt )
constexpr

◆ ScalarSignBit()

template<typename T >
HWY_API HWY_BITCASTSCALAR_CONSTEXPR bool hwy::ScalarSignBit ( T val)

◆ SecondsSince()

static double hwy::SecondsSince ( const Timestamp & t0)
inlinestatic

References hwy::Timestamp::t.

◆ SetAbortFunc()

AbortFunc hwy::SetAbortFunc ( AbortFunc func)

◆ SetSupportedTargetsForTest()

HWY_DLLEXPORT void hwy::SetSupportedTargetsForTest ( int64_t targets)

◆ SetThreadName()

static void hwy::SetThreadName ( const char * format,
int thread )
inlinestatic

◆ SignMask()

template<typename T >
constexpr MakeUnsigned< T > hwy::SignMask ( )
constexpr

References SignMask().

Referenced by hwy::HWY_NAMESPACE::SignBit(), and SignMask().

◆ SummarizeMeasurements()

static double hwy::SummarizeMeasurements ( std::vector< double > & seconds)
inlinestatic

◆ SupportedAndGeneratedTargets()

HWY_INLINE std::vector< int64_t > hwy::SupportedAndGeneratedTargets ( )

References HWY_TARGETS, and SupportedTargets().

◆ SupportedTargets()

HWY_DLLEXPORT int64_t hwy::SupportedTargets ( )

◆ TargetName()

static HWY_MAYBE_UNUSED const char * hwy::TargetName ( int64_t target)
inlinestatic

◆ TestParamTargetName()

static std::string hwy::TestParamTargetName ( const testing::TestParamInfo< int64_t > & info)
inlinestatic

References TargetName().

◆ TestParamTargetNameAndT()

template<typename T >
std::string hwy::TestParamTargetNameAndT ( const testing::TestParamInfo< std::tuple< int64_t, T > > & info)

References TargetName().

◆ TypeName()

template<typename T >
std::string hwy::TypeName ( T ,
size_t N )

References hwy::detail::TypeName().

Referenced by AssertArraySimilar().

◆ TypeTag()

template<typename T , class R = detail::Relations<T>>
constexpr auto hwy::TypeTag ( ) -> hwy::SizeTag<((R::is_signed + R::is_float + R::is_bf16) << 8)>
constexpr

References TypeTag().

Referenced by hwy::HWY_NAMESPACE::SumsOf4(), and TypeTag().

◆ Unpredictable1()

HWY_DLLEXPORT int hwy::Unpredictable1 ( )

◆ VectorBytes()

HWY_DLLEXPORT size_t hwy::VectorBytes ( )

◆ VQPartialSort() [1/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( double *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQPartialSort() [2/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( double *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQPartialSort() [3/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( float *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQPartialSort() [4/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( float *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQPartialSort() [5/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( float16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQPartialSort() [6/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( float16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQPartialSort() [7/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( int16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQPartialSort() [8/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( int16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQPartialSort() [9/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( int32_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQPartialSort() [10/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( int32_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQPartialSort() [11/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( int64_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQPartialSort() [12/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( int64_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQPartialSort() [13/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( K32V32 *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQPartialSort() [14/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( K32V32 *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQPartialSort() [15/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( K64V64 *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQPartialSort() [16/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( K64V64 *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQPartialSort() [17/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( uint128_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQPartialSort() [18/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( uint128_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQPartialSort() [19/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( uint16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

Referenced by hwy::HWY_NAMESPACE::Run().

◆ VQPartialSort() [20/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( uint16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQPartialSort() [21/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( uint32_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQPartialSort() [22/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( uint32_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQPartialSort() [23/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( uint64_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQPartialSort() [24/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQPartialSort ( uint64_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [1/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( double *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQSelect() [2/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( double *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [3/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( float *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQSelect() [4/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( float *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [5/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( float16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQSelect() [6/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( float16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [7/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( int16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQSelect() [8/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( int16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [9/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( int32_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQSelect() [10/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( int32_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [11/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( int64_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQSelect() [12/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( int64_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [13/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( K32V32 *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQSelect() [14/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( K32V32 *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [15/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( K64V64 *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQSelect() [16/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( K64V64 *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [17/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( uint128_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQSelect() [18/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( uint128_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [19/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( uint16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

Referenced by hwy::HWY_NAMESPACE::Run().

◆ VQSelect() [20/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( uint16_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [21/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( uint32_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQSelect() [22/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( uint32_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSelect() [23/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( uint64_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortAscending  )

◆ VQSelect() [24/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSelect ( uint64_t *HWY_RESTRICT keys,
const size_t n,
const size_t k,
SortDescending  )

◆ VQSort() [1/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( double *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

◆ VQSort() [2/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( double *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ VQSort() [3/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( float *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

◆ VQSort() [4/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( float *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ VQSort() [5/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( float16_t *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

◆ VQSort() [6/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( float16_t *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ VQSort() [7/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( int16_t *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

◆ VQSort() [8/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( int16_t *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ VQSort() [9/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( int32_t *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

◆ VQSort() [10/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( int32_t *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ VQSort() [11/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( int64_t *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

◆ VQSort() [12/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( int64_t *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ VQSort() [13/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( K32V32 *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

◆ VQSort() [14/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( K32V32 *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ VQSort() [15/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( K64V64 *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

◆ VQSort() [16/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( K64V64 *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ VQSort() [17/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( uint128_t *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

◆ VQSort() [18/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( uint128_t *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ VQSort() [19/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( uint16_t *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

Referenced by hwy::HWY_NAMESPACE::Run().

◆ VQSort() [20/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( uint16_t *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ VQSort() [21/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( uint32_t *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

◆ VQSort() [22/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( uint32_t *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ VQSort() [23/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( uint64_t *HWY_RESTRICT keys,
const size_t n,
SortAscending  )

◆ VQSort() [24/24]

HWY_CONTRIB_DLLEXPORT void hwy::VQSort ( uint64_t *HWY_RESTRICT keys,
const size_t n,
SortDescending  )

◆ WakeAll()

static void hwy::WakeAll ( std::atomic< uint32_t > & current)
inlinestatic

References HWY_DASSERT.

Referenced by hwy::PoolCommands::Broadcast().

◆ WrapTo() [1/2]

template<typename TTo , typename T , HWY_IF_NOT_FLOAT_NOR_SPECIAL(TTo) , HWY_IF_T_SIZE_LE(TTo, 4) >
T hwy::WrapTo ( T value)

◆ WrapTo() [2/2]

template<typename TTo , typename T , HWY_IF_FLOAT_OR_SPECIAL(TTo) >
T hwy::WrapTo ( T value)

◆ ZeroBytes() [1/2]

template<size_t kBytes, typename To >
HWY_API void hwy::ZeroBytes ( To * to)

◆ ZeroBytes() [2/2]

HWY_API void hwy::ZeroBytes ( void * to,
size_t num_bytes )

Variable Documentation

◆ format

HWY_DLLEXPORT HWY_NORETURN void int const char* hwy::format

Referenced by SetThreadName().

◆ kMaxVectorSize

constexpr HWY_MAYBE_UNUSED size_t hwy::kMaxVectorSize = 16
staticconstexpr

◆ kTestMaxVectorSize

HWY_MAYBE_UNUSED constexpr size_t hwy::kTestMaxVectorSize = 64
constexpr

◆ line

HWY_DLLEXPORT HWY_NORETURN void int hwy::line