Loading...
Searching...
No Matches
Block Recursive Iterative Kernels
Iterative Solvers Template Library (ISTL) » Sparse Matrix and Vector classes
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 >)
| 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 >)
| 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 >)
| 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 >)
| 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

enum Dune::WithDiagType

Enumerator
withdiag |
nodiag |

## WithRelaxType

enum Dune::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 > | )

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

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

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

relaxed unit block upper triangular solve