All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Types | Public Member Functions | Private Types | List of all members
blaze::StaticMatrix< typename, size_t, size_t, bool > Class Template Reference

Efficient implementation of a fixed-sized matrix.The StaticMatrix class template is the representation of a fixed-size matrix with statically allocated elements of arbitrary type. The type of the elements, the number of rows and columns and the storage order of the matrix can be specified via the four template parameters: More...

#include <StaticMatrix.h>

Inherits blaze::DenseMatrix< StaticMatrix< Type, M, N, SO >, SO >, and blaze::AlignedStorage< Type >.

Public Types

enum  { vectorizable = IsVectorizable<Type>::value }
 Compilation flag for intrinsic optimization. More...
 
typedef StaticMatrix< Type, M,
N, SO > 
This
 Type of this StaticMatrix instance.
 
typedef This ResultType
 Result type for expression template evaluations.
 
typedef StaticMatrix< Type, M,
N,!SO > 
OppositeType
 Result type with opposite storage order for expression template evaluations.
 
typedef StaticMatrix< Type, N,
M,!SO > 
TransposeType
 Transpose type for expression template evaluations.
 
typedef Type ElementType
 Type of the matrix elements.
 
typedef IT::Type IntrinsicType
 Intrinsic type of the matrix elements.
 
typedef const Type & ReturnType
 Return type for expression template evaluations.
 
typedef const ThisCompositeType
 Data type for composite expression templates.
 
typedef Type & Reference
 Reference to a non-constant matrix value.
 
typedef const Type & ConstReference
 Reference to a constant matrix value.
 
typedef Type * Iterator
 Iterator over non-constant elements.
 
typedef const Type * ConstIterator
 Iterator over constant elements.
 
typedef MT MatrixType
 Type of the matrix.
 

Public Member Functions

template<typename Other , bool SO2>
StaticMatrix< Type, M, N, SO > & operator= (const StaticMatrix< Other, M, N, SO2 > &rhs)
 Assignment operator for different StaticMatrix instances. More...
 
template<typename MT , bool SO2>
StaticMatrix< Type, M, N, SO > & operator= (const Matrix< MT, SO2 > &rhs)
 Assignment operator for different matrices. More...
 
template<typename MT , bool SO2>
StaticMatrix< Type, M, N, SO > & operator+= (const Matrix< MT, SO2 > &rhs)
 Addition assignment operator for the addition of a matrix ( $ A+=B $). More...
 
template<typename MT , bool SO2>
StaticMatrix< Type, M, N, SO > & operator-= (const Matrix< MT, SO2 > &rhs)
 Subtraction assignment operator for the subtraction of a matrix ( $ A-=B $). More...
 
template<typename MT , bool SO2>
StaticMatrix< Type, M, N, SO > & operator*= (const Matrix< MT, SO2 > &rhs)
 Multiplication assignment operator for the multiplication of a matrix ( $ A*=B $). More...
 
template<typename Other >
EnableIf< IsNumeric< Other >
, StaticMatrix< Type, M, N, SO >
>::Type & 
operator*= (Other rhs)
 Multiplication assignment operator for the multiplication between a matrix and a scalar value ( $ A*=s $). More...
 
template<typename Other >
EnableIf< IsNumeric< Other >
, StaticMatrix< Type, M, N, SO >
>::Type & 
operator/= (Other rhs)
 Division assignment operator for the division of a matrix by a scalar value ( $ A/=s $). More...
 
template<typename Other >
StaticMatrix< Type, M, N, SO > & scale (const Other &scalar)
 Scaling of the matrix by the scalar value scalar ( $ A*=s $). More...
 
template<typename MT , bool SO2>
DisableIf< typename
StaticMatrix< Type, M, N, SO >
::BLAZE_TEMPLATE
VectorizedAssign< MT > >::Type 
assign (const DenseMatrix< MT, SO2 > &rhs)
 Default implementation of the assignment of a dense matrix. More...
 
template<typename MT , bool SO2>
EnableIf< typename
StaticMatrix< Type, M, N, SO >
::BLAZE_TEMPLATE
VectorizedAssign< MT > >::Type 
assign (const DenseMatrix< MT, SO2 > &rhs)
 Intrinsic optimized implementation of the assignment of a dense matrix. More...
 
template<typename MT , bool SO2>
DisableIf< typename
StaticMatrix< Type, M, N, SO >
::BLAZE_TEMPLATE
VectorizedAddAssign< MT >
>::Type 
addAssign (const DenseMatrix< MT, SO2 > &rhs)
 Default implementation of the addition assignment of a row-major dense matrix. More...
 
template<typename MT , bool SO2>
EnableIf< typename
StaticMatrix< Type, M, N, SO >
::BLAZE_TEMPLATE
VectorizedAddAssign< MT >
>::Type 
addAssign (const DenseMatrix< MT, SO2 > &rhs)
 Intrinsic optimized implementation of the addition assignment of a dense matrix. More...
 
template<typename MT , bool SO2>
DisableIf< typename
StaticMatrix< Type, M, N, SO >
::BLAZE_TEMPLATE
VectorizedSubAssign< MT >
>::Type 
subAssign (const DenseMatrix< MT, SO2 > &rhs)
 Default implementation of the subtraction assignment of a dense matrix. More...
 
template<typename MT , bool SO2>
EnableIf< typename
StaticMatrix< Type, M, N, SO >
::BLAZE_TEMPLATE
VectorizedSubAssign< MT >
>::Type 
subAssign (const DenseMatrix< MT, SO2 > &rhs)
 Intrinsic optimized implementation of the subtraction assignment of a dense matrix. More...
 
MatrixTypeoperator~ ()
 Conversion operator for non-constant matrices. More...
 
const MatrixTypeoperator~ () const
 Conversion operator for constant matrices. More...
 
Constructors
 StaticMatrix ()
 The default constructor for StaticMatrix. More...
 
 StaticMatrix (const Type &init)
 Constructor for a homogenous initialization of all elements. More...
 
 StaticMatrix (const StaticMatrix &m)
 The copy constructor for StaticMatrix. More...
 
