Classes | Typedefs | Functions
Intrinsics

Classes

class  blaze::IntrinsicTrait< T >
 Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic characteristics of a specific data type: More...
 
class  blaze::simd_int8_t
 Intrinsic type for 8-bit integral data values. More...
 
class  blaze::simd_int16_t
 Intrinsic type for 16-bit integral data values. More...
 
class  blaze::simd_int32_t
 Intrinsic type for 32-bit integral data values. More...
 
class  blaze::simd_int64_t
 Intrinsic type for 64-bit integral data values. More...
 
class  blaze::simd_float_t
 Intrinsic type for 32-bit single precision floating point data values. More...
 
class  blaze::simd_double_t
 Intrinsic type for 64-bit double precision floating point data values. More...
 
class  blaze::simd_cint8_t
 Intrinsic type for 8-bit integral complex values. More...
 
class  blaze::simd_cint16_t
 Intrinsic type for 16-bit integral complex values. More...
 
class  blaze::simd_cint32_t
 Intrinsic type for 32-bit integral complex values. More...
 
class  blaze::simd_cint64_t
 Intrinsic type for 64-bit integral complex values. More...
 
class  blaze::simd_cfloat_t
 Intrinsic type for 32-bit single precision complex values. More...
 
class  blaze::simd_cdouble_t
 Intrinsic type for 64-bit double precision complex values. More...
 

Typedefs

typedef IntrinsicTrait< short >::Type blaze::simd_short_t
 The intrinsic data type for 'short'.
 
typedef IntrinsicTrait< unsigned short >::Type blaze::simd_ushort_t
 The intrinsic data type for 'unsigned short'.
 
typedef IntrinsicTrait< int >::Type blaze::simd_int_t
 The intrinsic data type for 'int'.
 
typedef IntrinsicTrait< unsigned int >::Type blaze::simd_uint_t
 The intrinsic data type for 'unsigned int'.
 
typedef IntrinsicTrait< long >::Type blaze::simd_long_t
 The intrinsic data type for 'long int'.
 
typedef IntrinsicTrait< unsigned long >::Type blaze::simd_ulong_t
 The intrinsic data type for 'unsigned long int'.
 
typedef IntrinsicTrait< complex< short > >::Type blaze::simd_cshort_t
 The intrinsic data type for 'complex<short>'.
 
typedef IntrinsicTrait< complex< unsigned short > >::Type blaze::simd_cushort_t
 The intrinsic data type for 'complex<unsigned short>'.
 
typedef IntrinsicTrait< complex< int > >::Type blaze::simd_cint_t
 The intrinsic data type for 'complex<int>'.
 
typedef IntrinsicTrait< complex< unsigned int > >::Type blaze::simd_cuint_t
 The intrinsic data type for 'complex<unsigned int>'.
 
typedef IntrinsicTrait< complex< long > >::Type blaze::simd_clong_t
 The intrinsic data type for 'complex<long int>'.
 
typedef IntrinsicTrait< complex< unsigned long > >::Type blaze::simd_culong_t
 The intrinsic data type for 'complex<unsigned long int>'.
 

Functions

template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, simd_int16_t >::Type blaze::loada (const T *address)
 Loads a vector of 2-byte integral values. More...
 
BLAZE_ALWAYS_INLINE simd_float_t blaze::loada (const float *address)
 Loads a vector of 'float' values. More...
 
BLAZE_ALWAYS_INLINE simd_double_t blaze::loada (const double *address)
 Loads a vector of 'double' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, simd_cint16_t >::Type blaze::loada (const complex< T > *address)
 Loads a vector of 2-byte integral complex values. More...
 
BLAZE_ALWAYS_INLINE simd_cfloat_t blaze::loada (const complex< float > *address)
 Loads a vector of 'complex<float>' values. More...
 
BLAZE_ALWAYS_INLINE simd_cdouble_t blaze::loada (const complex< double > *address)
 Loads a vector of 'complex<double>' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, simd_int16_t >::Type blaze::loadu (const T *address)
 Loads a vector of 2-byte integral values. More...
 
BLAZE_ALWAYS_INLINE simd_float_t blaze::loadu (const float *address)
 Loads a vector of 'float' values. More...
 
BLAZE_ALWAYS_INLINE simd_double_t blaze::loadu (const double *address)
 Loads a vector of 'double' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, simd_cint16_t >::Type blaze::loadu (const complex< T > *address)
 Loads a vector of 2-byte integral complex values. More...
 
BLAZE_ALWAYS_INLINE simd_cfloat_t blaze::loadu (const complex< float > *address)
 Loads a vector of 'complex<float>' values. More...
 
