Loading...
Searching...
No Matches
gsetc.hh
Go to the documentation of this file.
// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_ISTL_GSETC_HH
#define DUNE_ISTL_GSETC_HH
#include <cmath>
#include <complex>
#include <iostream>
#include <iomanip>
#include <string>
#include <dune/common/hybridutilities.hh>
#include "multitypeblockvector.hh"
#include "multitypeblockmatrix.hh"
#include "istlexception.hh"
namespace Dune {
//============================================================
// parameter types
//============================================================
template<int l>
struct BL {
enum {recursion_level = l};
};
enum WithDiagType {
withdiag=1,
nodiag=0
};
enum WithRelaxType {
withrelax=1,
norelax=0
};
//============================================================
// generic triangular solves
// consider block decomposition A = L + D + U
// we can invert L, L+D, U, U+D
// we can apply relaxation or not
// we can recurse over a fixed number of levels
//============================================================
// template meta program for triangular solves
template<int I, WithDiagType diag, WithRelaxType relax>
struct algmeta_btsolve {
template<class M, class X, class Y, class K>
static void bltsolve (const M& A, X& v, const Y& d, const K& w)
{
// iterator types
typedef typename M::ConstRowIterator rowiterator;
typedef typename M::ConstColIterator coliterator;
typedef typename Y::block_type bblock;
// local solve at each block and immediate update
rowiterator endi=A.end();
for (rowiterator i=A.begin(); i!=endi; ++i)
{
bblock rhs(d[i.index()]);
coliterator j;
for (j=(*i).begin(); j.index()<i.index(); ++j)
(*j).mmv(v[j.index()],rhs);
algmeta_btsolve<I-1,diag,relax>::bltsolve(*j,v[i.index()],rhs,w);
}
}
template<class M, class X, class Y, class K>
static void butsolve (const M& A, X& v, const Y& d, const K& w)
{
// iterator types
typedef typename M::ConstRowIterator rowiterator;
typedef typename M::ConstColIterator coliterator;
typedef typename Y::block_type bblock;
// local solve at each block and immediate update
rowiterator rendi=A.beforeBegin();
for (rowiterator i=A.beforeEnd(); i!=rendi; --i)
{
bblock rhs(d[i.index()]);
coliterator j;
for (j=(*i).beforeEnd(); j.index()>i.index(); --j)
(*j).mmv(v[j.index()],rhs);
algmeta_btsolve<I-1,diag,relax>::butsolve(*j,v[i.index()],rhs,w);
}
}
};
// recursion end ...
template<>
struct algmeta_btsolve<0,withdiag,withrelax> {
template<class M, class X, class Y, class K>
static void bltsolve (const M& A, X& v, const Y& d, const K& w)
{
A.solve(v,d);
v *= w;
}
template<class M, class X, class Y, class K>
static void butsolve (const M& A, X& v, const Y& d, const K& w)
{
A.solve(v,d);
v *= w;
}
};
template<>
struct algmeta_btsolve<0,withdiag,norelax> {
template<class M, class X, class Y, class K>
static void bltsolve (const M& A, X& v, const Y& d, const K& /*w*/)
{
A.solve(v,d);
}
template<class M, class X, class Y, class K>
static void butsolve (const M& A, X& v, const Y& d, const K& /*w*/)
{
A.solve(v,d);
}
};
template<>
struct algmeta_btsolve<0,nodiag,withrelax> {
template<class M, class X, class Y, class K>
static void bltsolve (const M& /*A*/, X& v, const Y& d, const K& w)
{
v = d;
v *= w;
}
template<class M, class X, class Y, class K>
static void butsolve (const M& /*A*/, X& v, const Y& d, const K& w)
{
v = d;
v *= w;
}
};
template<>
struct algmeta_btsolve<0,nodiag,norelax> {
template<class M, class X, class Y, class K>
static void bltsolve (const M& /*A*/, X& v, const Y& d, const K& /*w*/)
{
v = d;
}
template<class M, class X, class Y, class K>
static void butsolve (const M& /*A*/, X& v, const Y& d, const K& /*w*/)
{
v = d;
}
};
// user calls
// default block recursion level = 1
template<class M, class X, class Y>
void bltsolve (const M& A, X& v, const Y& d)
{
typename X::field_type w=1;
algmeta_btsolve<1,withdiag,norelax>::bltsolve(A,v,d,w);
}
template<class M, class X, class Y, class K>
void bltsolve (const M& A, X& v, const Y& d, const K& w)
{
algmeta_btsolve<1,withdiag,withrelax>::bltsolve(A,v,d,w);
}
template<class M, class X, class Y>
void ubltsolve (const M& A, X& v, const Y& d)
{
typename X::field_type w=1;
algmeta_btsolve<1,nodiag,norelax>::bltsolve(A,v,d,w);
}
template<class M, class X, class Y, class K>
void ubltsolve (const M& A, X& v, const Y& d, const K& w)
{
algmeta_btsolve<1,nodiag,withrelax>::bltsolve(A,v,d,w);
}
template<class M, class X, class Y>
void butsolve (const M& A, X& v, const Y& d)
{
typename X::field_type w=1;
algmeta_btsolve<1,withdiag,norelax>::butsolve(A,v,d,w);
}
template<class M, class X, class Y, class K>
void butsolve (const M& A, X& v, const Y& d, const K& w)
{
algmeta_btsolve<1,withdiag,withrelax>::butsolve(A,v,d,w);
}
template<class M, class X, class Y>
void ubutsolve (const M& A, X& v, const Y& d)
{
typename X::field_type w=1;
algmeta_btsolve<1,nodiag,norelax>::butsolve(A,v,d,w);
}
template<class M, class X, class Y, class K>
void ubutsolve (const M& A, X& v, const Y& d, const K& w)
{
algmeta_btsolve<1,nodiag,withrelax>::butsolve(A,v,d,w);
}
// general block recursion level >= 0
template<class M, class X, class Y, int l>
void bltsolve (const M& A, X& v, const Y& d, BL<l> /*bl*/)
{
typename X::field_type w=1;
algmeta_btsolve<l,withdiag,norelax>::bltsolve(A,v,d,w);
}
template<class M, class X, class Y, class K, int l>
void bltsolve (const M& A, X& v, const Y& d, const K& w, BL<l> /*bl*/)
{
algmeta_btsolve<l,withdiag,withrelax>::bltsolve(A,v,d,w);
}
template<class M, class X, class Y, int l>
void ubltsolve (const M& A, X& v, const Y& d, BL<l> /*bl*/)
{
typename X::field_type w=1;
algmeta_btsolve<l,nodiag,norelax>::bltsolve(A,v,d,w);
}
template<class M, class X, class Y, class K, int l>
void ubltsolve (const M& A, X& v, const Y& d, const K& w, BL<l> /*bl*/)
{
algmeta_btsolve<l,nodiag,withrelax>::bltsolve(A,v,d,w);
}
template<class M, class X, class Y, int l>
void butsolve (const M& A, X& v, const Y& d, BL<l> /*bl*/)
{
typename X::field_type w=1;
algmeta_btsolve<l,withdiag,norelax>::butsolve(A,v,d,w);
}
template<class M, class X, class Y, class K, int l>
void butsolve (const M& A, X& v, const Y& d, const K& w, BL<l> /*bl*/)
{
algmeta_btsolve<l,withdiag,withrelax>::butsolve(A,v,d,w);
}
template<class M, class X, class Y, int l>
void ubutsolve (const M& A, X& v, const Y& d, BL<l> /*bl*/)
{
typename X::field_type w=1;
algmeta_btsolve<l,nodiag,norelax>::butsolve(A,v,d,w);
}
template<class M, class X, class Y, class K, int l>
void ubutsolve (const M& A, X& v, const Y& d, const K& w, BL<l> /*bl*/)
{
algmeta_btsolve<l,nodiag,withrelax>::butsolve(A,v,d,w);
}
//============================================================
// generic block diagonal solves
// consider block decomposition A = L + D + U
// we can apply relaxation or not
// we can recurse over a fixed number of levels
//============================================================
// template meta program for diagonal solves
template<int I, WithRelaxType relax>
struct algmeta_bdsolve {
template<class M, class X, class Y, class K>
static void bdsolve (const M& A, X& v, const Y& d, const K& w)
{
// iterator types
typedef typename M::ConstRowIterator rowiterator;
typedef typename M::ConstColIterator coliterator;
// local solve at each block and immediate update
rowiterator rendi=A.beforeBegin();
for (rowiterator i=A.beforeEnd(); i!=rendi; --i)
{
coliterator ii=(*i).find(i.index());
algmeta_bdsolve<I-1,relax>::bdsolve(*ii,v[i.index()],d[i.index()],w);
}
}
};
// recursion end ...
template<>
struct algmeta_bdsolve<0,withrelax> {
template<class M, class X, class Y, class K>
static void bdsolve (const M& A, X& v, const Y& d, const K& w)
{
A.solve(v,d);
v *= w;
}
};
template<>
struct algmeta_bdsolve<0,norelax> {
template<class M, class X, class Y, class K>
static void bdsolve (const M& A, X& v, const Y& d, const K& /*w*/)
{
A.solve(v,d);
}
};
// user calls
// default block recursion level = 1
template<class M, class X, class Y>
void bdsolve (const M& A, X& v, const Y& d)
{
typename X::field_type w=1;
algmeta_bdsolve<1,norelax>::bdsolve(A,v,d,w);
}
template<class M, class X, class Y, class K>
void bdsolve (const M& A, X& v, const Y& d, const K& w)
{
algmeta_bdsolve<1,withrelax>::bdsolve(A,v,d,w);
}
// general block recursion level >= 0
template<class M, class X, class Y, int l>
void bdsolve (const M& A, X& v, const Y& d, BL<l> /*bl*/)
{
typename X::field_type w=1;
algmeta_bdsolve<l,norelax>::bdsolve(A,v,d,w);
}
template<class M, class X, class Y, class K, int l>
void bdsolve (const M& A, X& v, const Y& d, const K& w, BL<l> /*bl*/)
{
algmeta_bdsolve<l,withrelax>::bdsolve(A,v,d,w);
}
//============================================================
// generic steps of iteration methods
// Jacobi, Gauss-Seidel, SOR, SSOR
// work directly on Ax=b, ie solve M(x^{i+1}-x^i) = w (b-Ax^i)
// we can recurse over a fixed number of levels
//============================================================
// template meta program for iterative solver steps
template<int I, typename M>
struct algmeta_itsteps {
template<class X, class Y, class K>
static void dbgs (const M& A, X& x, const Y& b, const K& w)
{
typedef typename M::ConstRowIterator rowiterator;
typedef typename M::ConstColIterator coliterator;
typedef typename Y::block_type bblock;
bblock rhs;
X xold(x); // remember old x
rowiterator endi=A.end();
for (rowiterator i=A.begin(); i!=endi; ++i)
{
rhs = b[i.index()]; // rhs = b_i
coliterator endj=(*i).end();
coliterator j=(*i).begin();
if constexpr (IsNumber<typename M::block_type>())
{
for (; j.index()<i.index(); ++j)
rhs -= (*j) * x[j.index()];
coliterator diag=j++; // *diag = a_ii and increment coliterator j from a_ii to a_i+1,i to skip diagonal
for (; j != endj; ++j)
rhs -= (*j) * x[j.index()];
x[i.index()] = rhs / (*diag);
}
else
{
for (; j.index()<i.index(); ++j) // iterate over a_ij with j < i
(*j).mmv(x[j.index()],rhs); // rhs -= sum_{j<i} a_ij * xnew_j
coliterator diag=j++; // *diag = a_ii and increment coliterator j from a_ii to a_i+1,i to skip diagonal
for (; j != endj; ++j) // iterate over a_ij with j > i
(*j).mmv(x[j.index()],rhs); // rhs -= sum_{j>i} a_ij * xold_j
algmeta_itsteps<I-1,typename M::block_type>::dbgs(*diag,x[i.index()],rhs,w); // if I==1: xnew_i = rhs/a_ii
}
}
// next two lines: xnew_i = w / a_ii * (b_i - sum_{j<i} a_ij * xnew_j - sum_{j>=i} a_ij * xold_j) + (1-w)*xold;
x *= w;
x.axpy(K(1)-w,xold);
}
template<class X, class Y, class K>
static void bsorf (const M& A, X& x, const Y& b, const K& w)
{
typedef typename M::ConstRowIterator rowiterator;
typedef typename M::ConstColIterator coliterator;
typedef typename Y::block_type bblock;
typedef typename X::block_type xblock;
bblock rhs;
xblock v;
// Initialize nested data structure if there are entries
if(A.begin()!=A.end())
v=x[0];
rowiterator endi=A.end();
for (rowiterator i=A.begin(); i!=endi; ++i)
{
rhs = b[i.index()]; // rhs = b_i
coliterator endj=(*i).end(); // iterate over a_ij with j < i
coliterator j=(*i).begin();
if constexpr (IsNumber<typename M::block_type>())
{
for (; j.index()<i.index(); ++j)
rhs -= (*j) * x[j.index()]; // rhs -= sum_{j<i} a_ij * xnew_j
coliterator diag=j; // *diag = a_ii
for (; j!=endj; ++j)
rhs -= (*j) * x[j.index()]; // rhs -= sum_{j<i} a_ij * xnew_j
v = rhs / (*diag);
x[i.index()] += w*v; // x_i = w / a_ii * (b_i - sum_{j<i} a_ij * xnew_j - sum_{j>=i} a_ij * xold_j)
}
else
{
for (; j.index()<i.index(); ++j)
(*j).mmv(x[j.index()],rhs); // rhs -= sum_{j<i} a_ij * xnew_j
coliterator diag=j; // *diag = a_ii
for (; j!=endj; ++j)
(*j).mmv(x[j.index()],rhs); // rhs -= sum_{j<i} a_ij * xnew_j
algmeta_itsteps<I-1,typename M::block_type>::bsorf(*diag,v,rhs,w); // if blocksize I==1: v = rhs/a_ii
x[i.index()].axpy(w,v); // x_i = w / a_ii * (b_i - sum_{j<i} a_ij * xnew_j - sum_{j>=i} a_ij * xold_j)
}
}
}
template<class X, class Y, class K>
static void bsorb (const M& A, X& x, const Y& b, const K& w)
{
typedef typename M::ConstRowIterator rowiterator;
typedef typename M::ConstColIterator coliterator;
typedef typename Y::block_type bblock;
typedef typename X::block_type xblock;
bblock rhs;
xblock v;
// Initialize nested data structure if there are entries
if(A.begin()!=A.end())
v=x[0];
rowiterator endi=A.beforeBegin();
for (rowiterator i=A.beforeEnd(); i!=endi; --i)
{
rhs = b[i.index()];
coliterator endj=(*i).end();
coliterator j=(*i).begin();
if constexpr (IsNumber<typename M::block_type>())
{
for (; j.index()<i.index(); ++j)
rhs -= (*j) * x[j.index()];
coliterator diag=j;
for (; j!=endj; ++j)
rhs -= (*j) * x[j.index()];
v = rhs / (*diag);
x[i.index()] += w*v;
}
else
{
for (; j.index()<i.index(); ++j)
j->mmv(x[j.index()],rhs);
coliterator diag=j;
for (; j!=endj; ++j)
j->mmv(x[j.index()],rhs);
algmeta_itsteps<I-1,typename M::block_type>::bsorb(*diag,v,rhs,w);
x[i.index()].axpy(w,v);
}
}
}
template<class X, class Y, class K>
static void dbjac (const M& A, X& x, const Y& b, const K& w)
{
typedef typename M::ConstRowIterator rowiterator;
typedef typename M::ConstColIterator coliterator;
typedef typename Y::block_type bblock;
bblock rhs;
X v(x); // allocate with same size
rowiterator endi=A.end();
for (rowiterator i=A.begin(); i!=endi; ++i)
{
rhs = b[i.index()];
coliterator endj=(*i).end();
coliterator j=(*i).begin();
if constexpr (IsNumber<typename M::block_type>())
{
for (; j.index()<i.index(); ++j)
rhs -= (*j) * x[j.index()];
coliterator diag=j;
for (; j!=endj; ++j)
rhs -= (*j) * x[j.index()];
v[i.index()] = rhs / (*diag);
}
else
{
for (; j.index()<i.index(); ++j)
j->mmv(x[j.index()],rhs);
coliterator diag=j;
for (; j!=endj; ++j)
j->mmv(x[j.index()],rhs);
algmeta_itsteps<I-1,typename M::block_type>::dbjac(*diag,v[i.index()],rhs,w);
}
}
x.axpy(w,v);
}
};
// end of recursion
template<typename M>
struct algmeta_itsteps<0,M> {
template<class X, class Y, class K>
static void dbgs (const M& A, X& x, const Y& b, const K& /*w*/)
{
A.solve(x,b);
}
template<class X, class Y, class K>
static void bsorf (const M& A, X& x, const Y& b, const K& /*w*/)
{
A.solve(x,b);
}
template<class X, class Y, class K>
static void bsorb (const M& A, X& x, const Y& b, const K& /*w*/)
{
A.solve(x,b);
}
template<class X, class Y, class K>
static void dbjac (const M& A, X& x, const Y& b, const K& /*w*/)
{
A.solve(x,b);
}
};
template<int I, typename T1, typename... MultiTypeMatrixArgs>
struct algmeta_itsteps<I,MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>> {
template<
typename... MultiTypeVectorArgs,
class K>
static void dbgs (const MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>& A,
MultiTypeBlockVector<MultiTypeVectorArgs...>& x,
const MultiTypeBlockVector<MultiTypeVectorArgs...>& b,
const K& w)
{
static const int N = MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>::N();
Dune::MultiTypeBlockMatrix_Solver<I,0,N>::dbgs(A, x, b, w);
}
template<
typename... MultiTypeVectorArgs,
class K>
static void bsorf (const MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>& A,
MultiTypeBlockVector<MultiTypeVectorArgs...>& x,
const MultiTypeBlockVector<MultiTypeVectorArgs...>& b,
const K& w)
{
static const int N = MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>::N();
Dune::MultiTypeBlockMatrix_Solver<I,0,N>::bsorf(A, x, b, w);
}
template<
typename... MultiTypeVectorArgs,
class K>
static void bsorb (const MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>& A,
MultiTypeBlockVector<MultiTypeVectorArgs...>& x,
const MultiTypeBlockVector<MultiTypeVectorArgs...>& b,
const K& w)
{
static const int N = MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>::N();
Dune::MultiTypeBlockMatrix_Solver<I,N-1,N>::bsorb(A, x, b, w);
}
template<
typename... MultiTypeVectorArgs,
class K
>
static void dbjac (const MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>& A,
MultiTypeBlockVector<MultiTypeVectorArgs...>& x,
const MultiTypeBlockVector<MultiTypeVectorArgs...>& b,
const K& w)
{
static const int N = MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>::N();
Dune::MultiTypeBlockMatrix_Solver<I,0,N>::dbjac(A, x, b, w);
}
};
// user calls
template<class M, class X, class Y, class K>
void dbgs (const M& A, X& x, const Y& b, const K& w)
{
algmeta_itsteps<1,M>::dbgs(A,x,b,w);
}
template<class M, class X, class Y, class K, int l>
void dbgs (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
{
algmeta_itsteps<l,M>::dbgs(A,x,b,w);
}
template<class M, class X, class Y, class K>
void bsorf (const M& A, X& x, const Y& b, const K& w)
{
algmeta_itsteps<1,M>::bsorf(A,x,b,w);
}
template<class M, class X, class Y, class K, int l>
void bsorf (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
{
algmeta_itsteps<l,M>::bsorf(A,x,b,w);
}
template<class M, class X, class Y, class K>
void bsorb (const M& A, X& x, const Y& b, const K& w)
{
algmeta_itsteps<1,M>::bsorb(A,x,b,w);
}
template<class M, class X, class Y, class K, int l>
void bsorb (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
{
algmeta_itsteps<l,typename std::remove_cv<M>::type>::bsorb(A,x,b,w);
}
template<class M, class X, class Y, class K>
void dbjac (const M& A, X& x, const Y& b, const K& w)
{
algmeta_itsteps<1,M>::dbjac(A,x,b,w);
}
template<class M, class X, class Y, class K, int l>
void dbjac (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
{
algmeta_itsteps<l,M>::dbjac(A,x,b,w);
}
} // end namespace
#endif
istlexception.hh
multitypeblockvector.hh
multitypeblockmatrix.hh
Dune::MultiTypeBlockMatrix_Solver::dbjac
static void dbjac(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:584
Dune::MultiTypeBlockMatrix_Solver::dbgs
static void dbgs(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:500
Dune::MultiTypeBlockMatrix_Solver::bsorb
static void bsorb(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:556
Dune::MultiTypeBlockMatrix::N
static constexpr size_type N()
Return the number of matrix rows.
Definition multitypeblockmatrix.hh:84
Dune::MultiTypeBlockMatrix_Solver::bsorf
static void bsorf(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition multitypeblockmatrix.hh:529
Dune::bltsolve
void bltsolve(const M &A, X &v, const Y &d)
block lower triangular solve
Definition gsetc.hh:175
Dune::WithDiagType
WithDiagType
Definition gsetc.hh:49
Dune::bsorb
void bsorb(const M &A, X &x, const Y &b, const K &w)
SSOR step.
Definition gsetc.hh:646
Dune::ubltsolve
void ubltsolve(const M &A, X &v, const Y &d)
unit block lower triangular solve
Definition gsetc.hh:188
Dune::dbjac
void dbjac(const M &A, X &x, const Y &b, const K &w)
Jacobi step.
Definition gsetc.hh:658
Dune::dbgs
void dbgs(const M &A, X &x, const Y &b, const K &w)
GS step.
Definition gsetc.hh:622
Dune::WithRelaxType
WithRelaxType
Definition gsetc.hh:54
Dune::bdsolve
void bdsolve(const M &A, X &v, const Y &d)
block diagonal solve, no relaxation
Definition gsetc.hh:337
Dune::butsolve
void butsolve(const M &A, X &v, const Y &d)
block upper triangular solve
Definition gsetc.hh:202
Dune::bsorf
void bsorf(const M &A, X &x, const Y &b, const K &w)
SOR step.
Definition gsetc.hh:634
Dune::ubutsolve
void ubutsolve(const M &A, X &v, const Y &d)
unit block upper triangular solve
Definition gsetc.hh:215
Dune::nodiag
@ nodiag
Definition gsetc.hh:51
Dune::withdiag
@ withdiag
Definition gsetc.hh:50
Dune::norelax
@ norelax
Definition gsetc.hh:56
Dune::withrelax
@ withrelax
Definition gsetc.hh:55
Dune
Definition allocator.hh:11
Dune::MultiTypeBlockVector
A Vector class to support different block types.
Definition multitypeblockvector.hh:59
Dune::MultiTypeBlockMatrix
A Matrix class to support different block types.
Definition multitypeblockmatrix.hh:46
Dune::BL
compile-time parameter for block recursion depth
Definition gsetc.hh:45
Dune::BL::recursion_level
@ recursion_level
Definition gsetc.hh:46
Dune::algmeta_btsolve
Definition gsetc.hh:69
Dune::algmeta_btsolve::butsolve
static void butsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:90
Dune::algmeta_btsolve::bltsolve
static void bltsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:71
Dune::algmeta_btsolve< 0, withdiag, withrelax >::bltsolve
static void bltsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:114
Dune::algmeta_btsolve< 0, withdiag, withrelax >::butsolve
static void butsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:120
Dune::algmeta_btsolve< 0, withdiag, norelax >::bltsolve
static void bltsolve(const M &A, X &v, const Y &d, const K &)
Definition gsetc.hh:129
Dune::algmeta_btsolve< 0, withdiag, norelax >::butsolve
static void butsolve(const M &A, X &v, const Y &d, const K &)
Definition gsetc.hh:134
Dune::algmeta_btsolve< 0, nodiag, withrelax >::bltsolve
static void bltsolve(const M &, X &v, const Y &d, const K &w)
Definition gsetc.hh:142
Dune::algmeta_btsolve< 0, nodiag, withrelax >::butsolve
static void butsolve(const M &, X &v, const Y &d, const K &w)
Definition gsetc.hh:148
Dune::algmeta_btsolve< 0, nodiag, norelax >::bltsolve
static void bltsolve(const M &, X &v, const Y &d, const K &)
Definition gsetc.hh:157
Dune::algmeta_btsolve< 0, nodiag, norelax >::butsolve
static void butsolve(const M &, X &v, const Y &d, const K &)
Definition gsetc.hh:162
Dune::algmeta_bdsolve
Definition gsetc.hh:294
Dune::algmeta_bdsolve::bdsolve
static void bdsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:296
Dune::algmeta_bdsolve< 0, withrelax >::bdsolve
static void bdsolve(const M &A, X &v, const Y &d, const K &w)
Definition gsetc.hh:316
Dune::algmeta_bdsolve< 0, norelax >::bdsolve
static void bdsolve(const M &A, X &v, const Y &d, const K &)
Definition gsetc.hh:325
Dune::algmeta_itsteps
Definition gsetc.hh:375
Dune::algmeta_itsteps::bsorb
static void bsorb(const M &A, X &x, const Y &b, const K &w)
Definition gsetc.hh:461
Dune::algmeta_itsteps::bsorf
static void bsorf(const M &A, X &x, const Y &b, const K &w)
Definition gsetc.hh:418
Dune::algmeta_itsteps::dbjac
static void dbjac(const M &A, X &x, const Y &b, const K &w)
Definition gsetc.hh:504
Dune::algmeta_itsteps::dbgs
static void dbgs(const M &A, X &x, const Y &b, const K &w)
Definition gsetc.hh:378
Dune::algmeta_itsteps< 0, M >::dbgs
static void dbgs(const M &A, X &x, const Y &b, const K &)
Definition gsetc.hh:545
Dune::algmeta_itsteps< 0, M >::dbjac
static void dbjac(const M &A, X &x, const Y &b, const K &)
Definition gsetc.hh:560
Dune::algmeta_itsteps< 0, M >::bsorf
static void bsorf(const M &A, X &x, const Y &b, const K &)
Definition gsetc.hh:550
Dune::algmeta_itsteps< 0, M >::bsorb
static void bsorb(const M &A, X &x, const Y &b, const K &)
Definition gsetc.hh:555
Dune::algmeta_itsteps< I, MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > >::dbgs
static void dbgs(const MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > &A, MultiTypeBlockVector< MultiTypeVectorArgs... > &x, const MultiTypeBlockVector< MultiTypeVectorArgs... > &b, const K &w)
Definition gsetc.hh:571
Dune::algmeta_itsteps< I, MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > >::dbjac
static void dbjac(const MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > &A, MultiTypeBlockVector< MultiTypeVectorArgs... > &x, const MultiTypeBlockVector< MultiTypeVectorArgs... > &b, const K &w)
Definition gsetc.hh:608
Dune::algmeta_itsteps< I, MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > >::bsorf
static void bsorf(const MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > &A, MultiTypeBlockVector< MultiTypeVectorArgs... > &x, const MultiTypeBlockVector< MultiTypeVectorArgs... > &b, const K &w)
Definition gsetc.hh:583
Dune::algmeta_itsteps< I, MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > >::bsorb
static void bsorb(const MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > &A, MultiTypeBlockVector< MultiTypeVectorArgs... > &x, const MultiTypeBlockVector< MultiTypeVectorArgs... > &b, const K &w)
Definition gsetc.hh:595