template<typename Other , bool SO2>
 StaticMatrix (const StaticMatrix< Other, M, N, SO2 > &m)
 Conversion constructor from different StaticMatrix instances. More...
 
template<typename MT , bool SO2>
 StaticMatrix (const Matrix< MT, SO2 > &m)
 Conversion constructor from different matrices. More...
 
 StaticMatrix (const Type &v1, const Type &v2)
 Constructor for $ 1 \times 2 $ and $ 2 \times 1 $ matrices. More...
 
 StaticMatrix (const Type &v1, const Type &v2, const Type &v3)
 Constructor for $ 1 \times 3 $ and $ 3 \times 1 $ matrices. More...
 
 StaticMatrix (const Type &v1, const Type &v2, const Type &v3, const Type &v4)
 Constructor for $ 1 \times 4 $, $ 2 \times 2 $, and $ 4 \times 1 $ matrices. More...
 
 StaticMatrix (const Type &v1, const Type &v2, const Type &v3, const Type &v4, const Type &v5)
 Constructor for $ 1 \times 5 $ and $ 5 \times 1 $ matrices. More...
 
 StaticMatrix (const Type &v1, const Type &v2, const Type &v3, const Type &v4, const Type &v5, const Type &v6)
 Constructor for $ 1 \times 6 $, $ 2 \times 3 $, $ 3 \times 2 $, and $ 6 \times 1 $ matrices. More...
 
 StaticMatrix (const Type &v1, const Type &v2, const Type &v3, const Type &v4, const Type &v5, const Type &v6, const Type &v7)
 Constructor for $ 1 \times 7 $ and $ 7 \times 1 $ matrices. More...
 
 StaticMatrix (const Type &v1, const Type &v2, const Type &v3, const Type &v4, const Type &v5, const Type &v6, const Type &v7, const Type &v8)
 Constructor for $ 1 \times 8 $ and $ 8 \times 1 $ matrices. More...
 
 StaticMatrix (const Type &v1, const Type &v2, const Type &v3, const Type &v4, const Type &v5, const Type &v6, const Type &v7, const Type &v8, const Type &v9)
 Constructor for $ 1 \times 9 $, $ 3 \times 3 $, and $ 9 \times 1 $ matrices. More...
 
 StaticMatrix (const Type &v1, const Type &v2, const Type &v3, const Type &v4, const Type &v5, const Type &v6, const Type &v7, const Type &v8, const Type &v9, const Type &v10)
 Constructor for $ 1 \times 10 $, $ 2 \times 5 $, $ 5 \times 2 $, and $ 10 \times 1 $ matrices. More...
 
Data access functions
Reference operator() (size_t i, size_t j)
 2D-access to the matrix elements. More...
 
ConstReference operator() (size_t i, size_t j) const
 2D-access to the matrix elements. More...
 
Type * data ()
 Low-level data access to the matrix elements. More...
 
const Type * data () const
 Low-level data access to the matrix elements. More...
 
Type * data (size_t i)
 Low-level data access to the matrix elements of row/column i. More...
 
const Type * data (size_t i) const
 Low-level data access to the matrix elements of row/column i. More...
 
Iterator begin (size_t i)
 Returns an iterator to the first element of row/column i. More...
 
ConstIterator begin (size_t i) const
 Returns an iterator to the first element of row/column i. More...
 
ConstIterator cbegin (size_t i) const
 Returns an iterator to the first element of row/column i. More...
 
Iterator end (size_t i)
 Returns an iterator just past the last element of row/column i. More...
 
ConstIterator end (size_t i) const
 Returns an iterator just past the last element of row/column i. More...
 
ConstIterator cend (size_t i) const
 Returns an iterator just past the last element of row/column i. More...
 
Assignment operators
StaticMatrixoperator= (const Type &set)
 Homogenous assignment to all matrix elements. More...
 
StaticMatrixoperator= (const StaticMatrix &rhs)
 Copy assignment operator for StaticMatrix. More...
 
template<typename Other , bool SO2>
StaticMatrixoperator= (const StaticMatrix< Other, M, N, SO2 > &rhs)
 
template<typename MT , bool SO2>
StaticMatrixoperator= (const Matrix< MT, SO2 > &rhs)
 
template<typename MT , bool SO2>
StaticMatrixoperator+= (const Matrix< MT, SO2 > &rhs)
 
template<typename MT , bool SO2>
StaticMatrixoperator-= (const Matrix< MT, SO2 > &rhs)
 
template<typename MT , bool SO2>
StaticMatrixoperator*= (const Matrix< MT, SO2 > &rhs)
 
template<typename Other >
EnableIf< IsNumeric< Other >
, StaticMatrix >::Type & 
operator*= (Other rhs)
 
template<typename Other >
EnableIf< IsNumeric< Other >
, StaticMatrix >::Type & 
operator/= (Other rhs)
 
Utility functions
size_t rows () const
 Returns the current number of rows of the matrix. More...
 
size_t columns () const
 Returns the current number of columns of the matrix. More...
 
size_t spacing () const
 Returns the spacing between the beginning of two rows. More...
 
size_t capacity () const
 Returns the maximum capacity of the matrix. More...
 
size_t capacity (size_t i) const
 Returns the current capacity of the specified row/column. More...
 
size_t nonZeros () const
 Returns the total number of non-zero elements in the matrix. More...
 
size_t nonZeros (size_t i) const
 Returns the number of non-zero elements in the specified row/column. More...
 
void reset ()
 Reset to the default initial values. More...
 
void reset (size_t i)
 Reset the specified row/column to the default initial values. More...
 
StaticMatrixtranspose ()
 Transposing the matrix. More...
 
bool isDiagonal () const
 Checks if the matrix is diagonal. More...
 
bool isSymmetric () const
 Checks if the matrix is symmetric. More...
 
template<typename Other >
StaticMatrixscale (const Other &scalar)
 
void swap (StaticMatrix &m)
 Swapping the contents of two static matrices. More...
 
Expression template evaluation functions
template<typename Other >
bool canAlias (const Other *alias) const
 Returns whether the matrix can alias with the given address alias. More...
 