BLAZE_ALWAYS_INLINE simd_cdouble_t blaze::loadu (const complex< double > *address)
 Loads a vector of 'complex<double>' values. More...
 
BLAZE_ALWAYS_INLINE int16_t blaze::sum (const simd_int16_t &a)
 Returns the sum of all elements in the 16-bit integral intrinsic vector. More...
 
BLAZE_ALWAYS_INLINE int32_t blaze::sum (const simd_int32_t &a)
 Returns the sum of all elements in the 32-bit integral intrinsic vector. More...
 
BLAZE_ALWAYS_INLINE int64_t blaze::sum (const simd_int64_t &a)
 Returns the sum of all elements in the 64-bit integral intrinsic vector. More...
 
BLAZE_ALWAYS_INLINE float blaze::sum (const simd_float_t &a)
 Returns the sum of all elements in the single precision floating point intrinsic vector. More...
 
BLAZE_ALWAYS_INLINE double blaze::sum (const simd_double_t &a)
 Returns the sum of all elements in the double precision floating point intrinsic vector. More...
 
BLAZE_ALWAYS_INLINE complex< int8_t > blaze::sum (const simd_cint8_t &a)
 Returns the sum of all elements in the 8-bit integral complex intrinsic vector. More...
 
BLAZE_ALWAYS_INLINE complex< int16_t > blaze::sum (const simd_cint16_t &a)
 Returns the sum of all elements in the 16-bit integral complex intrinsic vector. More...
 
BLAZE_ALWAYS_INLINE complex< int32_t > blaze::sum (const simd_cint32_t &a)
 Returns the sum of all elements in the 32-bit integral complex intrinsic vector. More...
 
BLAZE_ALWAYS_INLINE complex< int64_t > blaze::sum (const simd_cint64_t &a)
 Returns the sum of all elements in the 64-bit integral complex intrinsic vector. More...
 
BLAZE_ALWAYS_INLINE complex< float > blaze::sum (const simd_cfloat_t &a)
 Returns the sum of all elements in the single precision complex intrinsic vector. More...
 
BLAZE_ALWAYS_INLINE complex< double > blaze::sum (const simd_cdouble_t &a)
 Returns the sum of all elements in the double precision complex intrinsic vector. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, simd_int16_t >::Type blaze::set (T value)
 Sets all values in the vector to the given 2-byte integral value. More...
 
BLAZE_ALWAYS_INLINE simd_float_t blaze::set (float value)
 Sets all values in the vector to the given 'float' value. More...
 
BLAZE_ALWAYS_INLINE simd_double_t blaze::set (double value)
 Sets all values in the vector to the given 'double' value. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, simd_cint16_t >::Type blaze::set (complex< T > value)
 Sets all values in the vector to the given 2-byte integral complex value. More...
 
BLAZE_ALWAYS_INLINE simd_cfloat_t blaze::set (const complex< float > &value)
 Sets all values in the vector to the given 'complex<float>' value. More...
 
BLAZE_ALWAYS_INLINE simd_cdouble_t blaze::set (const complex< double > &value)
 Sets all values in the vector to the given 'complex<double>' value. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (simd_int8_t &value)
 Setting an integral intrinsic type with 16 8-bit data values to zero. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (simd_int16_t &value)
 Setting an integral intrinsic type with 8 16-bit data values to zero. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (simd_int32_t &value)
 Setting an integral intrinsic type with 4 32-bit data values to zero. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (simd_int64_t &value)
 Setting an integral intrinsic type with 2 64-bit data values to zero. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (simd_float_t &value)
 Setting a floating point intrinsic type with 4 32-bit single precision data values to zero. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (simd_double_t &value)
 Setting a floating point intrinsic type with 4 32-bit double precision data values to zero. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (simd_cfloat_t &value)
 Setting a floating point intrinsic type with 4 32-bit single precision complex values to zero. More...
 
BLAZE_ALWAYS_INLINE void blaze::setzero (simd_cdouble_t &value)
 Setting a floating point intrinsic type with 4 32-bit double precision complex values to zero. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > > >::Type blaze::storea (T *address, const simd_int16_t &value)
 Aligned store of a vector of 2-byte integral values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 4UL > > >::Type blaze::storea (T *address, const simd_int32_t &value)
 Aligned store of a vector of 4-byte integral values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 8UL > > >::Type blaze::storea (T *address, const simd_int64_t &value)
 Aligned store of a vector of 8-byte integral values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storea (float *address, const simd_float_t &value)
 Aligned store of a vector of 'float' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storea (double *address, const simd_double_t &value)
 Aligned store of a vector of 'double' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > > >::Type blaze::storea (complex< T > *address, const simd_cint16_t &value)
 Aligned store of a vector of 2-byte integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 4UL > > >::Type blaze::storea (complex< T > *address, const simd_cint32_t &value)
 Aligned store of a vector of 4-byte integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 8UL > > >::Type blaze::storea (complex< T > *address, const simd_cint64_t &value)
 Aligned store of a vector of 8-byte integral complex values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storea (complex< float > *address, const simd_cfloat_t &value)
 Aligned store of a vector of 'complex<float>' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storea (complex< double > *address, const simd_cdouble_t &value)
 Aligned store of a vector of 'complex<double>' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > > >::Type blaze::storeu (T *address, const simd_int16_t &value)
 Unaligned store of a vector of 2-byte integral values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 4UL > > >::Type blaze::storeu (T *address, const simd_int32_t &value)
 Unaligned store of a vector of 4-byte integral values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 8UL > > >::Type blaze::storeu (T *address, const simd_int64_t &value)
 Unaligned store of a vector of 8-byte integral values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storeu (float *address, const simd_float_t &value)
 Unaligned store of a vector of 'float' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storeu (double *address, const simd_double_t &value)
 Unaligned store of a vector of 'double' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > > >::Type blaze::storeu (complex< T > *address, const simd_cint16_t &value)
 Unaligned store of a vector of 2-byte integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 4UL > > >::Type blaze::storeu (complex< T > *address, const simd_cint32_t &value)
 Unaligned store of a vector of 4-byte integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 8UL > > >::Type blaze::storeu (complex< T > *address, const simd_cint64_t &value)
 Unaligned store of a vector of 8-byte integral complex values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storeu (complex< float > *address, const simd_cfloat_t &value)
 Unaligned store of a vector of 'complex<float>' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::storeu (complex< double > *address, const simd_cdouble_t &value)
 Unaligned store of a vector of 'complex<double>' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > > >::Type blaze::stream (T *address, const simd_int16_t &value)
 Aligned, non-temporal store of a vector of 2-byte integral values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 4UL > > >::Type blaze::stream (T *address, const simd_int32_t &value)
 Aligned, non-temporal store of a vector of 4-byte integral values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 8UL > > >::Type blaze::stream (T *address, const simd_int64_t &value)
 Aligned, non-temporal store of a vector of 8-byte integral values. More...
 
BLAZE_ALWAYS_INLINE void blaze::stream (float *address, const simd_float_t &value)
 Aligned, non-temporal store of a vector of 'float' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::stream (double *address, const simd_double_t &value)
 Aligned, non-temporal store of a vector of 'double' values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > > >::Type blaze::stream (complex< T > *address, const simd_cint16_t &value)
 Aligned, non-temporal store of a vector of 2-byte integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 4UL > > >::Type blaze::stream (complex< T > *address, const simd_cint32_t &value)
 Aligned, non-temporal store of a vector of 4-byte integral complex values. More...
 
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 8UL > > >::Type blaze::stream (complex< T > *address, const simd_cint64_t &value)
 Aligned, non-temporal store of a vector of 8-byte integral complex values. More...
 
BLAZE_ALWAYS_INLINE void blaze::stream (complex< float > *address, const simd_cfloat_t &value)
 Aligned, non-temporal store of a vector of 'complex<float>' values. More...
 
BLAZE_ALWAYS_INLINE void blaze::stream (complex< double > *address, const simd_cdouble_t &value)
 Aligned, non-temporal store of a vector of 'complex<double>' values. More...
 
BLAZE_ALWAYS_INLINE simd_int8_t blaze::conj (const simd_int8_t &a)
 Complex conjugate of a vector of 8-bit integral values. More...
 
BLAZE_ALWAYS_INLINE simd_int16_t blaze::conj (const simd_int16_t &a)
 Complex conjugate of a vector of 16-bit integral values. More...
 
BLAZE_ALWAYS_INLINE simd_int32_t blaze::conj (const simd_int32_t &a)
 Complex conjugate of a vector of 32-bit integral values. More...
 
BLAZE_ALWAYS_INLINE simd_int64_t blaze::conj (const simd_int64_t &a)
 Complex conjugate of a vector of 64-bit integral values. More...
 
BLAZE_ALWAYS_INLINE simd_float_t blaze::conj (const simd_float_t &a)
 Complex conjugate of a vector of single precision floating point values. More...
 
