dune-istl  3.0-git
Modules | Files | Classes | Typedefs | Enumerations | Enumerator | Functions | Variables
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...

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...
 
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::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 ( $C=A*B$) 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 >
 
class  Dune::MultiTypeBlockVector< Args >
 A Vector class to support different block types. 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
 
typedef FirstRow::field_type Dune::MultiTypeBlockMatrix< FirstRow, Args >::field_type
 
typedef FieldTraits< Arg0 >::field_type Dune::FieldTraits< MultiTypeBlockVector< Arg0, Args... > >::field_type
 
typedef FieldTraits< Arg0 >::real_type Dune::FieldTraits< MultiTypeBlockVector< Arg0, Args... > >::real_type
 
typedef MultiTypeBlockVector< Args... > Dune::MultiTypeBlockVector< Args >::type
 
typedef double Dune::MultiTypeBlockVector< Args >::field_type
 The type used for scalars. More...
 

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 ( $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, bool tryHard=false)
 Calculate product of a transposed sparse matrix with another sparse matrices ( $C=A^T*B$). More...
 
template<class M >
int Dune::countNonZeros (const M &matrix)
 Get the number of nonzero fields in the matrix. More...
 
static constexpr std::size_t Dune::MultiTypeBlockMatrix< FirstRow, Args >::N ()
 Return the number of matrix rows. More...
 
static constexpr std::size_t Dune::MultiTypeBlockMatrix< FirstRow, Args >::M ()
 Return the number of matrix columns. More...
 
template<std::size_t index>
auto Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator[] (const std::integral_constant< std::size_t, index > indexVariable) -> decltype(std::get< index >(*this))
 Random-access operator. More...
 
template<std::size_t index>
auto Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator[] (const std::integral_constant< std::size_t, 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)
 
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 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 std::size_t Dune::MultiTypeBlockVector< Args >::size ()
 Return the number of vector entries. More...
 
int Dune::MultiTypeBlockVector< Args >::count ()
 
template<std::size_t index>
std::tuple_element< index, tupleType >::typeDune::MultiTypeBlockVector< Args >::operator[] (const std::integral_constant< std::size_t, index > indexVariable)
 Random-access operator. More...
 
template<std::size_t index>
const std::tuple_element< index, tupleType >::typeDune::MultiTypeBlockVector< Args >::operator[] (const std::integral_constant< std::size_t, 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)
 
void Dune::MultiTypeBlockVector< Args >::operator*= (const int &w)
 
void Dune::MultiTypeBlockVector< Args >::operator*= (const float &w)
 
void Dune::MultiTypeBlockVector< Args >::operator*= (const double &w)
 
field_type Dune::MultiTypeBlockVector< Args >::operator* (const type &newv) const
 
field_type Dune::MultiTypeBlockVector< Args >::dot (const type &newv) const
 
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...
 
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:

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:

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 Arg0 , typename... Args>
typedef FieldTraits<Arg0>::field_type Dune::FieldTraits< MultiTypeBlockVector< Arg0, Args... > >::field_type

◆ field_type [2/3]

template<typename FirstRow, typename... Args>
typedef FirstRow::field_type Dune::MultiTypeBlockMatrix< FirstRow, Args >::field_type

◆ field_type [3/3]

template<typename... Args>
typedef double Dune::MultiTypeBlockVector< Args >::field_type

The type used for scalars.

The current code hardwires it to 'double', which is far from nice. On the other hand, it is not clear what the correct type is. If the MultiTypeBlockVector class is instantiated with several vectors of different field_types, what should the resulting field_type be?

◆ 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 Arg0 , typename... Args>
typedef FieldTraits<Arg0>::real_type Dune::FieldTraits< MultiTypeBlockVector< Arg0, Args... > >::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/7]

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/7]

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/7]

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/7]

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/7]

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/7]

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/7]

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

◆ type [1/6]

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

own class' type

◆ type [2/6]

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

own class' type

◆ type [3/6]

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 [4/6]

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 [5/6]

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 [6/6]

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

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
TaType of the scalar 'a'