template<typename Other >
bool isAliased (const Other *alias) const
 Returns whether the matrix is aliased with the given address alias. More...
 
IntrinsicType get (size_t i, size_t j) const
 Access to the intrinsic elements of the matrix. More...
 
template<typename MT , bool SO2>
DisableIf< VectorizedAssign
< MT > >::Type 
assign (const DenseMatrix< MT, SO2 > &rhs)
 
template<typename MT , bool SO2>
EnableIf< VectorizedAssign< MT >
>::Type 
assign (const DenseMatrix< MT, SO2 > &rhs)
 
template<typename MT >
void assign (const SparseMatrix< MT, SO > &rhs)
 Default implementation of the assignment of a row-major sparse matrix. More...
 
template<typename MT >
void assign (const SparseMatrix< MT,!SO > &rhs)
 Default implementation of the assignment of a column-major sparse matrix. More...
 
template<typename MT , bool SO2>
DisableIf< VectorizedAddAssign
< MT > >::Type 
addAssign (const DenseMatrix< MT, SO2 > &rhs)
 
template<typename MT , bool SO2>
EnableIf< VectorizedAddAssign
< MT > >::Type 
addAssign (const DenseMatrix< MT, SO2 > &rhs)
 
template<typename MT >
void addAssign (const SparseMatrix< MT, SO > &rhs)
 Default implementation of the addition assignment of a row-major sparse matrix. More...
 
template<typename MT >
void addAssign (const SparseMatrix< MT,!SO > &rhs)
 Default implementation of the addition assignment of a column-major sparse matrix. More...
 
template<typename MT , bool SO2>
DisableIf< VectorizedSubAssign
< MT > >::Type 
subAssign (const DenseMatrix< MT, SO2 > &rhs)
 
template<typename MT , bool SO2>
EnableIf< VectorizedSubAssign
< MT > >::Type 
subAssign (const DenseMatrix< MT, SO2 > &rhs)
 
template<typename MT >
void subAssign (const SparseMatrix< MT, SO > &rhs)
 Default implementation of the subtraction assignment of a row-major sparse matrix. More...
 
template<typename MT >
void subAssign (const SparseMatrix< MT,!SO > &rhs)
 Default implementation of the subtraction assignment of a column-major sparse matrix. More...
 

Private Types

enum  { NN = N + ( IT::size - ( N % IT::size ) ) % IT::size }
 Alignment adjustment.
 
typedef IntrinsicTrait< Type > IT
 Intrinsic trait for the vector element type.
 

Private Attributes

Member variables
Type v_ [M *NN]
 The statically allocated matrix elements. More...
 

Detailed Description

template<typename, size_t, size_t, bool>
class blaze::StaticMatrix< typename, size_t, size_t, bool >

Efficient implementation of a fixed-sized matrix.

The StaticMatrix class template is the representation of a fixed-size matrix with statically allocated elements of arbitrary type. The type of the elements, the number of rows and columns and the storage order of the matrix can be specified via the four template parameters:

template< typename Type, size_t M, size_t N, bool SO >

Depending on the storage order, the matrix elements are either stored in a row-wise fashion or in a column-wise fashion. Given the 2x3 matrix

\[\left(\begin{array}{*{3}{c}} 1 & 2 & 3 \\ 4 & 5 & 6 \\ \end{array}\right)\]


in case of row-major order the elements are stored in the order

\[\left(\begin{array}{*{6}{c}} 1 & 2 & 3 & 4 & 5 & 6. \\ \end{array}\right)\]

In case of column-major order the elements are stored in the order

\[\left(\begin{array}{*{6}{c}} 1 & 4 & 2 & 5 & 3 & 6. \\ \end{array}\right)\]

The use of StaticMatrix is very natural and intuitive. All operations (addition, subtraction, multiplication, scaling, ...) can be performed on all possible combination of row-major and column-major dense and sparse matrices with fitting element types. The following example gives an impression of the use of StaticMatrix:

StaticMatrix<double,2UL,3UL,rowMajor> A; // Default constructed, non-initialized, row-major 2x3 matrix
A(0,0) = 1.0; A(0,1) = 2.0; A(0,2) = 3.0; // Initialization of the first row
A(1,0) = 4.0; A(1,1) = 5.0; A(1,2) = 6.0; // Initialization of the second row
DynamicMatrix<float,2UL,3UL,columnMajor> B; // Default constructed column-major single precision 2x3 matrix
B(0,0) = 1.0; B(0,1) = 3.0; B(0,2) = 5.0; // Initialization of the first row
B(1,0) = 2.0; B(1,1) = 4.0; B(1,2) = 6.0; // Initialization of the second row
CompressedMatrix<float> C( 2, 3 ); // Empty row-major sparse single precision matrix
StaticMatrix<float,3UL,2UL> D( 4.0F ); // Directly, homogeneously initialized single precision 3x2 matrix
StaticMatrix<double,2UL,3UL,rowMajor> E( A ); // Creation of a new row-major matrix as a copy of A
StaticMatrix<double,2UL,2UL,columnMajor> F; // Creation of a default column-major matrix
E = A + B; // Matrix addition and assignment to a row-major matrix
E = A - C; // Matrix subtraction and assignment to a column-major matrix
F = A * D; // Matrix multiplication between two matrices of different element types
A *= 2.0; // In-place scaling of matrix A
E = 2.0 * B; // Scaling of matrix B
E = B * 2.0; // Scaling of matrix B
E += A - B; // Addition assignment
E -= A + C; // Subtraction assignment
F *= A * D; // Multiplication assignment

Member Enumeration Documentation

template<typename , size_t , size_t , bool >
anonymous enum

Compilation flag for intrinsic optimization.

The vectorizable compilation flag indicates whether expressions the vector is involved in can be optimized via intrinsics. In case the element type of the vector is a vectorizable data type, the vectorizable compilation flag is set to true, otherwise it is set to false.

Constructor & Destructor Documentation

template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( )
inlineexplicit

The default constructor for StaticMatrix.

