![]() |
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::sse_int8_t |
Intrinsic type for 8-bit integral data values. More... | |
class | blaze::sse_int16_t |
Intrinsic type for 16-bit integral data values. More... | |
class | blaze::sse_int32_t |
Intrinsic type for 32-bit integral data values. More... | |
class | blaze::sse_int64_t |
Intrinsic type for 64-bit integral data values. More... | |
class | blaze::sse_float_t |
Intrinsic type for 32-bit single precision floating point data values. More... | |
class | blaze::sse_double_t |
Intrinsic type for 64-bit double precision floating point data values. More... | |
class | blaze::sse_cfloat_t |
Intrinsic type for 32-bit single precision complex values. More... | |
class | blaze::sse_cdouble_t |
Intrinsic type for 64-bit double precision complex values. More... | |
Typedefs | |
typedef IntrinsicTrait< short >::Type | blaze::sse_short_t |
The intrinsic data type for 'short'. | |
typedef IntrinsicTrait< unsigned short >::Type | blaze::sse_ushort_t |
The intrinsic data type for 'unsigned short'. | |
typedef IntrinsicTrait< int >::Type | blaze::sse_int_t |
The intrinsic data type for 'int'. | |
typedef IntrinsicTrait< unsigned int >::Type | blaze::sse_uint_t |
The intrinsic data type for 'unsigned int'. | |
typedef IntrinsicTrait< long >::Type | blaze::sse_long_t |
The intrinsic data type for 'long int'. | |
typedef IntrinsicTrait< unsigned long >::Type | blaze::sse_ulong_t |
The intrinsic data type for 'unsigned long int'. | |
Functions | |
template<typename T > | |
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral< T >, HasSize< T, 2UL > >, sse_int16_t >::Type | blaze::load (const T *address) |
Loads a vector of 2-byte integral values. More... | |
BLAZE_ALWAYS_INLINE sse_float_t | blaze::load (const float *address) |
Loads a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE sse_double_t | blaze::load (const double *address) |
Loads a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE sse_cfloat_t | blaze::load (const complex< float > *address) |
Loads a vector of 'complex<float>' values. More... | |
BLAZE_ALWAYS_INLINE sse_cdouble_t | blaze::load (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 > >, sse_int16_t >::Type | blaze::loadu (const T *address) |
Loads a vector of 2-byte integral values. More... | |
BLAZE_ALWAYS_INLINE sse_float_t | blaze::loadu (const float *address) |
Loads a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE sse_double_t | blaze::loadu (const double *address) |
Loads a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE sse_cfloat_t | blaze::loadu (const complex< float > *address) |
Loads a vector of 'complex<float>' values. More... | |
BLAZE_ALWAYS_INLINE sse_cdouble_t | blaze::loadu (const complex< double > *address) |
Loads a vector of 'complex<double>' values. More... | |
BLAZE_ALWAYS_INLINE int16_t | blaze::sum (const sse_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 sse_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 sse_int64_t &a) |
Returns the sum of all elements in the 64-bit integral intrinsic vector. More... | |
BLAZE_ALWAYS_INLINE float | blaze::sum (const sse_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 sse_double_t &a) |
Returns the sum of all elements in the double precision floating point intrinsic vector. More... | |
BLAZE_ALWAYS_INLINE complex< float > | blaze::sum (const sse_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 sse_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 > >, sse_int16_t >::Type | blaze::set (T value) |
Sets all values in the vector to the given 2-byte integral value. More... | |
BLAZE_ALWAYS_INLINE sse_float_t | blaze::set (float value) |
Sets all values in the vector to the given 'float' value. More... | |
BLAZE_ALWAYS_INLINE sse_double_t | blaze::set (double value) |
Sets all values in the vector to the given 'double' value. More... | |
BLAZE_ALWAYS_INLINE sse_cfloat_t | blaze::set (const complex< float > &value) |
Sets all values in the vector to the given 'complex<float>' value. More... | |
BLAZE_ALWAYS_INLINE sse_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 (sse_int8_t &value) |
Setting an integral intrinsic type with 16 8-bit data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | blaze::setzero (sse_int16_t &value) |
Setting an integral intrinsic type with 8 16-bit data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | blaze::setzero (sse_int32_t &value) |
Setting an integral intrinsic type with 4 32-bit data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | blaze::setzero (sse_int64_t &value) |
Setting an integral intrinsic type with 2 64-bit data values to zero. More... | |
BLAZE_ALWAYS_INLINE void | blaze::setzero (sse_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 (sse_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 (sse_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 (sse_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::store (T *address, const sse_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::store (T *address, const sse_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::store (T *address, const sse_int64_t &value) |
Aligned store of a vector of 8-byte integral values. More... | |
BLAZE_ALWAYS_INLINE void | blaze::store (float *address, const sse_float_t &value) |
Aligned store of a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE void | blaze::store (double *address, const sse_double_t &value) |
Aligned store of a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE void | blaze::store (complex< float > *address, const sse_cfloat_t &value) |
Aligned store of a vector of 'complex<float>' values. More... | |
BLAZE_ALWAYS_INLINE void | blaze::store (complex< double > *address, const sse_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 sse_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 sse_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 sse_int64_t &value) |
Unaligned store of a vector of 8-byte integral values. More... | |
BLAZE_ALWAYS_INLINE void | blaze::storeu (float *address, const sse_float_t &value) |
Unaligned store of a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE void | blaze::storeu (double *address, const sse_double_t &value) |
Unaligned store of a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE void | blaze::storeu (complex< float > *address, const sse_cfloat_t &value) |
Unaligned store of a vector of 'complex<float>' values. More... | |
BLAZE_ALWAYS_INLINE void | blaze::storeu (complex< double > *address, const sse_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 sse_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 sse_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 sse_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 sse_float_t &value) |
Aligned, non-temporal store of a vector of 'float' values. More... | |
BLAZE_ALWAYS_INLINE void | blaze::stream (double *address, const sse_double_t &value) |
Aligned, non-temporal store of a vector of 'double' values. More... | |
BLAZE_ALWAYS_INLINE void | blaze::stream (complex< float > *address, const sse_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 sse_cdouble_t &value) |
Aligned, non-temporal store of a vector of 'complex<double>' values. More... | |
BLAZE_ALWAYS_INLINE EnableIf< And< IsIntegral<T>, HasSize<T,2UL> >, sse_int16_t >::Type blaze::load | ( | 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 sse_float_t blaze::load | ( | 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 sse_double_t blaze::load | ( | 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 sse_cfloat_t blaze::load | ( | 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 sse_cdouble_t blaze::load | ( | 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> >, sse_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 sse_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 sse_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 sse_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 sse_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> >, sse_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 sse_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 sse_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 sse_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 sse_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 | ( | sse_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 | ( | sse_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 | ( | sse_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 | ( | sse_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 | ( | sse_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 | ( | sse_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 | ( | sse_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 | ( | sse_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::store | ( | T * | address, |
const sse_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::store | ( | T * | address, |
const sse_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::store | ( | T * | address, |
const sse_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::store | ( | float * | address, |
const sse_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::store | ( | double * | address, |
const sse_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 void blaze::store | ( | complex< float > * | address, |
const sse_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::store | ( | complex< double > * | address, |
const sse_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 sse_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 sse_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 sse_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 sse_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 sse_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 void blaze::storeu | ( | complex< float > * | address, |
const sse_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 sse_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 sse_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 sse_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 sse_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 sse_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 sse_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 void blaze::stream | ( | complex< float > * | address, |
const sse_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 sse_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 sse_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 sse_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 sse_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 sse_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 sse_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<float> blaze::sum | ( | const sse_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 sse_cdouble_t & | a | ) |
Returns the sum of all elements in the double precision complex intrinsic vector.
a | The vector to be sumed up. |