Classes | Typedefs | Functions

Classes

struct  blaze::SIMDf32FmaddExpr< T1, T2, T3 >
 Expression object for 32-bit floating point fused multiply-add operations.The SIMDf32FmaddExpr class represents the compile time expression 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.The SIMDf32FmsubExpr class represents the compile time expression 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.The SIMDf64FmsubExpr class represents the compile time expression for 64-bit floating point fused multiply-subtract operations. More...
 
struct  blaze::SIMDf32MultExpr< T1, T2 >
 Expression object for 32-bit floating point multiplication operations.The SIMDf32MultExpr class represents the compile time expression for 32-bit floating point multiplication operations. More...
 
struct  blaze::SIMDf64MultExpr< T1, T2 >
 Expression object for 64-bit floating point multiplication operations.The SIMDf64MultExpr class represents the compile time expression for 64-bit floating point multiplication operations. More...
 
struct  blaze::SIMDPack< T >
 Base class for all SIMD data types.The SIMDPack class template is a base class for all SIMD data types within the Blaze library. It provides an abstraction from the actual type of the SIMD pack, but enables a conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP). More...
 
class  blaze::SIMDTrait< T >
 SIMD characteristics of data types.The SIMDTrait class template provides the SIMD characteristics of a specific data type: More...
 
class  blaze::SIMDint8
 SIMD type for 8-bit signed integral data values. More...
 
class  blaze::SIMDuint8
 SIMD type for 8-bit unsigned integral data values. More...
 
class  blaze::SIMDcint8
 SIMD type for 8-bit signed integral complex values. More...
 
class  blaze::SIMDcuint8
 SIMD type for 8-bit unsigned integral complex values. More...
 
class  blaze::SIMDint16
 SIMD type for 16-bit signed integral data values. More...
 
class  blaze::SIMDuint16
 SIMD type for 16-bit unsigned integral data values. More...
 
class  blaze::SIMDcint16
 SIMD type for 16-bit signed integral complex values. More...
 
class  blaze::SIMDcuint16
 SIMD type for 16-bit unsigned integral complex values. More...
 
class  blaze::SIMDint32
 SIMD type for 32-bit signed integral data values. More...
 
class  blaze::SIMDuint32
 SIMD type for 32-bit unsigned integral data values. More...
 
class  blaze::SIMDcint32
 SIMD type for 32-bit signed integral complex values. More...
 
class  blaze::SIMDcuint32
 SIMD type for 32-bit unsigned integral complex values. More...
 
class  blaze::SIMDint64
 SIMD type for 64-bit integral data values. More...
 
class  blaze::SIMDuint64
 SIMD type for 64-bit unsigned integral data values. More...
 
class  blaze::SIMDcint64
 SIMD type for 64-bit signed integral complex values. More...
 
class  blaze::SIMDcuint64
 SIMD type for 64-bit unsigned integral complex values. More...
 
class  blaze::SIMDfloat
 SIMD type for 32-bit single precision floating point data values. More...
 
class  blaze::SIMDcfloat
 SIMD type for 32-bit single precision complex values. More...
 
class  blaze::SIMDdouble
 SIMD type for 64-bit double precision floating point data values. More...
 
class  blaze::SIMDcdouble
 SIMD type for 64-bit double precision complex values. More...
 

Typedefs

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

Functions

BLAZE_ALWAYS_INLINE const SIMDuint8 blaze::abs (const SIMDint8 &a) noexcept=delete
 Absolute value of a vector of 8-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint16 blaze::abs (const SIMDint16 &a) noexcept=delete
 Absolute value of a vector of 16-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint32 blaze::abs (const SIMDint32 &a) noexcept=delete
 Absolute value of a vector of 32-bit signed integral values. More...
 
BLAZE_ALWAYS_INLINE const SIMDuint64 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::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::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 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...
 
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 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 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 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 SIMDcint64 blaze::operator/ (const SIMDcint64 &a, const SIMDint64 &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 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 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::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::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 EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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 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 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 T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::pow (const SIMDf32< T > &a, const SIMDf32< T > &b) noexcept=delete
 Computes the exponential value of a vector of single precision floating point values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::pow (const SIMDf64< T > &a, const SIMDf64< T > &b) noexcept=delete
 Computes the exponential value of a vector of double precision floating point values. More...
 
BLAZE_ALWAYS_INLINE const complex< int8_t > blaze::sum (const SIMDcint8 &a) noexcept
 Returns the sum of all elements in the 8-bit integral complex SIMD vector. More...
 
BLAZE_ALWAYS_INLINE int16_t blaze::sum (const SIMDint16 &a) noexcept
 Returns the sum of all elements in the 16-bit integral SIMD vector. More...
 
BLAZE_ALWAYS_INLINE const complex< int16_t > blaze::sum (const SIMDcint16 &a) noexcept
 Returns the sum of all elements in the 16-bit integral complex SIMD vector. More...
 
BLAZE_ALWAYS_INLINE int32_t blaze::sum (const SIMDint32 &a) noexcept
 Returns the sum of all elements in the 32-bit integral SIMD vector. More...
 
BLAZE_ALWAYS_INLINE const complex< int32_t > blaze::sum (const SIMDcint32 &a) noexcept
 Returns the sum of all elements in the 32-bit integral complex SIMD vector. More...
 
BLAZE_ALWAYS_INLINE int64_t blaze::sum (const SIMDint64 &a) noexcept
 Returns the sum of all elements in the 64-bit integral SIMD vector. More...
 
BLAZE_ALWAYS_INLINE const complex< int64_t > blaze::sum (const SIMDcint64 &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 EnableIf_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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_< And< IsIntegral< T >, HasSize< T, 1UL > >, If_< IsSigned< 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 >
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...
 
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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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_< And< IsIntegral< T1 >, HasSize< 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 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...
 

Detailed Description

Typedef Documentation

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

Auxiliary alias declaration for the SIMDTrait class template.The SIMDTrait_ 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>;

Function Documentation

BLAZE_ALWAYS_INLINE const SIMDuint8 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.

BLAZE_ALWAYS_INLINE const SIMDuint16 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.

BLAZE_ALWAYS_INLINE const SIMDuint32 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, and AVX-512.

BLAZE_ALWAYS_INLINE const SIMDuint64 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 AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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.
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.
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 and AVX2.

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.
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, and AVX-512.

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.
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.
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.

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.
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.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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.

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.

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, and AVX-512.

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, and AVX-512.

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,1UL> > , If_< IsSigned<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 MIC).

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,1UL> > , If_< IsSigned<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 MIC).

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 MIC).

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 MIC).

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 MIC).

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 MIC).

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,1UL> > , If_< IsSigned<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.

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,1UL> > , If_< IsSigned<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.

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.

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.

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.

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.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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.

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.

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.

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.

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.

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.

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.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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.

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.

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, and AVX-512.

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, and AVX-512.

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.

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.

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, and AVX-512.

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, and AVX-512.

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.

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.
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 and AVX2.

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 and AVX2.

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 and AVX2.

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 and AVX2.

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 and AVX2.

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 and AVX2.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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.
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.

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.

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.

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.

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.

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.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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.
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 AVX-512.

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 AVX-512.

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 AVX-512.

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 AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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, and AVX-512.

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.
template<typename T >
BLAZE_ALWAYS_INLINE const SIMDfloat blaze::pow ( const SIMDf32< T > &  a,
const SIMDf32< T > &  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 for SSE, AVX, and AVX-512.

template<typename T >
BLAZE_ALWAYS_INLINE const SIMDdouble blaze::pow ( const SIMDf64< T > &  a,
const SIMDf64< T > &  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 for SSE, AVX, and AVX-512.

template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,1UL> > , If_< IsSigned<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.
template<typename T >
BLAZE_ALWAYS_INLINE const EnableIf_< And< IsIntegral<T>, HasSize<T,1UL> > , If_< IsSigned<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.
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.
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.
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.
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.
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
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
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
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
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
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
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
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
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
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
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
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
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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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, and AVX-512.

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, and AVX-512.

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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 MIC).

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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 MIC).

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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 MIC).

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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 MIC).

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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 MIC).

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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 MIC).

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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 MIC).

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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 MIC).

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 MIC).

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 MIC).

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 MIC).

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 MIC).

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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.

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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.

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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.

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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.

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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.

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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.

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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.

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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.

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.

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.

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.

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.

template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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
template<typename T1 , typename T2 >
BLAZE_ALWAYS_INLINE EnableIf_< And< IsIntegral<T1>, HasSize<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
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
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
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
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
BLAZE_ALWAYS_INLINE const complex<int8_t> blaze::sum ( const SIMDcint8 a)
noexcept

Returns the sum of all elements in the 8-bit integral complex SIMD vector.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
BLAZE_ALWAYS_INLINE int16_t blaze::sum ( const SIMDint16 a)
noexcept

Returns the sum of all elements in the 16-bit integral SIMD vector.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
BLAZE_ALWAYS_INLINE const complex<int16_t> blaze::sum ( const SIMDcint16 a)
noexcept

Returns the sum of all elements in the 16-bit integral complex SIMD vector.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
BLAZE_ALWAYS_INLINE int32_t blaze::sum ( const SIMDint32 a)
noexcept

Returns the sum of all elements in the 32-bit integral SIMD vector.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
BLAZE_ALWAYS_INLINE const complex<int32_t> blaze::sum ( const SIMDcint32 a)
noexcept

Returns the sum of all elements in the 32-bit integral complex SIMD vector.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
BLAZE_ALWAYS_INLINE int64_t blaze::sum ( const SIMDint64 a)
noexcept

Returns the sum of all elements in the 64-bit integral SIMD vector.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
BLAZE_ALWAYS_INLINE const complex<int64_t> blaze::sum ( const SIMDcint64 a)
noexcept

Returns the sum of all elements in the 64-bit integral complex SIMD vector.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
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 sumed up.
Returns
The sum of all vector elements.
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 sumed up.
Returns
The sum of all vector elements.
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 sumed up.
Returns
The sum of all vector elements.
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 sumed up.
Returns
The sum of all vector elements.
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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.

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 for SSE, AVX, and AVX-512.