All matrix elements are initialized to the default value (i.e. 0 for integral data types).

template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const Type &  init)
inlineexplicit

Constructor for a homogenous initialization of all elements.

Parameters
initInitial value for all matrix elements.
template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const StaticMatrix< typename, size_t, size_t, bool > &  m)
inline

The copy constructor for StaticMatrix.

Parameters
mMatrix to be copied.

The copy constructor is explicitly defined in order to enable/facilitate NRV optimization.

template<typename Type , size_t M, size_t N, bool SO>
template<typename Other , bool SO2>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const StaticMatrix< Other, M, N, SO2 > &  m)
inline

Conversion constructor from different StaticMatrix instances.

Parameters
mMatrix to be copied.
template<typename Type , size_t M, size_t N, bool SO>
template<typename MT , bool SO2>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const Matrix< MT, SO2 > &  m)
inline

Conversion constructor from different matrices.

Parameters
mMatrix to be copied.
Exceptions
std::invalid_argumentInvalid setup of static matrix.

This constructor initializes the static matrix from the given matrix. In case the size of the given matrix does not match the size of the static matrix (i.e. the number of rows is not M or the number of columns is not N), a std::invalid_argument exception is thrown.

template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const Type &  v1,
const Type &  v2 
)
inline

Constructor for $ 1 \times 2 $ and $ 2 \times 1 $ matrices.

Parameters
v1The initializer for the first matrix element.
v2The initializer for the second matrix element.

This constructor offers the option to directly initialize a newly created $ 1 \times 2 $ and $ 2 \times 1 $ matrix. The following example demonstrates this by creating the matrix

\[\left(\begin{array}{*{2}{c}} 1 & 2 \\ \end{array}\right)\]

:

template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const Type &  v1,
const Type &  v2,
const Type &  v3 
)
inline

Constructor for $ 1 \times 3 $ and $ 3 \times 1 $ matrices.

Parameters
v1The initializer for the first matrix element.
v2The initializer for the second matrix element.
v3The initializer for the third matrix element.

This constructor offers the option to directly initialize a newly created $ 1 \times 3 $ and $ 3 \times 1 $ matrix. The following example demonstrates this by creating the matrix

\[\left(\begin{array}{*{3}{c}} 1 & 2 & 3 \\ \end{array}\right)\]

:

template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const Type &  v1,
const Type &  v2,
const Type &  v3,
const Type &  v4 
)
inline

Constructor for $ 1 \times 4 $, $ 2 \times 2 $, and $ 4 \times 1 $ matrices.

Parameters
v1The initializer for the first matrix element.
v2The initializer for the second matrix element.
v3The initializer for the third matrix element.
v4The initializer for the fourth matrix element.

This constructor offers the option to directly initialize a newly created $ 1 \times 4 $, $ 2 \times 2 $ and $ 3 \times 1 $ matrix. The following example demonstrates this by creating the matrix

\[\left(\begin{array}{*{2}{c}} 1 & 2 \\ 3 & 4 \\ \end{array}\right)\]

:

template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const Type &  v1,
const Type &  v2,
const Type &  v3,
const Type &  v4,
const Type &  v5 
)
inline

Constructor for $ 1 \times 5 $ and $ 5 \times 1 $ matrices.

Parameters
v1The initializer for the first matrix element.
v2The initializer for the second matrix element.
v3The initializer for the third matrix element.
v4The initializer for the fourth matrix element.
v5The initializer for the fifth matrix element.

This constructor offers the option to directly initialize a newly created $ 1 \times 5 $, and $ 5 \times 1 $ matrix. The following example demonstrates this by creating the matrix

\[\left(\begin{array}{*{5}{c}} 1 & 2 & 3 & 4 & 5 \\ \end{array}\right)\]

:

template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const Type &  v1,
const Type &  v2,
const Type &  v3,
const Type &  v4,
const Type &  v5,
const Type &  v6 
)
inline

Constructor for $ 1 \times 6 $, $ 2 \times 3 $, $ 3 \times 2 $, and $ 6 \times 1 $ matrices.

Parameters
v1The initializer for the first matrix element.
v2The initializer for the second matrix element.
v3The initializer for the third matrix element.
v4The initializer for the fourth matrix element.
v5The initializer for the fifth matrix element.
v6The initializer for the sixth matrix element.

This constructor offers the option to directly initialize a newly created $ 1 \times 6 $, $ 2 \times 3 $, $ 3 \times 2 $, and $ 6 \times 1 $ matrix. The following example demonstrates this by creating the matrix

\[\left(\begin{array}{*{3}{c}} 1 & 2 & 3 \\ 4 & 5 & 6 \\ \end{array}\right)\]

:

blaze::StaticMatrix<int,2,3,false> A( 1, 2, 3, 4, 5, 6 );
template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const Type &  v1,
const Type &  v2,
const Type &  v3,
const Type &  v4,
const Type &  v5,
const Type &  v6,
const Type &  v7 
)
inline

Constructor for $ 1 \times 7 $ and $ 7 \times 1 $ matrices.

Parameters
v1The initializer for the first matrix element.
v2The initializer for the second matrix element.
v3The initializer for the third matrix element.
v4The initializer for the fourth matrix element.
v5The initializer for the fifth matrix element.
v6The initializer for the sixth matrix element.
v7The initializer for the seventh matrix element.

This constructor offers the option to directly initialize a newly created $ 1 \times 7 $, and $ 7 \times 1 $ matrix. The following example demonstrates this by creating the matrix

\[\left(\begin{array}{*{7}{c}} 1 & 2 & 3 & 4 & 5 & 6 & 7 \\ \end{array}\right)\]

:

blaze::StaticMatrix<int,1,7,false> A( 1, 2, 3, 4, 5, 6, 7 );
template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const Type &  v1,
const Type &  v2,
const Type &  v3,
const Type &  v4,
const Type &  v5,
const Type &  v6,
const Type &  v7,
const Type &  v8 
)
inline

Constructor for $ 1 \times 8 $ and $ 8 \times 1 $ matrices.

