Loading...
Searching...
No Matches
Dune::Matrix< T, A > Class Template Reference
Iterative Solvers Template Library (ISTL) » Sparse Matrix and Vector classes

A generic dynamic dense matrix. More...

`#include <dune/istl/matrix.hh>`

Inheritance diagram for Dune::Matrix< T, A >:

## Public Types

using | field_type = typename Imp::BlockTraits<T>::field_type
| Export the type representing the underlying field.
typedef T | block_type
| Export the type representing the components.
typedef A | allocator_type
| Export the allocator.
typedef MatrixImp::DenseMatrixBase< T, A >::window_type | row_type
| The type implementing a matrix row.
typedef A::size_type | size_type
| Type for indices and sizes.
typedef MatrixImp::DenseMatrixBase< T, A >::Iterator | RowIterator
| Iterator over the matrix rows.
typedef row_type::iterator | ColIterator
| Iterator for the entries of each row.
typedef MatrixImp::DenseMatrixBase< T, A >::ConstIterator | ConstRowIterator
| Const iterator over the matrix rows.
typedef row_type::const_iterator | ConstColIterator
| Const iterator for the entries of each row.

## Public Member Functions

| Matrix ()
| Create empty matrix.
| Matrix (size_type rows, size_type cols)
| Create uninitialized matrix of size rows x cols.
void | setSize (size_type rows, size_type cols)
| Change the matrix size.
RowIterator | begin ()
| Get iterator to first row.
RowIterator | end ()
| Get iterator to one beyond last row.
RowIterator | beforeEnd ()
RowIterator | beforeBegin ()
ConstRowIterator | begin () const
| Get const iterator to first row.
ConstRowIterator | end () const
| Get const iterator to one beyond last row.
ConstRowIterator | beforeEnd () const
ConstRowIterator | beforeBegin () const
Matrix & | operator= (const field_type &t)
| Assignment from scalar.
row_type | operator[] (size_type row)
| The index operator.
const row_type | operator[] (size_type row) const
| The const index operator.
size_type | N () const
| Return the number of rows.
size_type | M () const
| Return the number of columns.
Matrix< T > & | operator*= (const field_type &scalar)
| Multiplication with a scalar.
Matrix< T > & | operator/= (const field_type &scalar)
| Division by a scalar.
Matrix & | operator+= (const Matrix &b)
| Add the entries of another matrix to this one.
Matrix & | operator-= (const Matrix &b)
| Subtract the entries of another matrix from this one.
Matrix | transpose () const
| Return the transpose of the matrix.
template<class X, class Y>
void | mv (const X &x, Y &y) const
| y = A x
template<class X, class Y>
void | mtv (const X &x, Y &y) const
| y = A^T x
template<class X, class Y>
void | umv (const X &x, Y &y) const
| y += A x
template<class X, class Y>
void | mmv (const X &x, Y &y) const
| y -= A x
template<class X, class Y>
void | usmv (const field_type &alpha, const X &x, Y &y) const
template<class X, class Y>
void | umtv (const X &x, Y &y) const
| y += A^T x
template<class X, class Y>
void | mmtv (const X &x, Y &y) const
| y -= A^T x
template<class X, class Y>
void | usmtv (const field_type &alpha, const X &x, Y &y) const
| y += alpha A^T x
template<class X, class Y>
void | umhv (const X &x, Y &y) const
| y += A^H x
template<class X, class Y>
void | mmhv (const X &x, Y &y) const
| y -= A^H x
template<class X, class Y>
void | usmhv (const field_type &alpha, const X &x, Y &y) const
| y += alpha A^H x
FieldTraits< field_type >::real_type | frobenius_norm () const
| frobenius norm: sqrt(sum over squared values of entries)
FieldTraits< field_type >::real_type | frobenius_norm2 () const
| square of frobenius norm, need for block recursion
template<typename ft = field_type, typename std::enable_if<!HasNaN< ft >::value, int >::type = 0>
FieldTraits< ft >::real_type | infinity_norm () const
| infinity norm (row sum norm, how to generalize for blocks?)
template<typename ft = field_type, typename std::enable_if<!HasNaN< ft >::value, int >::type = 0>
FieldTraits< ft >::real_type | infinity_norm_real () const
| simplified infinity norm (uses Manhattan norm for complex values)
template<typename ft = field_type, typename std::enable_if< HasNaN< ft >::value, int >::type = 0>
FieldTraits< ft >::real_type | infinity_norm () const
| infinity norm (row sum norm, how to generalize for blocks?)
template<typename ft = field_type, typename std::enable_if< HasNaN< ft >::value, int >::type = 0>
FieldTraits< ft >::real_type | infinity_norm_real () const
| simplified infinity norm (uses Manhattan norm for complex values)
bool | exists (size_type i, size_type j) const
| return true if (i,j) is in pattern

