All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Modules | Classes | Functions

Modules

 Dense Vectors
 
 Sparse Vectors
 

Classes

struct  blaze::Vector< VT, TF >
 Base class for N-dimensional vectors.The Vector class is a base class for all arbitrarily sized (N-dimensional) dense and sparse vector classes within the Blaze library. It provides an abstraction from the actual type of the vector, but enables a conversion back to this type via the 'Curiously Recurring Template Pattern' (CRTP). More...
 

Functions

template<typename VT , bool TF>
size_t blaze::size (Vector< VT, TF > &v)
 Returns the current size/dimension of the vector.
 

Vector global functions

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::assign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the assignment of a vector to a vector.
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::addAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the addition assignment of a vector to a vector.
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::subAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the subtraction assignment of a vector to a vector.
 
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::multAssign (Vector< VT1, TF1 > &lhs, const Vector< VT2, TF2 > &rhs)
 Default implementation of the multiplication assignment of a vector to a vector.
 

Vector operators

template<typename T1 , typename T2 >
const MultTrait< typename
T1::ElementType, typename
T2::ElementType >::Type 
blaze::operator, (const Vector< T1, false > &lhs, const Vector< T2, false > &rhs)
 Multiplication operator for the scalar product (inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $).
 
template<typename T1 , typename T2 >
const MultTrait< typename
T1::ElementType, typename
T2::ElementType >::Type 
blaze::operator, (const Vector< T1, false > &lhs, const Vector< T2, true > &rhs)
 Multiplication operator for the scalar product (inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $).
 
template<typename T1 , typename T2 >
const MultTrait< typename
T1::ElementType, typename
T2::ElementType >::Type 
blaze::operator, (const Vector< T1, true > &lhs, const Vector< T2, false > &rhs)
 Multiplication operator for the scalar product (inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $).
 
template<typename T1 , typename T2 >
const MultTrait< typename
T1::ElementType, typename
T2::ElementType >::Type 
blaze::operator, (const Vector< T1, true > &lhs, const Vector< T2, true > &rhs)
 Multiplication operator for the scalar product (inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $).
 
template<typename VT , bool TF>
std::ostream & blaze::operator<< (std::ostream &os, const Vector< VT, TF > &v)
 Global output operator for dense and sparse vectors.
 

Detailed Description

Function Documentation

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::addAssign ( Vector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the addition assignment of a vector to a vector.

Parameters
lhsThe target left-hand side vector.
rhsThe right-hand side vector to be added.
Returns
void

This function implements the default addition assignment of a vector to a vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::assign ( Vector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the assignment of a vector to a vector.

Parameters
lhsThe target left-hand side vector.
rhsThe right-hand side vector to be assigned.
Returns
void

This function implements the default assignment of a vector to another vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::multAssign ( Vector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the multiplication assignment of a vector to a vector.

Parameters
lhsThe target left-hand side vector.
rhsThe right-hand side vector to be multiplied.
Returns
void

This function implements the default multiplication assignment of a vector to a vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.

template<typename T1 , typename T2 >
const MultTrait< typename T1::ElementType, typename T2::ElementType >::Type blaze::operator, ( const Vector< T1, false > &  lhs,
const Vector< T2, false > &  rhs 
)
inline

Multiplication operator for the scalar product (inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $).

Parameters
lhsThe left-hand side vector for the inner product.
rhsThe right-hand side vector for the inner product.
Returns
The scalar product.
template<typename T1 , typename T2 >
const MultTrait< typename T1::ElementType, typename T2::ElementType >::Type blaze::operator, ( const Vector< T1, false > &  lhs,
const Vector< T2, true > &  rhs 
)
inline

Multiplication operator for the scalar product (inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $).

Parameters
lhsThe left-hand side vector for the inner product.
rhsThe right-hand side vector for the inner product.
Returns
The scalar product.
template<typename T1 , typename T2 >
const MultTrait< typename T1::ElementType, typename T2::ElementType >::Type blaze::operator, ( const Vector< T1, true > &  lhs,
const Vector< T2, false > &  rhs 
)
inline

Multiplication operator for the scalar product (inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $).

Parameters
lhsThe left-hand side vector for the inner product.
rhsThe right-hand side vector for the inner product.
Returns
The scalar product.
template<typename T1 , typename T2 >
const MultTrait< typename T1::ElementType, typename T2::ElementType >::Type blaze::operator, ( const Vector< T1, true > &  lhs,
const Vector< T2, true > &  rhs 
)
inline

Multiplication operator for the scalar product (inner product) of two vectors ( $ s=(\vec{a},\vec{b}) $).

Parameters
lhsThe left-hand side vector for the inner product.
rhsThe right-hand side vector for the inner product.
Returns
The scalar product.
template<typename VT , bool TF>
std::ostream & blaze::operator<< ( std::ostream &  os,
const Vector< VT, TF > &  v 
)
inline

Global output operator for dense and sparse vectors.

Parameters
osReference to the output stream.
vReference to a constant vector object.
Returns
Reference to the output stream.
template<typename VT , bool TF>
size_t blaze::size ( Vector< VT, TF > &  v)
inline

Returns the current size/dimension of the vector.

Parameters
vThe given vector.
Returns
The size of the vector.
template<typename VT1 , bool TF1, typename VT2 , bool TF2>
void blaze::subAssign ( Vector< VT1, TF1 > &  lhs,
const Vector< VT2, TF2 > &  rhs 
)
inline

Default implementation of the subtraction assignment of a vector to a vector.

Parameters
lhsThe target left-hand side vector.
rhsThe right-hand side vector to be subtracted.
Returns
void

This function implements the default subtraction assignment of a vector to a vector.
This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors. Instead of using this function use the assignment operator.