Parameters
v1The initializer for the first matrix element.
v2The initializer for the second matrix element.
v3The initializer for the third matrix element.
v4The initializer for the fourth matrix element.
v5The initializer for the fifth matrix element.
v6The initializer for the sixth matrix element.
v7The initializer for the seventh matrix element.
v8The initializer for the eigth matrix element.

This constructor offers the option to directly initialize a newly created $ 1 \times 8 $, $ 2 \times 4 $, $ 4 \times 2 $, and $ 8 \times 1 $ matrix. The following example demonstrates this by creating the matrix

\[\left(\begin{array}{*{4}{c}} 1 & 2 & 3 & 4 \\ 5 & 6 & 7 & 8 \\ \end{array}\right)\]

:

blaze::StaticMatrix<int,2,4,false> A( 1, 2, 3, 4, 5, 6, 7, 8 );
template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const Type &  v1,
const Type &  v2,
const Type &  v3,
const Type &  v4,
const Type &  v5,
const Type &  v6,
const Type &  v7,
const Type &  v8,
const Type &  v9 
)
inline

Constructor for $ 1 \times 9 $, $ 3 \times 3 $, and $ 9 \times 1 $ matrices.

Parameters
v1The initializer for the first matrix element.
v2The initializer for the second matrix element.
v3The initializer for the third matrix element.
v4The initializer for the fourth matrix element.
v5The initializer for the fifth matrix element.
v6The initializer for the sixth matrix element.
v7The initializer for the seventh matrix element.
v8The initializer for the eigth matrix element.
v9The initializer for the ninth matrix element.

This constructor offers the option to directly initialize a newly created $ 1 \times 9 $, $ 3 \times 3 $, and $ 9 \times 1 $ matrix. The following example demonstrates this by creating the matrix

\[\left(\begin{array}{*{3}{c}} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \\ \end{array}\right)\]

:

blaze::StaticMatrix<int,3,3,false> A( 1, 2, 3, 4, 5, 6, 7, 8, 9 );
template<typename Type , size_t M, size_t N, bool SO>
blaze::StaticMatrix< Type, M, N, SO >::StaticMatrix ( const Type &  v1,
const Type &  v2,
const Type &  v3,
const Type &  v4,
const Type &  v5,
const Type &  v6,
const Type &  v7,
const Type &  v8,
const Type &  v9,
const Type &  v10 
)
inline

Constructor for $ 1 \times 10 $, $ 2 \times 5 $, $ 5 \times 2 $, and $ 10 \times 1 $ matrices.

Parameters
v1The initializer for the first matrix element.
v2The initializer for the second matrix element.
v3The initializer for the third matrix element.
v4The initializer for the fourth matrix element.
v5The initializer for the fifth matrix element.
v6The initializer for the sixth matrix element.
v7The initializer for the seventh matrix element.
v8The initializer for the eigth matrix element.
v9The initializer for the ninth matrix element.
v10The initializer for the tenth matrix element.

This constructor offers the option to directly initialize a newly created $ 1 \times 10 $, $ 2 \times 5 $, $ 5 \times 2 $, and $ 10 \times 1 $ matrix. The following example demonstrates this by creating the matrix

\[\left(\begin{array}{*{5}{c}} 1 & 2 & 3 & 4 & 5 \\ 6 & 7 & 8 & 8 & 10 \\ \end{array}\right)\]

:

blaze::StaticMatrix<int,2,5,false> A( 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 );

Member Function Documentation

template<typename Type , size_t M, size_t N, bool SO>
template<typename MT >
void blaze::StaticMatrix< Type, M, N, SO >::addAssign ( const SparseMatrix< MT, SO > &  rhs)
inline

Default implementation of the addition assignment of a row-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be added.
Returns
void

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 Type , size_t M, size_t N, bool SO>
template<typename MT >
void blaze::StaticMatrix< Type, M, N, SO >::addAssign ( const SparseMatrix< MT,!SO > &  rhs)
inline

Default implementation of the addition assignment of a column-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be added.
Returns
void

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 , size_t , size_t , bool >
template<typename MT , bool SO2>
DisableIf< typename StaticMatrix<Type,M,N,SO>::BLAZE_TEMPLATE VectorizedAddAssign<MT> >::Type blaze::StaticMatrix< typename, size_t, size_t, bool >::addAssign ( const DenseMatrix< MT, SO2 > &  rhs)
inline

Default implementation of the addition assignment of a row-major dense matrix.

Parameters
rhsThe right-hand side dense matrix to be added.
Returns
void

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 , size_t , size_t , bool >
template<typename MT , bool SO2>
EnableIf< typename StaticMatrix<Type,M,N,SO>::BLAZE_TEMPLATE VectorizedAddAssign<MT> >::Type blaze::StaticMatrix< typename, size_t, size_t, bool >::addAssign ( const DenseMatrix< MT, SO2 > &  rhs)
inline

Intrinsic optimized implementation of the addition assignment of a dense matrix.

Parameters
rhsThe right-hand side dense matrix to be added.
Returns
void

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 Type , size_t M, size_t N, bool SO>
template<typename MT >
void blaze::StaticMatrix< Type, M, N, SO >::assign ( const SparseMatrix< MT, SO > &  rhs)
inline

Default implementation of the assignment of a row-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be assigned.
Returns
void

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 Type , size_t M, size_t N, bool SO>
template<typename MT >
void blaze::StaticMatrix< Type, M, N, SO >::assign ( const SparseMatrix< MT,!SO > &  rhs)
inline

Default implementation of the assignment of a column-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be assigned.
Returns
void

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 , size_t , size_t , bool >
template<typename MT , bool SO2>
DisableIf< typename StaticMatrix<Type,M,N,SO>::BLAZE_TEMPLATE VectorizedAssign<MT> >::Type blaze::StaticMatrix< typename, size_t, size_t, bool >::assign ( const DenseMatrix< MT, SO2 > &  rhs)
inline

Default implementation of the assignment of a dense matrix.