## Protected Attributes

MatrixImp::DenseMatrixBase< T, A > | data_
| Abuse DenseMatrixBase as an engine for a 2d array ISTL-style.
size_type | cols_
| Number of columns of the matrix.

## Friends

Matrix< T > | operator* (const Matrix< T > &m1, const Matrix< T > &m2)
| Generic matrix multiplication.
template<class X, class Y>
Y | operator* (const Matrix< T > &m, const X &vec)
| Generic matrix-vector multiplication.

## Detailed Description

template<class T, class A = std::allocator<T>>
class Dune::Matrix< T, A >

A generic dynamic dense matrix.

## Member Typedef Documentation

## allocator_type

template<class T, class A = std::allocator<T>>

typedef A Dune::Matrix< T, A >::allocator_type

Export the allocator.

## block_type

template<class T, class A = std::allocator<T>>

typedef T Dune::Matrix< T, A >::block_type

Export the type representing the components.

## ColIterator

template<class T, class A = std::allocator<T>>

typedef row_type::iterator Dune::Matrix< T, A >::ColIterator

Iterator for the entries of each row.

## ConstColIterator

template<class T, class A = std::allocator<T>>

typedef row_type::const_iterator Dune::Matrix< T, A >::ConstColIterator

Const iterator for the entries of each row.

## ConstRowIterator

template<class T, class A = std::allocator<T>>

typedef MatrixImp::DenseMatrixBase<T,A>::ConstIterator Dune::Matrix< T, A >::ConstRowIterator

Const iterator over the matrix rows.

## field_type

template<class T, class A = std::allocator<T>>

using Dune::Matrix< T, A >::field_type = typename Imp::BlockTraits<T>::field_type

Export the type representing the underlying field.

## row_type

template<class T, class A = std::allocator<T>>

typedef MatrixImp::DenseMatrixBase<T,A>::window_type Dune::Matrix< T, A >::row_type

The type implementing a matrix row.

## RowIterator

template<class T, class A = std::allocator<T>>

typedef MatrixImp::DenseMatrixBase<T,A>::Iterator Dune::Matrix< T, A >::RowIterator

Iterator over the matrix rows.

## size_type

template<class T, class A = std::allocator<T>>

typedef A::size_type Dune::Matrix< T, A >::size_type

Type for indices and sizes.

## Constructor & Destructor Documentation

## Matrix() [1/2]

template<class T, class A = std::allocator<T>>

Dune::Matrix< T, A >::Matrix | ( |  | ) |

inline

Create empty matrix.

## Matrix() [2/2]

template<class T, class A = std::allocator<T>>

Dune::Matrix< T, A >::Matrix | ( | size_type | rows,
|  | size_type | cols )

inline

Create uninitialized matrix of size rows x cols.

## Member Function Documentation

## beforeBegin() [1/2]

template<class T, class A = std::allocator<T>>

RowIterator Dune::Matrix< T, A >::beforeBegin | ( |  | ) |

inline

Returns
  an iterator that is positioned before the first row of the matrix.

## beforeBegin() [2/2]

template<class T, class A = std::allocator<T>>

ConstRowIterator Dune::Matrix< T, A >::beforeBegin | ( |  | ) | const

inline

Returns
  an iterator that is positioned before the first row if the matrix.

## beforeEnd() [1/2]

template<class T, class A = std::allocator<T>>

RowIterator Dune::Matrix< T, A >::beforeEnd | ( |  | ) |

inline

Returns
  an iterator that is positioned before the end iterator of the rows, i.e. at the last row.

## beforeEnd() [2/2]

template<class T, class A = std::allocator<T>>

ConstRowIterator Dune::Matrix< T, A >::beforeEnd | ( |  | ) | const

inline

Returns
  an iterator that is positioned before the end iterator of the rows. i.e. at the last row.

## begin() [1/2]

template<class T, class A = std::allocator<T>>

RowIterator Dune::Matrix< T, A >::begin | ( |  | ) |

inline

Get iterator to first row.

## begin() [2/2]

template<class T, class A = std::allocator<T>>

ConstRowIterator Dune::Matrix< T, A >::begin | ( |  | ) | const

inline

Get const iterator to first row.

## end() [1/2]

template<class T, class A = std::allocator<T>>

RowIterator Dune::Matrix< T, A >::end | ( |  | ) |

inline

Get iterator to one beyond last row.

## end() [2/2]

template<class T, class A = std::allocator<T>>

ConstRowIterator Dune::Matrix< T, A >::end | ( |  | ) | const

inline

Get const iterator to one beyond last row.

## exists()

template<class T, class A = std::allocator<T>>

bool Dune::Matrix< T, A >::exists | ( | size_type | i,
|  | size_type | j ) const

inline

return true if (i,j) is in pattern

## frobenius_norm()

template<class T, class A = std::allocator<T>>

FieldTraits< field_type >::real_type Dune::Matrix< T, A >::frobenius_norm | ( |  | ) | const

inline

frobenius norm: sqrt(sum over squared values of entries)

## frobenius_norm2()

template<class T, class A = std::allocator<T>>

FieldTraits< field_type >::real_type Dune::Matrix< T, A >::frobenius_norm2 | ( |  | ) | const

inline

square of frobenius norm, need for block recursion

## infinity_norm() [1/2]

template<class T, class A = std::allocator<T>>
template<typename ft = field_type, typename std::enable_if< HasNaN< ft >::value, int >::type = 0>

FieldTraits< ft >::real_type Dune::Matrix< T, A >::infinity_norm | ( |  | ) | const

inline

infinity norm (row sum norm, how to generalize for blocks?)

## infinity_norm() [2/2]

template<class T, class A = std::allocator<T>>
template<typename ft = field_type, typename std::enable_if<!HasNaN< ft >::value, int >::type = 0>

FieldTraits< ft >::real_type Dune::Matrix< T, A >::infinity_norm | ( |  | ) | const

inline

infinity norm (row sum norm, how to generalize for blocks?)

## infinity_norm_real() [1/2]

template<class T, class A = std::allocator<T>>
template<typename ft = field_type, typename std::enable_if< HasNaN< ft >::value, int >::type = 0>

FieldTraits< ft >::real_type Dune::Matrix< T, A >::infinity_norm_real | ( |  | ) | const

inline

simplified infinity norm (uses Manhattan norm for complex values)

## infinity_norm_real() [2/2]

template<class T, class A = std::allocator<T>>
template<typename ft = field_type, typename std::enable_if<!HasNaN< ft >::value, int >::type = 0>

FieldTraits< ft >::real_type Dune::Matrix< T, A >::infinity_norm_real | ( |  | ) | const

inline

simplified infinity norm (uses Manhattan norm for complex values)

## M()

template<class T, class A = std::allocator<T>>

size_type Dune::Matrix< T, A >::M | ( |  | ) | const

inline

Return the number of columns.

## mmhv()

template<class T, class A = std::allocator<T>>
template<class X, class Y>

void Dune::Matrix< T, A >::mmhv | ( | const X & | x,
|  | Y & | y ) const

inline

y -= A^H x

## mmtv()

template<class T, class A = std::allocator<T>>
template<class X, class Y>

void Dune::Matrix< T, A >::mmtv | ( | const X & | x,
|  | Y & | y ) const

inline

y -= A^T x

## mmv()

template<class T, class A = std::allocator<T>>
template<class X, class Y>

void Dune::Matrix< T, A >::mmv | ( | const X & | x,
|  | Y & | y ) const

inline

y -= A x

## mtv()

template<class T, class A = std::allocator<T>>
template<class X, class Y>

void Dune::Matrix< T, A >::mtv | ( | const X & | x,
|  | Y & | y ) const

inline

y = A^T x

## mv()

template<class T, class A = std::allocator<T>>
template<class X, class Y>

void Dune::Matrix< T, A >::mv | ( | const X & | x,
|  | Y & | y ) const

inline

y = A x

## N()

template<class T, class A = std::allocator<T>>

size_type Dune::Matrix< T, A >::N | ( |  | ) | const

inline

Return the number of rows.

## operator*=()

template<class T, class A = std::allocator<T>>

Matrix< T > & Dune::Matrix< T, A >::operator*= | ( | const field_type & | scalar | ) |

inline

Multiplication with a scalar.

## operator+=()

template<class T, class A = std::allocator<T>>

Matrix & Dune::Matrix< T, A >::operator+= | ( | const Matrix< T, A > & | b | ) |

inline

Add the entries of another matrix to this one.

Parameters

  b | The matrix to add to this one. Its size has to be the same as the size of this matrix.

## operator-=()

template<class T, class A = std::allocator<T>>

Matrix & Dune::Matrix< T, A >::operator-= | ( | const Matrix< T, A > & | b | ) |

inline

Subtract the entries of another matrix from this one.

Parameters

  b | The matrix to subtract from this one. Its size has to be the same as the size of this matrix.

## operator/=()

template<class T, class A = std::allocator<T>>

Matrix< T > & Dune::Matrix< T, A >::operator/= | ( | const field_type & | scalar | ) |

inline

Division by a scalar.

## operator=()

template<class T, class A = std::allocator<T>>

Matrix & Dune::Matrix< T, A >::operator= | ( | const field_type & | t | ) |

inline

Assignment from scalar.

## operator[]() [1/2]

template<class T, class A = std::allocator<T>>

row_type Dune::Matrix< T, A >::operator[] | ( | size_type | row | ) |

inline

The index operator.

## operator[]() [2/2]

template<class T, class A = std::allocator<T>>

const row_type Dune::Matrix< T, A >::operator[] | ( | size_type | row | ) | const

inline

The const index operator.

## setSize()

template<class T, class A = std::allocator<T>>

void Dune::Matrix< T, A >::setSize | ( | size_type | rows,
|  | size_type | cols )

inline

Change the matrix size.

The way the data is handled is unpredictable.

## transpose()

template<class T, class A = std::allocator<T>>

Matrix Dune::Matrix< T, A >::transpose | ( |  | ) | const

inline

Return the transpose of the matrix.

## umhv()

template<class T, class A = std::allocator<T>>
template<class X, class Y>

void Dune::Matrix< T, A >::umhv | ( | const X & | x,
|  | Y & | y ) const

inline

y += A^H x

## umtv()

template<class T, class A = std::allocator<T>>
template<class X, class Y>

void Dune::Matrix< T, A >::umtv | ( | const X & | x,
|  | Y & | y ) const

inline

y += A^T x

## umv()

template<class T, class A = std::allocator<T>>
template<class X, class Y>

void Dune::Matrix< T, A >::umv | ( | const X & | x,
|  | Y & | y ) const

inline

y += A x

## usmhv()

template<class T, class A = std::allocator<T>>
template<class X, class Y>

void Dune::Matrix< T, A >::usmhv | ( | const field_type & | alpha,
|  | const X & | x,
|  | Y & | y ) const

inline

y += alpha A^H x

## usmtv()

template<class T, class A = std::allocator<T>>
template<class X, class Y>

void Dune::Matrix< T, A >::usmtv | ( | const field_type & | alpha,
|  | const X & | x,
|  | Y & | y ) const

inline

y += alpha A^T x

## usmv()

template<class T, class A = std::allocator<T>>
template<class X, class Y>

void Dune::Matrix< T, A >::usmv | ( | const field_type & | alpha,
|  | const X & | x,
|  | Y & | y ) const

inline

## Friends And Related Symbol Documentation

## operator* [1/2]

template<class T, class A = std::allocator<T>>
template<class X, class Y>

Y operator* | ( | const Matrix< T > & | m,
|  | const X & | vec )

friend

Generic matrix-vector multiplication.

## operator* [2/2]

template<class T, class A = std::allocator<T>>

Matrix< T > operator* | ( | const Matrix< T > & | m1,
|  | const Matrix< T > & | m2 )

friend

Generic matrix multiplication.

## Member Data Documentation

## cols_

template<class T, class A = std::allocator<T>>

size_type Dune::Matrix< T, A >::cols_

protected

Number of columns of the matrix.

In general you can extract the same information from the data_ member. However if you want to be able to properly handle 0xn matrices then you need a separate member.

## data_

template<class T, class A = std::allocator<T>>

MatrixImp::DenseMatrixBase<T,A> Dune::Matrix< T, A >::data_

protected

Abuse DenseMatrixBase as an engine for a 2d array ISTL-style.

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

- matrix.hh