Type traits to retrieve the field and the real type of classes. More...

Files
file	densematrix.hh
	Implements a matrix constructed from a given type representing a field and a compile-time given number of rows and columns.

file	densevector.hh
	Implements the dense vector interface, with an exchangeable storage class.

file	dynmatrix.hh
	This file implements a dense matrix with dynamic numbers of rows and columns.

file	dynvector.hh
	This file implements a dense vector with a dynamic size.

file	fmatrix.hh
	Implements a matrix constructed from a given type representing a field and compile-time given number of rows and columns.

file	fvector.hh
	Implements a vector constructed from a given type representing a field and a compile-time given size.

file	scalarmatrixview.hh
	Implements a scalar matrix view wrapper around an existing scalar.

file	scalarvectorview.hh
	Implements a scalar vector view wrapper around an existing scalar.

Namespaces
namespace	Dune
	Dune namespace.

namespace	Dune::MathOverloads
	namespace for customization of math functions with Dune-Semantics

Classes
struct	Dune::DenseMatrixAssigner< DenseMatrix, RHS >
	you have to specialize this structure for any type that should be assignable to a DenseMatrix More...

class	Dune::FMatrixError
	Error thrown if operations of a FieldMatrix fail. More...

class	Dune::DenseMatrix< MAT >
	A dense n x m matrix. More...

class	Dune::DenseIterator< C, T, R >
	Generic iterator class for dense vector and matrix implementations. More...

class	Dune::DenseVector< V >
	Interface for a class of dense vectors over a given field. More...

class	Dune::DiagonalMatrix< K, n >
	A diagonal matrix of static size. More...

class	Dune::ContainerWrapperIterator< CW, T, R >
	Iterator class for sparse vector-like containers. More...

class	Dune::DynamicMatrix< K >
	Construct a matrix with a dynamic size. More...

class	Dune::DynamicVector< K, Allocator >
	Construct a vector with a dynamic size. More...

class	Dune::FieldMatrix< K, ROWS, COLS >
	A dense n x m matrix. More...

class	Dune::FieldVector< K, SIZE >
	vector space out of a tensor product of fields. More...

struct	Dune::IsFieldVectorSizeCorrect< C, SIZE >
	TMP to check the size of a DenseVectors statically, if possible. More...

class	Dune::FMatrixPrecision< ctype >
	Precisions for calculations with FieldMatrix and FieldVector. More...

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

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

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

struct	std::tuple_size< Dune::MultiTypeBlockMatrix< Args... > >
	Make std::tuple_size work for MultiTypeBlockMatrix. More...

Typedefs
typedef K	Dune::DiagonalMatrix< K, n >::value_type
	export the type representing the field

typedef K	Dune::DiagonalMatrix< K, n >::block_type
	export the type representing the components

typedef std::size_t	Dune::DiagonalMatrix< K, n >::size_type
	The type used for the index access and size operations.

typedef DiagonalRowVector< K, n >	Dune::DiagonalMatrix< K, n >::row_type
	Each row is implemented by a field vector.

typedef ContainerWrapperIterator< const WrapperType, reference, reference >	Dune::DiagonalMatrix< K, n >::Iterator
	Iterator class for sequential access.

typedef Iterator	Dune::DiagonalMatrix< K, n >::iterator
	typedef for stl compliant access

typedef Iterator	Dune::DiagonalMatrix< K, n >::RowIterator
	rename the iterators for easier access

typedef row_type::Iterator	Dune::DiagonalMatrix< K, n >::ColIterator
	rename the iterators for easier access

typedef ContainerWrapperIterator< const WrapperType, const_reference, const_reference >	Dune::DiagonalMatrix< K, n >::ConstIterator
	Iterator class for sequential access.

typedef ConstIterator	Dune::DiagonalMatrix< K, n >::const_iterator
	typedef for stl compliant access

typedef ConstIterator	Dune::DiagonalMatrix< K, n >::ConstRowIterator
	rename the iterators for easier access

typedef const_row_type::ConstIterator	Dune::DiagonalMatrix< K, n >::ConstColIterator
	rename the iterators for easier access

typedef K	Dune::DiagonalRowVectorConst< K, n >::field_type
	export the type representing the field

typedef K	Dune::DiagonalRowVectorConst< K, n >::block_type
	export the type representing the components

typedef std::size_t	Dune::DiagonalRowVectorConst< K, n >::size_type
	The type used for the index access and size operation.