Parameters
rhsThe right-hand side dense matrix to be assigned.
Returns
void

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 , size_t , size_t , bool >
template<typename MT , bool SO2>
EnableIf< typename StaticMatrix<Type,M,N,SO>::BLAZE_TEMPLATE VectorizedAssign<MT> >::Type blaze::StaticMatrix< typename, size_t, size_t, bool >::assign ( const DenseMatrix< MT, SO2 > &  rhs)
inline

Intrinsic optimized implementation of the assignment of a dense matrix.

Parameters
rhsThe right-hand side dense matrix to be assigned.
Returns
void

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 Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO >::Iterator blaze::StaticMatrix< Type, M, N, SO >::begin ( size_t  i)
inline

Returns an iterator to the first element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator to the first element of row/column i.

This function returns a row/column iterator to the first element of row/column i. In case the storage order is set to rowMajor the function returns an iterator to the first element of row i, in case the storage flag is set to columnMajor the function returns an iterator to the first element of column i.

template<typename Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO >::ConstIterator blaze::StaticMatrix< Type, M, N, SO >::begin ( size_t  i) const
inline

Returns an iterator to the first element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator to the first element of row/column i.

This function returns a row/column iterator to the first element of row/column i. In case the storage order is set to rowMajor the function returns an iterator to the first element of row i, in case the storage flag is set to columnMajor the function returns an iterator to the first element of column i.

template<typename Type , size_t M, size_t N, bool SO>
template<typename Other >
bool blaze::StaticMatrix< Type, M, N, SO >::canAlias ( const Other *  alias) const
inline

Returns whether the matrix can alias with the given address alias.

Parameters
aliasThe alias to be checked.
Returns
true in case the alias corresponds to this matrix, false if not.

This function returns whether the given address can alias with the vector. In contrast to the isAliased() function this function is allowed to use compile time expressions to optimize the evaluation.

template<typename Type , size_t M, size_t N, bool SO>
size_t blaze::StaticMatrix< Type, M, N, SO >::capacity ( ) const
inline

Returns the maximum capacity of the matrix.

Returns
The capacity of the matrix.
template<typename Type , size_t M, size_t N, bool SO>
size_t blaze::StaticMatrix< Type, M, N, SO >::capacity ( size_t  i) const
inline

Returns the current capacity of the specified row/column.

Parameters
iThe index of the row/column.
Returns
The current capacity of row/column i.

This function returns the current capacity of the specified row/column. In case the storage order is set to rowMajor the function returns the capacity of row i, in case the storage flag is set to columnMajor the function returns the capacity of column i.

template<typename Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO >::ConstIterator blaze::StaticMatrix< Type, M, N, SO >::cbegin ( size_t  i) const
inline

Returns an iterator to the first element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator to the first element of row/column i.

This function returns a row/column iterator to the first element of row/column i. In case the storage order is set to rowMajor the function returns an iterator to the first element of row i, in case the storage flag is set to columnMajor the function returns an iterator to the first element of column i.

template<typename Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO >::ConstIterator blaze::StaticMatrix< Type, M, N, SO >::cend ( size_t  i) const
inline

Returns an iterator just past the last element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator just past the last element of row/column i.

This function returns an row/column iterator just past the last element of row/column i. In case the storage order is set to rowMajor the function returns an iterator just past the last element of row i, in case the storage flag is set to columnMajor the function returns an iterator just past the last element of column i.

template<typename Type , size_t M, size_t N, bool SO>
size_t blaze::StaticMatrix< Type, M, N, SO >::columns ( ) const
inline

Returns the current number of columns of the matrix.

Returns
The number of columns of the matrix.
template<typename Type , size_t M, size_t N, bool SO>
Type * blaze::StaticMatrix< Type, M, N, SO >::data ( )
inline

Low-level data access to the matrix elements.

Returns
Pointer to the internal element storage.
template<typename Type , size_t M, size_t N, bool SO>
const Type * blaze::StaticMatrix< Type, M, N, SO >::data ( ) const
inline

Low-level data access to the matrix elements.

Returns
Pointer to the internal element storage.
template<typename Type , size_t M, size_t N, bool SO>
Type * blaze::StaticMatrix< Type, M, N, SO >::data ( size_t  i)
inline

Low-level data access to the matrix elements of row/column i.

Parameters
iThe row/column index.
Returns
Pointer to the internal element storage.
template<typename Type , size_t M, size_t N, bool SO>
const Type * blaze::StaticMatrix< Type, M, N, SO >::data ( size_t  i) const
inline

Low-level data access to the matrix elements of row/column i.

Parameters
iThe row/column index.
Returns
Pointer to the internal element storage.
template<typename Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO >::Iterator blaze::StaticMatrix< Type, M, N, SO >::end ( size_t  i)
inline

Returns an iterator just past the last element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator just past the last element of row/column i.

This function returns an row/column iterator just past the last element of row/column i. In case the storage order is set to rowMajor the function returns an iterator just past the last element of row i, in case the storage flag is set to columnMajor the function returns an iterator just past the last element of column i.

template<typename Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO >::ConstIterator blaze::StaticMatrix< Type, M, N, SO >::end ( size_t  i) const
inline

Returns an iterator just past the last element of row/column i.

Parameters
iThe row/column index.
Returns
Iterator just past the last element of row/column i.

This function returns an row/column iterator just past the last element of row/column i. In case the storage order is set to rowMajor the function returns an iterator just past the last element of row i, in case the storage flag is set to columnMajor the function returns an iterator just past the last element of column i.

template<typename Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO >::IntrinsicType blaze::StaticMatrix< Type, M, N, SO >::get ( size_t  i,
size_t  j 
) const
inline

Access to the intrinsic elements of the matrix.

Parameters
iAccess index for the row. The index has to be in the range [0..M-1].
jAccess index for the column. The index has to be in the range [0..N-1].
Returns
Reference to the accessed values.

This function offers a direct access to the intrinsic elements of the matrix. It 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.

template<typename Type , size_t M, size_t N, bool SO>
template<typename Other >
bool blaze::StaticMatrix< Type, M, N, SO >::isAliased ( const Other *  alias) const
inline

Returns whether the matrix is aliased with the given address alias.

