Matrix and Vector classes that support a block recursive structure capable of representing the natural structure from Finite Element discretisations. More...

Collaboration diagram for Sparse Matrix and Vector classes:

Modules
	Block Recursive Iterative Kernels

	IO for matrices and vectors.
	Provides methods for reading and writing matrices and vectors in various formats.

	DenseMatVec

Files
file	matrixmatrix.hh
	provides functions for sparse matrix matrix multiplication.

file	matrixutils.hh
	Some handy generic functions for ISTL matrices.

Classes
struct	Dune::MatrixDimension< M >

struct	Dune::CompressionStatistics< size_type >
	Statistics about compression achieved in implicit mode. More...

class	Dune::ImplicitMatrixBuilder< M_ >
	A wrapper for uniform access to the BCRSMatrix during and after the build stage in implicit build mode. More...

class	Dune::BCRSMatrix< B, A >
	A sparse block matrix with compressed row storage. More...

struct	Dune::FieldTraits< BCRSMatrix< B, A > >

class	Dune::BDMatrix< B, A >
	A block-diagonal matrix. More...

struct	Dune::FieldTraits< BDMatrix< B, A > >

class	Dune::BTDMatrix< B, A >
	A block-tridiagonal matrix. More...

struct	Dune::FieldTraits< BTDMatrix< B, A > >

class	Dune::BlockVector< B, A >
	A vector of blocks with memory management. More...

class	Dune::Matrix< T, A >
	A generic dynamic dense matrix. More...

struct	Dune::FieldTraits< Matrix< T, A > >

struct	Dune::MatMultMatResult< M1, M2 >
	Helper TMP to get the result type of a sparse matrix matrix multiplication ( ) More...

struct	Dune::MatMultMatResult< FieldMatrix< T, n, k >, FieldMatrix< T, k, m > >

struct	Dune::MatMultMatResult< BCRSMatrix< FieldMatrix< T, n, k >, A >, BCRSMatrix< FieldMatrix< T, k, m >, A1 > >

struct	Dune::TransposedMatMultMatResult< M1, M2 >
	Helper TMP to get the result type of a sparse matrix matrix multiplication ( ) More...

struct	Dune::TransposedMatMultMatResult< FieldMatrix< T, k, n >, FieldMatrix< T, k, m > >

struct	Dune::TransposedMatMultMatResult< BCRSMatrix< FieldMatrix< T, k, n >, A >, BCRSMatrix< FieldMatrix< T, k, m >, A1 > >

struct	Dune::CheckIfDiagonalPresent< Matrix, blocklevel, l >
	Check whether the a matrix has diagonal values on blocklevel recursion levels. More...

struct	Dune::CheckIfDiagonalPresent< Matrix, 0, l >

class	Dune::MultiTypeBlockMatrix< FirstRow, Args >
	A Matrix class to support different block types. More...

struct	Dune::CheckIfDiagonalPresent< MultiTypeBlockMatrix< T1, Args... >, blocklevel, l >

struct	Dune::algmeta_itsteps< I, M >

class	Dune::MultiTypeBlockMatrix_Solver_Col< I, crow, ccol, remain_col >
	part of solvers for MultiTypeBlockVector & MultiTypeBlockMatrix types More...

class	Dune::MultiTypeBlockMatrix_Solver_Col< I, crow, ccol, 0 >

class	Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >
	solver for MultiTypeBlockVector & MultiTypeBlockMatrix types More...

class	Dune::MultiTypeBlockMatrix_Solver< I, crow, 0 >

struct	std::tuple_element< i, Dune::MultiTypeBlockMatrix< Args... > >
	Make std::tuple_element work for MultiTypeBlockMatrix. More...

class	Dune::MultiTypeBlockVector< Args >
	A Vector class to support different block types. More...

struct	std::tuple_element< i, Dune::MultiTypeBlockVector< Args... > >
	Make std::tuple_element work for MultiTypeBlockVector. More...

class	Dune::VariableBlockVector< B, A >
	A Vector of blocks with different blocksizes. More...

Typedefs
typedef BCRSMatrix< FieldMatrix< T, n, m >, A >::CreateIterator	Dune::SparsityPatternInitializer< T, A, n, m >::CreateIterator

typedef BCRSMatrix< FieldMatrix< T, n, m >, A >::size_type	Dune::SparsityPatternInitializer< T, A, n, m >::size_type

typedef Dune::BCRSMatrix< FieldMatrix< T, n, m >, TA >	Dune::MatrixInitializer< transpose, T, TA, n, m >::Matrix

typedef Matrix::CreateIterator	Dune::MatrixInitializer< transpose, T, TA, n, m >::CreateIterator

typedef Matrix::size_type	Dune::MatrixInitializer< transpose, T, TA, n, m >::size_type

typedef Dune::BCRSMatrix< Dune::FieldMatrix< T, n, m >, TA >	Dune::MatrixInitializer< 1, T, TA, n, m >::Matrix

typedef Matrix::CreateIterator	Dune::MatrixInitializer< 1, T, TA, n, m >::CreateIterator

typedef Matrix::size_type	Dune::MatrixInitializer< 1, T, TA, n, m >::size_type

typedef BCRSMatrix< FieldMatrix< T, n, m >, A >	Dune::EntryAccumulatorFather< T, A, n, m >::Matrix

typedef Matrix::RowIterator	Dune::EntryAccumulatorFather< T, A, n, m >::Row

typedef Matrix::ColIterator	Dune::EntryAccumulatorFather< T, A, n, m >::Col

typedef BCRSMatrix< FieldMatrix< T, n, m >, A >	Dune::EntryAccumulator< T, A, n, m, transpose >::Matrix

typedef Matrix::size_type	Dune::EntryAccumulator< T, A, n, m, transpose >::size_type

typedef BCRSMatrix< FieldMatrix< T, n, m >, A >	Dune::EntryAccumulator< T, A, n, m, 0 >::Matrix

typedef Matrix::size_type	Dune::EntryAccumulator< T, A, n, m, 0 >::size_type

typedef BCRSMatrix< FieldMatrix< T, n, m >, A >	Dune::EntryAccumulator< T, A, n, m, 1 >::Matrix

