Loading...
Searching...
No Matches
gsetc.hh File Reference

Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a generic way. More...

`#include <cmath>`
`#include <complex>`
`#include <iostream>`
`#include <iomanip>`
`#include <string>`
`#include <dune/common/hybridutilities.hh>`
`#include "multitypeblockvector.hh"`
`#include "multitypeblockmatrix.hh"`
`#include "istlexception.hh"`

Go to the source code of this file.

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

## Namespaces

namespace | Dune

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

Simple iterative methods like Jacobi, Gauss-Seidel, SOR, SSOR, etc. in a generic way.