Loading...
Searching...
No Matches
Dune::DenseMatrix< MAT > Class Template Reference
Common » Dense Matrix and Vector Template Library

A dense n x m matrix. More...

`#include <dune/common/densematrix.hh>`

Inheritance diagram for Dune::DenseMatrix< MAT >:

## Public Types

typedef Traits::derived_type | derived_type
| type of derived matrix class
typedef Traits::value_type | value_type
| export the type representing the field
typedef Traits::value_type | field_type
| export the type representing the field
typedef Traits::value_type | block_type
| export the type representing the components
typedef Traits::size_type | size_type
| The type used for the index access and size operation.
typedef Traits::row_type | row_type
| The type used to represent a row (must fulfill the Dune::DenseVector interface).
typedef Traits::row_reference | row_reference
| The type used to represent a reference to a row (usually row_type &).
typedef Traits::const_row_reference | const_row_reference
| The type used to represent a reference to a constant row (usually const row_type &).
typedef DenseIterator< DenseMatrix, row_type, row_reference > | Iterator
| Iterator class for sequential access.
typedef Iterator | iterator
| typedef for stl compliant access
typedef Iterator | RowIterator
| rename the iterators for easier access
typedef std::remove_reference< row_reference >::type::Iterator | ColIterator
| rename the iterators for easier access
typedef DenseIterator< const DenseMatrix, const row_type, const_row_reference > | ConstIterator
| Iterator class for sequential access.
typedef ConstIterator | const_iterator
| typedef for stl compliant access
typedef ConstIterator | ConstRowIterator
| rename the iterators for easier access
typedef std::remove_reference< const_row_reference >::type::ConstIterator | ConstColIterator
| rename the iterators for easier access

## Public Member Functions

constexpr row_reference | operator[] (size_type i)
| random access
constexpr const_row_reference | operator[] (size_type i) const
constexpr size_type | size () const
| size method (number of rows)
constexpr Iterator | begin ()
| begin iterator
constexpr Iterator | end ()
| end iterator
constexpr Iterator | beforeEnd ()
constexpr Iterator | beforeBegin ()
constexpr ConstIterator | begin () const
| begin iterator
constexpr ConstIterator | end () const
| end iterator
constexpr ConstIterator | beforeEnd () const
constexpr ConstIterator | beforeBegin () const
template<class RHS, class = std::enable_if_t< HasDenseMatrixAssigner< MAT, RHS >::value >>
constexpr derived_type & | operator= (const RHS &rhs)
template<class Other>
constexpr derived_type & | operator+= (const DenseMatrix< Other > &x)
| vector space addition
constexpr derived_type | operator- () const
| Matrix negation.
template<class Other>
constexpr derived_type & | operator-= (const DenseMatrix< Other > &x)
| vector space subtraction
constexpr derived_type & | operator*= (const field_type &k)
| vector space multiplication with scalar
constexpr derived_type & | operator/= (const field_type &k)
| vector space division by scalar
template<class Other>
constexpr derived_type & | axpy (const field_type &a, const DenseMatrix< Other > &x)
| vector space axpy operation (*this += a x)
template<class Other>
constexpr bool | operator== (const DenseMatrix< Other > &x) const
| Binary matrix comparison.
template<class Other>
constexpr bool | operator!= (const DenseMatrix< Other > &x) const
| Binary matrix incomparison.
template<class X, class Y>
constexpr void | mv (const X &x, Y &y) const
| y = A x
template<class X, class Y>
constexpr void | mtv (const X &x, Y &y) const
| y = A^T x
template<class X, class Y>
constexpr void | umv (const X &x, Y &y) const
| y += A x
template<class X, class Y>
constexpr void | umtv (const X &x, Y &y) const
| y += A^T x
template<class X, class Y>
constexpr void | umhv (const X &x, Y &y) const
| y += A^H x
template<class X, class Y>
constexpr void | mmv (const X &x, Y &y) const
| y -= A x
template<class X, class Y>
constexpr void | mmtv (const X &x, Y &y) const
| y -= A^T x
template<class X, class Y>
constexpr void | mmhv (const X &x, Y &y) const
| y -= A^H x
template<class X, class Y>
constexpr void | usmv (const typename FieldTraits< Y >::field_type &alpha, const X &x, Y &y) const
| y += alpha A x
template<class X, class Y>
constexpr void | usmtv (const typename FieldTraits< Y >::field_type &alpha, const X &x, Y &y) const
| y += alpha A^T x
template<class X, class Y>
constexpr void | usmhv (const typename FieldTraits< Y >::field_type &alpha, const X &x, Y &y) const
| y += alpha A^H x
constexpr FieldTraits< value_type >::real_type | frobenius_norm () const
| frobenius norm: sqrt(sum over squared values of entries)
constexpr FieldTraits< value_type >::real_type | frobenius_norm2 () const
| square of frobenius norm, need for block recursion
template<typename vt = value_type, typename std::enable_if<!HasNaN< vt >::value, int >::type = 0>
constexpr FieldTraits< vt >::real_type | infinity_norm () const
| infinity norm (row sum norm, how to generalize for blocks?)
template<typename vt = value_type, typename std::enable_if<!HasNaN< vt >::value, int >::type = 0>
constexpr FieldTraits< vt >::real_type | infinity_norm_real () const
| simplified infinity norm (uses Manhattan norm for complex values)
template<typename vt = value_type, typename std::enable_if< HasNaN< vt >::value, int >::type = 0>
constexpr FieldTraits< vt >::real_type | infinity_norm () const
| infinity norm (row sum norm, how to generalize for blocks?)
template<typename vt = value_type, typename std::enable_if< HasNaN< vt >::value, int >::type = 0>
constexpr FieldTraits< vt >::real_type | infinity_norm_real () const
| simplified infinity norm (uses Manhattan norm for complex values)
template<class V1, class V2>
void | solve (V1 &x, const V2 &b, bool doPivoting=true) const
| Solve system A x = b.
void | invert (bool doPivoting=true)
| Compute inverse.
field_type | determinant (bool doPivoting=true) const
| calculates the determinant of this matrix
template<typename M2>
MAT & | leftmultiply (const DenseMatrix< M2 > &M)
| Multiplies M from the left to this matrix.
template<typename M2>
MAT & | rightmultiply (const DenseMatrix< M2 > &M)
| Multiplies M from the right to this matrix.
constexpr size_type | N () const
| number of rows
constexpr size_type | M () const
| number of columns
constexpr size_type | rows () const
| number of rows
constexpr size_type | cols () const
| number of columns
constexpr bool | exists (size_type i, size_type j) const
| return true when (i,j) is in pattern

