dune-istl 2.10
Loading...
Searching...
No Matches
Namespaces | Classes | Enumerations | Functions
Collaboration diagram for Block Recursive Iterative Kernels:

Namespaces

namespace  Dune::DILU
 
namespace  Dune::ILU
 

Classes

struct  Dune::BL< l >
 compile-time parameter for block recursion depth More...
 
struct  Dune::algmeta_btsolve< I, diag, relax >
 
struct  Dune::algmeta_btsolve< 0, withdiag, withrelax >
 
struct  Dune::algmeta_btsolve< 0, withdiag, norelax >
 
struct  Dune::algmeta_btsolve< 0, nodiag, withrelax >
 
struct  Dune::algmeta_btsolve< 0, nodiag, norelax >
 
struct  Dune::algmeta_bdsolve< I, relax >
 
struct  Dune::algmeta_bdsolve< 0, withrelax >
 
struct  Dune::algmeta_bdsolve< 0, norelax >
 
struct  Dune::algmeta_itsteps< I, M >
 
struct  Dune::algmeta_itsteps< 0, M >
 
struct  Dune::algmeta_itsteps< I, MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > >
 

Enumerations

enum  Dune::WithDiagType { Dune::withdiag =1 , Dune::nodiag =0 }
 
enum  Dune::WithRelaxType { Dune::withrelax =1 , Dune::norelax =0 }
 

Functions

template<class M , class X , class Y >
void Dune::bltsolve (const M &A, X &v, const Y &d)
 block lower triangular solve
 
template<class M , class X , class Y , class K >
void Dune::bltsolve (const M &A, X &v, const Y &d, const K &w)
 relaxed block lower triangular solve
 
template<class M , class X , class Y >
void Dune::ubltsolve (const M &A, X &v, const Y &d)
 unit block lower triangular solve
 
template<class M , class X , class Y , class K >
void Dune::ubltsolve (const M &A, X &v, const Y &d, const K &w)
 relaxed unit block lower triangular solve
 
template<class M , class X , class Y >
void Dune::butsolve (const M &A, X &v, const Y &d)
 block upper triangular solve
 
template<class M , class X , class Y , class K >
void Dune::butsolve (const M &A, X &v, const Y &d, const K &w)
 relaxed block upper triangular solve
 
template<class M , class X , class Y >
void Dune::ubutsolve (const M &A, X &v, const Y &d)
 unit block upper triangular solve
 
template<class M , class X , class Y , class K >
void Dune::ubutsolve (const M &A, X &v, const Y &d, const K &w)
 relaxed unit block upper triangular solve
 
template<class M , class X , class Y , int l>
void Dune::bltsolve (const M &A, X &v, const Y &d, BL< l >)
 block lower triangular solve
 
template<class M , class X , class Y , class K , int l>
void Dune::bltsolve (const M &A, X &v, const Y &d, const K &w, BL< l >)
 relaxed block lower triangular solve
 
template<class M , class X , class Y , int l>
void Dune::ubltsolve (const M &A, X &v, const Y &d, BL< l >)
 unit block lower triangular solve
 
template<class M , class X , class Y , class K , int l>
void Dune::ubltsolve (const M &A, X &v, const Y &d, const K &w, BL< l >)
 relaxed unit block lower triangular solve
 
template<class M , class X , class Y , int l>
void Dune::butsolve (const M &A, X &v, const Y &d, BL< l > bl)
 block upper triangular solve
 
template<class M , class X , class Y , class K , int l>
void Dune::butsolve (const M &A, X &v, const Y &d, const K &w, BL< l > bl)
 relaxed block upper triangular solve
 
template<class M , class X , class Y , int l>
void Dune::ubutsolve (const M &A, X &v, const Y &d, BL< l > bl)
 unit block upper triangular solve
 
template<class M , class X , class Y , class K , int l>
void Dune::ubutsolve (const M &A, X &v, const Y &d, const K &w, BL< l > bl)
 relaxed unit block upper triangular solve
 
template<class M , class X , class Y >
void Dune::bdsolve (const M &A, X &v, const Y &d)
 block diagonal solve, no relaxation
 