Parameters
aliasThe alias to be checked.
Returns
true in case the alias corresponds to this matrix, false if not.

This function returns whether the given address is aliased with the vector. In contrast to the conAlias() function this function is not allowed to use compile time expressions to optimize the evaluation.

template<typename Type , size_t M, size_t N, bool SO>
bool blaze::StaticMatrix< Type, M, N, SO >::isDiagonal ( ) const
inline

Checks if the matrix is diagonal.

Returns
true if the matrix is diagonal, false if not.

This function tests whether the matrix is diagonal, i.e. if the non-diagonal elements are default elements. In case of integral or floating point data types, a diagonal matrix has the form

\[\left(\begin{array}{*{5}{c}} aa & 0 & 0 & \cdots & 0 \\ 0 & bb & 0 & \cdots & 0 \\ 0 & 0 & cc & \cdots & 0 \\ \vdots & \vdots & \vdots & \ddots & 0 \\ 0 & 0 & 0 & 0 & mn \\ \end{array}\right)\]

template<typename Type , size_t M, size_t N, bool SO>
bool blaze::StaticMatrix< Type, M, N, SO >::isSymmetric ( ) const
inline

Checks if the matrix is symmetric.

Returns
true if the matrix is symmetric, false if not.
template<typename Type , size_t M, size_t N, bool SO>
size_t blaze::StaticMatrix< Type, M, N, SO >::nonZeros ( ) const
inline

Returns the total number of non-zero elements in the matrix.

Returns
The number of non-zero elements in the matrix.
template<typename Type , size_t M, size_t N, bool SO>
size_t blaze::StaticMatrix< Type, M, N, SO >::nonZeros ( size_t  i) const
inline

Returns the number of non-zero elements in the specified row/column.

Parameters
iThe index of the row/column.
Returns
The number of non-zero elements of row/column i.

This function returns the current number of non-zero elements in the specified row/column. In case the storage order is set to rowMajor the function returns the number of non-zero elements in row i, in case the storage flag is set to columnMajor the function returns the number of non-zero elements in column i.

template<typename Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO >::Reference blaze::StaticMatrix< Type, M, N, SO >::operator() ( size_t  i,
size_t  j 
)
inline

2D-access to the matrix elements.

Parameters
iAccess index for the row. The index has to be in the range [0..M-1].
jAccess index for the column. The index has to be in the range [0..N-1].
Returns
Reference to the accessed value.
template<typename Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO >::ConstReference blaze::StaticMatrix< Type, M, N, SO >::operator() ( size_t  i,
size_t  j 
) const
inline

2D-access to the matrix elements.

Parameters
iAccess index for the row. The index has to be in the range [0..M-1].
jAccess index for the column. The index has to be in the range [0..N-1].
Returns
Reference-to-const to the accessed value.
template<typename , size_t , size_t , bool >
template<typename MT , bool SO2>
StaticMatrix<Type,M,N,SO>& blaze::StaticMatrix< typename, size_t, size_t, bool >::operator*= ( const Matrix< MT, SO2 > &  rhs)
inline

Multiplication assignment operator for the multiplication of a matrix ( $ A*=B $).

Parameters
rhsThe right-hand side matrix for the multiplication.
Returns
Reference to the matrix.
Exceptions
std::invalid_argumentMatrix sizes do not match.

In case the current sizes of the two given matrices don't match, a std::invalid_argument is thrown.

template<typename , size_t , size_t , bool >
template<typename Other >
EnableIf< IsNumeric<Other>, StaticMatrix<Type,M,N,SO> >::Type& blaze::StaticMatrix< typename, size_t, size_t, bool >::operator*= ( Other  rhs)
inline

Multiplication assignment operator for the multiplication between a matrix and a scalar value ( $ A*=s $).

Parameters
rhsThe right-hand side scalar value for the multiplication.
Returns
Reference to the matrix.
template<typename , size_t , size_t , bool >
template<typename MT , bool SO2>
StaticMatrix<Type,M,N,SO>& blaze::StaticMatrix< typename, size_t, size_t, bool >::operator+= ( const Matrix< MT, SO2 > &  rhs)
inline

Addition assignment operator for the addition of a matrix ( $ A+=B $).

Parameters
rhsThe right-hand side matrix to be added to the matrix.
Returns
Reference to the matrix.
Exceptions
std::invalid_argumentMatrix sizes do not match.

In case the current sizes of the two matrices don't match, a std::invalid_argument exception is thrown.

template<typename , size_t , size_t , bool >
template<typename MT , bool SO2>
StaticMatrix<Type,M,N,SO>& blaze::StaticMatrix< typename, size_t, size_t, bool >::operator-= ( const Matrix< MT, SO2 > &  rhs)
inline

Subtraction assignment operator for the subtraction of a matrix ( $ A-=B $).

Parameters
rhsThe right-hand side matrix to be subtracted from the matrix.
Returns
Reference to the matrix.
Exceptions
std::invalid_argumentMatrix sizes do not match.

In case the current sizes of the two matrices don't match, a std::invalid_argument exception is thrown.

template<typename , size_t , size_t , bool >
template<typename Other >
EnableIf< IsNumeric<Other>, StaticMatrix<Type,M,N,SO> >::Type& blaze::StaticMatrix< typename, size_t, size_t, bool >::operator/= ( Other  rhs)
inline

Division assignment operator for the division of a matrix by a scalar value ( $ A/=s $).

Parameters
rhsThe right-hand side scalar value for the division.
Returns
Reference to the matrix.

Note: A division by zero is only checked by an user assert.

template<typename Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO > & blaze::StaticMatrix< Type, M, N, SO >::operator= ( const Type &  set)
inline

Homogenous assignment to all matrix elements.

Parameters
setScalar value to be assigned to all matrix elements.
Returns
Reference to the assigned matrix.
template<typename Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO > & blaze::StaticMatrix< Type, M, N, SO >::operator= ( const StaticMatrix< typename, size_t, size_t, bool > &  rhs)
inline

Copy assignment operator for StaticMatrix.

Parameters
rhsMatrix to be copied.
Returns
Reference to the assigned matrix.