typedef ContainerWrapperIterator< DiagonalRowVectorConst< K, n >, const K, const K & >	Dune::DiagonalRowVectorConst< K, n >::ConstIterator
	ConstIterator class for sequential access.

typedef ConstIterator	Dune::DiagonalRowVectorConst< K, n >::const_iterator
	typedef for stl compliant access

typedef K	Dune::DiagonalRowVector< K, n >::field_type
	export the type representing the field

typedef K	Dune::DiagonalRowVector< K, n >::block_type
	export the type representing the components

typedef std::size_t	Dune::DiagonalRowVector< K, n >::size_type
	The type used for the index access and size operation.

typedef ContainerWrapperIterator< DiagonalRowVector< K, n >, K, K & >	Dune::DiagonalRowVector< K, n >::Iterator
	Iterator class for sequential access.

typedef Iterator	Dune::DiagonalRowVector< K, n >::iterator
	typedef for stl compliant access

typedef ContainerWrapperIterator< DiagonalRowVectorConst< K, n >, const K, const K & >	Dune::DiagonalRowVector< K, n >::ConstIterator
	ConstIterator class for sequential access.

typedef ConstIterator	Dune::DiagonalRowVector< K, n >::const_iterator
	typedef for stl compliant access

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

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

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

using	Dune::MultiTypeBlockMatrix< FirstRow, Args >::real_type = Std::detected_t< std::common_type_t, typename FieldTraits< FirstRow >::real_type, typename FieldTraits< Args >::real_type... >
	The type used for real values. More...

Functions
template<typename MAT >
std::ostream &	Dune::operator<< (std::ostream &s, const DenseMatrix< MAT > &a)
	Sends the matrix to an output stream.

constexpr	Dune::DiagonalMatrix< K, n >::DiagonalMatrix ()=default
	Default constructor.

	Dune::DiagonalMatrix< K, n >::DiagonalMatrix (const K &k)
	Constructor initializing the whole matrix with a scalar.

	Dune::DiagonalMatrix< K, n >::DiagonalMatrix (const FieldVector< K, n > &diag)
	Constructor initializing the diagonal with a vector.

	Dune::DiagonalMatrix< K, n >::DiagonalMatrix (std::initializer_list< K > const &l)
	Construct diagonal matrix from an initializer list. More...

DiagonalMatrix &	Dune::DiagonalMatrix< K, n >::operator= (const K &k)
	Assignment from a scalar.

bool	Dune::DiagonalMatrix< K, n >::identical (const DiagonalMatrix< K, n > &other) const
	Check if matrix is the same object as the other matrix.

DiagonalMatrix< K, n >	Dune::DiagonalMatrix< K, n >::transposed () const
	Return transposed of the matrix as DiagonalMatrix.

Iterator	Dune::DiagonalMatrix< K, n >::begin ()
	begin iterator

Iterator	Dune::DiagonalMatrix< K, n >::end ()
	end iterator

Iterator	Dune::DiagonalMatrix< K, n >::beforeEnd ()

Iterator	Dune::DiagonalMatrix< K, n >::beforeBegin ()

ConstIterator	Dune::DiagonalMatrix< K, n >::begin () const
	begin iterator

ConstIterator	Dune::DiagonalMatrix< K, n >::end () const
	end iterator

ConstIterator	Dune::DiagonalMatrix< K, n >::beforeEnd () const

ConstIterator	Dune::DiagonalMatrix< K, n >::beforeBegin () const

DiagonalMatrix &	Dune::DiagonalMatrix< K, n >::operator+= (const DiagonalMatrix &y)
	vector space addition

DiagonalMatrix &	Dune::DiagonalMatrix< K, n >::operator-= (const DiagonalMatrix &y)
	vector space subtraction

DiagonalMatrix &	Dune::DiagonalMatrix< K, n >::operator+= (const K &k)
	vector space multiplication with scalar

DiagonalMatrix &	Dune::DiagonalMatrix< K, n >::operator-= (const K &k)
	vector space division by scalar

DiagonalMatrix &	*Dune::DiagonalMatrix< K, n >::operator=** (const K &k)
	vector space multiplication with scalar

DiagonalMatrix &	Dune::DiagonalMatrix< K, n >::operator/= (const K &k)
	vector space division by scalar

bool	Dune::DiagonalMatrix< K, n >::operator== (const DiagonalMatrix &other) const
	comparison operator

bool	Dune::DiagonalMatrix< K, n >::operator!= (const DiagonalMatrix &other) const
	incomparison operator

template<class X , class Y >
void	Dune::DiagonalMatrix< K, n >::mv (const X &x, Y &y) const
	y = A x

