Blaze 3.9
Classes | Typedefs | Functions

Classes

struct  blaze::SIMDf32FmaddExpr< T1, T2, T3 >
 Expression object for 32-bit floating point fused multiply-add operations. More...
 
struct  blaze::SIMDf32FmsubExpr< T1, T2, T3 >
 Expression object for 32-bit floating point fused multiply-subtract operations. More...
 
struct  blaze::SIMDf64FmaddExpr< T1, T2, T3 >
 Addition operator for fusing a 32-bit floating point multiplication and addition. More...
 
struct  blaze::SIMDf64FmsubExpr< T1, T2, T3 >
 Expression object for 64-bit floating point fused multiply-subtract operations. More...
 
struct  blaze::SIMDf32MultExpr< T1, T2 >
 Expression object for 32-bit floating point multiplication operations. More...
 
struct  blaze::SIMDf64MultExpr< T1, T2 >
 Expression object for 64-bit floating point multiplication operations. More...
 
class  blaze::SIMDPack< T >
 Base class for all SIMD data types. More...
 
class  blaze::SIMDTrait< T >
 SIMD characteristics of data types. More...
 
class  SIMDint8
 SIMD type for 8-bit signed integral data values. More...
 
class  SIMDuint8
 SIMD type for 8-bit unsigned integral data values. More...
 
class  SIMDcint8
 SIMD type for 8-bit signed integral complex values. More...
 
class  SIMDcuint8
 SIMD type for 8-bit unsigned integral complex values. More...
 
class  SIMDint16
 SIMD type for 16-bit signed integral data values. More...
 
class  SIMDuint16
 SIMD type for 16-bit unsigned integral data values. More...
 
class  SIMDcint16
 SIMD type for 16-bit signed integral complex values. More...
 
class  SIMDcuint16
 SIMD type for 16-bit unsigned integral complex values. More...
 
class  SIMDint32
 SIMD type for 32-bit signed integral data values. More...
 
class  SIMDuint32
 SIMD type for 32-bit unsigned integral data values. More...
 
class  SIMDcint32
 SIMD type for 32-bit signed integral complex values. More...
 
class  SIMDcuint32
 SIMD type for 32-bit unsigned integral complex values. More...
 
class  SIMDint64
 SIMD type for 64-bit integral data values. More...
 
class  SIMDuint64
 SIMD type for 64-bit unsigned integral data values. More...
 
class  SIMDcint64
 SIMD type for 64-bit signed integral complex values. More...
 
class  SIMDcuint64
 SIMD type for 64-bit unsigned integral complex values. More...
 
class  SIMDfloat
 SIMD type for 32-bit single precision floating point data values. More...
 
class  SIMDcfloat
 SIMD type for 32-bit single precision complex values. More...
 
class  SIMDdouble
 SIMD type for 64-bit double precision floating point data values. More...
 
class  SIMDcdouble
 SIMD type for 64-bit double precision complex values. More...
 

Typedefs

using blaze::SIMDchar = SIMDTrait< char >::Type
 The SIMD data type for 'char'.
 
using blaze::SIMDschar = SIMDTrait< signed char >::Type
 The SIMD data type for 'signed char'.
 
using blaze::SIMDuchar = SIMDTrait< unsigned char >::Type
 The SIMD data type for 'unsigned char'.
 
using blaze::SIMDwchar = SIMDTrait< wchar_t >::Type
 The SIMD data type for 'wchar_t'.
 
using blaze::SIMDcchar = SIMDTrait< complex< char > >::Type
 The SIMD data type for 'complex<char>'.
 
using blaze::SIMDcschar = SIMDTrait< complex< signed char > >::Type
 The SIMD data type for 'complex<signed char>'.
 
using blaze::SIMDcuchar = SIMDTrait< complex< unsigned char > >::Type
 The SIMD data type for 'complex<unsigned char>'.
 
using blaze::SIMDcwchar = SIMDTrait< complex< wchar_t > >::Type
 The SIMD data type for 'complex<wchar_t>'.
 
using blaze::SIMDshort = SIMDTrait< short >::Type
 The SIMD data type for 'short'.
 
using blaze::SIMDushort = SIMDTrait< unsigned short >::Type
 The SIMD data type for 'unsigned short'.
 
using blaze::SIMDcshort = SIMDTrait< complex< short > >::Type
 The SIMD data type for 'complex<short>'.
 
using blaze::SIMDcushort = SIMDTrait< complex< unsigned short > >::Type
 The SIMD data type for 'complex<unsigned short>'.
 
using blaze::SIMDint = SIMDTrait< int >::Type
 The SIMD data type for 'int'.
 
using blaze::SIMDuint = SIMDTrait< unsigned int >::Type
 The SIMD data type for 'unsigned int'.
 
using blaze::SIMDcint = SIMDTrait< complex< int > >::Type
 The SIMD data type for 'complex<int>'.
 
using blaze::SIMDcuint = SIMDTrait< complex< unsigned int > >::Type
 The SIMD data type for 'complex<unsigned int>'.
 
using blaze::SIMDlong = SIMDTrait< long >::Type
 The SIMD data type for 'long int'.
 
using blaze::SIMDulong = SIMDTrait< unsigned long >::Type
 The SIMD data type for 'unsigned long int'.
 
using blaze::SIMDclong = SIMDTrait< complex< long > >::Type
 The SIMD data type for 'complex<long int>'.
 
using blaze::SIMDculong = SIMDTrait< complex< unsigned long > >::Type
 The SIMD data type for 'complex<unsigned long int>'.
 
template<typename T >
using blaze::SIMDTrait_t = typename SIMDTrait< T >::Type
 Auxiliary alias declaration for the SIMDTrait class template. More...
 

Functions