Explicit definition of a copy assignment operator for performance reasons.

template<typename , size_t , size_t , bool >
template<typename Other , bool SO2>
StaticMatrix<Type,M,N,SO>& blaze::StaticMatrix< typename, size_t, size_t, bool >::operator= ( const StaticMatrix< Other, M, N, SO2 > &  rhs)
inline

Assignment operator for different StaticMatrix instances.

Parameters
rhsMatrix to be copied.
Returns
Reference to the assigned matrix.
template<typename , size_t , size_t , bool >
template<typename MT , bool SO2>
StaticMatrix<Type,M,N,SO>& blaze::StaticMatrix< typename, size_t, size_t, bool >::operator= ( const Matrix< MT, SO2 > &  rhs)
inline

Assignment operator for different matrices.

Parameters
rhsMatrix to be copied.
Returns
Reference to the assigned matrix.
Exceptions
std::invalid_argumentInvalid assignment to static matrix.

This constructor initializes the matrix as a copy of the given matrix. In case the number of rows of the given matrix is not M or the number of columns is not N, a std::invalid_argument exception is thrown.

template<typename , bool >
MatrixType& blaze::Matrix< typename, bool >::operator~ ( )
inlineinherited

Conversion operator for non-constant matrices.

Returns
Reference of the actual type of the matrix.
template<typename , bool >
const MatrixType& blaze::Matrix< typename, bool >::operator~ ( ) const
inlineinherited

Conversion operator for constant matrices.

Returns
Constant reference of the actual type of the matrix.
template<typename Type , size_t M, size_t N, bool SO>
void blaze::StaticMatrix< Type, M, N, SO >::reset ( )
inline

Reset to the default initial values.

Returns
void
template<typename Type , size_t M, size_t N, bool SO>
void blaze::StaticMatrix< Type, M, N, SO >::reset ( size_t  i)
inline

Reset the specified row/column to the default initial values.

Parameters
iThe index of the row/column.
Returns
void

This function resets the values in the specified row/column to their default value. In case the storage order is set to rowMajor the function resets the values in row i, in case the storage order is set to columnMajor the function resets the values in column i. Note that the capacity of the row/column remains unchanged.

template<typename Type , size_t M, size_t N, bool SO>
size_t blaze::StaticMatrix< Type, M, N, SO >::rows ( ) const
inline

Returns the current number of rows of the matrix.

Returns
The number of rows of the matrix.
template<typename , size_t , size_t , bool >
template<typename Other >
StaticMatrix<Type,M,N,SO>& blaze::StaticMatrix< typename, size_t, size_t, bool >::scale ( const Other &  scalar)
inline

Scaling of the matrix by the scalar value scalar ( $ A*=s $).

Parameters
scalarThe scalar value for the matrix scaling.
Returns
Reference to the matrix.
template<typename Type , size_t M, size_t N, bool SO>
size_t blaze::StaticMatrix< Type, M, N, SO >::spacing ( ) const
inline

Returns the spacing between the beginning of two rows.

Returns
The spacing between the beginning of two rows.

This function returns the spacing between the beginning of two rows, i.e. the total number of elements of a row.

template<typename Type , size_t M, size_t N, bool SO>
template<typename MT >
void blaze::StaticMatrix< Type, M, N, SO >::subAssign ( const SparseMatrix< MT, SO > &  rhs)
inline

Default implementation of the subtraction assignment of a row-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be subtracted.
Returns
void

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 Type , size_t M, size_t N, bool SO>
template<typename MT >
void blaze::StaticMatrix< Type, M, N, SO >::subAssign ( const SparseMatrix< MT,!SO > &  rhs)
inline

Default implementation of the subtraction assignment of a column-major sparse matrix.

Parameters
rhsThe right-hand side sparse matrix to be subtracted.
Returns
void

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 , size_t , size_t , bool >
template<typename MT , bool SO2>
DisableIf< typename StaticMatrix<Type,M,N,SO>::BLAZE_TEMPLATE VectorizedSubAssign<MT> >::Type blaze::StaticMatrix< typename, size_t, size_t, bool >::subAssign ( const DenseMatrix< MT, SO2 > &  rhs)
inline

Default implementation of the subtraction assignment of a dense matrix.

Parameters
rhsThe right-hand side dense matrix to be subtracted.
Returns
void

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 , size_t , size_t , bool >
template<typename MT , bool SO2>
EnableIf< typename StaticMatrix<Type,M,N,SO>::BLAZE_TEMPLATE VectorizedSubAssign<MT> >::Type blaze::StaticMatrix< typename, size_t, size_t, bool >::subAssign ( const DenseMatrix< MT, SO2 > &  rhs)
inline

Intrinsic optimized implementation of the subtraction assignment of a dense matrix.

Parameters
rhsThe right-hand side dense matrix to be subtracted.
Returns
void

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 Type , size_t M, size_t N, bool SO>
void blaze::StaticMatrix< Type, M, N, SO >::swap ( StaticMatrix< typename, size_t, size_t, bool > &  m)
inline

Swapping the contents of two static matrices.

Parameters
mThe matrix to be swapped.
Returns
void
Exceptions
no-throwguarantee.
template<typename Type , size_t M, size_t N, bool SO>
StaticMatrix< Type, M, N, SO > & blaze::StaticMatrix< Type, M, N, SO >::transpose ( )
inline

Transposing the matrix.

Returns
Reference to the transposed matrix.

Member Data Documentation

template<typename , size_t , size_t , bool >
Type blaze::StaticMatrix< typename, size_t, size_t, bool >::v_[M *NN]
private

The statically allocated matrix elements.

Access to the matrix elements is gained via the function call operator. In case of row-major order the memory layout of the elements is

\[\left(\begin{array}{*{5}{c}} 0 & 1 & 2 & \cdots & N-1 \\ N & N+1 & N+2 & \cdots & 2 \cdot N-1 \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ M \cdot N-N & M \cdot N-N+1 & M \cdot N-N+2 & \cdots & M \cdot N-1 \\ \end{array}\right)\]

.


The documentation for this class was generated from the following files: