Sparse Matrix and Vector classes

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

Modules
	Block Recursive Iterative Kernels
	IO for matrices and vectors.
	Provides methods for reading and writing matrices and vectors in various formats.
	Dense Matrix and Vector Template Library
	Type traits to retrieve the field and the real type of classes.

Files
file	matrixmatrix.hh
	provides functions for sparse matrix matrix multiplication.
file	matrixutils.hh
	Some handy generic functions for ISTL matrices.

Classes
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...
class	Dune::BDMatrix< B, A >
	A block-diagonal matrix. More...
class	Dune::BTDMatrix< B, A >
	A block-tridiagonal matrix. More...
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::MatMultMatResult< M1, M2 >
	Helper TMP to get the result type of a sparse matrix matrix multiplication ( \(C=A*B\)) More...
struct	Dune::TransposedMatMultMatResult< M1, M2 >
	Helper TMP to get the result type of a sparse matrix matrix multiplication ( \(C=A*B\)) More...
struct	Dune::CheckIfDiagonalPresent< Matrix, blocklevel, l >
	Check whether the a matrix has diagonal values on blocklevel recursion levels. More...
class	Dune::MultiTypeBlockMatrix< FirstRow, Args >
	A Matrix class to support different block types. 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...
struct	std::tuple_size< Dune::MultiTypeBlockVector< Args... > >
	Make std::tuple_size work for MultiTypeBlockVector. More...
class	Dune::VariableBlockVector< B, A >
	A Vector of blocks with different blocksizes. More...

Typedefs
using	Dune::MultiTypeBlockVector< Args >::size_type = std::size_t
	Type used for vector sizes.
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...

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, [[maybe_unused]] bool tryHard=false)
	Calculate product of a sparse matrix with a transposed sparse matrices ( \(C=A*B^T\)). 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 ( \(C=A*B\)). 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, [[maybe_unused]] bool tryHard=false)
	Calculate product of a transposed sparse matrix with another sparse matrices ( \(C=A^T*B\)). More...
template<class M >
auto	Dune::countNonZeros (const M &, [[maybe_unused]] typename std::enable_if_t< Dune::IsNumber< M >::value > *sfinae=nullptr)
	Get the number of nonzero fields in the matrix. More...
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.
size_type	Dune::MultiTypeBlockVector< Args >::dim () const
	Number of scalar elements.
template<size_type index>
std::tuple_element< index, TupleType >::type &	Dune::MultiTypeBlockVector< Args >::operator[] ([[maybe_unused]] 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[] ([[maybe_unused]] 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.
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.
template<class T , std::enable_if_t< IsNumber< T >::value, int > = 0>
void	Dune::MultiTypeBlockVector< Args >::operator/= (const T &w)
	Division by a scalar.
auto	Dune::MultiTypeBlockVector< Args >::one_norm () const
	Compute the 1-norm.
auto	Dune::MultiTypeBlockVector< Args >::one_norm_real () const
	Compute the simplified 1-norm (uses 1-norm also for complex values)
FieldTraits< field_type >::real_type	Dune::MultiTypeBlockVector< Args >::two_norm2 () const
	Compute the squared Euclidean norm.
FieldTraits< field_type >::real_type	Dune::MultiTypeBlockVector< Args >::two_norm () const
	Compute the Euclidean norm.
FieldTraits< field_type >::real_type	Dune::MultiTypeBlockVector< Args >::infinity_norm () const
	Compute the maximum norm.
FieldTraits< field_type >::real_type	Dune::MultiTypeBlockVector< Args >::infinity_norm_real () const
	Compute the simplified maximum norm (uses 1-norm for complex values)
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.

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 \(V=K^n\) where the field \(K\) is represented by a numeric type (e.g. double, float, complex). \(n\) 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 \(m\) vector spaces, \(i=1,\ldots,m\).

The matrix classes represent linear maps \(A: V \mapsto W\) from vector space \(V\) to vector space \(W\) 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 \(V_1=K^n\) and \(V_2=K^m\) 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

field_type

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.

type

template<typename... Args>

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

own class' type

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'

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

countNonZeros()

template<class M >

auto Dune::countNonZeros ( const M &  , [[maybe_unused] ] 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.

Referenced by Dune::Amg::MatrixHierarchy< M, PI, A >::build().

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 ( \(C=A*B\)).

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,
		[[maybe_unused] ] bool	tryHard = false
	)

Calculate product of a sparse matrix with a transposed sparse matrices ( \(C=A*B^T\)).

Parameters

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

operator+=()

template<typename... Args>

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

inline

operator for MultiTypeBlockVector += MultiTypeBlockVector operations

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

operator-=()

template<typename... Args>

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

inline

operator for MultiTypeBlockVector -= MultiTypeBlockVector operations

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

operator[]() [1/2]

template<typename... Args>

template<size_type index>

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

inline

Random-access operator.

This method mimics 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/2]

template<typename... Args>

template<size_type index>

const std::tuple_element<index,TupleType>::type& Dune::MultiTypeBlockVector< Args >::operator[] ( [[maybe_unused] ] 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.

size()

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,
		[[maybe_unused] ] bool	tryHard = false
	)

Calculate product of a transposed sparse matrix with another sparse matrices ( \(C=A^T*B\)).

Parameters

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

Referenced by MatrixInfo< BCRSMatrix >::computeNonSymCond2().