Block Recursive Iterative Kernels

Collaboration diagram for Block Recursive Iterative Kernels:

Namespaces
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

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