## Static Public Attributes

static constexpr int | blocklevel = 1
| The number of block levels we contain. This is the leaf, that is, 1.

## Static Protected Member Functions

template<class Func, class Mask>
static void | luDecomposition (DenseMatrix< MAT > &A, Func func, Mask &nonsingularLanes, bool throwEarly, bool doPivoting)
| do an LU-Decomposition on matrix A

## Friends

template<class>
class | DenseMatrix

## Detailed Description

template<typename MAT>
class Dune::DenseMatrix< MAT >

A dense n x m matrix.

Matrices represent linear maps from a vector space V to a vector space W. This class represents such a linear map by storing a two-dimensional array of numbers of a given field type K. The number of rows and columns is given at compile time.

Template Parameters

  MAT | type of the matrix implementation

## Member Typedef Documentation

## block_type

template<typename MAT>

typedef Traits::value_type Dune::DenseMatrix< MAT >::block_type

export the type representing the components

## ColIterator

template<typename MAT>

typedef std::remove_reference<row_reference>::type::Iterator Dune::DenseMatrix< MAT >::ColIterator

rename the iterators for easier access

## const_iterator

template<typename MAT>

typedef ConstIterator Dune::DenseMatrix< MAT >::const_iterator

typedef for stl compliant access

## const_row_reference

template<typename MAT>

typedef Traits::const_row_reference Dune::DenseMatrix< MAT >::const_row_reference

The type used to represent a reference to a constant row (usually const row_type &).

## ConstColIterator

template<typename MAT>

typedef std::remove_reference<const_row_reference>::type::ConstIterator Dune::DenseMatrix< MAT >::ConstColIterator

rename the iterators for easier access

## ConstIterator

template<typename MAT>

typedef DenseIterator<const DenseMatrix,const row_type,const_row_reference> Dune::DenseMatrix< MAT >::ConstIterator

Iterator class for sequential access.

## ConstRowIterator

template<typename MAT>

typedef ConstIterator Dune::DenseMatrix< MAT >::ConstRowIterator

rename the iterators for easier access

## derived_type

template<typename MAT>

typedef Traits::derived_type Dune::DenseMatrix< MAT >::derived_type

type of derived matrix class

## field_type

template<typename MAT>

typedef Traits::value_type Dune::DenseMatrix< MAT >::field_type

export the type representing the field

## Iterator

template<typename MAT>

typedef DenseIterator<DenseMatrix,row_type,row_reference> Dune::DenseMatrix< MAT >::Iterator

Iterator class for sequential access.

## iterator

template<typename MAT>

typedef Iterator Dune::DenseMatrix< MAT >::iterator

typedef for stl compliant access

## row_reference

template<typename MAT>

typedef Traits::row_reference Dune::DenseMatrix< MAT >::row_reference

The type used to represent a reference to a row (usually row_type &).

## row_type

template<typename MAT>

typedef Traits::row_type Dune::DenseMatrix< MAT >::row_type

The type used to represent a row (must fulfill the Dune::DenseVector interface).

## RowIterator

template<typename MAT>

typedef Iterator Dune::DenseMatrix< MAT >::RowIterator

rename the iterators for easier access

## size_type

template<typename MAT>

typedef Traits::size_type Dune::DenseMatrix< MAT >::size_type

The type used for the index access and size operation.

## value_type

template<typename MAT>

typedef Traits::value_type Dune::DenseMatrix< MAT >::value_type

export the type representing the field

## Member Function Documentation

## axpy()

template<typename MAT>
template<class Other>

derived_type & Dune::DenseMatrix< MAT >::axpy | ( | const field_type & | a,
|  | const DenseMatrix< Other > & | x )

inline constexpr

vector space axpy operation (*this += a x)

## beforeBegin() [1/2]

template<typename MAT>

Iterator Dune::DenseMatrix< MAT >::beforeBegin | ( |  | ) |

inline constexpr

Returns
  an iterator that is positioned before the first entry of the vector.

## beforeBegin() [2/2]

template<typename MAT>

ConstIterator Dune::DenseMatrix< MAT >::beforeBegin | ( |  | ) | const

inline constexpr

Returns
  an iterator that is positioned before the first entry of the vector.

## beforeEnd() [1/2]

template<typename MAT>

Iterator Dune::DenseMatrix< MAT >::beforeEnd | ( |  | ) |

inline constexpr

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

## beforeEnd() [2/2]

template<typename MAT>

ConstIterator Dune::DenseMatrix< MAT >::beforeEnd | ( |  | ) | const

inline constexpr

Returns
  an iterator that is positioned before the end iterator of the vector. i.e. at the last element

## begin() [1/2]

template<typename MAT>

Iterator Dune::DenseMatrix< MAT >::begin | ( |  | ) |

inline constexpr

begin iterator

## begin() [2/2]

template<typename MAT>

ConstIterator Dune::DenseMatrix< MAT >::begin | ( |  | ) | const

inline constexpr

begin iterator

## cols()

template<typename MAT>

size_type Dune::DenseMatrix< MAT >::cols | ( |  | ) | const

inline constexpr

number of columns

## determinant()

template<typename MAT>

field_type Dune::DenseMatrix< MAT >::determinant | ( | bool | doPivoting = true | ) | const

calculates the determinant of this matrix

## end() [1/2]

template<typename MAT>

Iterator Dune::DenseMatrix< MAT >::end | ( |  | ) |

inline constexpr

end iterator

## end() [2/2]

template<typename MAT>

ConstIterator Dune::DenseMatrix< MAT >::end | ( |  | ) | const

inline constexpr

end iterator

## exists()

template<typename MAT>

bool Dune::DenseMatrix< MAT >::exists | ( | size_type | i,
|  | size_type | j ) const

inline constexpr

return true when (i,j) is in pattern

## frobenius_norm()

template<typename MAT>

FieldTraits< value_type >::real_type Dune::DenseMatrix< MAT >::frobenius_norm | ( |  | ) | const

inline constexpr

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

## frobenius_norm2()

template<typename MAT>

FieldTraits< value_type >::real_type Dune::DenseMatrix< MAT >::frobenius_norm2 | ( |  | ) | const

inline constexpr

square of frobenius norm, need for block recursion

## infinity_norm() [1/2]

template<typename MAT>
template<typename vt = value_type, typename std::enable_if< HasNaN< vt >::value, int >::type = 0>

FieldTraits< vt >::real_type Dune::DenseMatrix< MAT >::infinity_norm | ( |  | ) | const

inline constexpr

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

## infinity_norm() [2/2]

template<typename MAT>
template<typename vt = value_type, typename std::enable_if<!HasNaN< vt >::value, int >::type = 0>

FieldTraits< vt >::real_type Dune::DenseMatrix< MAT >::infinity_norm | ( |  | ) | const

inline constexpr

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

## infinity_norm_real() [1/2]

template<typename MAT>
template<typename vt = value_type, typename std::enable_if< HasNaN< vt >::value, int >::type = 0>

FieldTraits< vt >::real_type Dune::DenseMatrix< MAT >::infinity_norm_real | ( |  | ) | const

inline constexpr

simplified infinity norm (uses Manhattan norm for complex values)

## infinity_norm_real() [2/2]

template<typename MAT>
template<typename vt = value_type, typename std::enable_if<!HasNaN< vt >::value, int >::type = 0>

FieldTraits< vt >::real_type Dune::DenseMatrix< MAT >::infinity_norm_real | ( |  | ) | const

inline constexpr

simplified infinity norm (uses Manhattan norm for complex values)

## invert()

template<typename MAT>

void Dune::DenseMatrix< MAT >::invert | ( | bool | doPivoting = true | ) |

Compute inverse.

Exceptions

  FMatrixError | if the matrix is singular

## leftmultiply()

template<typename MAT>
template<typename M2>

MAT & Dune::DenseMatrix< MAT >::leftmultiply | ( | const DenseMatrix< M2 > & | M | ) |

inline

Multiplies M from the left to this matrix.

## luDecomposition()

template<typename MAT>
template<class Func, class Mask>

void Dune::DenseMatrix< MAT >::luDecomposition | ( | DenseMatrix< MAT > & | A,
|  | Func | func,
|  | Mask & | nonsingularLanes,
|  | bool | throwEarly,
|  | bool | doPivoting )

static protected

do an LU-Decomposition on matrix A

Parameters

  A | The matrix to decompose, and to store the result in.
  func | Functor used for swapping lanes and to conduct the elimination. Depending on the functor, `luDecomposition()` can be used for solving, for inverting, or to compute the determinant.
  nonsingularLanes | SimdMask of lanes that are nonsingular.
  throwEarly | Whether to throw an `FMatrixError` immediately as soon as one lane is discovered to be singular. If `false`, do not throw, instead continue until finished or all lanes are singular, and exit via return in both cases.
  doPivoting | Enable pivoting.

There are two modes of operation:

- Terminate as soon as one lane is discovered to be singular. Early termination is done by throwing an `FMatrixError`. On entry, `Simd::allTrue(nonsingularLanes)` and `throwEarly==true` should hold. After early termination, the contents of `A` should be considered bogus, and `nonsingularLanes` has the lane(s) that triggered the early termination unset. There may be more singular lanes than the one reported in `nonsingularLanes`, which just haven't been discovered yet; so the value of `nonsingularLanes` is mostly useful for diagnostics.
- Terminate only when all lanes are discovered to be singular. Use this when you want to apply special postprocessing in singular lines (e.g. setting the determinant of singular lanes to 0 in `determinant()`). On entry, `nonsingularLanes` may have any value and `throwEarly==false` should hold. The function will not throw an exception if some lanes are discovered to be singular, instead it will continue running until all lanes are singular or until finished, and terminate only via normal return. On exit, `nonsingularLanes` contains the map of lanes that are valid in `A`.

## M()

template<typename MAT>

size_type Dune::DenseMatrix< MAT >::M | ( |  | ) | const

inline constexpr

number of columns

## mmhv()

template<typename MAT>
template<class X, class Y>

void Dune::DenseMatrix< MAT >::mmhv | ( | const X & | x,
|  | Y & | y ) const

inline constexpr

y -= A^H x

## mmtv()

template<typename MAT>
template<class X, class Y>

void Dune::DenseMatrix< MAT >::mmtv | ( | const X & | x,
|  | Y & | y ) const

inline constexpr

y -= A^T x

## mmv()

template<typename MAT>
template<class X, class Y>

void Dune::DenseMatrix< MAT >::mmv | ( | const X & | x,
|  | Y & | y ) const

inline constexpr

y -= A x

## mtv()

template<typename MAT>
template<class X, class Y>

void Dune::DenseMatrix< MAT >::mtv | ( | const X & | x,
|  | Y & | y ) const

inline constexpr

y = A^T x

## mv()

template<typename MAT>
template<class X, class Y>

void Dune::DenseMatrix< MAT >::mv | ( | const X & | x,
|  | Y & | y ) const

inline constexpr

y = A x

## N()

template<typename MAT>

size_type Dune::DenseMatrix< MAT >::N | ( |  | ) | const

inline constexpr

number of rows

## operator!=()

template<typename MAT>
template<class Other>

bool Dune::DenseMatrix< MAT >::operator!= | ( | const DenseMatrix< Other > & | x | ) | const

inline constexpr

Binary matrix incomparison.

## operator*=()

template<typename MAT>

derived_type & Dune::DenseMatrix< MAT >::operator*= | ( | const field_type & | k | ) |

inline constexpr

vector space multiplication with scalar

## operator+=()

template<typename MAT>
template<class Other>

derived_type & Dune::DenseMatrix< MAT >::operator+= | ( | const DenseMatrix< Other > & | x | ) |

inline constexpr

vector space addition

## operator-()

template<typename MAT>

derived_type Dune::DenseMatrix< MAT >::operator- | ( |  | ) | const

inline constexpr

Matrix negation.

## operator-=()

template<typename MAT>
template<class Other>

derived_type & Dune::DenseMatrix< MAT >::operator-= | ( | const DenseMatrix< Other > & | x | ) |

inline constexpr

vector space subtraction

## operator/=()

template<typename MAT>

derived_type & Dune::DenseMatrix< MAT >::operator/= | ( | const field_type & | k | ) |

inline constexpr

vector space division by scalar

## operator=()

template<typename MAT>
template<class RHS, class = std::enable_if_t< HasDenseMatrixAssigner< MAT, RHS >::value >>

derived_type & Dune::DenseMatrix< MAT >::operator= | ( | const RHS & | rhs | ) |

inline constexpr

## operator==()

template<typename MAT>
template<class Other>

bool Dune::DenseMatrix< MAT >::operator== | ( | const DenseMatrix< Other > & | x | ) | const

inline constexpr

Binary matrix comparison.

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

template<typename MAT>

row_reference Dune::DenseMatrix< MAT >::operator[] | ( | size_type | i | ) |

inline constexpr

random access

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

template<typename MAT>

const_row_reference Dune::DenseMatrix< MAT >::operator[] | ( | size_type | i | ) | const

inline constexpr

## rightmultiply()

template<typename MAT>
template<typename M2>

MAT & Dune::DenseMatrix< MAT >::rightmultiply | ( | const DenseMatrix< M2 > & | M | ) |

inline

Multiplies M from the right to this matrix.

## rows()

template<typename MAT>

size_type Dune::DenseMatrix< MAT >::rows | ( |  | ) | const

inline constexpr

number of rows

## size()

template<typename MAT>

size_type Dune::DenseMatrix< MAT >::size | ( |  | ) | const

inline constexpr

size method (number of rows)

## solve()

template<typename MAT>
template<class V1, class V2>

void Dune::DenseMatrix< MAT >::solve | ( | V1 & | x,
|  | const V2 & | b,
|  | bool | doPivoting = true ) const

Solve system A x = b.

Exceptions

  FMatrixError | if the matrix is singular

## umhv()

template<typename MAT>
template<class X, class Y>

void Dune::DenseMatrix< MAT >::umhv | ( | const X & | x,
|  | Y & | y ) const

inline constexpr

y += A^H x

## umtv()

template<typename MAT>
template<class X, class Y>

void Dune::DenseMatrix< MAT >::umtv | ( | const X & | x,
|  | Y & | y ) const

inline constexpr

y += A^T x

## umv()

template<typename MAT>
template<class X, class Y>

void Dune::DenseMatrix< MAT >::umv | ( | const X & | x,
|  | Y & | y ) const

inline constexpr

y += A x

## usmhv()

template<typename MAT>
template<class X, class Y>

void Dune::DenseMatrix< MAT >::usmhv | ( | const typename FieldTraits< Y >::field_type & | alpha,
|  | const X & | x,
|  | Y & | y ) const

inline constexpr

y += alpha A^H x

## usmtv()

template<typename MAT>
template<class X, class Y>

void Dune::DenseMatrix< MAT >::usmtv | ( | const typename FieldTraits< Y >::field_type & | alpha,
|  | const X & | x,
|  | Y & | y ) const

inline constexpr

y += alpha A^T x

## usmv()

template<typename MAT>
template<class X, class Y>

void Dune::DenseMatrix< MAT >::usmv | ( | const typename FieldTraits< Y >::field_type & | alpha,
|  | const X & | x,
|  | Y & | y ) const

inline constexpr

y += alpha A x

## Friends And Related Symbol Documentation

## DenseMatrix

template<typename MAT>
template<class>

friend class DenseMatrix

friend

## Member Data Documentation

## blocklevel

template<typename MAT>

int Dune::DenseMatrix< MAT >::blocklevel = 1

static constexpr

The number of block levels we contain. This is the leaf, that is, 1.

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

- densematrix.hh