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 >
EnableIf< IsIntegral< T >
, Load< T, sizeof(T)>
>::Type::Type 
blaze::load (const T *address)
 Loads a vector of integral values. More...
 
sse_float_t blaze::load (const float *address)
 Loads a vector of 'float' values. More...
 
sse_double_t blaze::load (const double *address)
 Loads a vector of 'double' values. More...
 
sse_cfloat_t blaze::load (const complex< float > *address)
 Loads a vector of 'complex<float>' values. More...
 
sse_cdouble_t blaze::load (const complex< double > *address)
 Loads a vector of 'complex<double>' values. More...
 
template<typename T >
EnableIf< IsIntegral< T >
, Loadu< T, sizeof(T)>
>::Type::Type 
blaze::loadu (const T *address)
 Loads a vector of integral values. More...
 
sse_float_t blaze::loadu (const float *address)
 Loads a vector of 'float' values. More...
 
sse_double_t blaze::loadu (const double *address)
 Loads a vector of 'double' values. More...
 
sse_cfloat_t blaze::loadu (const complex< float > *address)
 Loads a vector of 'complex<float>' values. More...
 
sse_cdouble_t blaze::loadu (const complex< double > *address)
 Loads a vector of 'complex<double>' values. More...
 
int16_t blaze::sum (const sse_int16_t &a)
 Returns the sum of all elements in the 16-bit integral intrinsic vector. More...
 
int32_t blaze::sum (const sse_int32_t &a)
 Returns the sum of all elements in the 32-bit integral intrinsic vector. More...
 
int64_t blaze::sum (const sse_int64_t &a)
 Returns the sum of all elements in the 64-bit integral intrinsic vector. More...
 
float blaze::sum (const sse_float_t &a)
 Returns the sum of all elements in the single precision floating point intrinsic vector. More...
 
double blaze::sum (const sse_double_t &a)
 Returns the sum of all elements in the double precision floating point intrinsic vector. More...
 
complex< float > blaze::sum (const sse_cfloat_t &a)
 Returns the sum of all elements in the single precision complex intrinsic vector. More...
 
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 >
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...
 
sse_float_t blaze::set (float value)
 Sets all values in the vector to the given 'float' value. More...
 
sse_double_t blaze::set (double value)
 Sets all values in the vector to the given 'double' value. More...
 
sse_cfloat_t blaze::set (const complex< float > &value)
 Sets all values in the vector to the given 'complex<float>' value. More...
 
sse_cdouble_t blaze::set (const complex< double > &value)
 Sets all values in the vector to the given 'complex<double>' value. More...
 
void blaze::setzero (sse_int8_t &value)
 Setting an integral intrinsic type with 16 8-bit data values to zero. More...
 
void blaze::setzero (sse_int16_t &value)
 Setting an integral intrinsic type with 8 16-bit data values to zero. More...
 
void blaze::setzero (sse_int32_t &value)
 Setting an integral intrinsic type with 4 32-bit data values to zero. More...
 
void blaze::setzero (sse_int64_t &value)
 Setting an integral intrinsic type with 2 64-bit data values to zero. More...
 
void blaze::setzero (sse_float_t &value)
 Setting a floating point intrinsic type with 4 32-bit single precision data values to zero. More...
 
void blaze::setzero (sse_double_t &value)
 Setting a floating point intrinsic type with 4 32-bit double precision data values to zero. More...
 
void blaze::setzero (sse_cfloat_t &value)
 Setting a floating point intrinsic type with 4 32-bit single precision complex values to zero. More...
 
void blaze::setzero (sse_cdouble_t &value)
 Setting a floating point intrinsic type with 4 32-bit double precision complex values to zero. More...
 
void blaze::store (float *address, const sse_float_t &value)
 Aligned store of a vector of 'float' values. More...
 
void blaze::store (double *address, const sse_double_t &value)
 Aligned store of a vector of 'double' values. More...
 
void blaze::store (complex< float > *address, const sse_cfloat_t &value)
 Aligned store of a vector of 'complex<float>' values. More...
 
void blaze::store (complex< double > *address, const sse_cdouble_t &value)
 Aligned store of a vector of 'complex<double>' values. More...
 
void blaze::storeu (float *address, const sse_float_t &value)
 Unaligned store of a vector of 'float' values. More...
 
void blaze::storeu (double *address, const sse_double_t &value)
 Unaligned store of a vector of 'double' values. More...
 
void blaze::storeu (complex< float > *address, const sse_cfloat_t &value)
 Unaligned store of a vector of 'complex<float>' values. More...
 
