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

Detailed Description

Function Documentation

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.

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 sse_float_t blaze::load ( 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 sse_double_t blaze::load ( 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.

BLAZE_ALWAYS_INLINE sse_cfloat_t blaze::load ( 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 sse_cdouble_t blaze::load ( 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> >, sse_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 sse_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 sse_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.

BLAZE_ALWAYS_INLINE sse_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 sse_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> >, sse_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 sse_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 sse_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.
BLAZE_ALWAYS_INLINE sse_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 sse_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 ( sse_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 ( sse_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 ( sse_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 ( sse_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 ( sse_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 ( sse_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 ( sse_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 ( sse_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::store ( T *  address,
const sse_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::store ( T *  address,
const sse_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::store ( T *  address,
const sse_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::store ( float *  address,
const sse_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::store ( double *  address,
const sse_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.

BLAZE_ALWAYS_INLINE void blaze::store ( complex< float > *  address,
const sse_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::store ( complex< double > *  address,
const sse_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 sse_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 sse_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 sse_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 sse_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 sse_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.

BLAZE_ALWAYS_INLINE void blaze::storeu ( complex< float > *  address,
const sse_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 sse_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 sse_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 sse_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 sse_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 sse_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 sse_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
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.

Parameters
addressThe target address.
valueThe 'complex<float>' vector to be streamed.
Returns
void
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.

Parameters
addressThe target address.
valueThe 'complex<double>' vector to be streamed.
Returns
void
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.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
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.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
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.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
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.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
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.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
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.

Parameters
aThe vector to be sumed up.
Returns
The sum of all vector elements.
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.

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