typedef Matrix::size_type	Dune::EntryAccumulator< T, A, n, m, 1 >::size_type

typedef BCRSMatrix< FieldMatrix< T, n, m >, A >	Dune::EntryAccumulator< T, A, n, m, 2 >::Matrix

typedef Matrix::size_type	Dune::EntryAccumulator< T, A, n, m, 2 >::size_type

typedef FieldMatrix< T, n, m >	Dune::MatMultMatResult< FieldMatrix< T, n, k >, FieldMatrix< T, k, m > >::type

typedef BCRSMatrix< typename MatMultMatResult< FieldMatrix< T, n, k >, FieldMatrix< T, k, m > >::type, std::allocator< typename MatMultMatResult< FieldMatrix< T, n, k >, FieldMatrix< T, k, m > >::type > >	Dune::MatMultMatResult< BCRSMatrix< FieldMatrix< T, n, k >, A >, BCRSMatrix< FieldMatrix< T, k, m >, A1 > >::type

typedef FieldMatrix< T, n, m >	Dune::TransposedMatMultMatResult< FieldMatrix< T, k, n >, FieldMatrix< T, k, m > >::type

typedef BCRSMatrix< typename MatMultMatResult< FieldMatrix< T, n, k >, FieldMatrix< T, k, m > >::type, std::allocator< typename MatMultMatResult< FieldMatrix< T, n, k >, FieldMatrix< T, k, m > >::type > >	Dune::TransposedMatMultMatResult< BCRSMatrix< FieldMatrix< T, k, n >, A >, BCRSMatrix< FieldMatrix< T, k, m >, A1 > >::type

typedef MultiTypeBlockMatrix< FirstRow, Args... >	Dune::MultiTypeBlockMatrix< FirstRow, Args >::type

using	Dune::MultiTypeBlockMatrix< FirstRow, Args >::size_type = std::size_t
	Type used for sizes. More...

typedef FirstRow::field_type	Dune::MultiTypeBlockMatrix< FirstRow, Args >::field_type

using	std::tuple_element< i, Dune::MultiTypeBlockMatrix< Args... > >::type = typename std::tuple_element< i, std::tuple< Args... > >::type

using	Dune::FieldTraits< MultiTypeBlockVector< Args... > >::field_type = typename MultiTypeBlockVector< Args... >::field_type

using	Dune::FieldTraits< MultiTypeBlockVector< Args... > >::real_type = typename FieldTraits< field_type >::real_type

using	Dune::MultiTypeBlockVector< Args >::size_type = std::size_t
	Type used for vector sizes. More...

typedef MultiTypeBlockVector< Args... >	Dune::MultiTypeBlockVector< Args >::type

using	Dune::MultiTypeBlockVector< Args >::field_type = Std::detected_t< std::common_type_t, typename FieldTraits< std::decay_t< Args > >::field_type... >
	The type used for scalars. More...

using	std::tuple_element< i, Dune::MultiTypeBlockVector< Args... > >::type = typename std::tuple_element< i, std::tuple< Args... > >::type

Enumerations
enum	{ Dune::SparsityPatternInitializer< T, A, n, m >::do_break =true }

enum	{ Dune::MatrixInitializer< transpose, T, TA, n, m >::do_break =true }

enum	{ Dune::MatrixInitializer< 1, T, TA, n, m >::do_break =false }

enum	{ Dune::EntryAccumulatorFather< T, A, n, m >::do_break =false }

Functions
template<class T , class A , class A1 , class A2 , int n, int m, int k>
void	Dune::matMultTransposeMat (BCRSMatrix< FieldMatrix< T, n, k >, A > &res, const BCRSMatrix< FieldMatrix< T, n, m >, A1 > &mat, const BCRSMatrix< FieldMatrix< T, k, m >, A2 > &matt, bool tryHard=false)
	Calculate product of a sparse matrix with a transposed sparse matrices ( ). More...

template<class T , class A , class A1 , class A2 , int n, int m, int k>
void	Dune::matMultMat (BCRSMatrix< FieldMatrix< T, n, m >, A > &res, const BCRSMatrix< FieldMatrix< T, n, k >, A1 > &mat, const BCRSMatrix< FieldMatrix< T, k, m >, A2 > &matt, bool tryHard=false)
	Calculate product of two sparse matrices ( ). More...

template<class T , class A , class A1 , class A2 , int n, int m, int k>
void	Dune::transposeMatMultMat (BCRSMatrix< FieldMatrix< T, n, m >, A > &res, const BCRSMatrix< FieldMatrix< T, k, n >, A1 > &mat, const BCRSMatrix< FieldMatrix< T, k, m >, A2 > &matt, bool tryHard=false)
	Calculate product of a transposed sparse matrix with another sparse matrices ( ). More...

template<class M >
auto	Dune::countNonZeros (const M &, typename std::enable_if_t< Dune::IsNumber< M >::value > *sfinae=nullptr)
	Get the number of nonzero fields in the matrix. More...

template<class M >
auto	Dune::countNonZeros (const M &matrix, typename std::enable_if_t<!Dune::IsNumber< M >::value > *sfinae=nullptr)

static constexpr size_type	Dune::MultiTypeBlockMatrix< FirstRow, Args >::N ()
	Return the number of matrix rows. More...

static constexpr size_type	Dune::MultiTypeBlockMatrix< FirstRow, Args >::size ()
	Return the number of matrix rows. More...

static constexpr size_type	Dune::MultiTypeBlockMatrix< FirstRow, Args >::M ()
	Return the number of matrix columns. More...

template<size_type index>
auto	Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator[] (const std::integral_constant< size_type, index > indexVariable) -> decltype(std::get< index >(*this))
	Random-access operator. More...

template<size_type index>
auto	Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator[] (const std::integral_constant< size_type, index > indexVariable) const -> decltype(std::get< index >(*this))
	Const random-access operator. More...

template<typename T >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator= (const T &newval)

MultiTypeBlockMatrix &	Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator*= (const field_type &k)
	vector space multiplication with scalar More...

MultiTypeBlockMatrix &	Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator/= (const field_type &k)
	vector space division by scalar More...

MultiTypeBlockMatrix &	Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator+= (const MultiTypeBlockMatrix &b)
	Add the entries of another matrix to this one. More...

MultiTypeBlockMatrix &	Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator-= (const MultiTypeBlockMatrix &b)
	Subtract the entries of another matrix from this one. More...

template<typename X , typename Y >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::mv (const X &x, Y &y) const
	y = A x More...

template<typename X , typename Y >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::umv (const X &x, Y &y) const
	y += A x More...

template<typename X , typename Y >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::mmv (const X &x, Y &y) const
	y -= A x More...

template<typename AlphaType , typename X , typename Y >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::usmv (const AlphaType &alpha, const X &x, Y &y) const
	y += alpha A x More...

template<typename X , typename Y >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::mtv (const X &x, Y &y) const
	y = A^T x More...

template<typename X , typename Y >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::umtv (const X &x, Y &y) const
	y += A^T x More...

template<typename X , typename Y >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::mmtv (const X &x, Y &y) const
	y -= A^T x More...

template<typename X , typename Y >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::usmtv (const field_type &alpha, const X &x, Y &y) const
	y += alpha A^T x More...

template<typename X , typename Y >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::umhv (const X &x, Y &y) const
	y += A^H x More...

template<typename X , typename Y >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::mmhv (const X &x, Y &y) const
	y -= A^H x More...

template<typename X , typename Y >
void	Dune::MultiTypeBlockMatrix< FirstRow, Args >::usmhv (const field_type &alpha, const X &x, Y &y) const
	y += alpha A^H x More...

auto	Dune::MultiTypeBlockMatrix< FirstRow, Args >::frobenius_norm2 () const
	square of frobenius norm, need for block recursion More...

FieldTraits< field_type >::real_type	Dune::MultiTypeBlockMatrix< FirstRow, Args >::frobenius_norm () const
	frobenius norm: sqrt(sum over squared values of entries) More...

auto	Dune::MultiTypeBlockMatrix< FirstRow, Args >::infinity_norm () const
	Bastardized version of the infinity-norm / row-sum norm. More...

auto	Dune::MultiTypeBlockMatrix< FirstRow, Args >::infinity_norm_real () const
	Bastardized version of the infinity-norm / row-sum norm. More...

template<typename T1 , typename... Args>
std::ostream &	Dune::operator<< (std::ostream &s, const MultiTypeBlockMatrix< T1, Args... > &m)
	<< operator for a MultiTypeBlockMatrix More...

template<typename Trhs , typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver_Col< I, crow, ccol, remain_col >::calc_rhs (const TMatrix &A, TVector &x, TVector &v, Trhs &b, const K &w)

template<typename Trhs , typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver_Col< I, crow, ccol, 0 >::calc_rhs (const TMatrix &, TVector &, TVector &, Trhs &, const K &)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::dbgs (const TMatrix &A, TVector &x, const TVector &b, const K &w)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::dbgs (const TMatrix &A, TVector &x, TVector &v, const TVector &b, const K &w)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::bsorf (const TMatrix &A, TVector &x, const TVector &b, const K &w)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::bsorf (const TMatrix &A, TVector &x, TVector &v, const TVector &b, const K &w)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::bsorb (const TMatrix &A, TVector &x, const TVector &b, const K &w)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::bsorb (const TMatrix &A, TVector &x, TVector &v, const TVector &b, const K &w)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::dbjac (const TMatrix &A, TVector &x, const TVector &b, const K &w)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::dbjac (const TMatrix &A, TVector &x, TVector &v, const TVector &b, const K &w)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, 0 >::dbgs (const TMatrix &, TVector &, TVector &, const TVector &, const K &)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, 0 >::bsorf (const TMatrix &, TVector &, TVector &, const TVector &, const K &)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, 0 >::bsorb (const TMatrix &, TVector &, TVector &, const TVector &, const K &)

template<typename TVector , typename TMatrix , typename K >
static void	Dune::MultiTypeBlockMatrix_Solver< I, crow, 0 >::dbjac (const TMatrix &, TVector &, TVector &, const TVector &, const K &)

static constexpr size_type	Dune::MultiTypeBlockVector< Args >::size ()
	Return the number of non-zero vector entries. More...

static constexpr size_type	Dune::MultiTypeBlockVector< Args >::N ()
	Number of elements. More...

int	Dune::MultiTypeBlockVector< Args >::count () const

size_type	Dune::MultiTypeBlockVector< Args >::dim () const
	Number of scalar elements. More...

template<size_type index>
std::tuple_element< index, TupleType >::type &	Dune::MultiTypeBlockVector< Args >::operator[] (const std::integral_constant< size_type, index > indexVariable)
	Random-access operator. More...

template<size_type index>
const std::tuple_element< index, TupleType >::type &	Dune::MultiTypeBlockVector< Args >::operator[] (const std::integral_constant< size_type, index > indexVariable) const
	Const random-access operator. More...

template<typename T >
void	Dune::MultiTypeBlockVector< Args >::operator= (const T &newval)
	Assignment operator. More...

void	Dune::MultiTypeBlockVector< Args >::operator+= (const type &newv)

void	Dune::MultiTypeBlockVector< Args >::operator-= (const type &newv)

template<class T , std::enable_if_t< IsNumber< T >::value, int > = 0>
void	Dune::MultiTypeBlockVector< Args >::operator*= (const T &w)
	Multiplication with a scalar. More...

template<class T , std::enable_if_t< IsNumber< T >::value, int > = 0>
void	Dune::MultiTypeBlockVector< Args >::operator/= (const T &w)
	Division by a scalar. More...

field_type	Dune::MultiTypeBlockVector< Args >::operator* (const type &newv) const

field_type	Dune::MultiTypeBlockVector< Args >::dot (const type &newv) const

auto	Dune::MultiTypeBlockVector< Args >::one_norm () const
	Compute the 1-norm. More...

auto	Dune::MultiTypeBlockVector< Args >::one_norm_real () const
	Compute the simplified 1-norm (uses 1-norm also for complex values) More...

FieldTraits< field_type >::real_type	Dune::MultiTypeBlockVector< Args >::two_norm2 () const
	Compute the squared Euclidean norm. More...

FieldTraits< field_type >::real_type	Dune::MultiTypeBlockVector< Args >::two_norm () const
	Compute the Euclidean norm. More...

FieldTraits< field_type >::real_type	Dune::MultiTypeBlockVector< Args >::infinity_norm () const
	Compute the maximum norm. More...

FieldTraits< field_type >::real_type	Dune::MultiTypeBlockVector< Args >::infinity_norm_real () const
	Compute the simplified maximum norm (uses 1-norm for complex values) More...

template<typename Ta >
void	Dune::MultiTypeBlockVector< Args >::axpy (const Ta &a, const type &y)
	Axpy operation on this vector (this += a y) More...

template<typename... Args>
std::ostream &	Dune::operator<< (std::ostream &s, const MultiTypeBlockVector< Args... > &v)
	Send MultiTypeBlockVector to an outstream. More...

Variables
Matrix & mat

Col col

Detailed Description

Matrix and Vector classes that support a block recursive structure capable of representing the natural structure from Finite Element discretisations.

The interface of our matrices is designed according to what they represent from a mathematical point of view. The vector classes are representations of vector spaces:

FieldVector represents a vector space where the field is represented by a numeric type (e.g. double, float, complex). is known at compile time.
BlockVector represents a vector space $V=W\times W \times W \times\cdots\times W$ where W is itself a vector space.
VariableBlockVector represents a vector space having a two-level block structure of the form $V=B^{n_1}\times B^{n_2}\times\ldots \times B^{n_m}$ , i.e. it is constructed from vector spaces, $i=1,\ldots,m$ .

The matrix classes represent linear maps $A: V \mapsto W$ from vector space to vector space the recursive block structure of the matrix rows and columns immediately follows from the recursive block structure of the vectors representing the domain and range of the mapping, respectively:

FieldMatrix represents a linear map $M: V_1 \to V_2$ where and are vector spaces over the same field represented by a numerix type.
BCRSMatrix represents a linear map $M: V_1 \to V_2$ where $V_1=W\times W \times W \times\cdots\times W$ and $V_2=W\times W \times W \times\cdots\times W$ where W is itself a vector space.
VariableBCRSMatrix is not yet implemented.

Typedef Documentation

◆ Col

template<class T , class A , int n, int m>

typedef Matrix::ColIterator Dune::EntryAccumulatorFather< T, A, n, m >::Col

◆ CreateIterator [1/3]

template<class T , class A , int n, int m>

typedef BCRSMatrix<FieldMatrix<T,n,m>,A>::CreateIterator Dune::SparsityPatternInitializer< T, A, n, m >::CreateIterator

◆ CreateIterator [2/3]

template<int transpose, class T , class TA , int n, int m>

typedef Matrix::CreateIterator Dune::MatrixInitializer< transpose, T, TA, n, m >::CreateIterator

◆ CreateIterator [3/3]

template<class T , class TA , int n, int m>

typedef Matrix::CreateIterator Dune::MatrixInitializer< 1, T, TA, n, m >::CreateIterator

◆ field_type [1/3]

template<typename FirstRow , typename... Args>

typedef FirstRow::field_type Dune::MultiTypeBlockMatrix< FirstRow, Args >::field_type

◆ field_type [2/3]

template<typename... Args>

using Dune::FieldTraits< MultiTypeBlockVector< Args... > >::field_type = typename MultiTypeBlockVector<Args...>::field_type

◆ field_type [3/3]

template<typename... Args>

using Dune::MultiTypeBlockVector< Args >::field_type = Std::detected_t<std::common_type_t, typename FieldTraits< std::decay_t<Args> >::field_type...>

The type used for scalars.

Use the std::common_type_t of the Args' field_type and use nonesuch if no implementation of std::common_type is provided for the given field_type arguments.

◆ Matrix [1/7]

template<int transpose, class T , class TA , int n, int m>

typedef Dune::BCRSMatrix<FieldMatrix<T,n,m>,TA> Dune::MatrixInitializer< transpose, T, TA, n, m >::Matrix

◆ Matrix [2/7]

template<class T , class TA , int n, int m>

typedef Dune::BCRSMatrix<Dune::FieldMatrix<T,n,m>,TA> Dune::MatrixInitializer< 1, T, TA, n, m >::Matrix

◆ Matrix [3/7]

template<class T , class A , int n, int m>

typedef BCRSMatrix<FieldMatrix<T,n,m>,A> Dune::EntryAccumulatorFather< T, A, n, m >::Matrix

◆ Matrix [4/7]

template<class T , class A , int n, int m, int transpose>

typedef BCRSMatrix<FieldMatrix<T,n,m>,A> Dune::EntryAccumulator< T, A, n, m, transpose >::Matrix

◆ Matrix [5/7]

template<class T , class A , int n, int m>

typedef BCRSMatrix<FieldMatrix<T,n,m>,A> Dune::EntryAccumulator< T, A, n, m, 0 >::Matrix

◆ Matrix [6/7]

template<class T , class A , int n, int m>

typedef BCRSMatrix<FieldMatrix<T,n,m>,A> Dune::EntryAccumulator< T, A, n, m, 1 >::Matrix

◆ Matrix [7/7]

template<class T , class A , int n, int m>

typedef BCRSMatrix<FieldMatrix<T,n,m>,A> Dune::EntryAccumulator< T, A, n, m, 2 >::Matrix

◆ real_type

template<typename... Args>

using Dune::FieldTraits< MultiTypeBlockVector< Args... > >::real_type = typename FieldTraits<field_type>::real_type

◆ Row

template<class T , class A , int n, int m>

typedef Matrix::RowIterator Dune::EntryAccumulatorFather< T, A, n, m >::Row

◆ size_type [1/9]

template<class T , class A , int n, int m>

typedef BCRSMatrix<FieldMatrix<T,n,m>,A>::size_type Dune::SparsityPatternInitializer< T, A, n, m >::size_type

◆ size_type [2/9]

template<int transpose, class T , class TA , int n, int m>

typedef Matrix::size_type Dune::MatrixInitializer< transpose, T, TA, n, m >::size_type

◆ size_type [3/9]

template<class T , class TA , int n, int m>

typedef Matrix::size_type Dune::MatrixInitializer< 1, T, TA, n, m >::size_type

◆ size_type [4/9]

template<class T , class A , int n, int m, int transpose>

typedef Matrix::size_type Dune::EntryAccumulator< T, A, n, m, transpose >::size_type

◆ size_type [5/9]

template<class T , class A , int n, int m>

typedef Matrix::size_type Dune::EntryAccumulator< T, A, n, m, 0 >::size_type

◆ size_type [6/9]

template<class T , class A , int n, int m>

typedef Matrix::size_type Dune::EntryAccumulator< T, A, n, m, 1 >::size_type

◆ size_type [7/9]

template<class T , class A , int n, int m>

typedef Matrix::size_type Dune::EntryAccumulator< T, A, n, m, 2 >::size_type

◆ size_type [8/9]

template<typename FirstRow , typename... Args>

using Dune::MultiTypeBlockMatrix< FirstRow, Args >::size_type = std::size_t

Type used for sizes.

◆ size_type [9/9]

template<typename... Args>

using Dune::MultiTypeBlockVector< Args >::size_type = std::size_t

Type used for vector sizes.

◆ type [1/8]

template<typename T , int n, int k, int m>

typedef FieldMatrix<T,n,m> Dune::MatMultMatResult< FieldMatrix< T, n, k >, FieldMatrix< T, k, m > >::type

◆ type [2/8]

template<typename T , typename A , typename A1 , int n, int k, int m>

typedef BCRSMatrix<typename MatMultMatResult<FieldMatrix<T,n,k>,FieldMatrix<T,k,m> >::type, std::allocator<typename MatMultMatResult<FieldMatrix<T,n,k>,FieldMatrix<T,k,m> >::type> > Dune::MatMultMatResult< BCRSMatrix< FieldMatrix< T, n, k >, A >, BCRSMatrix< FieldMatrix< T, k, m >, A1 > >::type

◆ type [3/8]

template<typename T , int n, int k, int m>

typedef FieldMatrix<T,n,m> Dune::TransposedMatMultMatResult< FieldMatrix< T, k, n >, FieldMatrix< T, k, m > >::type

◆ type [4/8]

template<typename T , typename A , typename A1 , int n, int k, int m>

typedef BCRSMatrix<typename MatMultMatResult<FieldMatrix<T,n,k>,FieldMatrix<T,k,m> >::type, std::allocator<typename MatMultMatResult<FieldMatrix<T,n,k>,FieldMatrix<T,k,m> >::type> > Dune::TransposedMatMultMatResult< BCRSMatrix< FieldMatrix< T, k, n >, A >, BCRSMatrix< FieldMatrix< T, k, m >, A1 > >::type

◆ type [5/8]

template<typename FirstRow , typename... Args>

typedef MultiTypeBlockMatrix<FirstRow, Args...> Dune::MultiTypeBlockMatrix< FirstRow, Args >::type

own class' type

◆ type [6/8]

template<size_t i, typename... Args>

using std::tuple_element< i, Dune::MultiTypeBlockMatrix< Args... > >::type = typename std::tuple_element<i, std::tuple<Args...> >::type

◆ type [7/8]

template<typename... Args>

typedef MultiTypeBlockVector<Args...> Dune::MultiTypeBlockVector< Args >::type

own class' type

◆ type [8/8]

template<size_t i, typename... Args>

using std::tuple_element< i, Dune::MultiTypeBlockVector< Args... > >::type = typename std::tuple_element<i, std::tuple<Args...> >::type

Enumeration Type Documentation

◆ anonymous enum

template<class T , class A , int n, int m>

anonymous enum

Enumerator
do_break

◆ anonymous enum

template<int transpose, class T , class TA , int n, int m>

anonymous enum

Enumerator
do_break

◆ anonymous enum

template<class T , class TA , int n, int m>

anonymous enum

Enumerator
do_break

◆ anonymous enum

template<class T , class A , int n, int m>

anonymous enum

Enumerator
do_break

Function Documentation

◆ axpy()

template<typename... Args>

template<typename Ta >

void Dune::MultiTypeBlockVector< Args >::axpy	(	const Ta &	a,
		const type &	y
	)

inline

Axpy operation on this vector (*this += a * y)

Template Parameters

Ta	Type of the scalar 'a'

◆ bsorb() [1/3]

template<int I, int crow>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, 0 >::bsorb	(	const TMatrix &	,
		TVector &	,
		TVector &	,
		const TVector &	,
		const K &
	)

inlinestatic

◆ bsorb() [2/3]

template<int I, int crow, int remain_row>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::bsorb	(	const TMatrix &	A,
		TVector &	x,
		const TVector &	b,
		const K &	w
	)

inlinestatic

bsorb for MultiTypeBlockMatrix & MultiTypeBlockVector types

◆ bsorb() [3/3]

template<int I, int crow, int remain_row>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::bsorb	(	const TMatrix &	A,
		TVector &	x,
		TVector &	v,
		const TVector &	b,
		const K &	w
	)

inlinestatic

◆ bsorf() [1/3]

template<int I, int crow>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, 0 >::bsorf	(	const TMatrix &	,
		TVector &	,
		TVector &	,
		const TVector &	,
		const K &
	)

inlinestatic

◆ bsorf() [2/3]

template<int I, int crow, int remain_row>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::bsorf	(	const TMatrix &	A,
		TVector &	x,
		const TVector &	b,
		const K &	w
	)

inlinestatic

bsorf for MultiTypeBlockMatrix & MultiTypeBlockVector types

◆ bsorf() [3/3]

template<int I, int crow, int remain_row>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::bsorf	(	const TMatrix &	A,
		TVector &	x,
		TVector &	v,
		const TVector &	b,
		const K &	w
	)

inlinestatic

◆ calc_rhs() [1/2]

template<int I, int crow, int ccol>

template<typename Trhs , typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver_Col< I, crow, ccol, 0 >::calc_rhs	(	const TMatrix &	,
		TVector &	,
		TVector &	,
		Trhs &	,
		const K &
	)

inlinestatic

◆ calc_rhs() [2/2]

template<int I, int crow, int ccol, int remain_col>

template<typename Trhs , typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver_Col< I, crow, ccol, remain_col >::calc_rhs	(	const TMatrix &	A,
		TVector &	x,
		TVector &	v,
		Trhs &	b,
		const K &	w
	)

inlinestatic

iterating over one row in MultiTypeBlockMatrix to calculate right side b-A[i][j]*x[j]

◆ count()

template<typename... Args>

int Dune::MultiTypeBlockVector< Args >::count ( ) const

inline

number of elements

Deprecated:: Use method N instead. This will be removed after Dune 2.8.

◆ countNonZeros() [1/2]

template<class M >

auto Dune::countNonZeros	(	const M &	,
		typename std::enable_if_t< Dune::IsNumber< M >::value > *	sfinae = `nullptr`
	)

inline

Get the number of nonzero fields in the matrix.

This is not the number of nonzero blocks, but the number of non zero scalar entries (on blocklevel 1) if the matrix is viewed as a flat matrix.

For FieldMatrix this is simply the number of columns times the number of rows, for a BCRSMatrix<FieldMatrix<K,n,m>> this is the number of nonzero blocks time n*m.

◆ countNonZeros() [2/2]

template<class M >

auto Dune::countNonZeros	(	const M &	matrix,
		typename std::enable_if_t<!Dune::IsNumber< M >::value > *	sfinae = `nullptr`
	)

inline

◆ dbgs() [1/3]

template<int I, int crow>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, 0 >::dbgs	(	const TMatrix &	,
		TVector &	,
		TVector &	,
		const TVector &	,
		const K &
	)

inlinestatic

◆ dbgs() [2/3]

template<int I, int crow, int remain_row>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::dbgs	(	const TMatrix &	A,
		TVector &	x,
		const TVector &	b,
		const K &	w
	)

inlinestatic

Gauss-Seidel solver for MultiTypeBlockMatrix & MultiTypeBlockVector types

◆ dbgs() [3/3]

template<int I, int crow, int remain_row>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::dbgs	(	const TMatrix &	A,
		TVector &	x,
		TVector &	v,
		const TVector &	b,
		const K &	w
	)

inlinestatic

◆ dbjac() [1/3]

template<int I, int crow>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, 0 >::dbjac	(	const TMatrix &	,
		TVector &	,
		TVector &	,
		const TVector &	,
		const K &
	)

inlinestatic

◆ dbjac() [2/3]

template<int I, int crow, int remain_row>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::dbjac	(	const TMatrix &	A,
		TVector &	x,
		const TVector &	b,
		const K &	w
	)

inlinestatic

Jacobi solver for MultiTypeBlockMatrix & MultiTypeBlockVector types

◆ dbjac() [3/3]

template<int I, int crow, int remain_row>

template<typename TVector , typename TMatrix , typename K >

static void Dune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >::dbjac	(	const TMatrix &	A,
		TVector &	x,
		TVector &	v,
		const TVector &	b,
		const K &	w
	)

inlinestatic

◆ dim()

template<typename... Args>

size_type Dune::MultiTypeBlockVector< Args >::dim ( ) const

inline

Number of scalar elements.

◆ dot()

template<typename... Args>

field_type Dune::MultiTypeBlockVector< Args >::dot ( const type & newv ) const

inline

◆ frobenius_norm()

template<typename FirstRow , typename... Args>

FieldTraits< field_type >::real_type Dune::MultiTypeBlockMatrix< FirstRow, Args >::frobenius_norm ( ) const

inline

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

◆ frobenius_norm2()

template<typename FirstRow , typename... Args>

auto Dune::MultiTypeBlockMatrix< FirstRow, Args >::frobenius_norm2 ( ) const

inline

square of frobenius norm, need for block recursion

◆ infinity_norm() [1/2]

template<typename FirstRow , typename... Args>

auto Dune::MultiTypeBlockMatrix< FirstRow, Args >::infinity_norm ( ) const

inline

Bastardized version of the infinity-norm / row-sum norm.

◆ infinity_norm() [2/2]

template<typename... Args>

FieldTraits< field_type >::real_type Dune::MultiTypeBlockVector< Args >::infinity_norm ( ) const

inline

Compute the maximum norm.

◆ infinity_norm_real() [1/2]

template<typename FirstRow , typename... Args>

auto Dune::MultiTypeBlockMatrix< FirstRow, Args >::infinity_norm_real ( ) const

inline

Bastardized version of the infinity-norm / row-sum norm.

◆ infinity_norm_real() [2/2]

template<typename... Args>

FieldTraits< field_type >::real_type Dune::MultiTypeBlockVector< Args >::infinity_norm_real ( ) const

inline

Compute the simplified maximum norm (uses 1-norm for complex values)

◆ M()

template<typename FirstRow , typename... Args>

static constexpr size_type Dune::MultiTypeBlockMatrix< FirstRow, Args >::M ( )

inlinestaticconstexpr

Return the number of matrix columns.

◆ matMultMat()

template<class T , class A , class A1 , class A2 , int n, int m, int k>

void Dune::matMultMat	(	BCRSMatrix< FieldMatrix< T, n, m >, A > &	res,
		const BCRSMatrix< FieldMatrix< T, n, k >, A1 > &	mat,
		const BCRSMatrix< FieldMatrix< T, k, m >, A2 > &	matt,
		bool	tryHard = `false`
	)

Calculate product of two sparse matrices ( ).

Parameters

res	Matrix for the result of the computation.
mat	Matrix A.
matt	Matrix B.
tryHard	ignored

◆ matMultTransposeMat()

template<class T , class A , class A1 , class A2 , int n, int m, int k>

void Dune::matMultTransposeMat	(	BCRSMatrix< FieldMatrix< T, n, k >, A > &	res,
		const BCRSMatrix< FieldMatrix< T, n, m >, A1 > &	mat,
		const BCRSMatrix< FieldMatrix< T, k, m >, A2 > &	matt,
		bool	tryHard = `false`
	)

Calculate product of a sparse matrix with a transposed sparse matrices ( ).

Parameters

res	Matrix for the result of the computation.
mat	Matrix A.
matt	Matrix B, which will be transposed before the multiplication.
tryHard	ignored

◆ mmhv()

template<typename FirstRow , typename... Args>

template<typename X , typename Y >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::mmhv	(	const X &	x,
		Y &	y
	)		const

inline

y -= A^H x

◆ mmtv()

template<typename FirstRow , typename... Args>

template<typename X , typename Y >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::mmtv	(	const X &	x,
		Y &	y
	)		const

inline

y -= A^T x

◆ mmv()

template<typename FirstRow , typename... Args>

template<typename X , typename Y >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::mmv	(	const X &	x,
		Y &	y
	)		const

inline

y -= A x

◆ mtv()

template<typename FirstRow , typename... Args>

template<typename X , typename Y >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::mtv	(	const X &	x,
		Y &	y
	)		const

inline

y = A^T x

◆ mv()

template<typename FirstRow , typename... Args>

template<typename X , typename Y >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::mv	(	const X &	x,
		Y &	y
	)		const

inline

y = A x

◆ N() [1/2]

template<typename FirstRow , typename... Args>

static constexpr size_type Dune::MultiTypeBlockMatrix< FirstRow, Args >::N ( )

inlinestaticconstexpr

Return the number of matrix rows.

◆ N() [2/2]

template<typename... Args>

static constexpr size_type Dune::MultiTypeBlockVector< Args >::N ( )

inlinestaticconstexpr

Number of elements.

◆ one_norm()

template<typename... Args>

auto Dune::MultiTypeBlockVector< Args >::one_norm ( ) const

inline

Compute the 1-norm.

◆ one_norm_real()

template<typename... Args>

auto Dune::MultiTypeBlockVector< Args >::one_norm_real ( ) const

inline

Compute the simplified 1-norm (uses 1-norm also for complex values)

◆ operator*()

template<typename... Args>

field_type Dune::MultiTypeBlockVector< Args >::operator* ( const type & newv ) const

inline

◆ operator*=() [1/2]

template<typename FirstRow , typename... Args>

MultiTypeBlockMatrix & Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator*= ( const field_type & k )

inline

vector space multiplication with scalar

◆ operator*=() [2/2]

template<typename... Args>

template<class T , std::enable_if_t< IsNumber< T >::value, int > = 0>

void Dune::MultiTypeBlockVector< Args >::operator*= ( const T & w )

inline

Multiplication with a scalar.

◆ operator+=() [1/2]

template<typename FirstRow , typename... Args>

MultiTypeBlockMatrix & Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator+= ( const MultiTypeBlockMatrix< FirstRow, Args > & b )

inline

Add the entries of another matrix to this one.

Parameters

b	The matrix to add to this one. Its sparsity pattern has to be subset of the sparsity pattern of this matrix.

◆ operator+=() [2/2]

template<typename... Args>

void Dune::MultiTypeBlockVector< Args >::operator+= ( const type & newv )

inline

operator for MultiTypeBlockVector += MultiTypeBlockVector operations

◆ operator-=() [1/2]

template<typename FirstRow , typename... Args>

MultiTypeBlockMatrix & Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator-= ( const MultiTypeBlockMatrix< FirstRow, Args > & b )

inline

Subtract the entries of another matrix from this one.

Parameters

b	The matrix to subtract from this one. Its sparsity pattern has to be subset of the sparsity pattern of this matrix.

◆ operator-=() [2/2]

template<typename... Args>

void Dune::MultiTypeBlockVector< Args >::operator-= ( const type & newv )

inline

operator for MultiTypeBlockVector -= MultiTypeBlockVector operations

◆ operator/=() [1/2]

template<typename FirstRow , typename... Args>

MultiTypeBlockMatrix & Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator/= ( const field_type & k )

inline

vector space division by scalar

◆ operator/=() [2/2]

template<typename... Args>

template<class T , std::enable_if_t< IsNumber< T >::value, int > = 0>

void Dune::MultiTypeBlockVector< Args >::operator/= ( const T & w )

inline

Division by a scalar.

◆ operator<<() [1/2]

template<typename T1 , typename... Args>

std::ostream & Dune::operator<<	(	std::ostream &	s,
		const MultiTypeBlockMatrix< T1, Args... > &	m
	)

<< operator for a MultiTypeBlockMatrix

operator<< for printing out a MultiTypeBlockMatrix

◆ operator<<() [2/2]

template<typename... Args>

std::ostream & Dune::operator<<	(	std::ostream &	s,
		const MultiTypeBlockVector< Args... > &	v
	)

Send MultiTypeBlockVector to an outstream.

◆ operator=() [1/2]

template<typename FirstRow , typename... Args>

template<typename T >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator= ( const T & newval )

inline

assignment operator

◆ operator=() [2/2]

template<typename... Args>

template<typename T >

void Dune::MultiTypeBlockVector< Args >::operator= ( const T & newval )

inline

Assignment operator.

◆ operator[]() [1/4]

template<typename... Args>

template<size_type index>

std::tuple_element< index, TupleType >::type & Dune::MultiTypeBlockVector< Args >::operator[] ( const std::integral_constant< size_type, index > indexVariable )

inline

Random-access operator.

This method mimicks the behavior of normal vector access with square brackets like, e.g., v[5] = 1. The problem is that the return type is different for each value of the argument in the brackets. Therefore we implement a trick using std::integral_constant. To access the first entry of a MultiTypeBlockVector named v write

MultiTypeBlockVector<A,B,C,D> v;
std::integral_constant<std::size_t,0> _0;
v[_0] = ...

The name '_0' used here as a static replacement of the integer number zero is arbitrary. Any other variable name can be used. If you don't like the separate variable, you can writee

MultiTypeBlockVector<A,B,C,D> v;

v[std::integral_constant<std::size_t,0>()] = ...

◆ operator[]() [2/4]

template<typename FirstRow , typename... Args>

template<size_type index>

auto Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator[] ( const std::integral_constant< size_type, index > indexVariable ) -> decltype(std::get<index>(*this))

inline

Random-access operator.

This method mimicks the behavior of normal vector access with square brackets like, e.g., m[5] = .... The problem is that the return type is different for each value of the argument in the brackets. Therefore we implement a trick using std::integral_constant. To access the first row of a MultiTypeBlockMatrix named m write

std::integral_constant<size_type,0> _0;

m[_0] = ...

The name '_0' used here as a static replacement of the integer number zero is arbitrary. Any other variable name can be used. If you don't like the separate variable, you can write

m[std::integral_constant<size_type,0>()] = ...

◆ operator[]() [3/4]

template<typename... Args>

template<size_type index>

const std::tuple_element< index, TupleType >::type & Dune::MultiTypeBlockVector< Args >::operator[] ( const std::integral_constant< size_type, index > indexVariable ) const

inline

Const random-access operator.

This is the const version of the random-access operator. See the non-const version for a full explanation of how to use it.

◆ operator[]() [4/4]

template<typename FirstRow , typename... Args>

template<size_type index>

auto Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator[] ( const std::integral_constant< size_type, index > indexVariable ) const -> decltype(std::get<index>(*this))

inline

Const random-access operator.

This is the const version of the random-access operator. See the non-const version for a full explanation of how to use it.

◆ size() [1/2]

template<typename FirstRow , typename... Args>

static constexpr size_type Dune::MultiTypeBlockMatrix< FirstRow, Args >::size ( )

inlinestaticconstexpr

Return the number of matrix rows.

Deprecated:: Use method N instead. This will be removed after Dune 2.8.

◆ size() [2/2]

template<typename... Args>

static constexpr size_type Dune::MultiTypeBlockVector< Args >::size ( )

inlinestaticconstexpr

Return the number of non-zero vector entries.

As this is a dense vector data structure, all entries are non-zero, and hence 'size' returns the same number as 'N'.

◆ transposeMatMultMat()

template<class T , class A , class A1 , class A2 , int n, int m, int k>

void Dune::transposeMatMultMat	(	BCRSMatrix< FieldMatrix< T, n, m >, A > &	res,
		const BCRSMatrix< FieldMatrix< T, k, n >, A1 > &	mat,
		const BCRSMatrix< FieldMatrix< T, k, m >, A2 > &	matt,
		bool	tryHard = `false`
	)

Calculate product of a transposed sparse matrix with another sparse matrices ( ).

Parameters

res	Matrix for the result of the computation.
mat	Matrix A, which will be transposed before the multiplication.
matt	Matrix B.
tryHard	ignored

◆ two_norm()

template<typename... Args>

FieldTraits< field_type >::real_type Dune::MultiTypeBlockVector< Args >::two_norm ( ) const

inline

Compute the Euclidean norm.

◆ two_norm2()

template<typename... Args>

FieldTraits< field_type >::real_type Dune::MultiTypeBlockVector< Args >::two_norm2 ( ) const

inline

Compute the squared Euclidean norm.

◆ umhv()

template<typename FirstRow , typename... Args>

template<typename X , typename Y >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::umhv	(	const X &	x,
		Y &	y
	)		const

inline

y += A^H x

◆ umtv()

template<typename FirstRow , typename... Args>

template<typename X , typename Y >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::umtv	(	const X &	x,
		Y &	y
	)		const

inline

y += A^T x

◆ umv()

template<typename FirstRow , typename... Args>

template<typename X , typename Y >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::umv	(	const X &	x,
		Y &	y
	)		const

inline

y += A x

◆ usmhv()

template<typename FirstRow , typename... Args>

template<typename X , typename Y >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::usmhv	(	const field_type &	alpha,
		const X &	x,
		Y &	y
	)		const

inline

y += alpha A^H x

◆ usmtv()

template<typename FirstRow , typename... Args>

template<typename X , typename Y >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::usmtv	(	const field_type &	alpha,
		const X &	x,
		Y &	y
	)		const

inline

y += alpha A^T x

◆ usmv()

template<typename FirstRow , typename... Args>

template<typename AlphaType , typename X , typename Y >

void Dune::MultiTypeBlockMatrix< FirstRow, Args >::usmv	(	const AlphaType &	alpha,
		const X &	x,
		Y &	y
	)		const

inline

y += alpha A x

Variable Documentation

◆ col [1/2]

Col col

protected

◆ col [2/2]

template<class T , class A , int n, int m>

Col Dune::EntryAccumulatorFather< T, A, n, m >::col

protected

◆ mat [1/2]

Matrix& mat

protected

◆ mat [2/2]

template<class T , class A , int n, int m>

Matrix& Dune::EntryAccumulatorFather< T, A, n, m >::mat

protected

Modules

Files

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ Col

◆ CreateIterator [1/3]

◆ CreateIterator [2/3]

◆ CreateIterator [3/3]

◆ field_type [1/3]

◆ field_type [2/3]

◆ field_type [3/3]

◆ Matrix [1/7]

◆ Matrix [2/7]

◆ Matrix [3/7]

◆ Matrix [4/7]

◆ Matrix [5/7]

◆ Matrix [6/7]

◆ Matrix [7/7]

◆ real_type

◆ Row

◆ size_type [1/9]

◆ size_type [2/9]

◆ size_type [3/9]

◆ size_type [4/9]

◆ size_type [5/9]

◆ size_type [6/9]

◆ size_type [7/9]

◆ size_type [8/9]

◆ size_type [9/9]

◆ type [1/8]

◆ type [2/8]

◆ type [3/8]

◆ type [4/8]

◆ type [5/8]

◆ type [6/8]

◆ type [7/8]

◆ type [8/8]

Enumeration Type Documentation

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

◆ anonymous enum

Function Documentation

◆ axpy()

◆ bsorb() [1/3]

◆ bsorb() [2/3]

◆ bsorb() [3/3]

◆ bsorf() [1/3]

◆ bsorf() [2/3]

◆ bsorf() [3/3]

◆ calc_rhs() [1/2]

◆ calc_rhs() [2/2]

◆ count()

◆ countNonZeros() [1/2]

◆ countNonZeros() [2/2]

◆ dbgs() [1/3]

◆ dbgs() [2/3]

◆ dbgs() [3/3]

◆ dbjac() [1/3]

◆ dbjac() [2/3]

◆ dbjac() [3/3]

◆ dim()

◆ dot()

◆ frobenius_norm()

◆ frobenius_norm2()

◆ infinity_norm() [1/2]

◆ infinity_norm() [2/2]

◆ infinity_norm_real() [1/2]

◆ infinity_norm_real() [2/2]

◆ M()

◆ matMultMat()

◆ matMultTransposeMat()

◆ mmhv()

◆ mmtv()

◆ mmv()