template<class X , class Y >
void	Dune::DiagonalMatrix< K, n >::mtv (const X &x, Y &y) const
	y = A^T x

template<class X , class Y >
void	Dune::DiagonalMatrix< K, n >::umv (const X &x, Y &y) const
	y += A x

template<class X , class Y >
void	Dune::DiagonalMatrix< K, n >::umtv (const X &x, Y &y) const
	y += A^T x

template<class X , class Y >
void	Dune::DiagonalMatrix< K, n >::umhv (const X &x, Y &y) const
	y += A^H x

template<class X , class Y >
void	Dune::DiagonalMatrix< K, n >::mmv (const X &x, Y &y) const
	y -= A x

template<class X , class Y >
void	Dune::DiagonalMatrix< K, n >::mmtv (const X &x, Y &y) const
	y -= A^T x

template<class X , class Y >
void	Dune::DiagonalMatrix< K, n >::mmhv (const X &x, Y &y) const
	y -= A^H x

template<class X , class Y >
void	Dune::DiagonalMatrix< K, n >::usmv (const typename FieldTraits< Y >::field_type &alpha, const X &x, Y &y) const
	y += alpha A x

template<class X , class Y >
void	Dune::DiagonalMatrix< K, n >::usmtv (const typename FieldTraits< Y >::field_type &alpha, const X &x, Y &y) const
	y += alpha A^T x

template<class X , class Y >
void	Dune::DiagonalMatrix< K, n >::usmhv (const typename FieldTraits< Y >::field_type &alpha, const X &x, Y &y) const
	y += alpha A^H x

double	Dune::DiagonalMatrix< K, n >::frobenius_norm () const
	frobenius norm: sqrt(sum over squared values of entries)

double	Dune::DiagonalMatrix< K, n >::frobenius_norm2 () const
	square of frobenius norm, need for block recursion

double	Dune::DiagonalMatrix< K, n >::infinity_norm () const
	infinity norm (row sum norm, how to generalize for blocks?)

double	Dune::DiagonalMatrix< K, n >::infinity_norm_real () const
	simplified infinity norm (uses Manhattan norm for complex values)

template<class V >
void	Dune::DiagonalMatrix< K, n >::solve (V &x, const V &b) const
	Solve system A x = b.

void	Dune::DiagonalMatrix< K, n >::invert ()
	Compute inverse.

K	Dune::DiagonalMatrix< K, n >::determinant () const
	calculates the determinant of this matrix

static constexpr size_type	Dune::DiagonalMatrix< K, n >::N ()
	number of blocks in row direction

static constexpr size_type	Dune::DiagonalMatrix< K, n >::M ()
	number of blocks in column direction

bool	Dune::DiagonalMatrix< K, n >::exists (size_type i, size_type j) const
	return true when (i,j) is in pattern

reference	Dune::DiagonalMatrix< K, n >::operator[] (size_type i)
	Return reference object as row replacement.

const_reference	Dune::DiagonalMatrix< K, n >::operator[] (size_type i) const
	Return const_reference object as row replacement.

const K &	Dune::DiagonalMatrix< K, n >::diagonal (size_type i) const
	Get const reference to diagonal entry.

K &	Dune::DiagonalMatrix< K, n >::diagonal (size_type i)
	Get reference to diagonal entry.

const FieldVector< K, n > &	Dune::DiagonalMatrix< K, n >::diagonal () const
	Get const reference to diagonal vector.

FieldVector< K, n > &	Dune::DiagonalMatrix< K, n >::diagonal ()
	Get reference to diagonal vector.

	Dune::DiagonalRowVectorConst< K, n >::DiagonalRowVectorConst ()
	Constructor making uninitialized vector.

	Dune::DiagonalRowVectorConst< K, n >::DiagonalRowVectorConst (K *p, int col)
	Constructor making vector with identical coordinates.

const K &	Dune::DiagonalRowVectorConst< K, n >::operator[] (size_type i) const
	same for read only access

ConstIterator	Dune::DiagonalRowVectorConst< K, n >::begin () const
	begin ConstIterator

ConstIterator	Dune::DiagonalRowVectorConst< K, n >::end () const
	end ConstIterator

ConstIterator	Dune::DiagonalRowVectorConst< K, n >::beforeEnd () const

ConstIterator	Dune::DiagonalRowVectorConst< K, n >::beforeBegin () const

bool	Dune::DiagonalRowVectorConst< K, n >::operator== (const DiagonalRowVectorConst &y) const
	Binary vector comparison.

size_type	Dune::DiagonalRowVectorConst< K, n >::N () const
	number of blocks in the vector (are of size 1 here)

size_type	Dune::DiagonalRowVectorConst< K, n >::dim () const
	dimension of the vector space

size_type	Dune::DiagonalRowVectorConst< K, n >::rowIndex () const
	index of this row in surrounding matrix

const K &	Dune::DiagonalRowVectorConst< K, n >::diagonal () const
	the diagonal value

	Dune::DiagonalRowVector< K, n >::DiagonalRowVector ()
	Constructor making uninitialized vector.

	Dune::DiagonalRowVector< K, n >::DiagonalRowVector (K *p, int col)
	Constructor making vector with identical coordinates.

DiagonalRowVector &	Dune::DiagonalRowVector< K, n >::operator= (const K &k)
	Assignment operator for scalar.

K &	Dune::DiagonalRowVector< K, n >::operator[] (size_type i)
	random access

Iterator	Dune::DiagonalRowVector< K, n >::begin ()
	begin iterator

Iterator	Dune::DiagonalRowVector< K, n >::end ()
	end iterator

Iterator	Dune::DiagonalRowVector< K, n >::beforeEnd ()

Iterator	Dune::DiagonalRowVector< K, n >::beforeBegin ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 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 >::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 >::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 >::dbjac (const TMatrix &A, TVector &x, const TVector &b, const K &w)

template<typename V >
std::ostream &	operator<< (std::ostream &s, const DenseVector< V > &v)
	Write a DenseVector to an output stream. More...

template<class K , class Allocator >
std::istream &	operator>> (std::istream &in, DynamicVector< K, Allocator > &v)
	Read a DynamicVector from an input stream. More...

template<class K , int SIZE>
std::istream &	operator>> (std::istream &in, FieldVector< K, SIZE > &v)
	Read a FieldVector from an input stream. More...

Variables
static constexpr int	Dune::DiagonalMatrix< K, n >::blocklevel = 1
	The number of block levels we contain. This is the leaf, that is, 1.

static constexpr int	Dune::DiagonalMatrix< K, n >::rows = n
	The number of rows.

static constexpr int	Dune::DiagonalMatrix< K, n >::cols = n
	The number of columns.

static constexpr int	Dune::DiagonalRowVectorConst< K, n >::blocklevel = 1
	The number of block levels we contain.

static constexpr int	Dune::DiagonalRowVectorConst< K, n >::size = n
	The size of this vector.

Friends
template<class OtherScalar >
auto	Dune::DiagonalMatrix< K, n >::operator* (const DiagonalMatrix &matrixA, const DiagonalMatrix< OtherScalar, n > &matrixB)
	Matrix-matrix multiplication.

std::ostream &	Dune::DiagonalMatrix< K, n >::operator<< (std::ostream &s, const DiagonalMatrix< K, n > &a)
	Sends the matrix to an output stream.

Detailed Description

Type traits to retrieve the field and the real type of classes.

Type Traits to retrieve types associated with an implementation of Dune::DenseVector or Dune::DenseMatrix.

Type traits to retrieve the field and the real type of classes e.g. that of FieldVector or FieldMatrix

you have to specialize this class for every implementation of DenseVector or DenseMatrix.

 
typedef ... derived_type;
typedef ... value_type;
typedef ... size_type;

Typedef Documentation

◆ field_type

template<typename FirstRow , typename... Args>

using Dune::MultiTypeBlockMatrix< FirstRow, Args >::field_type = Std::detected_t<std::common_type_t, typename FieldTraits<FirstRow>::field_type, typename FieldTraits<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.

◆ real_type

template<typename FirstRow , typename... Args>

using Dune::MultiTypeBlockMatrix< FirstRow, Args >::real_type = Std::detected_t<std::common_type_t, typename FieldTraits<FirstRow>::real_type, typename FieldTraits<Args>::real_type...>

The type used for real values.

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

◆ type

template<typename FirstRow , typename... Args>

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

own class' type

Function Documentation

◆ beforeBegin() [1/4]

template<class K , int n>

Iterator Dune::DiagonalMatrix< K, n >::beforeBegin ( )

inline

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

◆ beforeBegin() [2/4]

template<class K , int n>

Iterator Dune::DiagonalRowVector< K, n >::beforeBegin ( )

inline

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

◆ beforeBegin() [3/4]

template<class K , int n>

ConstIterator Dune::DiagonalMatrix< K, n >::beforeBegin ( ) const

inline

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

◆ beforeBegin() [4/4]

template<class K , int n>

ConstIterator Dune::DiagonalRowVectorConst< K, n >::beforeBegin ( ) const

inline

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

◆ beforeEnd() [1/4]

template<class K , int n>

Iterator Dune::DiagonalMatrix< K, n >::beforeEnd ( )

inline

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

◆ beforeEnd() [2/4]

template<class K , int n>

Iterator Dune::DiagonalRowVector< K, n >::beforeEnd ( )

inline

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

◆ beforeEnd() [3/4]

template<class K , int n>

ConstIterator Dune::DiagonalMatrix< K, n >::beforeEnd ( ) const

inline

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

◆ beforeEnd() [4/4]

template<class K , int n>

ConstIterator Dune::DiagonalRowVectorConst< K, n >::beforeEnd ( ) const

inline

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

◆ bsorb()

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

◆ bsorf()

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

◆ calc_rhs()

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]

◆ dbgs()

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

◆ dbjac()

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

◆ DiagonalMatrix()

template<class K , int n>

Dune::DiagonalMatrix< K, n >::DiagonalMatrix ( std::initializer_list< K > const & l )

inline

Construct diagonal matrix from an initializer list.

The elements of the list are copied into the diagonal elements of the matrix. If the initializer list is shorter than the matrix diagonal (which has n elements), the remaining matrix diagonal elements are left uninitialized. If the initializer list is longer, than only the first n elements will be copied into the matrix diagonal.

References Dune::DenseVector< V >::begin(), Dune::Hybrid::min, and Dune::DiagonalMatrix< K, n >::rows.

◆ operator+=()

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.

References Dune::Hybrid::forEach(), Dune::Hybrid::integralRange(), and Dune::size().

◆ operator-=()

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.

References Dune::Hybrid::forEach(), Dune::Hybrid::integralRange(), and Dune::size().

◆ operator<<() [1/2]

template<typename V >

std::ostream & operator<<	(	std::ostream &	s,
		const DenseVector< V > &	v
	)

Parameters

[in]	s	std :: ostream to write to
[in]	v	DenseVector to write

Returns: the output stream (s)

References Dune::DenseVector< V >::size().

◆ operator<<() [2/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

References Dune::Hybrid::forEach(), and Dune::Hybrid::integralRange().

◆ operator=()

template<typename FirstRow , typename... Args>

template<typename T >

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

inline

assignment operator

References Dune::Hybrid::forEach(), Dune::Hybrid::integralRange(), and Dune::size().

◆ operator>>() [1/2]

template<class K , class Allocator >

std::istream & operator>>	(	std::istream &	in,
		DynamicVector< K, Allocator > &	v
	)

Note: This operator is STL compliant, i.e., the content of v is only changed if the read operation is successful.

Parameters

[in]	in	std :: istream to read from
[out]	v	DynamicVector to be read

Returns: the input stream (in)

◆ operator>>() [2/2]

template<class K , int SIZE>

std::istream & operator>>	(	std::istream &	in,
		FieldVector< K, SIZE > &	v
	)

Note: This operator is STL compliant, i.e., the content of v is only changed if the read operation is successful.

Parameters

[in]	in	std :: istream to read from
[out]	v	FieldVector to be read

Returns: the input stream (in)

◆ operator[]() [1/2]

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 mimics 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] = ...

Dune::Indices::_0

constexpr index_constant< 0 > _0

Compile time index with value 0.

Definition: indices.hh:52

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[]() [2/2]

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.

DUNE Distributed and Unified Numerics Environment

Dune Core Modules (2.10.0)

Files

Namespaces

Classes

Typedefs

Functions

Variables

Friends

Detailed Description

Typedef Documentation

◆ field_type

◆ real_type

◆ type

Function Documentation

◆ beforeBegin() [1/4]

◆ beforeBegin() [2/4]

◆ beforeBegin() [3/4]

◆ beforeBegin() [4/4]

◆ beforeEnd() [1/4]

◆ beforeEnd() [2/4]

◆ beforeEnd() [3/4]

◆ beforeEnd() [4/4]

◆ bsorb()

◆ bsorf()

◆ calc_rhs()

◆ dbgs()

◆ dbjac()

◆ DiagonalMatrix()

◆ operator+=()

◆ operator-=()

◆ operator<<() [1/2]

◆ operator<<() [2/2]

◆ operator=()

◆ operator>>() [1/2]

◆ operator>>() [2/2]

◆ operator[]() [1/2]

◆ operator[]() [2/2]