BLAZE_ALWAYS_INLINE simd_double_t blaze::conj (const simd_double_t &a)
 Complex conjugate of a vector of double precision floating point values. More...
 

Detailed Description

Function Documentation

simd_int8_t blaze::conj ( const simd_int8_t a)

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

Parameters
aThe vector of 8-bit integral values.
Returns
The complex conjugate values.
simd_int16_t blaze::conj ( const simd_int16_t a)

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

Parameters
aThe vector of 16-bit integral values.
Returns
The complex conjugate values.
simd_int32_t blaze::conj ( const simd_int32_t a)

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

Parameters
aThe vector of 32-bit integral values.
Returns
The complex conjugate values.
simd_int64_t blaze::conj ( const simd_int64_t a)

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

Parameters
aThe vector of 64-bit integral values.
Returns
The complex conjugate values.
simd_float_t blaze::conj ( const simd_float_t a)

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.
simd_double_t blaze::conj ( const simd_double_t a)

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.
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> >, simd_int16_t >::Type blaze::loada ( const T *  address)

Loads a vector of 2-byte integral values.

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

This function loads 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.

BLAZE_ALWAYS_INLINE simd_float_t blaze::loada ( const float *  address)

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 simd_double_t blaze::loada ( const double *  address)

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.

template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> >, simd_cint16_t >::Type blaze::loada ( const complex< T > *  address)

Loads a vector of 2-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 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.

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

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 simd_cdouble_t blaze::loada ( const complex< double > *  address)

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 EnableIf< And< IsIntegral<T>, HasSize<T,2UL> >, simd_int16_t >::Type blaze::loadu ( const T *  address)

Loads a vector of 2-byte integral values.

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

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

BLAZE_ALWAYS_INLINE simd_float_t blaze::loadu ( const float *  address)

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 load function, the given address is not required to be properly aligned.

BLAZE_ALWAYS_INLINE simd_double_t blaze::loadu ( const double *  address)

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 load function, the given address is not required to be properly aligned.

template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> >, simd_cint16_t >::Type blaze::loadu ( const complex< T > *  address)

Loads a vector of 2-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 2-byte integral complex values. In contrast to the according load function, the given address is not required to be properly aligned.

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

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 load function, the given address is not required to be properly aligned.

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

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 load function, the given address is not required to be properly aligned.

template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> >, simd_int16_t >::Type blaze::set ( value)

Sets all values in the vector to the given 2-byte integral value.

Parameters
valueThe given 2-byte integral value.
Returns
The set vector of 2-byte integral values.
BLAZE_ALWAYS_INLINE simd_float_t blaze::set ( float  value)

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 simd_double_t blaze::set ( double  value)

Sets all values in the vector to the given 'double' value.

Parameters
valueThe given 'double' value.
Returns
The set vector of 'double' values.
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> >, simd_cint16_t >::Type blaze::set ( complex< T >  value)

Sets all values in the vector to the given 2-byte integral complex value.

Parameters
valueThe given 2-byte integral complex value.
Returns
The set vector of 2-byte integral complex values.
BLAZE_ALWAYS_INLINE simd_cfloat_t blaze::set ( const complex< float > &  value)

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 simd_cdouble_t blaze::set ( const complex< double > &  value)

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.
BLAZE_ALWAYS_INLINE void blaze::setzero ( simd_int8_t value)

Setting an integral intrinsic type with 16 8-bit data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void
BLAZE_ALWAYS_INLINE void blaze::setzero ( simd_int16_t value)

Setting an integral intrinsic type with 8 16-bit data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void
BLAZE_ALWAYS_INLINE void blaze::setzero ( simd_int32_t value)

Setting an integral intrinsic type with 4 32-bit data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void
BLAZE_ALWAYS_INLINE void blaze::setzero ( simd_int64_t value)

Setting an integral intrinsic type with 2 64-bit data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void
BLAZE_ALWAYS_INLINE void blaze::setzero ( simd_float_t value)

Setting a floating point intrinsic type with 4 32-bit single precision data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void
BLAZE_ALWAYS_INLINE void blaze::setzero ( simd_double_t value)

Setting a floating point intrinsic type with 4 32-bit double precision data values to zero.

Parameters
valueThe value to be set to zero.
Returns
void
BLAZE_ALWAYS_INLINE void blaze::setzero ( simd_cfloat_t value)

Setting a floating point intrinsic type with 4 32-bit single precision complex values to zero.

Parameters
valueThe value to be set to zero.
Returns
void
BLAZE_ALWAYS_INLINE void blaze::setzero ( simd_cdouble_t value)

Setting a floating point intrinsic type with 4 32-bit double precision complex values to zero.

