![]() |
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... | |
simd_int8_t blaze::conj | ( | const simd_int8_t & | a | ) |
Complex conjugate of a vector of 8-bit integral values.
a | The vector of 8-bit integral values. |
simd_int16_t blaze::conj | ( | const simd_int16_t & | a | ) |
Complex conjugate of a vector of 16-bit integral values.
a | The vector of 16-bit integral values. |
simd_int32_t blaze::conj | ( | const simd_int32_t & | a | ) |
Complex conjugate of a vector of 32-bit integral values.
a | The vector of 32-bit integral values. |
simd_int64_t blaze::conj | ( | const simd_int64_t & | a | ) |
Complex conjugate of a vector of 64-bit integral values.
a | The vector of 64-bit integral values. |
simd_float_t blaze::conj | ( | const simd_float_t & | a | ) |
Complex conjugate of a vector of single precision floating point values.
a | The vector of single precision floating point values. |
simd_double_t blaze::conj | ( | const simd_double_t & | a | ) |
Complex conjugate of a vector of double precision floating point values.
a | The vector of double precision floating point values. |
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.
address | The first integral value to be loaded. |
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.
address | The first 'float' value to be loaded. |
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.
address | The first 'double' value to be loaded. |
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 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.
address | The first integral complex value to be loaded. |
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.
address | The first 'complex<float>' value to be loaded. |
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.
address | The first 'complex<double>' value to be loaded. |
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.
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.
address | The first integral value to be loaded. |
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.
address | The first 'float' value to be loaded. |
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.
address | The first 'double' value to be loaded. |
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.
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.
address | The first integral complex value to be loaded. |
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.
address | The first 'complex<float>' value to be loaded. |
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.
address | The first 'complex<double>' value to be loaded. |
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.
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.
value | The given 2-byte integral value. |
BLAZE_ALWAYS_INLINE simd_float_t blaze::set | ( | float | value | ) |
Sets all values in the vector to the given 'float' value.
value | The given 'float' value. |
BLAZE_ALWAYS_INLINE simd_double_t blaze::set | ( | double | value | ) |
Sets all values in the vector to the given 'double' value.
value | The given 'double' value. |
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.
value | The given 2-byte integral complex value. |
BLAZE_ALWAYS_INLINE simd_cfloat_t blaze::set | ( | const complex< float > & | value | ) |
Sets all values in the vector to the given 'complex<float>' value.
value | The given 'complex<float>' value. |
BLAZE_ALWAYS_INLINE simd_cdouble_t blaze::set | ( | const complex< double > & | value | ) |
Sets all values in the vector to the given 'complex<double>' value.
value | The given 'complex<double>' value. |
BLAZE_ALWAYS_INLINE void blaze::setzero | ( | simd_int8_t & | value | ) |
Setting an integral intrinsic type with 16 8-bit data values to zero.
value | The value to be set to zero. |
BLAZE_ALWAYS_INLINE void blaze::setzero | ( | simd_int16_t & | value | ) |
Setting an integral intrinsic type with 8 16-bit data values to zero.
value | The value to be set to zero. |
BLAZE_ALWAYS_INLINE void blaze::setzero | ( | simd_int32_t & | value | ) |
Setting an integral intrinsic type with 4 32-bit data values to zero.
value | The value to be set to zero. |
BLAZE_ALWAYS_INLINE void blaze::setzero | ( | simd_int64_t & | value | ) |
Setting an integral intrinsic type with 2 64-bit data values to zero.
value | The value to be set to zero. |
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.
value | The value to be set to zero. |
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.
value | The value to be set to zero. |
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.
value | The value to be set to zero. |
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.
value | The value to be set to zero. |
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.
address | The target address. |
value | The 2-byte integral vector to be stored. |
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.
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.
address | The target address. |
value | The 4-byte integral vector to be stored. |
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.
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.
address | The target address. |
value | The 8-byte integral vector to be stored. |
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.
address | The target address. |
value | The 'float' vector to be stored. |
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.
address | The target address. |
value | The 'double' vector to be stored. |
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 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.
address | The target address. |
value | The 2-byte integral complex vector to be stored. |
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.
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.
address | The target address. |
value | The 4-byte integral complex vector to be stored. |
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.
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.
address | The target address. |
value | The 8-byte integral complex vector to be stored. |
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.
address | The target address. |
value | The 'complex<float>' vector to be stored. |
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.
address | The target address. |
value | The 'complex<double>' vector to be stored. |
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.
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.
address | The target address. |
value | The 2-byte integral vector to be stored. |
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.
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.
address | The target address. |
value | The 4-byte integral vector to be stored. |
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.
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.
address | The target address. |
value | The 8-byte integral vector to be stored. |
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.
address | The target address. |
value | The 'float' vector to be stored. |
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.
address | The target address. |
value | The 'double' vector to be stored. |
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.
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.
address | The target address. |
value | The 2-byte integral complex vector to be stored. |
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.
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.
address | The target address. |
value | The 4-byte integral complex vector to be stored. |
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.
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.
address | The target address. |
value | The 8-byte integral complex vector to be stored. |
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.
address | The target address. |
value | The 'complex<float>' vector to be stored. |
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.
address | The target address. |
value | The 'complex<double>' vector to be stored. |
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.
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.
address | The target address. |
value | The 2-byte integral vector to be streamed. |
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.
address | The target address. |
value | The 4-byte integral vector to be streamed. |
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.
address | The target address. |
value | The 8-byte integral vector to be streamed. |
BLAZE_ALWAYS_INLINE void blaze::stream | ( | float * | address, |
const simd_float_t & | value | ||
) |
Aligned, non-temporal store of a vector of 'float' values.
address | The target address. |
value | The 'float' vector to be streamed. |
BLAZE_ALWAYS_INLINE void blaze::stream | ( | double * | address, |
const simd_double_t & | value | ||
) |
Aligned, non-temporal store of a vector of 'double' values.
address | The target address. |
value | The 'double' vector to be streamed. |
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.
address | The target address. |
value | The 2-byte integral complex vector to be streamed. |
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.
address | The target address. |
value | The 4-byte integral complex vector to be streamed. |
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.
address | The target address. |
value | The 8-byte integral complex vector to be streamed. |
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.
address | The target address. |
value | The 'complex<float>' vector to be streamed. |
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.
address | The target address. |
value | The 'complex<double>' vector to be streamed. |
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.
a | The vector to be sumed up. |
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.
a | The vector to be sumed up. |
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.
a | The vector to be sumed up. |
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.
a | The vector to be sumed up. |
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.
a | The vector to be sumed up. |
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.
a | The vector to be sumed up. |
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.
a | The vector to be sumed up. |
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.
a | The vector to be sumed up. |
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.
a | The vector to be sumed up. |
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.
a | The vector to be sumed up. |
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.
a | The vector to be sumed up. |