void blaze::storeu (complex< double > *address, const sse_cdouble_t &value)
 Unaligned store of a vector of 'complex<double>' values. More...
 
void blaze::stream (float *address, const sse_float_t &value)
 Aligned, non-temporal store of a vector of 'float' values. More...
 
void blaze::stream (double *address, const sse_double_t &value)
 Aligned, non-temporal store of a vector of 'double' values. More...
 
void blaze::stream (complex< float > *address, const sse_cfloat_t &value)
 Aligned, non-temporal store of a vector of 'complex<float>' values. More...
 
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 >
EnableIf< IsIntegral<T>, Load<T,sizeof(T)> >::Type::Type blaze::load ( const T *  address)
inline

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.

sse_float_t blaze::load ( const float *  address)
inline

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.

sse_double_t blaze::load ( const double *  address)
inline

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.

sse_cfloat_t blaze::load ( const complex< float > *  address)
inline

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.

sse_cdouble_t blaze::load ( const complex< double > *  address)
inline

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 >
EnableIf< IsIntegral<T>, Loadu<T,sizeof(T)> >::Type::Type blaze::loadu ( const T *  address)
inline

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.

sse_float_t blaze::loadu ( const float *  address)
inline

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.

sse_double_t blaze::loadu ( const double *  address)
inline

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.

sse_cfloat_t blaze::loadu ( const complex< float > *  address)
inline

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.

sse_cdouble_t blaze::loadu ( const complex< double > *  address)
inline

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 >
EnableIf< IsIntegral<T>, Set<T,sizeof(T)> >::Type::Type blaze::set ( value)
inline

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

Parameters
valueThe given integral value.
Returns
The set vector of integral values.
sse_float_t blaze::set ( float  value)
inline

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

Parameters
valueThe given 'float' value.
Returns
The set vector of 'float' values.
sse_double_t blaze::set ( double  value)
inline

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

Parameters
valueThe given 'double' value.
Returns
The set vector of 'double' values.
sse_cfloat_t blaze::set ( const complex< float > &  value)
inline

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

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.
void blaze::setzero ( sse_int8_t &  value)
inline

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

Parameters
valueThe value to be set to zero.
Returns
void
void blaze::setzero ( sse_int16_t &  value)
inline

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

Parameters
valueThe value to be set to zero.
Returns
void
void blaze::setzero ( sse_int32_t &  value)
inline

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

Parameters
valueThe value to be set to zero.
Returns
void
void blaze::setzero ( sse_int64_t &  value)
inline

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

Parameters
valueThe value to be set to zero.
Returns
void
void blaze::setzero ( sse_float_t &  value)
inline

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
void blaze::setzero ( sse_double_t &  value)
inline

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
void blaze::setzero ( sse_cfloat_t &  value)
inline

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
void blaze::setzero ( sse_cdouble_t &  value)
inline

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
void blaze::store ( float *  address,
const sse_float_t &  value 
)
inline

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.

void blaze::store ( double *  address,
const sse_double_t &  value 
)
inline

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.

void blaze::store ( complex< float > *  address,
const sse_cfloat_t &  value 
)
inline

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.

void blaze::store ( complex< double > *  address,
const sse_cdouble_t &  value 
)
inline

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.

void blaze::storeu ( float *  address,
const sse_float_t &  value 
)
inline

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.

void blaze::storeu ( double *  address,
const sse_double_t &  value 
)
inline

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.

void blaze::storeu ( complex< float > *  address,
const sse_cfloat_t &  value 
)
inline

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.

void blaze::storeu ( complex< double > *  address,
const sse_cdouble_t &  value 
)
inline

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.

void blaze::stream ( float *  address,
const sse_float_t &  value 
)
inline

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

Parameters
addressThe target address.
valueThe 'float' vector to be streamed.
Returns
void
void blaze::stream ( double *  address,
const sse_double_t &  value 
)
inline

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

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

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

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

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

Parameters
addressThe target address.
valueThe 'complex<double>' vector to be streamed.
Returns
void
int16_t blaze::sum ( const sse_int16_t &  a)
inline

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.
int32_t blaze::sum ( const sse_int32_t &  a)
inline

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.
int64_t blaze::sum ( const sse_int64_t &  a)
inline

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.
float blaze::sum ( const sse_float_t &  a)
inline

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.
double blaze::sum ( const sse_double_t &  a)
inline

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.
complex<float> blaze::sum ( const sse_cfloat_t &  a)
inline

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.
complex<double> blaze::sum ( const sse_cdouble_t &  a)
inline

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.