template<class M , class X , class Y , class K >
void Dune::bdsolve (const M &A, X &v, const Y &d, const K &w)
 block diagonal solve, with relaxation
 
template<class M , class X , class Y , int l>
void Dune::bdsolve (const M &A, X &v, const Y &d, BL< l >)
 block diagonal solve, no relaxation
 
template<class M , class X , class Y , class K , int l>
void Dune::bdsolve (const M &A, X &v, const Y &d, const K &w, BL< l >)
 block diagonal solve, with relaxation
 
template<class M , class X , class Y , class K >
void Dune::dbgs (const M &A, X &x, const Y &b, const K &w)
 GS step.
 
template<class M , class X , class Y , class K , int l>
void Dune::dbgs (const M &A, X &x, const Y &b, const K &w, BL< l >)
 GS step.
 
template<class M , class X , class Y , class K >
void Dune::bsorf (const M &A, X &x, const Y &b, const K &w)
 SOR step.
 
template<class M , class X , class Y , class K , int l>
void Dune::bsorf (const M &A, X &x, const Y &b, const K &w, BL< l >)
 SOR step.
 
template<class M , class X , class Y , class K >
void Dune::bsorb (const M &A, X &x, const Y &b, const K &w)
 SSOR step.
 
template<class M , class X , class Y , class K , int l>
void Dune::bsorb (const M &A, X &x, const Y &b, const K &w, BL< l >)
 Backward SOR step.
 
template<class M , class X , class Y , class K >
void Dune::dbjac (const M &A, X &x, const Y &b, const K &w)
 Jacobi step.
 
template<class M , class X , class Y , class K , int l>
void Dune::dbjac (const M &A, X &x, const Y &b, const K &w, BL< l >)
 Jacobi step.
 

Detailed Description

Generic iterative kernels for the solvers which work on the block recursive structure of the matrices and vectors.

Enumeration Type Documentation

◆ WithDiagType

Enumerator
withdiag 
nodiag 

◆ WithRelaxType

Enumerator
withrelax 
norelax 

Function Documentation

◆ bdsolve() [1/4]

template<class M , class X , class Y >
void Dune::bdsolve ( const M &  A,
X &  v,
const Y &  d 
)

block diagonal solve, no relaxation

◆ bdsolve() [2/4]

template<class M , class X , class Y , int l>
void Dune::bdsolve ( const M &  A,
X &  v,
const Y &  d,
BL< l >   
)

block diagonal solve, no relaxation

◆ bdsolve() [3/4]

template<class M , class X , class Y , class K >
void Dune::bdsolve ( const M &  A,
X &  v,
const Y &  d,
const K &  w 
)

block diagonal solve, with relaxation

◆ bdsolve() [4/4]

template<class M , class X , class Y , class K , int l>
void Dune::bdsolve ( const M &  A,
X &  v,
const Y &  d,
const K &  w,
BL< l >   
)

block diagonal solve, with relaxation

◆ bltsolve() [1/4]

template<class M , class X , class Y >
void Dune::bltsolve ( const M &  A,
X &  v,
const Y &  d 
)

block lower triangular solve

◆ bltsolve() [2/4]

template<class M , class X , class Y , int l>
void Dune::bltsolve ( const M &  A,
X &  v,
const Y &  d,
BL< l >   
)

block lower triangular solve

◆ bltsolve() [3/4]

template<class M , class X , class Y , class K >
void Dune::bltsolve ( const M &  A,
X &  v,
const Y &  d,
const K &  w 
)

relaxed block lower triangular solve

◆ bltsolve() [4/4]

template<class M , class X , class Y , class K , int l>
void Dune::bltsolve ( const M &  A,
X &  v,
const Y &  d,
const K &  w,
BL< l >   
)

relaxed block lower triangular solve

◆ bsorb() [1/2]

template<class M , class X , class Y , class K >
void Dune::bsorb ( const M &  A,
X &  x,
const Y &  b,
const K &  w 
)

SSOR step.

◆ bsorb() [2/2]