Parameters
valueThe value to be set to zero.
Returns
void
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> > >::Type blaze::storea ( T *  address,
const simd_int16_t value 
)

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 T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,4UL> > >::Type blaze::storea ( T *  address,
const simd_int32_t value 
)

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 T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,8UL> > >::Type blaze::storea ( T *  address,
const simd_int64_t value 
)

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.

BLAZE_ALWAYS_INLINE void blaze::storea ( float *  address,
const simd_float_t value 
)

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 ( double *  address,
const simd_double_t value 
)

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.

template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> > >::Type blaze::storea ( complex< T > *  address,
const simd_cint16_t value 
)

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 T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,4UL> > >::Type blaze::storea ( complex< T > *  address,
const simd_cint32_t value 
)

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 T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,8UL> > >::Type blaze::storea ( complex< T > *  address,
const simd_cint64_t value 
)

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.

BLAZE_ALWAYS_INLINE void blaze::storea ( complex< float > *  address,
const simd_cfloat_t value 
)

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.

BLAZE_ALWAYS_INLINE void blaze::storea ( complex< double > *  address,
const simd_cdouble_t value 
)

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 T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> > >::Type blaze::storeu ( T *  address,
const simd_int16_t value 
)

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 store function, the given address is not required to be properly aligned.

template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,4UL> > >::Type blaze::storeu ( T *  address,
const simd_int32_t value 
)

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 store function, the given address is not required to be properly aligned.

template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,8UL> > >::Type blaze::storeu ( T *  address,
const simd_int64_t value 
)

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 store function, the given address is not required to be properly aligned.

BLAZE_ALWAYS_INLINE void blaze::storeu ( float *  address,
const simd_float_t value 
)

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 store function, the given address is not required to be properly aligned.

BLAZE_ALWAYS_INLINE void blaze::storeu ( double *  address,
const simd_double_t value 
)

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 store function, the given address is not required to be properly aligned.

template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> > >::Type blaze::storeu ( complex< T > *  address,
const simd_cint16_t value 
)

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 store function, the given address is not required to be properly aligned.

template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,4UL> > >::Type blaze::storeu ( complex< T > *  address,
const simd_cint32_t value 
)

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 store function, the given address is not required to be properly aligned.

template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,8UL> > >::Type blaze::storeu ( complex< T > *  address,
const simd_cint64_t value 
)

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 store function, the given address is not required to be properly aligned.

BLAZE_ALWAYS_INLINE void blaze::storeu ( complex< float > *  address,
const simd_cfloat_t value 
)

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 store function, the given address is not required to be properly aligned.

BLAZE_ALWAYS_INLINE void blaze::storeu ( complex< double > *  address,
const simd_cdouble_t value 
)

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 store function, the given address is not required to be properly aligned.

template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> > >::Type blaze::stream ( T *  address,
const simd_int16_t value 
)

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 T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,4UL> > >::Type blaze::stream ( T *  address,
const simd_int32_t value 
)

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 T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,8UL> > >::Type blaze::stream ( T *  address,
const simd_int64_t value 
)

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
BLAZE_ALWAYS_INLINE void blaze::stream ( float *  address,
const simd_float_t value 
)

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 ( double *  address,
const simd_double_t value 
)

Aligned, non-temporal store of a vector of 'double' values.

Parameters
addressThe target address.
valueThe 'double' vector to be streamed.
Returns
void
template<typename T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> > >::Type blaze::stream ( complex< T > *  address,
const simd_cint16_t value 
)

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 T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,4UL> > >::Type blaze::stream ( complex< T > *  address,
const simd_cint32_t value 
)

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 T >
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,8UL> > >::Type blaze::stream ( complex< T > *  address,
const simd_cint64_t value 
)

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
BLAZE_ALWAYS_INLINE void blaze::stream ( complex< float > *  address,
const simd_cfloat_t value 
)

Aligned, non-temporal store of a vector of 'complex<float>' values.

Parameters
addressThe target address.
valueThe 'complex<float>' vector to be streamed.
Returns
void
BLAZE_ALWAYS_INLINE void blaze::stream ( complex< double > *  address,
const simd_cdouble_t value 
)

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 int16_t blaze::sum ( const simd_int16_t a)

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

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

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

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

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

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

Returns the sum of all elements in the single precision floating point intrinsic vector.

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

Returns the sum of all elements in the double precision floating point intrinsic vector.

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

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

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

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

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

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

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

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

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

Returns the sum of all elements in the single precision complex intrinsic vector.

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

Returns the sum of all elements in the double precision complex intrinsic vector.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.