All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
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
< IsIntegral< T >, Load< T,
sizeof(T)> >::Type::Type 
blaze::load (const T *address)
 Loads a vector of 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
< IsIntegral< T >, Loadu< T,
sizeof(T)> >::Type::Type 
blaze::loadu (const T *address)
 Loads a vector of 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
< IsIntegral< T >, Set< T,
sizeof(T)> >::Type::Type 
blaze::set (T value)
 Sets all values in the vector to the given 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
< IsIntegral< T > >::Type 
blaze::store (T *address, const typename Store< T, sizeof(T)>::Type &value)
 Aligned store of a vector of 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
< IsIntegral< T > >::Type 
blaze::storeu (T *address, const typename Storeu< T, sizeof(T)>::Type &value)
 Unaligned store of a vector of 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
< IsIntegral< T > >::Type 
blaze::stream (T *address, const typename Stream< T, sizeof(T)>::Type &value)
 Aligned, non-temporal store of a vector of 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< IsIntegral<T>, Load<T,sizeof(T)> >::Type::Type blaze::load ( const T *  address)

Loads a vector of integral values.

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

This function loads a vector of 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< IsIntegral<T>, Loadu<T,sizeof(T)> >::Type::Type blaze::loadu ( const T *  address)

Loads a vector of integral values.

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

This function loads a vector of 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< IsIntegral<T>, Set<T,sizeof(T)> >::Type::Type blaze::set ( value)

Sets all values in the vector to the given integral value.

Parameters
valueThe given integral value.
Returns
The set vector of 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< IsIntegral<T> >::Type blaze::store ( T *  address,
const typename Store< T, sizeof(T)>::Type &  value 
)

Aligned store of a vector of integral values.

Parameters
addressThe target address.
valueThe integral vector to be stored.
Returns
void

This function stores a vector of 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< IsIntegral<T> >::Type blaze::storeu ( T *  address,
const typename Storeu< T, sizeof(T)>::Type &  value 
)

Unaligned store of a vector of integral values.

Parameters
addressThe target address.
valueThe integral vector to be stored.
Returns
void

This function stores a vector of 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< IsIntegral<T> >::Type blaze::stream ( T *  address,
const typename Stream< T, sizeof(T)>::Type &  value 
)

Aligned, non-temporal store of a vector of integral values.

Parameters
addressThe target address.
valueThe 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.