template<class M , class X , class Y , class K , int l>
void Dune::bsorb ( const M &  A,
X &  x,
const Y &  b,
const K &  w,
BL< l >   
)

Backward SOR step.

◆ bsorf() [1/2]

template<class M , class X , class Y , class K >
void Dune::bsorf ( const M &  A,
X &  x,
const Y &  b,
const K &  w 
)

SOR step.

◆ bsorf() [2/2]

template<class M , class X , class Y , class K , int l>
void Dune::bsorf ( const M &  A,
X &  x,
const Y &  b,
const K &  w,
BL< l >   
)

SOR step.

◆ butsolve() [1/4]

template<class M , class X , class Y >
void Dune::butsolve ( const M &  A,
X &  v,
const Y &  d 
)

block upper triangular solve

◆ butsolve() [2/4]

template<class M , class X , class Y , int l>
void Dune::butsolve ( const M &  A,
X &  v,
const Y &  d,
BL< l >  bl 
)

block upper triangular solve

◆ butsolve() [3/4]

template<class M , class X , class Y , class K >
void Dune::butsolve ( const M &  A,
X &  v,
const Y &  d,
const K &  w 
)

relaxed block upper triangular solve

◆ butsolve() [4/4]

template<class M , class X , class Y , class K , int l>
void Dune::butsolve ( const M &  A,
X &  v,
const Y &  d,
const K &  w,
BL< l >  bl 
)

relaxed block upper triangular solve

◆ dbgs() [1/2]

template<class M , class X , class Y , class K >
void Dune::dbgs ( const M &  A,
X &  x,
const Y &  b,
const K &  w 
)

GS step.

◆ dbgs() [2/2]

template<class M , class X , class Y , class K , int l>
void Dune::dbgs ( const M &  A,
X &  x,
const Y &  b,
const K &  w,
BL< l >   
)

GS step.

◆ dbjac() [1/2]

template<class M , class X , class Y , class K >
void Dune::dbjac ( const M &  A,
X &  x,
const Y &  b,
const K &  w 
)

Jacobi step.

◆ dbjac() [2/2]

template<class M , class X , class Y , class K , int l>
void Dune::dbjac ( const M &  A,
X &  x,
const Y &  b,
const K &  w,
BL< l >   
)

Jacobi step.

◆ ubltsolve() [1/4]

template<class M , class X , class Y >
void Dune::ubltsolve ( const M &  A,
X &  v,
const Y &  d 
)

unit block lower triangular solve

◆ ubltsolve() [2/4]

template<class M , class X , class Y , int l>
void Dune::ubltsolve ( const M &  A,
X &  v,
const Y &  d,
BL< l >   
)

unit block lower triangular solve

◆ ubltsolve() [3/4]

template<class M , class X , class Y , class K >
void Dune::ubltsolve ( const M &  A,
X &  v,
const Y &  d,
const K &  w 
)

relaxed unit block lower triangular solve

◆ ubltsolve() [4/4]

template<class M , class X , class Y , class K , int l>
void Dune::ubltsolve ( const M &  A,
X &  v,
const Y &  d,
const K &  w,
BL< l >   
)

relaxed unit block lower triangular solve

◆ ubutsolve() [1/4]

template<class M , class X , class Y >
void Dune::ubutsolve ( const M &  A,
X &  v,
const Y &  d 
)

unit block upper triangular solve

◆ ubutsolve() [2/4]

template<class M , class X , class Y , int l>
void Dune::ubutsolve ( const M &  A,
X &  v,
const Y &  d,
BL< l >  bl 
)

unit block upper triangular solve

◆ ubutsolve() [3/4]

template<class M , class X , class Y , class K >
void Dune::ubutsolve ( const M &  A,
X &  v,
const Y &  d,
const K &  w 
)

relaxed unit block upper triangular solve

◆ ubutsolve() [4/4]

template<class M , class X , class Y , class K , int l>
void Dune::ubutsolve ( const M &  A,
X &  v,
const Y &  d,
const K &  w,
BL< l >  bl 
)

relaxed unit block upper triangular solve