BLAZE_ALWAYS_INLINE const SIMDint8 blaze::abs (const SIMDint8 &a) noexcept=delete
 Absolute value of a vector of 8-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint16 blaze::abs (const SIMDint16 &a) noexcept=delete
 Absolute value of a vector of 16-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint32 blaze::abs (const SIMDint32 &a) noexcept=delete
 Absolute value of a vector of 32-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint64 blaze::abs (const SIMDint64 &a) noexcept=delete
 Absolute value of a vector of 64-bit signed integral values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::abs (const SIMDf32< T > &a) noexcept=delete
 Absolute of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::abs (const SIMDf64< T > &a) noexcept=delete
 Absolute of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::acos (const SIMDf32< T > &a) noexcept=delete
 Inverse cosine of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::acos (const SIMDf64< T > &a) noexcept=delete
 Inverse cosine of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::acosh (const SIMDf32< T > &a) noexcept=delete
 Inverse hyperbolic cosine of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::acosh (const SIMDf64< T > &a) noexcept=delete
 Inverse hyperbolic cosine of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept=delete
 Addition of two vectors of 8-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator+ (const SIMDi8< T1 > &a, const SIMDi8< T2 > &b) noexcept=delete
 Addition of two vectors of 8-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept=delete
 Addition of two vectors of 8-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete
 Addition of two vectors of 16-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator+ (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete
 Addition of two vectors of 16-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete
 Addition of two vectors of 16-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete
 Addition of two vectors of 32-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator+ (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete
 Addition of two vectors of 32-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete
 Addition of two vectors of 32-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete
 Addition of two vectors of 64-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator+ (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete
 Addition of two vectors of 64-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete
 Addition of two vectors of 64-bit integral complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::operator+ (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete
 Addition of two vectors of single precision floating point SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator+ (const SIMDcfloat &a, const SIMDcfloat &b) noexcept=delete
 Addition of two vectors of single precision complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::operator+ (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete
 Addition of two vectors of double precision floating point SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator+ (const SIMDcdouble &a, const SIMDcdouble &b) noexcept=delete
 Addition of two vectors of double precision complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::asin (const SIMDf32< T > &a) noexcept=delete
 Inverse sine of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::asin (const SIMDf64< T > &a) noexcept=delete
 Inverse sine of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::asinh (const SIMDf32< T > &a) noexcept=delete
 Inverse hyperbolic sine of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::asinh (const SIMDf64< T > &a) noexcept=delete
 Inverse hyperbolic sine of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::atan (const SIMDf32< T > &a) noexcept=delete
 Inverse tangent of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::atan (const SIMDf64< T > &a) noexcept=delete
 Inverse tangent of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::atan2 (const SIMDf32< T > &a, const SIMDf32< T > &b) noexcept=delete
 Multi-valued inverse tangent of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::atan2 (const SIMDf64< T > &a, const SIMDf64< T > &b) noexcept=delete
 Multi-valued inverse tangent of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::atanh (const SIMDf32< T > &a) noexcept=delete
 Inverse hyperbolic tangent of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::atanh (const SIMDf64< T > &a) noexcept=delete
 Inverse hyperbolic tangent of a vector of double precision floating point values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE T1 & blaze::operator+= (SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
 Addition assignment operator for the addition of two SIMD packs. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE T1 & blaze::operator-= (SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
 Subtraction assignment operator for the subtraction of two SIMD packs. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE T1 & blaze::operator*= (SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
 Multiplication assignment operator for the multiplication of two SIMD packs. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE T1 & blaze::operator/= (SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
 Division assignment operator for the division of two SIMD packs. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 8-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator& (const SIMDi8< T1 > &a, const SIMDi8< T2 > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 8-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 8-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 16-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator& (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 16-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 16-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 32-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator& (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 32-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 32-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 64-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator& (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 64-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete
 Bitwise AND ('&') of two vectors of 64-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 8-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator| (const SIMDi8< T1 > &a, const SIMDi8< T2 > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 8-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 8-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 16-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator| (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 16-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 16-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 32-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator| (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 32-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 32-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 64-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator| (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 64-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete
 Bitwise OR ('|') of two vectors of 64-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 8-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator^ (const SIMDi8< T1 > &a, const SIMDi8< T2 > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 8-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 8-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 16-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator^ (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 16-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 16-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 32-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator^ (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 32-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 32-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 64-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator^ (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 64-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete
 Bitwise XOR ('^') of two vectors of 64-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::cbrt (const SIMDf32< T > &a) noexcept=delete
 Computes the cubic root for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::cbrt (const SIMDf64< T > &a) noexcept=delete
 Computes the cubic root for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::ceil (const SIMDf32< T > &a) noexcept=delete
 Computes the largest integer value not less than the given value for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::ceil (const SIMDf64< T > &a) noexcept=delete
 Computes the largest integer value not less than the given value for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj (const SIMDi8< T > &a) noexcept
 Complex conjugate of a vector of 8-bit integral values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj (const SIMDi16< T > &a) noexcept
 Complex conjugate of a vector of 16-bit integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcint16 blaze::conj (const SIMDcint16 &a) noexcept=delete
 Complex conjugate of a vector of 16-bit integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj (const SIMDi32< T > &a) noexcept
 Complex conjugate of a vector of 32-bit integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcint32 blaze::conj (const SIMDcint32 &a) noexcept=delete
 Complex conjugate of a vector of 32-bit integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj (const SIMDi64< T > &a) noexcept
 Complex conjugate of a vector of 64-bit integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcint64 blaze::conj (const SIMDcint64 &a) noexcept=delete
 Complex conjugate of a vector of 64-bit integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj (const SIMDf32< T > &a) noexcept
 Complex conjugate of a vector of single precision floating point values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::conj (const SIMDcfloat &a) noexcept=delete
 Complex conjugate of a vector of single precision complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj (const SIMDf64< T > &a) noexcept
 Complex conjugate of a vector of double precision floating point values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::conj (const SIMDcdouble &a) noexcept=delete
 Complex conjugate of a vector of double precision complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::cos (const SIMDf32< T > &a) noexcept=delete
 Cosine of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::cos (const SIMDf64< T > &a) noexcept=delete
 Cosine of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::cosh (const SIMDf32< T > &a) noexcept=delete
 Hyperbolic cosine of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::cosh (const SIMDf64< T > &a) noexcept=delete
 Hyperbolic cosine of a vector of double precision floating point values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint8 blaze::operator/ (const SIMDint8 &a, const SIMDint8 &b) noexcept=delete
 Division of two vectors of 8-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator/ (const SIMDuint8 &a, const SIMDuint8 &b) noexcept=delete
 Division of two vectors of 8-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcint8 blaze::operator/ (const SIMDcint8 &a, const SIMDint8 &b) noexcept=delete
 Scaling of a vector of 8-bit signed integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcuint8 blaze::operator/ (const SIMDcuint8 &a, const SIMDuint8 &b) noexcept=delete
 Scaling of a vector of 8-bit unsigned integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint16 blaze::operator/ (const SIMDint16 &a, const SIMDint16 &b) noexcept=delete
 Division of two vectors of 16-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator/ (const SIMDuint16 &a, const SIMDuint16 &b) noexcept=delete
 Division of two vectors of 16-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcint16 blaze::operator/ (const SIMDcint16 &a, const SIMDint16 &b) noexcept=delete
 Scaling of a vector of 16-bit signed integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcuint16 blaze::operator/ (const SIMDcuint16 &a, const SIMDuint16 &b) noexcept=delete
 Scaling of a vector of 16-bit unsigned integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint32 blaze::operator/ (const SIMDint32 &a, const SIMDint32 &b) noexcept=delete
 Division of two vectors of 32-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator/ (const SIMDuint32 &a, const SIMDuint32 &b) noexcept=delete
 Division of two vectors of 32-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcint32 blaze::operator/ (const SIMDcint32 &a, const SIMDint32 &b) noexcept=delete
 Scaling of a vector of 32-bit signed integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcuint32 blaze::operator/ (const SIMDcuint32 &a, const SIMDuint32 &b) noexcept=delete
 Scaling of a vector of 32-bit unsigned integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint64 blaze::operator/ (const SIMDint64 &a, const SIMDint64 &b) noexcept=delete
 Division of two vectors of 64-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator/ (const SIMDuint64 &a, const SIMDuint64 &b) noexcept=delete
 Division of two vectors of 64-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcint64 blaze::operator/ (const SIMDcint64 &a, const SIMDint64 &b) noexcept=delete
 Scaling of a vector of 64-bit signed integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcuint64 blaze::operator/ (const SIMDcuint64 &a, const SIMDuint64 &b) noexcept=delete
 Scaling of a vector of 64-bit unsigned integral complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::operator/ (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete
 Division of two vectors of single precision floating point SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator/ (const SIMDcfloat &a, const SIMDfloat &b) noexcept=delete
 Scaling of a vector of single precision floating point values complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::operator/ (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete
 Division of two vectors of double precision floating point SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator/ (const SIMDcdouble &a, const SIMDdouble &b) noexcept=delete
 Scaling of a vector of double precision floating point values complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept
 Equality comparison of two vectors of 8-bit integral SIMD values of the same type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept
 Equality comparison of two vectors of 8-bit integral SIMD complex values of the same type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept
 Equality comparison of two vectors of 16-bit integral SIMD values of the same type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept
 Equality comparison of two vectors of 16-bit integral complex SIMD values of the same type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept
 Equality comparison of two vectors of 32-bit integral SIMD values of the same type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept
 Equality comparison of two vectors of 32-bit integral complex SIMD values of the same type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept
 Equality comparison of two vectors of 64-bit integral SIMD values of the same type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept
 Equality comparison of two vectors of 64-bit integral SIMD complex values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete
 Equality comparison of two vectors of single precision floating point SIMD values. More...
 
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDcfloat &a, const SIMDcfloat &b) noexcept=delete
 Equality comparison of two vectors of single precision complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete
 Equality comparison of two vectors of double precision floating point SIMD values. More...
 
BLAZE_ALWAYS_INLINE bool blaze::operator== (const SIMDcdouble &a, const SIMDcdouble &b) noexcept=delete
 Equality comparison of two vectors of double precision complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator!= (const SIMDPack< T > &a, const SIMDPack< T > &b) noexcept
 Inequality comparison of two SIMD vectors of the same type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::erf (const SIMDf32< T > &a) noexcept=delete
 Computes the error function for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::erf (const SIMDf64< T > &a) noexcept=delete
 Computes the error function for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::erfc (const SIMDf32< T > &a) noexcept=delete
 Computes the complementary error function for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::erfc (const SIMDf64< T > &a) noexcept=delete
 Computes the complementary error function for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::exp (const SIMDf32< T > &a) noexcept=delete
 Computes $ e^x $ for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::exp (const SIMDf64< T > &a) noexcept=delete
 Computes $ e^x $ for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::exp10 (const SIMDf32< T > &a) noexcept=delete
 Computes $ 10^x $ for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::exp10 (const SIMDf64< T > &a) noexcept=delete
 Computes $ 10^x $ for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::exp2 (const SIMDf32< T > &a) noexcept=delete
 Computes $ 2^x $ for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::exp2 (const SIMDf64< T > &a) noexcept=delete
 Computes $ 2^x $ for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::floor (const SIMDf32< T > &a) noexcept=delete
 Computes the largest integer value not greater than the given value for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::floor (const SIMDf64< T > &a) noexcept=delete
 Computes the largest integer value not greater than the given value for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::hypot (const SIMDf32< T > &a, const SIMDf32< T > &b) noexcept=delete
 Computes the length of the hypotenous of a right triangle of a vector of single precision floating point values ( $ \sqrt( a^2 + b^2 ) $). More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::hypot (const SIMDf64< T > &a, const SIMDf64< T > &b) noexcept=delete
 Computes the length of the hypotenous of a right triangle of a vector of double precision floating point values ( $ \sqrt( a^2 + b^2 ) $). More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::invcbrt (const SIMDf32< T > &a) noexcept=delete
 Computes the inverse cubic root for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::invcbrt (const SIMDf64< T > &a) noexcept=delete
 Computes the inverse cubic root for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::invsqrt (const SIMDf32< T > &a) noexcept=delete
 Computes the inverse square root for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::invsqrt (const SIMDf64< T > &a) noexcept=delete
 Computes the inverse square root for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::lgamma (const SIMDf32< T > &a) noexcept=delete
 Computes the lgamma function for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::lgamma (const SIMDf64< T > &a) noexcept=delete
 Computes the lgamma function for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > blaze::loada (const T *address) noexcept
 Loads a vector of 1-byte integral values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDcint8, SIMDcuint8 > > blaze::loada (const complex< T > *address) noexcept
 Loads a vector of 1-byte integral complex values. More...
 
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::loada (const float *address) noexcept
 Loads a vector of 'float' values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::loada (const complex< float > *address) noexcept
 Loads a vector of 'complex<float>' values. More...
 
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::loada (const double *address) noexcept
 Loads a vector of 'double' values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::loada (const complex< double > *address) noexcept
 Loads a vector of 'complex<double>' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > blaze::loadu (const T *address) noexcept
 Loads a vector of 1-byte integral values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDcint8, SIMDcuint8 > > blaze::loadu (const complex< T > *address) noexcept
 Loads a vector of 1-byte integral complex values. More...
 
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::loadu (const float *address) noexcept
 Loads a vector of 'float' values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::loadu (const complex< float > *address) noexcept
 Loads a vector of 'complex<float>' values. More...
 
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::loadu (const double *address) noexcept
 Loads a vector of 'double' values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::loadu (const complex< double > *address) noexcept
 Loads a vector of 'complex<double>' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::log (const SIMDf32< T > &a) noexcept=delete
 Computes the natural logarithm for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::log (const SIMDf64< T > &a) noexcept=delete
 Computes the natural logarithm for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::log10 (const SIMDf32< T > &a) noexcept=delete
 Computes the common logarithm for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::log10 (const SIMDf64< T > &a) noexcept=delete
 Computes the common logarithm for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::log1p (const SIMDf32< T > &a) noexcept=delete
 Computes the natural logarithm of x+1 for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::log1p (const SIMDf64< T > &a) noexcept=delete
 Computes the natural logarithm of x+1 for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::log2 (const SIMDf32< T > &a) noexcept=delete
 Computes the binary logarithm for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::log2 (const SIMDf64< T > &a) noexcept=delete
 Computes the binary logarithm for a vector of double precision floating point values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint8 blaze::max (const SIMDint8 &a, const SIMDint8 &b) noexcept=delete
 Componentwise maximum of two vectors of 8-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::max (const SIMDuint8 &a, const SIMDuint8 &b) noexcept=delete
 Componentwise maximum of two vectors of 8-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint16 blaze::max (const SIMDint16 &a, const SIMDint16 &b) noexcept=delete
 Componentwise maximum of two vectors of 16-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::max (const SIMDuint16 &a, const SIMDuint16 &b) noexcept=delete
 Componentwise maximum of two vectors of 16-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint32 blaze::max (const SIMDint32 &a, const SIMDint32 &b) noexcept=delete
 Componentwise maximim of two vectors of 32-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::max (const SIMDuint32 &a, const SIMDuint32 &b) noexcept=delete
 Componentwise maximum of two vectors of 32-bit unsigned integral SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::max (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete
 Componentwise maximum of two vectors of single precision floating point SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::max (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete
 Componentwise maximum of two vectors of double precision floating point SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint8 blaze::min (const SIMDint8 &a, const SIMDint8 &b) noexcept=delete
 Componentwise minimum of two vectors of 8-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::min (const SIMDuint8 &a, const SIMDuint8 &b) noexcept=delete
 Componentwise minimum of two vectors of 8-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint16 blaze::min (const SIMDint16 &a, const SIMDint16 &b) noexcept=delete
 Componentwise minimum of two vectors of 16-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::min (const SIMDuint16 &a, const SIMDuint16 &b) noexcept=delete
 Componentwise minimum of two vectors of 16-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint32 blaze::min (const SIMDint32 &a, const SIMDint32 &b) noexcept=delete
 Componentwise minimum of two vectors of 32-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::min (const SIMDuint32 &a, const SIMDuint32 &b) noexcept=delete
 Componentwise minimum of two vectors of 32-bit unsigned integral SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::min (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete
 Componentwise minimum of two vectors of single precision floating point SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::min (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete
 Componentwise minimum of two vectors of double precision floating point SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete
 Multiplication of two vectors of 16-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator* (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete
 Multiplication of two vectors of 16-bit integral SIMD values of different type. More...
 
BLAZE_ALWAYS_INLINE const SIMDcint16 blaze::operator* (const SIMDcint16 &a, const SIMDint16 &b) noexcept=delete
 Scaling of a vector of 16-bit signed integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcuint16 blaze::operator* (const SIMDcuint16 &a, const SIMDuint16 &b) noexcept=delete
 Scaling of a vector of 16-bit unsigned integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcint16 blaze::operator* (const SIMDint16 &a, const SIMDcint16 &b) noexcept=delete
 Scaling of a vector of 16-bit signed integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcuint16 blaze::operator* (const SIMDuint16 &a, const SIMDcuint16 &b) noexcept=delete
 Scaling of a vector of 16-bit unsigned integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete
 Multiplication of two vectors of 16-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete
 Multiplication of two vectors of 32-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator* (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete
 Multiplication of two vectors of 32-bit integral SIMD values of different type. More...
 
BLAZE_ALWAYS_INLINE const SIMDcint32 blaze::operator* (const SIMDcint32 &a, const SIMDint32 &b) noexcept=delete
 Scaling of a vector of 32-bit signed integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcuint32 blaze::operator* (const SIMDcuint32 &a, const SIMDuint32 &b) noexcept=delete
 Scaling of a vector of 32-bit unsigned integral complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDcint32 blaze::operator* (const SIMDint32 &a, const SIMDcint32 &b) noexcept=delete
 Scaling of a vector of 32-bit signed integral complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDcuint32 blaze::operator* (const SIMDuint32 &a, const SIMDcuint32 &b) noexcept=delete
 Scaling of a vector of 32-bit unsigned integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete
 Multiplication of two vectors of 32-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete
 Multiplication of two vectors of 64-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator* (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete
 Multiplication of two vectors of 64-bit integral SIMD values of different type. More...
 
BLAZE_ALWAYS_INLINE const SIMDcint64 blaze::operator* (const SIMDcint64 &a, const SIMDint64 &b) noexcept=delete
 Scaling of a vector of 64-bit signed integral complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcuint64 blaze::operator* (const SIMDcuint64 &a, const SIMDuint64 &b) noexcept=delete
 Scaling of a vector of 64-bit unsigned integral complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDcint64 blaze::operator* (const SIMDint64 &a, const SIMDcint64 &b) noexcept=delete
 Scaling of a vector of 64-bit signed integral complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDcuint64 blaze::operator* (const SIMDuint64 &a, const SIMDcuint64 &b) noexcept=delete
 Scaling of a vector of 64-bit unsigned integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete
 Multiplication of two vectors of 64-bit integral complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDf32MultExpr< T1, T2 > blaze::operator* (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept
 Multiplication of two vectors of single precision floating point SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator* (const SIMDcfloat &a, const SIMDfloat &b) noexcept=delete
 Scaling of a vector of single precision complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator* (const SIMDfloat &a, const SIMDcfloat &b) noexcept=delete
 Scaling of a vector of single precision complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator* (const SIMDcfloat &a, const SIMDcfloat &b) noexcept=delete
 Multiplication of two vectors of single precision complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDf64MultExpr< T1, T2 > blaze::operator* (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept
 Multiplication of two vectors of double precision floating point SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator* (const SIMDcdouble &a, const SIMDdouble &b) noexcept=delete
 Scaling of a vector of double precision complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator* (const SIMDdouble &a, const SIMDcdouble &b) noexcept=delete
 Scaling of a vector of double precision complex SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator* (const SIMDcdouble &a, const SIMDcdouble &b) noexcept=delete
 Multiplication of two vectors of double precision complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::pow (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete
 Computes the exponential value of a vector of single precision floating point values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::pow (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete
 Computes the exponential value of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::prod (const SIMDi8< T > &a) noexcept
 Returns the product of all elements in the 8-bit integral SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::prod (const SIMDci8< T > &a) noexcept
 Returns the product of all elements in the 8-bit integral complex SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::prod (const SIMDi16< T > &a) noexcept
 Returns the product of all elements in the 16-bit integral SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::prod (const SIMDci16< T > &a) noexcept
 Returns the product of all elements in the 16-bit integral complex SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::prod (const SIMDi32< T > &a) noexcept
 Returns the product of all elements in the 32-bit integral SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::prod (const SIMDci32< T > &a) noexcept
 Returns the product of all elements in the 32-bit integral complex SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::prod (const SIMDi64< T > &a) noexcept
 Returns the product of all elements in the 64-bit integral SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::prod (const SIMDci64< T > &a) noexcept
 Returns the product of all elements in the 64-bit integral complex SIMD vector. More...
 
BLAZE_ALWAYS_INLINE float blaze::prod (const SIMDfloat &a) noexcept
 Returns the product of all elements in the single precision floating point SIMD vector. More...
 
BLAZE_ALWAYS_INLINE const complex< float > blaze::prod (const SIMDcfloat &a) noexcept
 Returns the product of all elements in the single precision complex SIMD vector. More...
 
BLAZE_ALWAYS_INLINE double blaze::prod (const SIMDdouble &a) noexcept
 Returns the product of all elements in the double precision floating point SIMD vector. More...
 
BLAZE_ALWAYS_INLINE const complex< double > blaze::prod (const SIMDcdouble &a) noexcept
 Returns the product of all elements in the double precision complex SIMD vector. More...
 
template<typename T , typename OP >
decltype(auto) blaze::reduce (const SIMDPack< T > &a, OP op)
 Reduces the elements in the given SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::round (const SIMDf32< T > &a) noexcept=delete
 Computes the nearest integers for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::round (const SIMDf64< T > &a) noexcept=delete
 Computes the nearest integers for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > blaze::set (T value) noexcept
 Sets all values in the vector to the given 1-byte integral value. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDcint8, SIMDcuint8 > > blaze::set (complex< T > value) noexcept
 Sets all values in the vector to the given 1-byte integral complex value. More...
 
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::set (float value) noexcept
 Sets all values in the vector to the given float value. More...
 
BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::set (const complex< float > &value) noexcept
 Sets all values in the vector to the given complex<float> value. More...
 
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::set (double value) noexcept
 Sets all values in the vector to the given double value. More...
 
BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::set (const complex< double > &value) noexcept
 Sets all values in the vector to the given complex<double> value. More...
 
template<typename T , typename... Ts>
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > blaze::setall (T v0, Ts... vs) noexcept
 Sets all values in a SIMD vector to the given 1-byte integral values. More...
 
template<typename T , typename... Ts>
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDcint8, SIMDcuint8 > > blaze::setall (const complex< T > &v0, const complex< Ts > &... vs) noexcept
 Sets all values in the vector to the given 1-byte integral complex values. More...
 
template<typename... Ts>
SIMDfloat blaze::setall (float v0, Ts... vs) noexcept
 Sets all values in a SIMD vector to the given float values. More...
 
template<typename... Ts>
SIMDcfloat blaze::setall (const complex< float > &v0, Ts... vs) noexcept
 Sets all values in the vector to the given complex<float> values. More...
 
template<typename... Ts>
SIMDdouble blaze::setall (double v0, Ts... vs) noexcept
 Sets all values in a SIMD vector to the given double values. More...
 
template<typename... Ts>
SIMDcdouble blaze::setall (const complex< double > &v0, Ts... vs) noexcept
 Sets all values in the vector to the given complex<double> values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDi8< T > &value) noexcept
 Setting an integral SIMD type with 8-bit data values to zero. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDci8< T > &value) noexcept
 Setting an integral SIMD type with 8-bit complex values to zero. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDi16< T > &value) noexcept
 Setting an integral SIMD type with 16-bit data values to zero. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDci16< T > &value) noexcept
 Setting an integral SIMD type with 16-bit complex values to zero. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDi32< T > &value) noexcept
 Setting an integral SIMD type with 32-bit data values to zero. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDci32< T > &value) noexcept
 Setting an integral SIMD type with 32-bit complex values to zero. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDi64< T > &value) noexcept
 Setting an integral SIMD type with 64-bit data values to zero. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDci64< T > &value) noexcept
 Setting an integral SIMD type with 64-bit complex values to zero. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDfloat &value) noexcept
 Setting a floating point SIMD type with 32-bit single precision data values to zero. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDcfloat &value) noexcept
 Setting a floating point SIMD type with 32-bit single precision complex values to zero. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDdouble &value) noexcept
 Setting a floating point SIMD type with 64-bit double precision data values to zero. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (SIMDcdouble &value) noexcept
 Setting a floating point SIMD type with 32-bit double precision complex values to zero. More...
 
BLAZE_ALWAYS_INLINE const SIMDint16 blaze::operator<< (const SIMDint16 &a, int count) noexcept=delete
 Uniform left-shift of a vector of 16-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator<< (const SIMDuint16 &a, int count) noexcept=delete
 Uniform left-shift of a vector of 16-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint32 blaze::operator<< (const SIMDint32 &a, int count) noexcept=delete
 Uniform left-shift of a vector of 32-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator<< (const SIMDuint32 &a, int count) noexcept=delete
 Uniform left-shift of a vector of 32-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint64 blaze::operator<< (const SIMDint64 &a, int count) noexcept=delete
 Uniform left-shift of a vector of 64-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator<< (const SIMDuint64 &a, int count) noexcept=delete
 Uniform left-shift of a vector of 64-bit unsigned integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint16 blaze::operator<< (const SIMDint16 &a, const SIMDi16< T > &b) noexcept=delete
 Elementwise left-shift of a vector of 16-bit signed integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator<< (const SIMDuint16 &a, const SIMDi16< T > &b) noexcept=delete
 Elementwise left-shift of a vector of 16-bit unsigned integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint32 blaze::operator<< (const SIMDint32 &a, const SIMDi32< T > &b) noexcept=delete
 Elementwise left-shift of a vector of 32-bit signed integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator<< (const SIMDuint32 &a, const SIMDi32< T > &b) noexcept=delete
 Elementwise left-shift of a vector of 32-bit unsigned integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint64 blaze::operator<< (const SIMDint64 &a, const SIMDi64< T > &b) noexcept=delete
 Elementwise left-shift of a vector of 64-bit signed integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator<< (const SIMDuint64 &a, const SIMDi64< T > &b) noexcept=delete
 Elementwise left-shift of a vector of 64-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint16 blaze::operator>> (const SIMDint16 &a, int count) noexcept=delete
 Uniform right-shift of a vector of 16-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator>> (const SIMDuint16 &a, int count) noexcept=delete
 Uniform right-shift of a vector of 16-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint32 blaze::operator>> (const SIMDint32 &a, int count) noexcept=delete
 Uniform right-shift of a vector of 32-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator>> (const SIMDuint32 &a, int count) noexcept=delete
 Uniform right-shift of a vector of 32-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDint64 blaze::operator>> (const SIMDint64 &a, int count) noexcept=delete
 Uniform right-shift of a vector of 64-bit signed integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator>> (const SIMDuint64 &a, int count) noexcept=delete
 Uniform right-shift of a vector of 64-bit unsigned integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint16 blaze::operator>> (const SIMDint16 &a, const SIMDi16< T > &b) noexcept=delete
 Elementwise right-shift of a vector of 16-bit signed integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator>> (const SIMDuint16 &a, const SIMDi16< T > &b) noexcept=delete
 Elementwise right-shift of a vector of 16-bit unsigned integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint32 blaze::operator>> (const SIMDint32 &a, const SIMDi32< T > &b) noexcept=delete
 Elementwise right-shift of a vector of 32-bit signed integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator>> (const SIMDuint32 &a, const SIMDi32< T > &b) noexcept=delete
 Elementwise right-shift of a vector of 32-bit unsigned integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint64 blaze::operator>> (const SIMDint64 &a, const SIMDi64< T > &b) noexcept=delete
 Elementwise right-shift of a vector of 64-bit signed integral SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator>> (const SIMDuint64 &a, const SIMDi64< T > &b) noexcept=delete
 Elementwise right-shift of a vector of 64-bit unsigned integral SIMD values. More...
 
BLAZE_ALWAYS_INLINE SIMDint8 blaze::sign (const SIMDint8 &a) noexcept=delete
 Sign function for a vector of 8-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE SIMDint16 blaze::sign (const SIMDint16 &a) noexcept=delete
 Sign function for a vector of 16-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE SIMDint32 blaze::sign (const SIMDint32 &a) noexcept=delete
 Sign function for a vector of 32-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE SIMDint64 blaze::sign (const SIMDint64 &a) noexcept=delete
 Sign function for a vector of 64-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE SIMDfloat blaze::sign (const SIMDfloat &a) noexcept=delete
 Sign function for a vector of single precision floating point values. More...
 
BLAZE_ALWAYS_INLINE SIMDdouble blaze::sign (const SIMDdouble &a) noexcept=delete
 Sign function for a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::sin (const SIMDf32< T > &a) noexcept=delete
 Sine of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::sin (const SIMDf64< T > &a) noexcept=delete
 Sine of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::sinh (const SIMDf32< T > &a) noexcept=delete
 Hyperbolic sine of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::sinh (const SIMDf64< T > &a) noexcept=delete
 Hyperbolic sine of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::sqrt (const SIMDf32< T > &a) noexcept=delete
 Computes the square root for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::sqrt (const SIMDf64< T > &a) noexcept=delete
 Computes the square root for a vector of double precision floating point values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::storea (T1 *address, const SIMDi8< T2 > &value) noexcept
 Aligned store of a vector of 1-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::storea (complex< T1 > *address, const SIMDci8< T2 > &value) noexcept
 Aligned store of a vector of 1-byte integral complex values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::storea (T1 *address, const SIMDi16< T2 > &value) noexcept
 Aligned store of a vector of 2-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::storea (complex< T1 > *address, const SIMDci16< T2 > &value) noexcept
 Aligned store of a vector of 2-byte integral complex values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::storea (T1 *address, const SIMDi32< T2 > &value) noexcept
 Aligned store of a vector of 4-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::storea (complex< T1 > *address, const SIMDci32< T2 > &value) noexcept
 Aligned store of a vector of 4-byte integral complex values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::storea (T1 *address, const SIMDi64< T2 > &value) noexcept
 Aligned store of a vector of 8-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::storea (complex< T1 > *address, const SIMDci64< T2 > &value) noexcept
 Aligned store of a vector of 8-byte integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::storea (float *address, const SIMDf32< T > &value) noexcept
 Aligned store of a vector of 'float' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storea (complex< float > *address, const SIMDcfloat &value) noexcept
 Aligned store of a vector of 'complex<float>' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::storea (double *address, const SIMDf64< T > &value) noexcept
 Aligned store of a vector of 'double' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storea (complex< double > *address, const SIMDcdouble &value) noexcept
 Aligned store of a vector of 'complex<double>' values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::storeu (T1 *address, const SIMDi8< T2 > &value) noexcept
 Unaligned store of a vector of 1-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::storeu (complex< T1 > *address, const SIMDci8< T2 > &value) noexcept
 Unaligned store of a vector of 1-byte integral complex values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::storeu (T1 *address, const SIMDi16< T2 > &value) noexcept
 Unaligned store of a vector of 2-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::storeu (complex< T1 > *address, const SIMDci16< T2 > &value) noexcept
 Unaligned store of a vector of 2-byte integral complex values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::storeu (T1 *address, const SIMDi32< T2 > &value) noexcept
 Unaligned store of a vector of 4-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::storeu (complex< T1 > *address, const SIMDci32< T2 > &value) noexcept
 Unaligned store of a vector of 4-byte integral complex values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::storeu (T1 *address, const SIMDi64< T2 > &value) noexcept
 Unaligned store of a vector of 8-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::storeu (complex< T1 > *address, const SIMDci64< T2 > &value) noexcept
 Unaligned store of a vector of 8-byte integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::storeu (float *address, const SIMDf32< T > &value) noexcept
 Unaligned store of a vector of 'float' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storeu (complex< float > *address, const SIMDcfloat &value) noexcept
 Unaligned store of a vector of 'complex<float>' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::storeu (double *address, const SIMDf64< T > &value) noexcept
 Unaligned store of a vector of 'double' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storeu (complex< double > *address, const SIMDcdouble &value) noexcept
 Unaligned store of a vector of 'complex<double>' values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::stream (T1 *address, const SIMDi8< T2 > &value) noexcept
 Aligned, non-temporal store of a vector of 1-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::stream (complex< T1 > *address, const SIMDci8< T2 > &value) noexcept
 Aligned, non-temporal store of a vector of 1-byte integral complex values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::stream (T1 *address, const SIMDi16< T2 > &value) noexcept
 Aligned, non-temporal store of a vector of 2-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::stream (complex< T1 > *address, const SIMDci16< T2 > &value) noexcept
 Aligned, non-temporal store of a vector of 2-byte integral complex values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::stream (T1 *address, const SIMDi32< T2 > &value) noexcept
 Aligned, non-temporal store of a vector of 4-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::stream (complex< T1 > *address, const SIMDci32< T2 > &value) noexcept
 Aligned, non-temporal store of a vector of 4-byte integral complex values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::stream (T1 *address, const SIMDi64< T2 > &value) noexcept
 Aligned, non-temporal store of a vector of 8-byte integral values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::stream (complex< T1 > *address, const SIMDci64< T2 > &value) noexcept
 Aligned, non-temporal store of a vector of 8-byte integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::stream (float *address, const SIMDf32< T > &value) noexcept
 Aligned, non-temporal store of a vector of 'float' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::stream (complex< float > *address, const SIMDcfloat &value) noexcept
 Aligned, non-temporal store of a vector of 'complex<float>' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE void blaze::stream (double *address, const SIMDf64< T > &value) noexcept
 Aligned, non-temporal store of a vector of 'double' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::stream (complex< double > *address, const SIMDcdouble &value) noexcept
 Aligned, non-temporal store of a vector of 'complex<double>' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- (const SIMDi8< T > &a, const SIMDi8< T > &b) noexcept=delete
 Subtraction of two vectors of 8-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator- (const SIMDi8< T1 > &a, const SIMDi8< T2 > &b) noexcept=delete
 Subtraction of two vectors of 8-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- (const SIMDci8< T > &a, const SIMDci8< T > &b) noexcept=delete
 Subtraction of two vectors of 8-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- (const SIMDi16< T > &a, const SIMDi16< T > &b) noexcept=delete
 Subtraction of two vectors of 16-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator- (const SIMDi16< T1 > &a, const SIMDi16< T2 > &b) noexcept=delete
 Subtraction of two vectors of 16-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- (const SIMDci16< T > &a, const SIMDci16< T > &b) noexcept=delete
 Subtraction of two vectors of 16-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- (const SIMDi32< T > &a, const SIMDi32< T > &b) noexcept=delete
 Subtraction of two vectors of 32-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator- (const SIMDi32< T1 > &a, const SIMDi32< T2 > &b) noexcept=delete
 Subtraction of two vectors of 32-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- (const SIMDci32< T > &a, const SIMDci32< T > &b) noexcept=delete
 Subtraction of two vectors of 32-bit integral complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- (const SIMDi64< T > &a, const SIMDi64< T > &b) noexcept=delete
 Subtraction of two vectors of 64-bit integral SIMD values of the same type. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator- (const SIMDi64< T1 > &a, const SIMDi64< T2 > &b) noexcept=delete
 Subtraction of two vectors of 64-bit integral SIMD values of different type. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- (const SIMDci64< T > &a, const SIMDci64< T > &b) noexcept=delete
 Subtraction of two vectors of 64-bit integral complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::operator- (const SIMDf32< T1 > &a, const SIMDf32< T2 > &b) noexcept=delete
 Subtraction of two vectors of single precision floating point SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator- (const SIMDcfloat &a, const SIMDcfloat &b) noexcept=delete
 Subtraction of two vectors of single precision complex SIMD values. More...
 
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::operator- (const SIMDf64< T1 > &a, const SIMDf64< T2 > &b) noexcept=delete
 Subtraction of two vectors of double precision floating point SIMD values. More...
 
BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator- (const SIMDcdouble &a, const SIMDcdouble &b) noexcept=delete
 Subtraction of two vectors of double precision complex SIMD values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::sum (const SIMDi8< T > &a) noexcept
 Returns the sum of all elements in the 8-bit integral SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::sum (const SIMDci8< T > &a) noexcept
 Returns the sum of all elements in the 8-bit integral complex SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::sum (const SIMDi16< T > &a) noexcept
 Returns the sum of all elements in the 16-bit integral SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::sum (const SIMDci16< T > &a) noexcept
 Returns the sum of all elements in the 16-bit integral complex SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::sum (const SIMDi32< T > &a) noexcept
 Returns the sum of all elements in the 32-bit integral SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::sum (const SIMDci32< T > &a) noexcept
 Returns the sum of all elements in the 32-bit integral complex SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::sum (const SIMDi64< T > &a) noexcept
 Returns the sum of all elements in the 64-bit integral SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::sum (const SIMDci64< T > &a) noexcept
 Returns the sum of all elements in the 64-bit integral complex SIMD vector. More...
 
BLAZE_ALWAYS_INLINE float blaze::sum (const SIMDfloat &a) noexcept
 Returns the sum of all elements in the single precision floating point SIMD vector. More...
 
BLAZE_ALWAYS_INLINE const complex< float > blaze::sum (const SIMDcfloat &a) noexcept
 Returns the sum of all elements in the single precision complex SIMD vector. More...
 
BLAZE_ALWAYS_INLINE double blaze::sum (const SIMDdouble &a) noexcept
 Returns the sum of all elements in the double precision floating point SIMD vector. More...
 
BLAZE_ALWAYS_INLINE const complex< double > blaze::sum (const SIMDcdouble &a) noexcept
 Returns the sum of all elements in the double precision complex SIMD vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::tan (const SIMDf32< T > &a) noexcept=delete
 Tangent of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::tan (const SIMDf64< T > &a) noexcept=delete
 Tangent of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::tanh (const SIMDf32< T > &a) noexcept=delete
 Hyperbolic tangent of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::tanh (const SIMDf64< T > &a) noexcept=delete
 Hyperbolic tangent of a vector of double precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::trunc (const SIMDf32< T > &a) noexcept=delete
 Computes the nearest integer not greater in magnitude than the given value for a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::trunc (const SIMDf64< T > &a) noexcept=delete
 Computes the nearest integer not greater in magnitude than the given value for a vector of double precision floating point values. More...
 

Detailed Description

Typedef Documentation

◆ SIMDTrait_t

template<typename T >
using blaze::SIMDTrait_t = typedef typename SIMDTrait<T>::Type

Auxiliary alias declaration for the SIMDTrait class template.

The SIMDTrait_t alias declaration provides a convenient shortcut to access the nested Type of the SIMDTrait class template. For instance, given the type T the following two type definitions are identical:

using Type1 = typename SIMDTrait<T>::Type;
using Type2 = SIMDTrait_t<T>;
SIMD characteristics of data types.
Definition: SIMDTrait.h:297
typename SIMDTrait< T >::Type SIMDTrait_t
Auxiliary alias declaration for the SIMDTrait class template.
Definition: SIMDTrait.h:315

Function Documentation

◆ abs() [1/6]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::abs ( const SIMDf32< T > &  a)
deletenoexcept

Absolute of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values $[-1..1]$.
Returns
The resulting vector.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ abs() [2/6]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::abs ( const SIMDf64< T > &  a)
deletenoexcept

Absolute of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values $[-1..1]$.
Returns
The resulting vector.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ abs() [3/6]

BLAZE_ALWAYS_INLINE const SIMDint16 blaze::abs ( const SIMDint16 a)
deletenoexcept

Absolute value of a vector of 16-bit signed integral values.

Parameters
aThe vector of 16-bit unsigned integral values.
Returns
The absolute values.

This operation is only available for SSSE3, AVX2, and AVX-512.

◆ abs() [4/6]

BLAZE_ALWAYS_INLINE const SIMDint32 blaze::abs ( const SIMDint32 a)
deletenoexcept

Absolute value of a vector of 32-bit signed integral values.

Parameters
aThe vector of 32-bit unsigned integral values.
Returns
The absolute values.

This operation is only available for SSSE3, AVX2, MIC, and AVX-512.

◆ abs() [5/6]

BLAZE_ALWAYS_INLINE const SIMDint64 blaze::abs ( const SIMDint64 a)
deletenoexcept

Absolute value of a vector of 64-bit signed integral values.

Parameters
aThe vector of 64-bit unsigned integral values.
Returns
The absolute values.

This operation is only available for MIC and AVX-512.

◆ abs() [6/6]

BLAZE_ALWAYS_INLINE const SIMDint8 blaze::abs ( const SIMDint8 a)
deletenoexcept

Absolute value of a vector of 8-bit signed integral values.

Parameters
aThe vector of 8-bit unsigned integral values.
Returns
The absolute values.

This operation is only available for SSSE3, AVX2, and AVX-512.

◆ acos() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::acos ( const SIMDf32< T > &  a)
deletenoexcept

Inverse cosine of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values $[-1..1]$.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ acos() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::acos ( const SIMDf64< T > &  a)
deletenoexcept

Inverse cosine of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values $[-1..1]$.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ acosh() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::acosh ( const SIMDf32< T > &  a)
deletenoexcept

Inverse hyperbolic cosine of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values $[1..\infty)$.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ acosh() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::acosh ( const SIMDf64< T > &  a)
deletenoexcept

Inverse hyperbolic cosine of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values $[1..\infty)$.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ asin() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::asin ( const SIMDf32< T > &  a)
deletenoexcept

Inverse sine of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values $[-1..1]$.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ asin() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::asin ( const SIMDf64< T > &  a)
deletenoexcept

Inverse sine of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values $[-1..1]$.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ asinh() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::asinh ( const SIMDf32< T > &  a)
deletenoexcept

Inverse hyperbolic sine of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ asinh() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::asinh ( const SIMDf64< T > &  a)
deletenoexcept

Inverse hyperbolic sine of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ atan() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::atan ( const SIMDf32< T > &  a)
deletenoexcept

Inverse tangent of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ atan() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::atan ( const SIMDf64< T > &  a)
deletenoexcept

Inverse tangent of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ atan2() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::atan2 ( const SIMDf32< T > &  a,
const SIMDf32< T > &  b 
)
deletenoexcept

Multi-valued inverse tangent of a vector of single precision floating point values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ atan2() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::atan2 ( const SIMDf64< T > &  a,
const SIMDf64< T > &  b 
)
deletenoexcept

Multi-valued inverse tangent of a vector of double precision floating point values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ atanh() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::atanh ( const SIMDf32< T > &  a)
deletenoexcept

Inverse hyperbolic tangent of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values $[-1..1]$.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ atanh() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::atanh ( const SIMDf64< T > &  a)
deletenoexcept

Inverse hyperbolic tangent of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values $[-1..1]$.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, and MIC, AVX-512.

◆ cbrt() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::cbrt ( const SIMDf32< T > &  a)
deletenoexcept

Computes the cubic root for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ cbrt() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::cbrt ( const SIMDf64< T > &  a)
deletenoexcept

Computes the cubic root for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ ceil() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::ceil ( const SIMDf32< T > &  a)
deletenoexcept

Computes the largest integer value not less than the given value for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ ceil() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::ceil ( const SIMDf64< T > &  a)
deletenoexcept

Computes the largest integer value not less than the given value for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ conj() [1/11]

BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::conj ( const SIMDcdouble a)
deletenoexcept

Complex conjugate of a vector of double precision complex values.

Parameters
aThe vector of double precision complex values.
Returns
The complex conjugate values.

This operation is only available for SSE2, AVX, and AVX-512.

◆ conj() [2/11]

BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::conj ( const SIMDcfloat a)
deletenoexcept

Complex conjugate of a vector of single precision complex values.

Parameters
aThe vector of single precision complex values.
Returns
The complex conjugate values.

This operation is only available for SSE2, AVX, and AVX-512.

◆ conj() [3/11]

BLAZE_ALWAYS_INLINE const SIMDcint16 blaze::conj ( const SIMDcint16 a)
deletenoexcept

Complex conjugate of a vector of 16-bit integral complex values.

Parameters
aThe vector of 16-bit integral complex values.
Returns
The complex conjugate values.

This operation is only available for SSE2, AVX2, and AVX-512.

◆ conj() [4/11]

BLAZE_ALWAYS_INLINE const SIMDcint32 blaze::conj ( const SIMDcint32 a)
deletenoexcept

Complex conjugate of a vector of 32-bit integral complex values.

Parameters
aThe vector of 32-bit integral complex values.
Returns
The complex conjugate values.

This operation is only available for SSE4, AVX2, MIC, and AVX-512.

◆ conj() [5/11]

BLAZE_ALWAYS_INLINE const SIMDcint64 blaze::conj ( const SIMDcint64 a)
deletenoexcept

Complex conjugate of a vector of 64-bit integral complex values.

Parameters
aThe vector of 64-bit integral values.
Returns
The complex conjugate values.

This operation is only available for AVX-512.

◆ conj() [6/11]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj ( const SIMDf32< T > &  a)
noexcept

Complex conjugate of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The complex conjugate values.

◆ conj() [7/11]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj ( const SIMDf64< T > &  a)
noexcept

Complex conjugate of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The complex conjugate values.

◆ conj() [8/11]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj ( const SIMDi16< T > &  a)
noexcept

Complex conjugate of a vector of 16-bit integral values.

Parameters
aThe vector of 16-bit integral values.
Returns
The complex conjugate values.

◆ conj() [9/11]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj ( const SIMDi32< T > &  a)
noexcept

Complex conjugate of a vector of 32-bit integral values.

Parameters
aThe vector of 32-bit integral values.
Returns
The complex conjugate values.

◆ conj() [10/11]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj ( const SIMDi64< T > &  a)
noexcept

Complex conjugate of a vector of 64-bit integral values.

Parameters
aThe vector of 64-bit integral values.
Returns
The complex conjugate values.

◆ conj() [11/11]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::conj ( const SIMDi8< T > &  a)
noexcept

Complex conjugate of a vector of 8-bit integral values.

Parameters
aThe vector of 8-bit integral values.
Returns
The complex conjugate values.

◆ cos() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::cos ( const SIMDf32< T > &  a)
deletenoexcept

Cosine of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ cos() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::cos ( const SIMDf64< T > &  a)
deletenoexcept

Cosine of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ cosh() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::cosh ( const SIMDf32< T > &  a)
deletenoexcept

Hyperbolic cosine of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ cosh() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::cosh ( const SIMDf64< T > &  a)
deletenoexcept

Hyperbolic cosine of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ erf() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::erf ( const SIMDf32< T > &  a)
deletenoexcept

Computes the error function for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ erf() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::erf ( const SIMDf64< T > &  a)
deletenoexcept

Computes the error function for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ erfc() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::erfc ( const SIMDf32< T > &  a)
deletenoexcept

Computes the complementary error function for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ erfc() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::erfc ( const SIMDf64< T > &  a)
deletenoexcept

Computes the complementary error function for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ exp() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::exp ( const SIMDf32< T > &  a)
deletenoexcept

Computes $ e^x $ for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF or Sleef for SSE, AVX, MIC, and AVX-512.

◆ exp() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::exp ( const SIMDf64< T > &  a)
deletenoexcept

Computes $ e^x $ for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF or Sleef for SSE, AVX, MIC, and AVX-512.

◆ exp10() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::exp10 ( const SIMDf32< T > &  a)
deletenoexcept

Computes $ 10^x $ for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ exp10() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::exp10 ( const SIMDf64< T > &  a)
deletenoexcept

Computes $ 10^x $ for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ exp2() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::exp2 ( const SIMDf32< T > &  a)
deletenoexcept

Computes $ 2^x $ for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ exp2() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::exp2 ( const SIMDf64< T > &  a)
deletenoexcept

Computes $ 2^x $ for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ floor() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::floor ( const SIMDf32< T > &  a)
deletenoexcept

Computes the largest integer value not greater than the given value for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ floor() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::floor ( const SIMDf64< T > &  a)
deletenoexcept

Computes the largest integer value not greater than the given value for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ hypot() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::hypot ( const SIMDf32< T > &  a,
const SIMDf32< T > &  b 
)
deletenoexcept

Computes the length of the hypotenous of a right triangle of a vector of single precision floating point values ( $ \sqrt( a^2 + b^2 ) $).

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This function computes the square root of the sum of the squares of a and b, which corresponds to the length of the hypotenous of a right triangle. This operation is only available via the SVML or SLEEF or Sleef for SSE, AVX, MIC, and AVX-512.

◆ hypot() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::hypot ( const SIMDf64< T > &  a,
const SIMDf64< T > &  b 
)
deletenoexcept

Computes the length of the hypotenous of a right triangle of a vector of double precision floating point values ( $ \sqrt( a^2 + b^2 ) $).

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This function computes the square root of the sum of the squares of a and b, which corresponds to the length of the hypotenous of a right triangle. This operation is only available via the SVML or SLEEF or Sleef for SSE, AVX, MIC, and AVX-512.

◆ invcbrt() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::invcbrt ( const SIMDf32< T > &  a)
deletenoexcept

Computes the inverse cubic root for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML for SSE, AVX, and AVX-512.

◆ invcbrt() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::invcbrt ( const SIMDf64< T > &  a)
deletenoexcept

Computes the inverse cubic root for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML for SSE, AVX, and AVX-512.

◆ invsqrt() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::invsqrt ( const SIMDf32< T > &  a)
deletenoexcept

Computes the inverse square root for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML for SSE, AVX, MIC, and AVX-512.

◆ invsqrt() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::invsqrt ( const SIMDf64< T > &  a)
deletenoexcept

Computes the inverse square root for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML for SSE, AVX, MIC, and AVX-512.

◆ lgamma() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::lgamma ( const SIMDf32< T > &  a)
deletenoexcept

Computes the lgamma function for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SLEEF for SSE, AVX, MIC, and AVX-512.

◆ lgamma() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::lgamma ( const SIMDf64< T > &  a)
deletenoexcept

Computes the lgamma function for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SLEEF for SSE, AVX, MIC, and AVX-512.

◆ loada() [1/6]

BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::loada ( const complex< double > *  address)
noexcept

Loads a vector of 'complex<double>' values.

Parameters
addressThe first 'complex<double>' value to be loaded.
Returns
The loaded vector of 'complex<double>' values.

This function loads a vector of 'complex<double>' values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ loada() [2/6]

BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::loada ( const complex< float > *  address)
noexcept

Loads a vector of 'complex<float>' values.

Parameters
addressThe first 'complex<float>' value to be loaded.
Returns
The loaded vector of 'complex<float>' values.

This function loads a vector of 'complex<float>' values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ loada() [3/6]

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDcint8, SIMDcuint8 > > blaze::loada ( const complex< T > *  address)
noexcept

Loads a vector of 1-byte integral complex values.

Parameters
addressThe first integral complex value to be loaded.
Returns
The loaded vector of integral complex values.

This function loads a vector of 1-byte integral complex values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512).

◆ loada() [4/6]

BLAZE_ALWAYS_INLINE const SIMDdouble blaze::loada ( const double *  address)
noexcept

Loads a vector of 'double' values.

Parameters
addressThe first 'double' value to be loaded.
Returns
The loaded vector of 'double' values.

This function loads a vector of 'double' values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ loada() [5/6]

BLAZE_ALWAYS_INLINE const SIMDfloat blaze::loada ( const float *  address)
noexcept

Loads a vector of 'float' values.

Parameters
addressThe first 'float' value to be loaded.
Returns
The loaded vector of 'float' values.

This function loads a vector of 'float' values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ loada() [6/6]

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > blaze::loada ( const T *  address)
noexcept

Loads a vector of 1-byte integral values.

Parameters
addressThe first integral value to be loaded.
Returns
The loaded vector of integral values.

This function loads a vector of 1-byte integral values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512).

◆ loadu() [1/6]

BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::loadu ( const complex< double > *  address)
noexcept

Loads a vector of 'complex<double>' values.

Parameters
addressThe first 'complex<double>' value to be loaded.
Returns
The loaded vector of 'complex<double>' values.

This function loads a vector of 'complex<double>' values. In contrast to the according loada() function, the given address is not required to be properly aligned.

◆ loadu() [2/6]

BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::loadu ( const complex< float > *  address)
noexcept

Loads a vector of 'complex<float>' values.

Parameters
addressThe first 'complex<float>' value to be loaded.
Returns
The loaded vector of 'complex<float>' values.

This function loads a vector of 'complex<float>' values. In contrast to the according loada() function, the given address is not required to be properly aligned.

◆ loadu() [3/6]

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDcint8, SIMDcuint8 > > blaze::loadu ( const complex< T > *  address)
noexcept

Loads a vector of 1-byte integral complex values.

Parameters
addressThe first integral complex value to be loaded.
Returns
The loaded vector of integral complex values.

This function loads a vector of 1-byte integral complex values. In contrast to the according loada() function, the given address is not required to be properly aligned.

◆ loadu() [4/6]

BLAZE_ALWAYS_INLINE const SIMDdouble blaze::loadu ( const double *  address)
noexcept

Loads a vector of 'double' values.

Parameters
addressThe first 'double' value to be loaded.
Returns
The loaded vector of 'double' values.

This function loads a vector of 'double' values. In contrast to the according loada() function, the given address is not required to be properly aligned.

◆ loadu() [5/6]

BLAZE_ALWAYS_INLINE const SIMDfloat blaze::loadu ( const float *  address)
noexcept

Loads a vector of 'float' values.

Parameters
addressThe first 'float' value to be loaded.
Returns
The loaded vector of 'float' values.

This function loads a vector of 'float' values. In contrast to the according loada() function, the given address is not required to be properly aligned.

◆ loadu() [6/6]

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > blaze::loadu ( const T *  address)
noexcept

Loads a vector of 1-byte integral values.

Parameters
addressThe first integral value to be loaded.
Returns
The loaded vector of integral values.

This function loads a vector of 1-byte integral values. In contrast to the according loada() function, the given address is not required to be properly aligned.

◆ log() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::log ( const SIMDf32< T > &  a)
deletenoexcept

Computes the natural logarithm for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ log() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::log ( const SIMDf64< T > &  a)
deletenoexcept

Computes the natural logarithm for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ log10() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::log10 ( const SIMDf32< T > &  a)
deletenoexcept

Computes the common logarithm for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ log10() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::log10 ( const SIMDf64< T > &  a)
deletenoexcept

Computes the common logarithm for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ log1p() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::log1p ( const SIMDf32< T > &  a)
deletenoexcept

Computes the natural logarithm of x+1 for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SLEEF for SSE, AVX, MIC, and AVX-512.

◆ log1p() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::log1p ( const SIMDf64< T > &  a)
deletenoexcept

Computes the natural logarithm of x+1 for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SLEEF for SSE, AVX, MIC, and AVX-512.

◆ log2() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::log2 ( const SIMDf32< T > &  a)
deletenoexcept

Computes the binary logarithm for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ log2() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::log2 ( const SIMDf64< T > &  a)
deletenoexcept

Computes the binary logarithm for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ max() [1/8]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::max ( const SIMDf32< T1 > &  a,
const SIMDf32< T2 > &  b 
)
deletenoexcept

Componentwise maximum of two vectors of single precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ max() [2/8]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::max ( const SIMDf64< T1 > &  a,
const SIMDf64< T2 > &  b 
)
deletenoexcept

Componentwise maximum of two vectors of double precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ max() [3/8]

BLAZE_ALWAYS_INLINE const SIMDint16 blaze::max ( const SIMDint16 a,
const SIMDint16 b 
)
deletenoexcept

Componentwise maximum of two vectors of 16-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE2, AVX2, and AVX-512.

◆ max() [4/8]

BLAZE_ALWAYS_INLINE const SIMDint32 blaze::max ( const SIMDint32 a,
const SIMDint32 b 
)
deletenoexcept

Componentwise maximim of two vectors of 32-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE4, AVX2, MIC, and AVX-512.

◆ max() [5/8]

BLAZE_ALWAYS_INLINE const SIMDint8 blaze::max ( const SIMDint8 a,
const SIMDint8 b 
)
deletenoexcept

Componentwise maximum of two vectors of 8-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE4, AVX2, and AVX-512.

◆ max() [6/8]

BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::max ( const SIMDuint16 a,
const SIMDuint16 b 
)
deletenoexcept

Componentwise maximum of two vectors of 16-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE4, AVX2, and AVX-512.

◆ max() [7/8]

BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::max ( const SIMDuint32 a,
const SIMDuint32 b 
)
deletenoexcept

Componentwise maximum of two vectors of 32-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE4, AVX2, MIC, and AVX-512.

◆ max() [8/8]

BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::max ( const SIMDuint8 a,
const SIMDuint8 b 
)
deletenoexcept

Componentwise maximum of two vectors of 8-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE2, AVX2, and AVX-512.

◆ min() [1/8]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::min ( const SIMDf32< T1 > &  a,
const SIMDf32< T2 > &  b 
)
deletenoexcept

Componentwise minimum of two vectors of single precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ min() [2/8]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::min ( const SIMDf64< T1 > &  a,
const SIMDf64< T2 > &  b 
)
deletenoexcept

Componentwise minimum of two vectors of double precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ min() [3/8]

BLAZE_ALWAYS_INLINE const SIMDint16 blaze::min ( const SIMDint16 a,
const SIMDint16 b 
)
deletenoexcept

Componentwise minimum of two vectors of 16-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE2, AVX2, and AVX-512.

◆ min() [4/8]

BLAZE_ALWAYS_INLINE const SIMDint32 blaze::min ( const SIMDint32 a,
const SIMDint32 b 
)
deletenoexcept

Componentwise minimum of two vectors of 32-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE4, AVX2, MIC, and AVX-512.

◆ min() [5/8]

BLAZE_ALWAYS_INLINE const SIMDint8 blaze::min ( const SIMDint8 a,
const SIMDint8 b 
)
deletenoexcept

Componentwise minimum of two vectors of 8-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE4, AVX2, and AVX-512.

◆ min() [6/8]

BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::min ( const SIMDuint16 a,
const SIMDuint16 b 
)
deletenoexcept

Componentwise minimum of two vectors of 16-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE4, AVX2, and AVX-512.

◆ min() [7/8]

BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::min ( const SIMDuint32 a,
const SIMDuint32 b 
)
deletenoexcept

Componentwise minimum of two vectors of 32-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE4, AVX2, MIC, and AVX-512.

◆ min() [8/8]

BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::min ( const SIMDuint8 a,
const SIMDuint8 b 
)
deletenoexcept

Componentwise minimum of two vectors of 8-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The resulting vector.

This operation is only available for SSE2, AVX2, and AVX-512.

◆ operator!=()

template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator!= ( const SIMDPack< T > &  a,
const SIMDPack< T > &  b 
)
noexcept

Inequality comparison of two SIMD vectors of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
false if the two vectors are equal, true if not.

◆ operator&() [1/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& ( const SIMDci16< T > &  a,
const SIMDci16< T > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 16-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator&() [2/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& ( const SIMDci32< T > &  a,
const SIMDci32< T > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 32-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator&() [3/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& ( const SIMDci64< T > &  a,
const SIMDci64< T > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 64-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator&() [4/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& ( const SIMDci8< T > &  a,
const SIMDci8< T > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 8-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator&() [5/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& ( const SIMDi16< T > &  a,
const SIMDi16< T > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 16-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator&() [6/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator& ( const SIMDi16< T1 > &  a,
const SIMDi16< T2 > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 16-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator&() [7/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& ( const SIMDi32< T > &  a,
const SIMDi32< T > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 32-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator&() [8/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator& ( const SIMDi32< T1 > &  a,
const SIMDi32< T2 > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 32-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator&() [9/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& ( const SIMDi64< T > &  a,
const SIMDi64< T > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 64-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator&() [10/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator& ( const SIMDi64< T1 > &  a,
const SIMDi64< T2 > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 64-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator&() [11/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator& ( const SIMDi8< T > &  a,
const SIMDi8< T > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 8-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator&() [12/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator& ( const SIMDi8< T1 > &  a,
const SIMDi8< T2 > &  b 
)
deletenoexcept

Bitwise AND ('&') of two vectors of 8-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise AND.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator*() [1/29]

BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator* ( const SIMDcdouble a,
const SIMDcdouble b 
)
deletenoexcept

Multiplication of two vectors of double precision complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for SSE3 and AVX.

◆ operator*() [2/29]

BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator* ( const SIMDcdouble a,
const SIMDdouble b 
)
deletenoexcept

Scaling of a vector of double precision complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the scaling operation.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ operator*() [3/29]

BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator* ( const SIMDcfloat a,
const SIMDcfloat b 
)
deletenoexcept

Multiplication of two vectors of single precision complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for SSE3 and AVX.

◆ operator*() [4/29]

BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator* ( const SIMDcfloat a,
const SIMDfloat b 
)
deletenoexcept

Scaling of a vector of single precision complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the scaling operation.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator*() [5/29]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* ( const SIMDci16< T > &  a,
const SIMDci16< T > &  b 
)
deletenoexcept

Multiplication of two vectors of 16-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for SSE2 and AVX2.

◆ operator*() [6/29]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* ( const SIMDci32< T > &  a,
const SIMDci32< T > &  b 
)
deletenoexcept

Multiplication of two vectors of 32-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for SSE4, AVX2, and AVX-512.

◆ operator*() [7/29]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* ( const SIMDci64< T > &  a,
const SIMDci64< T > &  b 
)
deletenoexcept

Multiplication of two vectors of 64-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for AVX-512.

◆ operator*() [8/29]

BLAZE_ALWAYS_INLINE const SIMDcint16 blaze::operator* ( const SIMDcint16 a,
const SIMDint16 b 
)
deletenoexcept

Scaling of a vector of 16-bit signed integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the scaling operation.

This operation is only available for SSE2 and AVX2.

◆ operator*() [9/29]

BLAZE_ALWAYS_INLINE const SIMDcint32 blaze::operator* ( const SIMDcint32 a,
const SIMDint32 b 
)
deletenoexcept

Scaling of a vector of 32-bit signed integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the scaling operation.

This operation is only available for SSE4, AVX2, MIC, and AVX-512.

◆ operator*() [10/29]

BLAZE_ALWAYS_INLINE const SIMDcint64 blaze::operator* ( const SIMDcint64 a,
const SIMDint64 b 
)
deletenoexcept

Scaling of a vector of 64-bit signed integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the scaling operation.

This operation is only available for AVX-512.

◆ operator*() [11/29]

BLAZE_ALWAYS_INLINE const SIMDcuint16 blaze::operator* ( const SIMDcuint16 a,
const SIMDuint16 b 
)
deletenoexcept

Scaling of a vector of 16-bit unsigned integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the scaling operation.

This operation is only available for SSE2 and AVX2.

◆ operator*() [12/29]

BLAZE_ALWAYS_INLINE const SIMDcuint32 blaze::operator* ( const SIMDcuint32 a,
const SIMDuint32 b 
)
deletenoexcept

Scaling of a vector of 32-bit unsigned integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the scaling operation.

This operation is only available for SSE4, AVX2, MIC, and AVX-512.

◆ operator*() [13/29]

BLAZE_ALWAYS_INLINE const SIMDcuint64 blaze::operator* ( const SIMDcuint64 a,
const SIMDuint64 b 
)
deletenoexcept

Scaling of a vector of 64-bit unsigned integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the scaling operation.

This operation is only available for AVX-512.

◆ operator*() [14/29]

BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator* ( const SIMDdouble a,
const SIMDcdouble b 
)
deletenoexcept

Scaling of a vector of double precision complex SIMD values.

Parameters
aThe left-hand side scalars.
bThe right-hand side complex values to be scaled.
Returns
The result of the scaling operation.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ operator*() [15/29]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDf32MultExpr< T1, T2 > blaze::operator* ( const SIMDf32< T1 > &  a,
const SIMDf32< T2 > &  b 
)
noexcept

Multiplication of two vectors of single precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for SSE, AVX, and AVX-512.

◆ operator*() [16/29]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDf64MultExpr< T1, T2 > blaze::operator* ( const SIMDf64< T1 > &  a,
const SIMDf64< T2 > &  b 
)
noexcept

Multiplication of two vectors of double precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for SSE2, AVX, and AVX-512.

◆ operator*() [17/29]

BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator* ( const SIMDfloat a,
const SIMDcfloat b 
)
deletenoexcept

Scaling of a vector of single precision complex SIMD values.

Parameters
aThe left-hand side scalars.
bThe right-hand side complex values to be scaled.
Returns
The result of the scaling operation.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator*() [18/29]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* ( const SIMDi16< T > &  a,
const SIMDi16< T > &  b 
)
deletenoexcept

Multiplication of two vectors of 16-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for SSE2 and AVX2.

◆ operator*() [19/29]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator* ( const SIMDi16< T1 > &  a,
const SIMDi16< T2 > &  b 
)
deletenoexcept

Multiplication of two vectors of 16-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for SSE2 and AVX2.

◆ operator*() [20/29]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* ( const SIMDi32< T > &  a,
const SIMDi32< T > &  b 
)
deletenoexcept

Multiplication of two vectors of 32-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for SSE4, AVX2, MIC, and AVX-512.

◆ operator*() [21/29]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator* ( const SIMDi32< T1 > &  a,
const SIMDi32< T2 > &  b 
)
deletenoexcept

Multiplication of two vectors of 32-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for SSE4, AVX2, MIC, and AVX-512.

◆ operator*() [22/29]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator* ( const SIMDi64< T > &  a,
const SIMDi64< T > &  b 
)
deletenoexcept

Multiplication of two vectors of 64-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for AVX-512.

◆ operator*() [23/29]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator* ( const SIMDi64< T1 > &  a,
const SIMDi64< T2 > &  b 
)
deletenoexcept

Multiplication of two vectors of 64-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the multiplication.

This operation is only available for AVX-512.

◆ operator*() [24/29]

BLAZE_ALWAYS_INLINE const SIMDcint16 blaze::operator* ( const SIMDint16 a,
const SIMDcint16 b 
)
deletenoexcept

Scaling of a vector of 16-bit signed integral complex SIMD values.

Parameters
aThe left-hand side scalars.
bThe right-hand side complex values to be scaled.
Returns
The result of the scaling operation.

This operation is only available for SSE2 and AVX2.

◆ operator*() [25/29]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDcint32 blaze::operator* ( const SIMDint32 a,
const SIMDcint32 b 
)
deletenoexcept

Scaling of a vector of 32-bit signed integral complex SIMD values.

Parameters
aThe left-hand side scalars.
bThe right-hand side complex values to be scaled.
Returns
The result of the scaling operation.

This operation is only available for SSE4, AVX2, MIC, and AVX-512.

◆ operator*() [26/29]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDcint64 blaze::operator* ( const SIMDint64 a,
const SIMDcint64 b 
)
deletenoexcept

Scaling of a vector of 64-bit signed integral complex SIMD values.

Parameters
aThe left-hand side scalars.
bThe right-hand side complex values to be scaled.
Returns
The result of the scaling operation.

This operation is only available for AVX-512.

◆ operator*() [27/29]

BLAZE_ALWAYS_INLINE const SIMDcuint16 blaze::operator* ( const SIMDuint16 a,
const SIMDcuint16 b 
)
deletenoexcept

Scaling of a vector of 16-bit unsigned integral complex SIMD values.

Parameters
aThe left-hand side scalars.
bThe right-hand side complex values to be scaled.
Returns
The result of the scaling operation.

This operation is only available for SSE2 and AVX2.

◆ operator*() [28/29]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDcuint32 blaze::operator* ( const SIMDuint32 a,
const SIMDcuint32 b 
)
deletenoexcept

Scaling of a vector of 32-bit unsigned integral complex SIMD values.

Parameters
aThe left-hand side scalars.
bThe right-hand side complex values to be scaled.
Returns
The result of the scaling operation.

This operation is only available for SSE4, AVX2, MIC, and AVX-512.

◆ operator*() [29/29]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDcuint64 blaze::operator* ( const SIMDuint64 a,
const SIMDcuint64 b 
)
deletenoexcept

Scaling of a vector of 64-bit unsigned integral complex SIMD values.

Parameters
aThe left-hand side scalars.
bThe right-hand side complex values to be scaled.
Returns
The result of the scaling operation.

This operation is only available for MIC and AVX-512.

◆ operator*=()

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE T1 & blaze::operator*= ( SIMDPack< T1 > &  lhs,
const SIMDPack< T2 > &  rhs 
)

Multiplication assignment operator for the multiplication of two SIMD packs.

Parameters
lhsThe left-hand side SIMD operand for the multiplication.
rhsThe right-hand side SIMD operand for the multiplication.
Returns
Reference to the left-hand side SIMD operand.

◆ operator+() [1/16]

BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator+ ( const SIMDcdouble a,
const SIMDcdouble b 
)
deletenoexcept

Addition of two vectors of double precision complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ operator+() [2/16]

BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator+ ( const SIMDcfloat a,
const SIMDcfloat b 
)
deletenoexcept

Addition of two vectors of single precision complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator+() [3/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ ( const SIMDci16< T > &  a,
const SIMDci16< T > &  b 
)
deletenoexcept

Addition of two vectors of 16-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2 and AVX512BW.

◆ operator+() [4/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ ( const SIMDci32< T > &  a,
const SIMDci32< T > &  b 
)
deletenoexcept

Addition of two vectors of 32-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator+() [5/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ ( const SIMDci64< T > &  a,
const SIMDci64< T > &  b 
)
deletenoexcept

Addition of two vectors of 64-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator+() [6/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ ( const SIMDci8< T > &  a,
const SIMDci8< T > &  b 
)
deletenoexcept

Addition of two vectors of 8-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2 and AVX512BW.

◆ operator+() [7/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::operator+ ( const SIMDf32< T1 > &  a,
const SIMDf32< T2 > &  b 
)
deletenoexcept

Addition of two vectors of single precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator+() [8/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::operator+ ( const SIMDf64< T1 > &  a,
const SIMDf64< T2 > &  b 
)
deletenoexcept

Addition of two vectors of double precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ operator+() [9/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ ( const SIMDi16< T > &  a,
const SIMDi16< T > &  b 
)
deletenoexcept

Addition of two vectors of 16-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2 and AVX512BW.

◆ operator+() [10/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator+ ( const SIMDi16< T1 > &  a,
const SIMDi16< T2 > &  b 
)
deletenoexcept

Addition of two vectors of 16-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2 and AVX512BW.

◆ operator+() [11/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ ( const SIMDi32< T > &  a,
const SIMDi32< T > &  b 
)
deletenoexcept

Addition of two vectors of 32-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator+() [12/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator+ ( const SIMDi32< T1 > &  a,
const SIMDi32< T2 > &  b 
)
deletenoexcept

Addition of two vectors of 32-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator+() [13/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ ( const SIMDi64< T > &  a,
const SIMDi64< T > &  b 
)
deletenoexcept

Addition of two vectors of 64-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator+() [14/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator+ ( const SIMDi64< T1 > &  a,
const SIMDi64< T2 > &  b 
)
deletenoexcept

Addition of two vectors of 64-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator+() [15/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator+ ( const SIMDi8< T > &  a,
const SIMDi8< T > &  b 
)
deletenoexcept

Addition of two vectors of 8-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2 and AVX512BW.

◆ operator+() [16/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator+ ( const SIMDi8< T1 > &  a,
const SIMDi8< T2 > &  b 
)
deletenoexcept

Addition of two vectors of 8-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the addition.

This operation is only available for SSE2, AVX2 and AVX512BW.

◆ operator+=()

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE T1 & blaze::operator+= ( SIMDPack< T1 > &  lhs,
const SIMDPack< T2 > &  rhs 
)

Addition assignment operator for the addition of two SIMD packs.

Parameters
lhsThe left-hand side SIMD operand for the addition.
rhsThe right-hand side SIMD operand for the addition.
Returns
Reference to the left-hand side SIMD operand.

◆ operator-() [1/16]

BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator- ( const SIMDcdouble a,
const SIMDcdouble b 
)
deletenoexcept

Subtraction of two vectors of double precision complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ operator-() [2/16]

BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator- ( const SIMDcfloat a,
const SIMDcfloat b 
)
deletenoexcept

Subtraction of two vectors of single precision complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator-() [3/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- ( const SIMDci16< T > &  a,
const SIMDci16< T > &  b 
)
deletenoexcept

Subtraction of two vectors of 16-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2 and AVX2.

◆ operator-() [4/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- ( const SIMDci32< T > &  a,
const SIMDci32< T > &  b 
)
deletenoexcept

Subtraction of two vectors of 32-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator-() [5/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- ( const SIMDci64< T > &  a,
const SIMDci64< T > &  b 
)
deletenoexcept

Subtraction of two vectors of 64-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator-() [6/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- ( const SIMDci8< T > &  a,
const SIMDci8< T > &  b 
)
deletenoexcept

Subtraction of two vectors of 8-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2 and AVX2.

◆ operator-() [7/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::operator- ( const SIMDf32< T1 > &  a,
const SIMDf32< T2 > &  b 
)
deletenoexcept

Subtraction of two vectors of single precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator-() [8/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::operator- ( const SIMDf64< T1 > &  a,
const SIMDf64< T2 > &  b 
)
deletenoexcept

Subtraction of two vectors of double precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ operator-() [9/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- ( const SIMDi16< T > &  a,
const SIMDi16< T > &  b 
)
deletenoexcept

Subtraction of two vectors of 16-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2 and AVX2.

◆ operator-() [10/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator- ( const SIMDi16< T1 > &  a,
const SIMDi16< T2 > &  b 
)
deletenoexcept

Subtraction of two vectors of 16-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2 and AVX2.

◆ operator-() [11/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- ( const SIMDi32< T > &  a,
const SIMDi32< T > &  b 
)
deletenoexcept

Subtraction of two vectors of 32-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator-() [12/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator- ( const SIMDi32< T1 > &  a,
const SIMDi32< T2 > &  b 
)
deletenoexcept

Subtraction of two vectors of 32-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator-() [13/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- ( const SIMDi64< T > &  a,
const SIMDi64< T > &  b 
)
deletenoexcept

Subtraction of two vectors of 64-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator-() [14/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator- ( const SIMDi64< T1 > &  a,
const SIMDi64< T2 > &  b 
)
deletenoexcept

Subtraction of two vectors of 64-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator-() [15/16]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator- ( const SIMDi8< T > &  a,
const SIMDi8< T > &  b 
)
deletenoexcept

Subtraction of two vectors of 8-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2 and AVX2.

◆ operator-() [16/16]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator- ( const SIMDi8< T1 > &  a,
const SIMDi8< T2 > &  b 
)
deletenoexcept

Subtraction of two vectors of 8-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the subtraction.

This operation is only available for SSE2 and AVX2.

◆ operator-=()

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE T1 & blaze::operator-= ( SIMDPack< T1 > &  lhs,
const SIMDPack< T2 > &  rhs 
)

Subtraction assignment operator for the subtraction of two SIMD packs.

Parameters
lhsThe left-hand side SIMD operand for the subtraction.
rhsThe right-hand side SIMD operand for the subtraction.
Returns
Reference to the left-hand side SIMD operand.

◆ operator/() [1/20]

BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::operator/ ( const SIMDcdouble a,
const SIMDdouble b 
)
deletenoexcept

Scaling of a vector of double precision floating point values complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the division.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator/() [2/20]

BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::operator/ ( const SIMDcfloat a,
const SIMDfloat b 
)
deletenoexcept

Scaling of a vector of single precision floating point values complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the division.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator/() [3/20]

BLAZE_ALWAYS_INLINE const SIMDcint16 blaze::operator/ ( const SIMDcint16 a,
const SIMDint16 b 
)
deletenoexcept

Scaling of a vector of 16-bit signed integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the division.

This operation is only available for AVX2 and AVX-512.

◆ operator/() [4/20]

BLAZE_ALWAYS_INLINE const SIMDcint32 blaze::operator/ ( const SIMDcint32 a,
const SIMDint32 b 
)
deletenoexcept

Scaling of a vector of 32-bit signed integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the division.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator/() [5/20]

BLAZE_ALWAYS_INLINE const SIMDcint64 blaze::operator/ ( const SIMDcint64 a,
const SIMDint64 b 
)
deletenoexcept

Scaling of a vector of 64-bit signed integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the division.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator/() [6/20]

BLAZE_ALWAYS_INLINE const SIMDcint8 blaze::operator/ ( const SIMDcint8 a,
const SIMDint8 b 
)
deletenoexcept

Scaling of a vector of 8-bit signed integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the division.

This operation is only available for AVX2 and AVX-512.

◆ operator/() [7/20]

BLAZE_ALWAYS_INLINE const SIMDcuint16 blaze::operator/ ( const SIMDcuint16 a,
const SIMDuint16 b 
)
deletenoexcept

Scaling of a vector of 16-bit unsigned integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the division.

This operation is only available for AVX2 and AVX-512.

◆ operator/() [8/20]

BLAZE_ALWAYS_INLINE const SIMDcuint32 blaze::operator/ ( const SIMDcuint32 a,
const SIMDuint32 b 
)
deletenoexcept

Scaling of a vector of 32-bit unsigned integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the division.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator/() [9/20]

BLAZE_ALWAYS_INLINE const SIMDcuint64 blaze::operator/ ( const SIMDcuint64 a,
const SIMDuint64 b 
)
deletenoexcept

Scaling of a vector of 64-bit unsigned integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the division.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator/() [10/20]

BLAZE_ALWAYS_INLINE const SIMDcuint8 blaze::operator/ ( const SIMDcuint8 a,
const SIMDuint8 b 
)
deletenoexcept

Scaling of a vector of 8-bit unsigned integral complex SIMD values.

Parameters
aThe left-hand side complex values to be scaled.
bThe right-hand side scalars.
Returns
The result of the division.

This operation is only available for AVX2 and AVX-512.

◆ operator/() [11/20]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::operator/ ( const SIMDf32< T1 > &  a,
const SIMDf32< T2 > &  b 
)
deletenoexcept

Division of two vectors of single precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the division.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator/() [12/20]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::operator/ ( const SIMDf64< T1 > &  a,
const SIMDf64< T2 > &  b 
)
deletenoexcept

Division of two vectors of double precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the division.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator/() [13/20]

BLAZE_ALWAYS_INLINE const SIMDint16 blaze::operator/ ( const SIMDint16 a,
const SIMDint16 b 
)
deletenoexcept

Division of two vectors of 16-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the division.

This operation is only available for AVX2 and AVX-512.

◆ operator/() [14/20]

BLAZE_ALWAYS_INLINE const SIMDint32 blaze::operator/ ( const SIMDint32 a,
const SIMDint32 b 
)
deletenoexcept

Division of two vectors of 32-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the division.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator/() [15/20]

BLAZE_ALWAYS_INLINE const SIMDint64 blaze::operator/ ( const SIMDint64 a,
const SIMDint64 b 
)
deletenoexcept

Division of two vectors of 64-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the division.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator/() [16/20]

BLAZE_ALWAYS_INLINE const SIMDint8 blaze::operator/ ( const SIMDint8 a,
const SIMDint8 b 
)
deletenoexcept

Division of two vectors of 8-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the division.

This operation is only available for AVX2 and AVX-512.

◆ operator/() [17/20]

BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator/ ( const SIMDuint16 a,
const SIMDuint16 b 
)
deletenoexcept

Division of two vectors of 16-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the division.

This operation is only available for AVX2 and AVX-512.

◆ operator/() [18/20]

BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator/ ( const SIMDuint32 a,
const SIMDuint32 b 
)
deletenoexcept

Division of two vectors of 32-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the division.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator/() [19/20]

BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator/ ( const SIMDuint64 a,
const SIMDuint64 b 
)
deletenoexcept

Division of two vectors of 64-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the division.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator/() [20/20]

BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator/ ( const SIMDuint8 a,
const SIMDuint8 b 
)
deletenoexcept

Division of two vectors of 8-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the division.

This operation is only available for AVX2 and AVX-512.

◆ operator/=()

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE T1 & blaze::operator/= ( SIMDPack< T1 > &  lhs,
const SIMDPack< T2 > &  rhs 
)

Division assignment operator for the division of two SIMD packs.

Parameters
lhsThe left-hand side SIMD operand for the division.
rhsThe right-hand side SIMD operand for the division.
Returns
Reference to the left-hand side SIMD operand.

◆ operator<<() [1/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint16 blaze::operator<< ( const SIMDint16 a,
const SIMDi16< T > &  b 
)
deletenoexcept

Elementwise left-shift of a vector of 16-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 16-bit signed integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the left-shift.

This operation is only available for AVX-512.

◆ operator<<() [2/12]

BLAZE_ALWAYS_INLINE const SIMDint16 blaze::operator<< ( const SIMDint16 a,
int  count 
)
deletenoexcept

Uniform left-shift of a vector of 16-bit signed integral SIMD values.

Parameters
aThe vector of 16-bit signed integral values to be shifted.
countThe number of bits to shift $[0..15]$.
Returns
The result of the left-shift.

This operation is only available for SSE2, AVX2, and AVX-512.

◆ operator<<() [3/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint32 blaze::operator<< ( const SIMDint32 a,
const SIMDi32< T > &  b 
)
deletenoexcept

Elementwise left-shift of a vector of 32-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 32-bit signed integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the left-shift.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator<<() [4/12]

BLAZE_ALWAYS_INLINE const SIMDint32 blaze::operator<< ( const SIMDint32 a,
int  count 
)
deletenoexcept

Uniform left-shift of a vector of 32-bit signed integral SIMD values.

Parameters
aThe vector of 32-bit signed integral values to be shifted.
countThe number of bits to shift $[0..31]$.
Returns
The result of the left-shift.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator<<() [5/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint64 blaze::operator<< ( const SIMDint64 a,
const SIMDi64< T > &  b 
)
deletenoexcept

Elementwise left-shift of a vector of 64-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 64-bit signed integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the left-shift.

This operation is only available for AVX2 and AVX-512.

◆ operator<<() [6/12]

BLAZE_ALWAYS_INLINE const SIMDint64 blaze::operator<< ( const SIMDint64 a,
int  count 
)
deletenoexcept

Uniform left-shift of a vector of 64-bit signed integral SIMD values.

Parameters
aThe vector of 64-bit signed integral values to be shifted.
countThe number of bits to shift $[0..63]$.
Returns
The result of the left-shift.

This operation is only available for SSE2, AVX2, and AVX-512.

◆ operator<<() [7/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator<< ( const SIMDuint16 a,
const SIMDi16< T > &  b 
)
deletenoexcept

Elementwise left-shift of a vector of 16-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 16-bit unsigned integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the left-shift.

This operation is only available for AVX-512.

◆ operator<<() [8/12]

BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator<< ( const SIMDuint16 a,
int  count 
)
deletenoexcept

Uniform left-shift of a vector of 16-bit unsigned integral SIMD values.

Parameters
aThe vector of 16-bit unsigned integral values to be shifted.
countThe number of bits to shift $[0..15]$.
Returns
The result of the left-shift.

This operation is only available for SSE2, AVX2, and AVX-512.

◆ operator<<() [9/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator<< ( const SIMDuint32 a,
const SIMDi32< T > &  b 
)
deletenoexcept

Elementwise left-shift of a vector of 32-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 32-bit unsigned integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the left-shift.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator<<() [10/12]

BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator<< ( const SIMDuint32 a,
int  count 
)
deletenoexcept

Uniform left-shift of a vector of 32-bit unsigned integral SIMD values.

Parameters
aThe vector of 32-bit unsigned integral values to be shifted.
countThe number of bits to shift $[0..31]$.
Returns
The result of the left-shift.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator<<() [11/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator<< ( const SIMDuint64 a,
const SIMDi64< T > &  b 
)
deletenoexcept

Elementwise left-shift of a vector of 64-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 64-bit unsigned integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the left-shift.

This operation is only available for AVX2 and AVX-512.

◆ operator<<() [12/12]

BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator<< ( const SIMDuint64 a,
int  count 
)
deletenoexcept

Uniform left-shift of a vector of 64-bit unsigned integral SIMD values.

Parameters
aThe vector of 64-bit unsigned integral values to be shifted.
countThe number of bits to shift $[0..63]$.
Returns
The result of the left-shift.

This operation is only available for SSE2, AVX2, and AVX-512.

◆ operator==() [1/12]

BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDcdouble a,
const SIMDcdouble b 
)
deletenoexcept

Equality comparison of two vectors of double precision complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ operator==() [2/12]

BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDcfloat a,
const SIMDcfloat b 
)
deletenoexcept

Equality comparison of two vectors of single precision complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator==() [3/12]

template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDci16< T > &  a,
const SIMDci16< T > &  b 
)
noexcept

Equality comparison of two vectors of 16-bit integral complex SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator==() [4/12]

template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDci32< T > &  a,
const SIMDci32< T > &  b 
)
noexcept

Equality comparison of two vectors of 32-bit integral complex SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator==() [5/12]

template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDci64< T > &  a,
const SIMDci64< T > &  b 
)
noexcept

Equality comparison of two vectors of 64-bit integral SIMD complex values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE4.1, AVX2, MIC, and AVX-512.

◆ operator==() [6/12]

template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDci8< T > &  a,
const SIMDci8< T > &  b 
)
noexcept

Equality comparison of two vectors of 8-bit integral SIMD complex values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator==() [7/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDf32< T1 > &  a,
const SIMDf32< T2 > &  b 
)
deletenoexcept

Equality comparison of two vectors of single precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ operator==() [8/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDf64< T1 > &  a,
const SIMDf64< T2 > &  b 
)
deletenoexcept

Equality comparison of two vectors of double precision floating point SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ operator==() [9/12]

template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDi16< T > &  a,
const SIMDi16< T > &  b 
)
noexcept

Equality comparison of two vectors of 16-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator==() [10/12]

template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDi32< T > &  a,
const SIMDi32< T > &  b 
)
noexcept

Equality comparison of two vectors of 32-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator==() [11/12]

template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDi64< T > &  a,
const SIMDi64< T > &  b 
)
noexcept

Equality comparison of two vectors of 64-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE4.1, AVX2, MIC, and AVX-512.

◆ operator==() [12/12]

template<typename T >
BLAZE_ALWAYS_INLINE bool blaze::operator== ( const SIMDi8< T > &  a,
const SIMDi8< T > &  b 
)
noexcept

Equality comparison of two vectors of 8-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
true if the two vectors are equal, false if not.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator>>() [1/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint16 blaze::operator>> ( const SIMDint16 a,
const SIMDi16< T > &  b 
)
deletenoexcept

Elementwise right-shift of a vector of 16-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 16-bit signed integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the right-shift.

This operation is only available for AVX-512.

◆ operator>>() [2/12]

BLAZE_ALWAYS_INLINE const SIMDint16 blaze::operator>> ( const SIMDint16 a,
int  count 
)
deletenoexcept

Uniform right-shift of a vector of 16-bit signed integral SIMD values.

Parameters
aThe vector of 16-bit signed integral values to be shifted.
countThe number of bits to shift $[0..15]$.
Returns
The result of the right-shift.

This operation is only available for SSE2, AVX2, and AVX-512.

◆ operator>>() [3/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint32 blaze::operator>> ( const SIMDint32 a,
const SIMDi32< T > &  b 
)
deletenoexcept

Elementwise right-shift of a vector of 32-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 32-bit signed integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the right-shift.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator>>() [4/12]

BLAZE_ALWAYS_INLINE const SIMDint32 blaze::operator>> ( const SIMDint32 a,
int  count 
)
deletenoexcept

Uniform right-shift of a vector of 32-bit signed integral SIMD values.

Parameters
aThe vector of 32-bit signed integral values to be shifted.
countThe number of bits to shift $[0..31]$.
Returns
The result of the right-shift.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator>>() [5/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDint64 blaze::operator>> ( const SIMDint64 a,
const SIMDi64< T > &  b 
)
deletenoexcept

Elementwise right-shift of a vector of 64-bit signed integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 64-bit signed integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the right-shift.

This operation is only available for AVX-512.

◆ operator>>() [6/12]

BLAZE_ALWAYS_INLINE const SIMDint64 blaze::operator>> ( const SIMDint64 a,
int  count 
)
deletenoexcept

Uniform right-shift of a vector of 64-bit signed integral SIMD values.

Parameters
aThe vector of 64-bit signed integral values to be shifted.
countThe number of bits to shift $[0..63]$.
Returns
The result of the right-shift.

This operation is only available for AVX-512.

◆ operator>>() [7/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator>> ( const SIMDuint16 a,
const SIMDi16< T > &  b 
)
deletenoexcept

Elementwise right-shift of a vector of 16-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 16-bit unsigned integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the right-shift.

This operation is only available for AVX-512.

◆ operator>>() [8/12]

BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator>> ( const SIMDuint16 a,
int  count 
)
deletenoexcept

Uniform right-shift of a vector of 16-bit unsigned integral SIMD values.

Parameters
aThe vector of 16-bit unsigned integral values to be shifted.
countThe number of bits to shift $[0..15]$.
Returns
The result of the right-shift.

This operation is only available for SSE2, AVX2, and AVX-512.

◆ operator>>() [9/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator>> ( const SIMDuint32 a,
const SIMDi32< T > &  b 
)
deletenoexcept

Elementwise right-shift of a vector of 32-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 32-bit unsigned integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the right-shift.

This operation is only available for AVX2, MIC, and AVX-512.

◆ operator>>() [10/12]

BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator>> ( const SIMDuint32 a,
int  count 
)
deletenoexcept

Uniform right-shift of a vector of 32-bit unsigned integral SIMD values.

Parameters
aThe vector of 32-bit unsigned integral values to be shifted.
countThe number of bits to shift $[0..31]$.
Returns
The result of the right-shift.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator>>() [11/12]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator>> ( const SIMDuint64 a,
const SIMDi64< T > &  b 
)
deletenoexcept

Elementwise right-shift of a vector of 64-bit unsigned integral SIMD values.

Parameters
aThe left-hand side SIMD vector of 64-bit unsigned integral values to be shifted.
bThe right-hand side SIMD vector of bits to shift.
Returns
The result of the right-shift.

This operation is only available for AVX2 and AVX-512.

◆ operator>>() [12/12]

BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator>> ( const SIMDuint64 a,
int  count 
)
deletenoexcept

Uniform right-shift of a vector of 64-bit unsigned integral SIMD values.

Parameters
aThe vector of 64-bit unsigned integral values to be shifted.
countThe number of bits to shift $[0..63]$.
Returns
The result of the right-shift.

This operation is only available for SSE2, AVX2 and AVX-512.

◆ operator^() [1/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ ( const SIMDci16< T > &  a,
const SIMDci16< T > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 16-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator^() [2/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ ( const SIMDci32< T > &  a,
const SIMDci32< T > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 32-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator^() [3/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ ( const SIMDci64< T > &  a,
const SIMDci64< T > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 64-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator^() [4/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ ( const SIMDci8< T > &  a,
const SIMDci8< T > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 8-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator^() [5/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ ( const SIMDi16< T > &  a,
const SIMDi16< T > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 16-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator^() [6/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator^ ( const SIMDi16< T1 > &  a,
const SIMDi16< T2 > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 16-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator^() [7/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ ( const SIMDi32< T > &  a,
const SIMDi32< T > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 32-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator^() [8/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator^ ( const SIMDi32< T1 > &  a,
const SIMDi32< T2 > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 32-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator^() [9/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ ( const SIMDi64< T > &  a,
const SIMDi64< T > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 64-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator^() [10/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator^ ( const SIMDi64< T1 > &  a,
const SIMDi64< T2 > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 64-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator^() [11/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator^ ( const SIMDi8< T > &  a,
const SIMDi8< T > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 8-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator^() [12/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator^ ( const SIMDi8< T1 > &  a,
const SIMDi8< T2 > &  b 
)
deletenoexcept

Bitwise XOR ('^') of two vectors of 8-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise XOR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator|() [1/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| ( const SIMDci16< T > &  a,
const SIMDci16< T > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 16-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator|() [2/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| ( const SIMDci32< T > &  a,
const SIMDci32< T > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 32-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator|() [3/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| ( const SIMDci64< T > &  a,
const SIMDci64< T > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 64-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator|() [4/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| ( const SIMDci8< T > &  a,
const SIMDci8< T > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 8-bit integral complex SIMD values.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator|() [5/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| ( const SIMDi16< T > &  a,
const SIMDi16< T > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 16-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator|() [6/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::operator| ( const SIMDi16< T1 > &  a,
const SIMDi16< T2 > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 16-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator|() [7/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| ( const SIMDi32< T > &  a,
const SIMDi32< T > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 32-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator|() [8/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::operator| ( const SIMDi32< T1 > &  a,
const SIMDi32< T2 > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 32-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator|() [9/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| ( const SIMDi64< T > &  a,
const SIMDi64< T > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 64-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator|() [10/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint64 blaze::operator| ( const SIMDi64< T1 > &  a,
const SIMDi64< T2 > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 64-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC, and AVX-512.

◆ operator|() [11/12]

template<typename T >
BLAZE_ALWAYS_INLINE const T blaze::operator| ( const SIMDi8< T > &  a,
const SIMDi8< T > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 8-bit integral SIMD values of the same type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ operator|() [12/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::operator| ( const SIMDi8< T1 > &  a,
const SIMDi8< T2 > &  b 
)
deletenoexcept

Bitwise OR ('|') of two vectors of 8-bit integral SIMD values of different type.

Parameters
aThe left-hand side SIMD operand.
bThe right-hand side SIMD operand.
Returns
The result of the bitwise OR.

This operation is only available for SSE2, AVX2, MIC and AVX512F.

◆ pow() [1/2]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::pow ( const SIMDf32< T1 > &  a,
const SIMDf32< T2 > &  b 
)
deletenoexcept

Computes the exponential value of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point base values.
bThe vector of single precision floating point exponents.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ pow() [2/2]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::pow ( const SIMDf64< T1 > &  a,
const SIMDf64< T2 > &  b 
)
deletenoexcept

Computes the exponential value of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point base values.
bThe vector of double precision floating point exponents.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ prod() [1/12]

BLAZE_ALWAYS_INLINE const complex< double > blaze::prod ( const SIMDcdouble a)
noexcept

Returns the product of all elements in the double precision complex SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The product of all vector elements.

◆ prod() [2/12]

BLAZE_ALWAYS_INLINE const complex< float > blaze::prod ( const SIMDcfloat a)
noexcept

Returns the product of all elements in the single precision complex SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The product of all vector elements.

◆ prod() [3/12]

template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::prod ( const SIMDci16< T > &  a)
noexcept

Returns the product of all elements in the 16-bit integral complex SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The product of all vector elements.

◆ prod() [4/12]

template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::prod ( const SIMDci32< T > &  a)
noexcept

Returns the product of all elements in the 32-bit integral complex SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The product of all vector elements.

◆ prod() [5/12]

template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::prod ( const SIMDci64< T > &  a)
noexcept

Returns the product of all elements in the 64-bit integral complex SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The product of all vector elements.

◆ prod() [6/12]

template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::prod ( const SIMDci8< T > &  a)
noexcept

Returns the product of all elements in the 8-bit integral complex SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The product of all vector elements.

◆ prod() [7/12]

BLAZE_ALWAYS_INLINE double blaze::prod ( const SIMDdouble a)
noexcept

Returns the product of all elements in the double precision floating point SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The produdct of all vector elements.

◆ prod() [8/12]

BLAZE_ALWAYS_INLINE float blaze::prod ( const SIMDfloat a)
noexcept

Returns the product of all elements in the single precision floating point SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The product of all vector elements.

◆ prod() [9/12]

template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::prod ( const SIMDi16< T > &  a)
noexcept

Returns the product of all elements in the 16-bit integral SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The product of all vector elements.

◆ prod() [10/12]

template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::prod ( const SIMDi32< T > &  a)
noexcept

Returns the product of all elements in the 32-bit integral SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The product of all vector elements.

◆ prod() [11/12]

template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::prod ( const SIMDi64< T > &  a)
noexcept

Returns the product of all elements in the 64-bit integral SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The product of all vector elements.

◆ prod() [12/12]

template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::prod ( const SIMDi8< T > &  a)
noexcept

Returns the product of all elements in the 8-bit integral SIMD vector.

Parameters
aThe vector to be reduced by multiplication.
Returns
The product of all vector elements.

◆ reduce()

template<typename T , typename OP >
decltype(auto) blaze::reduce ( const SIMDPack< T > &  a,
OP  op 
)
inline

Reduces the elements in the given SIMD vector.

Parameters
aThe SIMD vector to be reduced.
opThe reduction operation.
Returns
The result of the reduction operation.

◆ round() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::round ( const SIMDf32< T > &  a)
deletenoexcept

Computes the nearest integers for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available for SSE4.1, AVX, MIC, and AVX-512.

◆ round() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::round ( const SIMDf64< T > &  a)
deletenoexcept

Computes the nearest integers for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available for SSE4.1, AVX, and AVX-512.

◆ set() [1/6]

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDcint8, SIMDcuint8 > > blaze::set ( complex< T >  value)
noexcept

Sets all values in the vector to the given 1-byte integral complex value.

Parameters
valueThe given 1-byte integral complex value.
Returns
The set vector of 1-byte integral complex values.

◆ set() [2/6]

BLAZE_ALWAYS_INLINE const SIMDcdouble blaze::set ( const complex< double > &  value)
noexcept

Sets all values in the vector to the given complex<double> value.

Parameters
valueThe given complex<double> value.
Returns
The set vector of complex<double> values.

◆ set() [3/6]

BLAZE_ALWAYS_INLINE const SIMDcfloat blaze::set ( const complex< float > &  value)
noexcept

Sets all values in the vector to the given complex<float> value.

Parameters
valueThe given complex<float> value.
Returns
The set vector of complex<float> values.

◆ set() [4/6]

BLAZE_ALWAYS_INLINE const SIMDdouble blaze::set ( double  value)
noexcept

Sets all values in the vector to the given double value.

Parameters
valueThe given double value.
Returns
The set vector of double values.

◆ set() [5/6]

BLAZE_ALWAYS_INLINE const SIMDfloat blaze::set ( float  value)
noexcept

Sets all values in the vector to the given float value.

Parameters
valueThe given float value.
Returns
The set vector of float values.

◆ set() [6/6]

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > blaze::set ( value)
noexcept

Sets all values in the vector to the given 1-byte integral value.

Parameters
valueThe given 1-byte integral value.
Returns
The set vector of 1-byte integral values.

◆ setall() [1/6]

template<typename... Ts>
SIMDcdouble blaze::setall ( const complex< double > &  v0,
Ts...  vs 
)
noexcept

Sets all values in the vector to the given complex<double> values.

Parameters
v0The first given complex<double> value.
vsThe remaining complex<double> values.
Returns
The set vector of complex<double> values.

This function sets the values of a SIMD vector to the given values. Depending on the available SIMD instruction set, the function accepts another maximum number of values:

SIMD instruction setMaximum number of values
SSE 1
AVX 2
AVX-5124

In case less arguments are given than the SIMD vector contains values, the missing values are set to 0.

◆ setall() [2/6]

template<typename... Ts>
SIMDcfloat blaze::setall ( const complex< float > &  v0,
Ts...  vs 
)
noexcept

Sets all values in the vector to the given complex<float> values.

Parameters
v0The first given complex<float> value.
vsThe remaining complex<float> values.
Returns
The set vector of complex<float> values.

This function sets the values of a SIMD vector to the given values. Depending on the available SIMD instruction set, the function accepts another maximum number of values:

SIMD instruction setMaximum number of values
SSE 2
AVX 4
AVX-5128

In case less arguments are given than the SIMD vector contains values, the missing values are set to 0.

◆ setall() [3/6]

template<typename T , typename... Ts>
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDcint8, SIMDcuint8 > > blaze::setall ( const complex< T > &  v0,
const complex< Ts > &...  vs 
)
noexcept

Sets all values in the vector to the given 1-byte integral complex values.

Parameters
v0The first given 1-byte integral complex value.
vsThe remaining 1-byte integral complex values.
Returns
The SIMD vector of 1-byte integral complex values.

This function sets the values of a SIMD vector to the given values. Depending on the available SIMD instruction set, the function accepts another maximum number of values:

SIMD instruction setMaximum number of values
SSE 8
AVX 16
AVX-51232

In case less arguments are given than the SIMD vector contains values, the missing values are set to 0.

◆ setall() [4/6]

template<typename... Ts>
SIMDdouble blaze::setall ( double  v0,
Ts...  vs 
)
noexcept

Sets all values in a SIMD vector to the given double values.

Parameters
v0The first given double value.
vsThe remaining double values.
Returns
The SIMD vector of double values.

This function sets the values of a SIMD vector to the given values. Depending on the available SIMD instruction set, the function accepts another maximum number of values:

SIMD instruction setMaximum number of values
SSE 2
AVX 4
AVX-5128

In case less arguments are given than the SIMD vector contains values, the missing values are set to 0.

◆ setall() [5/6]

template<typename... Ts>
SIMDfloat blaze::setall ( float  v0,
Ts...  vs 
)
noexcept

Sets all values in a SIMD vector to the given float values.

Parameters
v0The first given float value.
vsThe remaining float values.
Returns
The SIMD vector of float values.

This function sets the values of a SIMD vector to the given values. Depending on the available SIMD instruction set, the function accepts another maximum number of values:

SIMD instruction setMaximum number of values
SSE 4
AVX 8
AVX-51216

In case less arguments are given than the SIMD vector contains values, the missing values are set to 0.

◆ setall() [6/6]

template<typename T , typename... Ts>
BLAZE_ALWAYS_INLINE const EnableIf_t< IsIntegral_v< T > &&HasSize_v< T, 1UL >, If_t< IsSigned_v< T >, SIMDint8, SIMDuint8 > > blaze::setall ( v0,
Ts...  vs 
)
noexcept

Sets all values in a SIMD vector to the given 1-byte integral values.

Parameters
v0The first given 1-byte integral value.
vsThe remaining 1-byte integral values.
Returns
The SIMD vector of 1-byte integral values.

This function sets the values of a SIMD vector to the given values. Depending on the available SIMD instruction set, the function accepts another maximum number of values:

SIMD instruction setMaximum number of values
SSE 16
AVX 32
AVX-51264

In case less arguments are given than the SIMD vector contains values, the missing values are set to 0.

◆ setzero() [1/12]

BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDcdouble value)
noexcept

Setting a floating point SIMD type with 32-bit double precision complex values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ setzero() [2/12]

BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDcfloat value)
noexcept

Setting a floating point SIMD type with 32-bit single precision complex values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ setzero() [3/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDci16< T > &  value)
noexcept

Setting an integral SIMD type with 16-bit complex values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ setzero() [4/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDci32< T > &  value)
noexcept

Setting an integral SIMD type with 32-bit complex values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ setzero() [5/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDci64< T > &  value)
noexcept

Setting an integral SIMD type with 64-bit complex values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ setzero() [6/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDci8< T > &  value)
noexcept

Setting an integral SIMD type with 8-bit complex values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ setzero() [7/12]

BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDdouble value)
noexcept

Setting a floating point SIMD type with 64-bit double precision data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ setzero() [8/12]

BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDfloat value)
noexcept

Setting a floating point SIMD type with 32-bit single precision data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ setzero() [9/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDi16< T > &  value)
noexcept

Setting an integral SIMD type with 16-bit data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ setzero() [10/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDi32< T > &  value)
noexcept

Setting an integral SIMD type with 32-bit data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ setzero() [11/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDi64< T > &  value)
noexcept

Setting an integral SIMD type with 64-bit data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ setzero() [12/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::setzero ( SIMDi8< T > &  value)
noexcept

Setting an integral SIMD type with 8-bit data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void

◆ sign() [1/6]

BLAZE_ALWAYS_INLINE SIMDdouble blaze::sign ( const SIMDdouble a)
deletenoexcept

Sign function for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
1 if the value is greater than zero, 0 if it is zero, and -1 if it is less than zero.

The function returns a vector of double precision floating point values, each of which is set to 1 if the corresponding value in a is greater than zero, to 0 if the corresponding value in a is zero, and to -1 if the corresponding value in a is less than zero. This operation is only available for SSE4, AVX, MIC, and AVX-512F.

◆ sign() [2/6]

BLAZE_ALWAYS_INLINE SIMDfloat blaze::sign ( const SIMDfloat a)
deletenoexcept

Sign function for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
1 if the value is greater than zero, 0 if it is zero, and -1 if it is less than zero.

The function returns a vector of single precision floating point values, each of which is set to 1 if the corresponding value in a is greater than zero, to 0 if the corresponding value in a is zero, and to -1 if the corresponding value in a is less than zero. This operation is only available for SSE4, AVX, MIC, and AVX-512F.

◆ sign() [3/6]

BLAZE_ALWAYS_INLINE SIMDint16 blaze::sign ( const SIMDint16 a)
deletenoexcept

Sign function for a vector of 16-bit signed integral values.

Parameters
aThe vector of 16-bit unsigned integral values.
Returns
1 if the value is greater than zero, 0 if it is zero, and -1 if it is less than zero.

The function returns a vector of 16-bit signed integral values, each of which is set to 1 if the corresponding value in a is greater than zero, to 0 if the corresponding value in a is zero, and to -1 if the corresponding value in a is less than zero. This operation is only available for SSSE3, AVX2, and AVX-512BW.

◆ sign() [4/6]

BLAZE_ALWAYS_INLINE SIMDint32 blaze::sign ( const SIMDint32 a)
deletenoexcept

Sign function for a vector of 32-bit signed integral values.

Parameters
aThe vector of 32-bit unsigned integral values.
Returns
1 if the value is greater than zero, 0 if it is zero, and -1 if it is less than zero.

The function returns a vector of 32-bit signed integral values, each of which is set to 1 if the corresponding value in a is greater than zero, to 0 if the corresponding value in a is zero, and to -1 if the corresponding value in a is less than zero. This operation is only available for SSSE3, AVX2, and AVX-512F.

◆ sign() [5/6]

BLAZE_ALWAYS_INLINE SIMDint64 blaze::sign ( const SIMDint64 a)
deletenoexcept

Sign function for a vector of 64-bit signed integral values.

Parameters
aThe vector of 64-bit unsigned integral values.
Returns
1 if the value is greater than zero, 0 if it is zero, and -1 if it is less than zero.

The function returns a vector of 64-bit signed integral values, each of which is set to 1 if the corresponding value in a is greater than zero, to 0 if the corresponding value in a is zero, and to -1 if the corresponding value in a is less than zero. This operation is only available for AVX-512F.

◆ sign() [6/6]

BLAZE_ALWAYS_INLINE SIMDint8 blaze::sign ( const SIMDint8 a)
deletenoexcept

Sign function for a vector of 8-bit signed integral values.

Parameters
aThe vector of 8-bit unsigned integral values.
Returns
1 if the value is greater than zero, 0 if it is zero, and -1 if it is less than zero.

The function returns a vector of 8-bit signed integral values, each of which is set to 1 if the corresponding value in a is greater than zero, to 0 if the corresponding value in a is zero, and to -1 if the corresponding value in a is less than zero. This operation is only available for SSSE3, AVX2, and AVX-512BW.

◆ sin() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::sin ( const SIMDf32< T > &  a)
deletenoexcept

Sine of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ sin() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::sin ( const SIMDf64< T > &  a)
deletenoexcept

Sine of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ sinh() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::sinh ( const SIMDf32< T > &  a)
deletenoexcept

Hyperbolic sine of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ sinh() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::sinh ( const SIMDf64< T > &  a)
deletenoexcept

Hyperbolic sine of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ sqrt() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::sqrt ( const SIMDf32< T > &  a)
deletenoexcept

Computes the square root for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available for SSE, AVX, MIC, and AVX-512.

◆ sqrt() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::sqrt ( const SIMDf64< T > &  a)
deletenoexcept

Computes the square root for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available for SSE2, AVX, MIC, and AVX-512.

◆ storea() [1/12]

BLAZE_ALWAYS_INLINE void blaze::storea ( complex< double > *  address,
const SIMDcdouble value 
)
noexcept

Aligned store of a vector of 'complex<double>' values.

Parameters
addressThe target address.
valueThe 'complex<double>' vector to be stored.
Returns
void

This function stores a vector of 'complex<double>' values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ storea() [2/12]

BLAZE_ALWAYS_INLINE void blaze::storea ( complex< float > *  address,
const SIMDcfloat value 
)
noexcept

Aligned store of a vector of 'complex<float>' values.

Parameters
addressThe target address.
valueThe 'complex<float>' vector to be stored.
Returns
void

This function stores a vector of 'complex<float>' values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ storea() [3/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::storea ( complex< T1 > *  address,
const SIMDci16< T2 > &  value 
)
noexcept

Aligned store of a vector of 2-byte integral complex values.

Parameters
addressThe target address.
valueThe 2-byte integral complex vector to be stored.
Returns
void

This function stores a vector of 2-byte integral complex values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512).

◆ storea() [4/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::storea ( complex< T1 > *  address,
const SIMDci32< T2 > &  value 
)
noexcept

Aligned store of a vector of 4-byte integral complex values.

Parameters
addressThe target address.
valueThe 4-byte integral complex vector to be stored.
Returns
void

This function stores a vector of 4-byte integral complex values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ storea() [5/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::storea ( complex< T1 > *  address,
const SIMDci64< T2 > &  value 
)
noexcept

Aligned store of a vector of 8-byte integral complex values.

Parameters
addressThe target address.
valueThe 8-byte integral complex vector to be stored.
Returns
void

This function stores a vector of 8-byte integral complex values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ storea() [6/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::storea ( complex< T1 > *  address,
const SIMDci8< T2 > &  value 
)
noexcept

Aligned store of a vector of 1-byte integral complex values.

Parameters
addressThe target address.
valueThe 1-byte integral complex vector to be stored.
Returns
void

This function stores a vector of 1-byte integral complex values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512).

◆ storea() [7/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::storea ( double *  address,
const SIMDf64< T > &  value 
)
noexcept

Aligned store of a vector of 'double' values.

Parameters
addressThe target address.
valueThe 'double' vector to be stored.
Returns
void

This function stores a vector of 'double' values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ storea() [8/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::storea ( float *  address,
const SIMDf32< T > &  value 
)
noexcept

Aligned store of a vector of 'float' values.

Parameters
addressThe target address.
valueThe 'float' vector to be stored.
Returns
void

This function stores a vector of 'float' values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ storea() [9/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::storea ( T1 *  address,
const SIMDi16< T2 > &  value 
)
noexcept

Aligned store of a vector of 2-byte integral values.

Parameters
addressThe target address.
valueThe 2-byte integral vector to be stored.
Returns
void

This function stores a vector of 2-byte integral values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512).

◆ storea() [10/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::storea ( T1 *  address,
const SIMDi32< T2 > &  value 
)
noexcept

Aligned store of a vector of 4-byte integral values.

Parameters
addressThe target address.
valueThe 4-byte integral vector to be stored.
Returns
void

This function stores a vector of 4-byte integral values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ storea() [11/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::storea ( T1 *  address,
const SIMDi64< T2 > &  value 
)
noexcept

Aligned store of a vector of 8-byte integral values.

Parameters
addressThe target address.
valueThe 8-byte integral vector to be stored.
Returns
void

This function stores a vector of 8-byte integral values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512/MIC).

◆ storea() [12/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::storea ( T1 *  address,
const SIMDi8< T2 > &  value 
)
noexcept

Aligned store of a vector of 1-byte integral values.

Parameters
addressThe target address.
valueThe 1-byte integral vector to be stored.
Returns
void

This function stores a vector of 1-byte integral values. The given address must be aligned according to the enabled instruction set (16-byte alignment in case of SSE, 32-byte alignment in case of AVX, and 64-byte alignment in case of AVX-512).

◆ storeu() [1/12]

BLAZE_ALWAYS_INLINE void blaze::storeu ( complex< double > *  address,
const SIMDcdouble value 
)
noexcept

Unaligned store of a vector of 'complex<double>' values.

Parameters
addressThe target address.
valueThe 'complex<double>' vector to be stored.
Returns
void

This function stores a vector of 'complex<double>' values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ storeu() [2/12]

BLAZE_ALWAYS_INLINE void blaze::storeu ( complex< float > *  address,
const SIMDcfloat value 
)
noexcept

Unaligned store of a vector of 'complex<float>' values.

Parameters
addressThe target address.
valueThe 'complex<float>' vector to be stored.
Returns
void

This function stores a vector of 'complex<float>' values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ storeu() [3/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::storeu ( complex< T1 > *  address,
const SIMDci16< T2 > &  value 
)
noexcept

Unaligned store of a vector of 2-byte integral complex values.

Parameters
addressThe target address.
valueThe 2-byte integral complex vector to be stored.
Returns
void

This function stores a vector of 2-byte integral complex values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ storeu() [4/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::storeu ( complex< T1 > *  address,
const SIMDci32< T2 > &  value 
)
noexcept

Unaligned store of a vector of 4-byte integral complex values.

Parameters
addressThe target address.
valueThe 4-byte integral complex vector to be stored.
Returns
void

This function stores a vector of 4-byte integral complex values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ storeu() [5/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::storeu ( complex< T1 > *  address,
const SIMDci64< T2 > &  value 
)
noexcept

Unaligned store of a vector of 8-byte integral complex values.

Parameters
addressThe target address.
valueThe 8-byte integral complex vector to be stored.
Returns
void

This function stores a vector of 8-byte integral complex values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ storeu() [6/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::storeu ( complex< T1 > *  address,
const SIMDci8< T2 > &  value 
)
noexcept

Unaligned store of a vector of 1-byte integral complex values.

Parameters
addressThe target address.
valueThe 1-byte integral complex vector to be stored.
Returns
void

This function stores a vector of 1-byte integral complex values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ storeu() [7/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::storeu ( double *  address,
const SIMDf64< T > &  value 
)
noexcept

Unaligned store of a vector of 'double' values.

Parameters
addressThe target address.
valueThe 'double' vector to be stored.
Returns
void

This function stores a vector of 'double' values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ storeu() [8/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::storeu ( float *  address,
const SIMDf32< T > &  value 
)
noexcept

Unaligned store of a vector of 'float' values.

Parameters
addressThe target address.
valueThe 'float' vector to be stored.
Returns
void

This function stores a vector of 'float' values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ storeu() [9/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::storeu ( T1 *  address,
const SIMDi16< T2 > &  value 
)
noexcept

Unaligned store of a vector of 2-byte integral values.

Parameters
addressThe target address.
valueThe 2-byte integral vector to be stored.
Returns
void

This function stores a vector of 2-byte integral values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ storeu() [10/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::storeu ( T1 *  address,
const SIMDi32< T2 > &  value 
)
noexcept

Unaligned store of a vector of 4-byte integral values.

Parameters
addressThe target address.
valueThe 4-byte integral vector to be stored.
Returns
void

This function stores a vector of 4-byte integral values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ storeu() [11/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::storeu ( T1 *  address,
const SIMDi64< T2 > &  value 
)
noexcept

Unaligned store of a vector of 8-byte integral values.

Parameters
addressThe target address.
valueThe 8-byte integral vector to be stored.
Returns
void

This function stores a vector of 8-byte integral values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ storeu() [12/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::storeu ( T1 *  address,
const SIMDi8< T2 > &  value 
)
noexcept

Unaligned store of a vector of 1-byte integral values.

Parameters
addressThe target address.
valueThe 1-byte integral vector to be stored.
Returns
void

This function stores a vector of 1-byte integral values. In contrast to the according storea() function, the given address is not required to be properly aligned.

◆ stream() [1/12]

BLAZE_ALWAYS_INLINE void blaze::stream ( complex< double > *  address,
const SIMDcdouble value 
)
noexcept

Aligned, non-temporal store of a vector of 'complex<double>' values.

Parameters
addressThe target address.
valueThe 'complex<double>' vector to be streamed.
Returns
void

◆ stream() [2/12]

BLAZE_ALWAYS_INLINE void blaze::stream ( complex< float > *  address,
const SIMDcfloat value 
)
noexcept

Aligned, non-temporal store of a vector of 'complex<float>' values.

Parameters
addressThe target address.
valueThe 'complex<float>' vector to be streamed.
Returns
void

◆ stream() [3/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::stream ( complex< T1 > *  address,
const SIMDci16< T2 > &  value 
)
noexcept

Aligned, non-temporal store of a vector of 2-byte integral complex values.

Parameters
addressThe target address.
valueThe 2-byte integral complex vector to be streamed.
Returns
void

◆ stream() [4/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::stream ( complex< T1 > *  address,
const SIMDci32< T2 > &  value 
)
noexcept

Aligned, non-temporal store of a vector of 4-byte integral complex values.

Parameters
addressThe target address.
valueThe 4-byte integral complex vector to be streamed.
Returns
void

◆ stream() [5/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::stream ( complex< T1 > *  address,
const SIMDci64< T2 > &  value 
)
noexcept

Aligned, non-temporal store of a vector of 8-byte integral complex values.

Parameters
addressThe target address.
valueThe 8-byte integral complex vector to be streamed.
Returns
void

◆ stream() [6/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::stream ( complex< T1 > *  address,
const SIMDci8< T2 > &  value 
)
noexcept

Aligned, non-temporal store of a vector of 1-byte integral complex values.

Parameters
addressThe target address.
valueThe 1-byte integral complex vector to be streamed.
Returns
void

◆ stream() [7/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::stream ( double *  address,
const SIMDf64< T > &  value 
)
noexcept

Aligned, non-temporal store of a vector of 'double' values.

Parameters
addressThe target address.
valueThe 'double' vector to be streamed.
Returns
void

◆ stream() [8/12]

template<typename T >
BLAZE_ALWAYS_INLINE void blaze::stream ( float *  address,
const SIMDf32< T > &  value 
)
noexcept

Aligned, non-temporal store of a vector of 'float' values.

Parameters
addressThe target address.
valueThe 'float' vector to be streamed.
Returns
void

◆ stream() [9/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 2UL > > blaze::stream ( T1 *  address,
const SIMDi16< T2 > &  value 
)
noexcept

Aligned, non-temporal store of a vector of 2-byte integral values.

Parameters
addressThe target address.
valueThe 2-byte integral vector to be streamed.
Returns
void

◆ stream() [10/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 4UL > > blaze::stream ( T1 *  address,
const SIMDi32< T2 > &  value 
)
noexcept

Aligned, non-temporal store of a vector of 4-byte integral values.

Parameters
addressThe target address.
valueThe 4-byte integral vector to be streamed.
Returns
void

◆ stream() [11/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 8UL > > blaze::stream ( T1 *  address,
const SIMDi64< T2 > &  value 
)
noexcept

Aligned, non-temporal store of a vector of 8-byte integral values.

Parameters
addressThe target address.
valueThe 8-byte integral vector to be streamed.
Returns
void

◆ stream() [12/12]

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_t< IsIntegral_v< T1 > &&HasSize_v< T1, 1UL > > blaze::stream ( T1 *  address,
const SIMDi8< T2 > &  value 
)
noexcept

Aligned, non-temporal store of a vector of 1-byte integral values.

Parameters
addressThe target address.
valueThe 1-byte integral vector to be streamed.
Returns
void

◆ sum() [1/12]

BLAZE_ALWAYS_INLINE const complex< double > blaze::sum ( const SIMDcdouble a)
noexcept

Returns the sum of all elements in the double precision complex SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ sum() [2/12]

BLAZE_ALWAYS_INLINE const complex< float > blaze::sum ( const SIMDcfloat a)
noexcept

Returns the sum of all elements in the single precision complex SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ sum() [3/12]

template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::sum ( const SIMDci16< T > &  a)
noexcept

Returns the sum of all elements in the 16-bit integral complex SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ sum() [4/12]

template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::sum ( const SIMDci32< T > &  a)
noexcept

Returns the sum of all elements in the 32-bit integral complex SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ sum() [5/12]

template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::sum ( const SIMDci64< T > &  a)
noexcept

Returns the sum of all elements in the 64-bit integral complex SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ sum() [6/12]

template<typename T >
BLAZE_ALWAYS_INLINE const ValueType_t< T > blaze::sum ( const SIMDci8< T > &  a)
noexcept

Returns the sum of all elements in the 8-bit integral complex SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ sum() [7/12]

BLAZE_ALWAYS_INLINE double blaze::sum ( const SIMDdouble a)
noexcept

Returns the sum of all elements in the double precision floating point SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ sum() [8/12]

BLAZE_ALWAYS_INLINE float blaze::sum ( const SIMDfloat a)
noexcept

Returns the sum of all elements in the single precision floating point SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ sum() [9/12]

template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::sum ( const SIMDi16< T > &  a)
noexcept

Returns the sum of all elements in the 16-bit integral SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ sum() [10/12]

template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::sum ( const SIMDi32< T > &  a)
noexcept

Returns the sum of all elements in the 32-bit integral SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ sum() [11/12]

template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::sum ( const SIMDi64< T > &  a)
noexcept

Returns the sum of all elements in the 64-bit integral SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ sum() [12/12]

template<typename T >
BLAZE_ALWAYS_INLINE ValueType_t< T > blaze::sum ( const SIMDi8< T > &  a)
noexcept

Returns the sum of all elements in the 8-bit integral SIMD vector.

Parameters
aThe vector to be summed up.
Returns
The sum of all vector elements.

◆ tan() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::tan ( const SIMDf32< T > &  a)
deletenoexcept

Tangent of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ tan() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::tan ( const SIMDf64< T > &  a)
deletenoexcept

Tangent of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ tanh() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::tanh ( const SIMDf32< T > &  a)
deletenoexcept

Hyperbolic tangent of a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ tanh() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::tanh ( const SIMDf64< T > &  a)
deletenoexcept

Hyperbolic tangent of a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ trunc() [1/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::trunc ( const SIMDf32< T > &  a)
deletenoexcept

Computes the nearest integer not greater in magnitude than the given value for a vector of single precision floating point values.

Parameters
aThe vector of single precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.

◆ trunc() [2/2]

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::trunc ( const SIMDf64< T > &  a)
deletenoexcept

Computes the nearest integer not greater in magnitude than the given value for a vector of double precision floating point values.

Parameters
aThe vector of double precision floating point values.
Returns
The resulting vector.

This operation is only available via the SVML or SLEEF for SSE, AVX, MIC, and AVX-512.