◆ bsorb() [1/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() [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,
TVector &  v,
const TVector &  b,
const K &  w 
)
inlinestatic

◆ bsorb() [3/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

◆ bsorf() [1/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() [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,
TVector &  v,
const TVector &  b,
const K &  w 
)
inlinestatic

◆ bsorf() [3/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

◆ calc_rhs() [1/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]

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

◆ count()

template<typename... Args>
int Dune::MultiTypeBlockVector< Args >::count ( )
inline

number of elements

◆ countNonZeros()

template<class M >
int Dune::countNonZeros ( const M &  matrix)
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.

◆ dbgs() [1/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() [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,
TVector &  v,
const TVector &  b,
const K &  w 
)
inlinestatic

◆ dbgs() [3/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

◆ dbjac() [1/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() [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,
TVector &  v,
const TVector &  b,
const K &  w 
)
inlinestatic

◆ dbjac() [3/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

◆ dot()

template<typename... Args>
field_type Dune::MultiTypeBlockVector< Args >::dot ( const type newv) const
inline

◆ infinity_norm()

template<typename... Args>
FieldTraits<field_type>::real_type Dune::MultiTypeBlockVector< Args >::infinity_norm ( ) const
inline

Compute the maximum norm.

◆ M()

template<typename FirstRow, typename... Args>
static constexpr std::size_t Dune::MultiTypeBlockMatrix< FirstRow, Args >::M ( )
inlinestatic

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

Parameters
resMatrix for the result of the computation.
matMatrix A.
mattMatrix B.
tryHardignored

◆ 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 ( $C=A*B^T$).

Parameters
resMatrix for the result of the computation.
matMatrix A.
mattMatrix B, which will be transposed before the multiplication.
tryHardignored

◆ 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

◆ 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()

template<typename FirstRow, typename... Args>
static constexpr std::size_t Dune::MultiTypeBlockMatrix< FirstRow, Args >::N ( )
inlinestatic

Return the number of matrix rows.

◆ operator*()

template<typename... Args>
field_type Dune::MultiTypeBlockVector< Args >::operator* ( const type newv) const
inline

◆ operator*=() [1/3]

template<typename... Args>
void Dune::MultiTypeBlockVector< Args >::operator*= ( const int &  w)
inline

◆ operator*=() [2/3]

template<typename... Args>
void Dune::MultiTypeBlockVector< Args >::operator*= ( const float &  w)
inline

◆ operator*=() [3/3]

template<typename... Args>
void Dune::MultiTypeBlockVector< Args >::operator*= ( const double &  w)
inline

◆ operator+=()

template<typename... Args>
void Dune::MultiTypeBlockVector< Args >::operator+= ( const type newv)
inline

operator for MultiTypeBlockVector += MultiTypeBlockVector operations

◆ operator-=()

template<typename... Args>
void Dune::MultiTypeBlockVector< Args >::operator-= ( const type newv)
inline

operator for MultiTypeBlockVector -= MultiTypeBlockVector operations

◆ 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 FirstRow, typename... Args>
template<std::size_t index>
auto Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator[] ( const std::integral_constant< std::size_t, 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<std::size_t,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<std::size_t,0>()] = ...

◆ operator[]() [2/4]

template<typename FirstRow, typename... Args>
template<std::size_t index>
auto Dune::MultiTypeBlockMatrix< FirstRow, Args >::operator[] ( const std::integral_constant< std::size_t, 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.

◆ operator[]() [3/4]

template<typename... Args>
template<std::size_t index>
std::tuple_element<index,tupleType>::type& Dune::MultiTypeBlockVector< Args >::operator[] ( const std::integral_constant< std::size_t, 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[]() [4/4]

template<typename... Args>
template<std::size_t index>
const std::tuple_element<index,tupleType>::type& Dune::MultiTypeBlockVector< Args >::operator[] ( const std::integral_constant< std::size_t, 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 std::size_t Dune::MultiTypeBlockVector< Args >::size ( )
inlinestatic

Return the number of vector entries.

◆ 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 ( $C=A^T*B$).

Parameters
resMatrix for the result of the computation.
matMatrix A, which will be transposed before the multiplication.
mattMatrix B.
tryHardignored

◆ 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.

◆ 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

◆ 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