Dune Core Modules (2.4.1)

gsetc.hh
Go to the documentation of this file.
1// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2// vi: set et ts=4 sw=2 sts=2:
3#ifndef DUNE_ISTL_GSETC_HH
4#define DUNE_ISTL_GSETC_HH
5
6#include <cmath>
7#include <complex>
8#include <iostream>
9#include <iomanip>
10#include <string>
11#include "multitypeblockvector.hh"
12#include "multitypeblockmatrix.hh"
13
14#include "istlexception.hh"
15
16
22namespace Dune {
23
34 //============================================================
35 // parameter types
36 //============================================================
37
39 template<int l>
40 struct BL {
41 enum {recursion_level = l};
42 };
43
44 enum WithDiagType {
45 withdiag=1,
46 nodiag=0
47 };
48
49 enum WithRelaxType {
50 withrelax=1,
51 norelax=0
52 };
53
54 //============================================================
55 // generic triangular solves
56 // consider block decomposition A = L + D + U
57 // we can invert L, L+D, U, U+D
58 // we can apply relaxation or not
59 // we can recurse over a fixed number of levels
60 //============================================================
61
62 // template meta program for triangular solves
63 template<int I, WithDiagType diag, WithRelaxType relax>
64 struct algmeta_btsolve {
65 template<class M, class X, class Y, class K>
66 static void bltsolve (const M& A, X& v, const Y& d, const K& w)
67 {
68 // iterator types
69 typedef typename M::ConstRowIterator rowiterator;
70 typedef typename M::ConstColIterator coliterator;
71 typedef typename Y::block_type bblock;
72
73 // local solve at each block and immediate update
74 rowiterator endi=A.end();
75 for (rowiterator i=A.begin(); i!=endi; ++i)
76 {
77 bblock rhs(d[i.index()]);
78 coliterator j;
79 for (j=(*i).begin(); j.index()<i.index(); ++j)
80 (*j).mmv(v[j.index()],rhs);
81 algmeta_btsolve<I-1,diag,relax>::bltsolve(*j,v[i.index()],rhs,w);
82 }
83 }
84 template<class M, class X, class Y, class K>
85 static void butsolve (const M& A, X& v, const Y& d, const K& w)
86 {
87 // iterator types
88 typedef typename M::ConstRowIterator rowiterator;
89 typedef typename M::ConstColIterator coliterator;
90 typedef typename Y::block_type bblock;
91
92 // local solve at each block and immediate update
93 rowiterator rendi=A.beforeBegin();
94 for (rowiterator i=A.beforeEnd(); i!=rendi; --i)
95 {
96 bblock rhs(d[i.index()]);
97 coliterator j;
98 for (j=(*i).beforeEnd(); j.index()>i.index(); --j)
99 (*j).mmv(v[j.index()],rhs);
100 algmeta_btsolve<I-1,diag,relax>::butsolve(*j,v[i.index()],rhs,w);
101 }
102 }
103 };
104
105 // recursion end ...
106 template<>
107 struct algmeta_btsolve<0,withdiag,withrelax> {
108 template<class M, class X, class Y, class K>
109 static void bltsolve (const M& A, X& v, const Y& d, const K& w)
110 {
111 A.solve(v,d);
112 v *= w;
113 }
114 template<class M, class X, class Y, class K>
115 static void butsolve (const M& A, X& v, const Y& d, const K& w)
116 {
117 A.solve(v,d);
118 v *= w;
119 }
120 };
121 template<>
122 struct algmeta_btsolve<0,withdiag,norelax> {
123 template<class M, class X, class Y, class K>
124 static void bltsolve (const M& A, X& v, const Y& d, const K& /*w*/)
125 {
126 A.solve(v,d);
127 }
128 template<class M, class X, class Y, class K>
129 static void butsolve (const M& A, X& v, const Y& d, const K& /*w*/)
130 {
131 A.solve(v,d);
132 }
133 };
134 template<>
135 struct algmeta_btsolve<0,nodiag,withrelax> {
136 template<class M, class X, class Y, class K>
137 static void bltsolve (const M& /*A*/, X& v, const Y& d, const K& w)
138 {
139 v = d;
140 v *= w;
141 }
142 template<class M, class X, class Y, class K>
143 static void butsolve (const M& /*A*/, X& v, const Y& d, const K& w)
144 {
145 v = d;
146 v *= w;
147 }
148 };
149 template<>
150 struct algmeta_btsolve<0,nodiag,norelax> {
151 template<class M, class X, class Y, class K>
152 static void bltsolve (const M& /*A*/, X& v, const Y& d, const K& /*w*/)
153 {
154 v = d;
155 }
156 template<class M, class X, class Y, class K>
157 static void butsolve (const M& /*A*/, X& v, const Y& d, const K& /*w*/)
158 {
159 v = d;
160 }
161 };
162
163
164 // user calls
165
166 // default block recursion level = 1
167
169 template<class M, class X, class Y>
170 void bltsolve (const M& A, X& v, const Y& d)
171 {
172 typename X::field_type w=1;
173 algmeta_btsolve<1,withdiag,norelax>::bltsolve(A,v,d,w);
174 }
176 template<class M, class X, class Y, class K>
177 void bltsolve (const M& A, X& v, const Y& d, const K& w)
178 {
179 algmeta_btsolve<1,withdiag,withrelax>::bltsolve(A,v,d,w);
180 }
182 template<class M, class X, class Y>
183 void ubltsolve (const M& A, X& v, const Y& d)
184 {
185 typename X::field_type w=1;
186 algmeta_btsolve<1,nodiag,norelax>::bltsolve(A,v,d,w);
187 }
189 template<class M, class X, class Y, class K>
190 void ubltsolve (const M& A, X& v, const Y& d, const K& w)
191 {
192 algmeta_btsolve<1,nodiag,withrelax>::bltsolve(A,v,d,w);
193 }
194
196 template<class M, class X, class Y>
197 void butsolve (const M& A, X& v, const Y& d)
198 {
199 typename X::field_type w=1;
200 algmeta_btsolve<1,withdiag,norelax>::butsolve(A,v,d,w);
201 }
203 template<class M, class X, class Y, class K>
204 void butsolve (const M& A, X& v, const Y& d, const K& w)
205 {
206 algmeta_btsolve<1,withdiag,withrelax>::butsolve(A,v,d,w);
207 }
209 template<class M, class X, class Y>
210 void ubutsolve (const M& A, X& v, const Y& d)
211 {
212 typename X::field_type w=1;
213 algmeta_btsolve<1,nodiag,norelax>::butsolve(A,v,d,w);
214 }
216 template<class M, class X, class Y, class K>
217 void ubutsolve (const M& A, X& v, const Y& d, const K& w)
218 {
219 algmeta_btsolve<1,nodiag,withrelax>::butsolve(A,v,d,w);
220 }
221
222 // general block recursion level >= 0
223
225 template<class M, class X, class Y, int l>
226 void bltsolve (const M& A, X& v, const Y& d, BL<l> /*bl*/)
227 {
228 typename X::field_type w=1;
229 algmeta_btsolve<l,withdiag,norelax>::bltsolve(A,v,d,w);
230 }
232 template<class M, class X, class Y, class K, int l>
233 void bltsolve (const M& A, X& v, const Y& d, const K& w, BL<l> /*bl*/)
234 {
235 algmeta_btsolve<l,withdiag,withrelax>::bltsolve(A,v,d,w);
236 }
238 template<class M, class X, class Y, int l>
239 void ubltsolve (const M& A, X& v, const Y& d, BL<l> /*bl*/)
240 {
241 typename X::field_type w=1;
242 algmeta_btsolve<l,nodiag,norelax>::bltsolve(A,v,d,w);
243 }
245 template<class M, class X, class Y, class K, int l>
246 void ubltsolve (const M& A, X& v, const Y& d, const K& w, BL<l> /*bl*/)
247 {
248 algmeta_btsolve<l,nodiag,withrelax>::bltsolve(A,v,d,w);
249 }
250
252 template<class M, class X, class Y, int l>
253 void butsolve (const M& A, X& v, const Y& d, BL<l> bl)
254 {
255 typename X::field_type w=1;
256 algmeta_btsolve<l,withdiag,norelax>::butsolve(A,v,d,w);
257 }
259 template<class M, class X, class Y, class K, int l>
260 void butsolve (const M& A, X& v, const Y& d, const K& w, BL<l> bl)
261 {
262 algmeta_btsolve<l,withdiag,withrelax>::butsolve(A,v,d,w);
263 }
265 template<class M, class X, class Y, int l>
266 void ubutsolve (const M& A, X& v, const Y& d, BL<l> bl)
267 {
268 typename X::field_type w=1;
269 algmeta_btsolve<l,nodiag,norelax>::butsolve(A,v,d,w);
270 }
272 template<class M, class X, class Y, class K, int l>
273 void ubutsolve (const M& A, X& v, const Y& d, const K& w, BL<l> bl)
274 {
275 algmeta_btsolve<l,nodiag,withrelax>::butsolve(A,v,d,w);
276 }
277
278
279
280 //============================================================
281 // generic block diagonal solves
282 // consider block decomposition A = L + D + U
283 // we can apply relaxation or not
284 // we can recurse over a fixed number of levels
285 //============================================================
286
287 // template meta program for diagonal solves
288 template<int I, WithRelaxType relax>
289 struct algmeta_bdsolve {
290 template<class M, class X, class Y, class K>
291 static void bdsolve (const M& A, X& v, const Y& d, const K& w)
292 {
293 // iterator types
294 typedef typename M::ConstRowIterator rowiterator;
295 typedef typename M::ConstColIterator coliterator;
296
297 // local solve at each block and immediate update
298 rowiterator rendi=A.beforeBegin();
299 for (rowiterator i=A.beforeEnd(); i!=rendi; --i)
300 {
301 coliterator ii=(*i).find(i.index());
302 algmeta_bdsolve<I-1,relax>::bdsolve(*ii,v[i.index()],d[i.index()],w);
303 }
304 }
305 };
306
307 // recursion end ...
308 template<>
309 struct algmeta_bdsolve<0,withrelax> {
310 template<class M, class X, class Y, class K>
311 static void bdsolve (const M& A, X& v, const Y& d, const K& w)
312 {
313 A.solve(v,d);
314 v *= w;
315 }
316 };
317 template<>
318 struct algmeta_bdsolve<0,norelax> {
319 template<class M, class X, class Y, class K>
320 static void bdsolve (const M& A, X& v, const Y& d, const K& /*w*/)
321 {
322 A.solve(v,d);
323 }
324 };
325
326 // user calls
327
328 // default block recursion level = 1
329
331 template<class M, class X, class Y>
332 void bdsolve (const M& A, X& v, const Y& d)
333 {
334 typename X::field_type w=1;
335 algmeta_bdsolve<1,norelax>::bdsolve(A,v,d,w);
336 }
338 template<class M, class X, class Y, class K>
339 void bdsolve (const M& A, X& v, const Y& d, const K& w)
340 {
341 algmeta_bdsolve<1,withrelax>::bdsolve(A,v,d,w);
342 }
343
344 // general block recursion level >= 0
345
347 template<class M, class X, class Y, int l>
348 void bdsolve (const M& A, X& v, const Y& d, BL<l> /*bl*/)
349 {
350 typename X::field_type w=1;
351 algmeta_bdsolve<l,norelax>::bdsolve(A,v,d,w);
352 }
354 template<class M, class X, class Y, class K, int l>
355 void bdsolve (const M& A, X& v, const Y& d, const K& w, BL<l> /*bl*/)
356 {
357 algmeta_bdsolve<l,withrelax>::bdsolve(A,v,d,w);
358 }
359
360
361
362
363
364 //============================================================
365 // generic steps of iteration methods
366 // Jacobi, Gauss-Seidel, SOR, SSOR
367 // work directly on Ax=b, ie solve M(x^{i+1}-x^i) = w (b-Ax^i)
368 // we can recurse over a fixed number of levels
369 //============================================================
370
371
372 // template meta program for iterative solver steps
373 template<int I>
374 struct algmeta_itsteps {
375
376#if HAVE_DUNE_BOOST
377#ifdef HAVE_BOOST_FUSION
378
379 template<typename T11, typename T12, typename T13, typename T14,
380 typename T15, typename T16, typename T17, typename T18,
381 typename T19, typename T21, typename T22, typename T23,
382 typename T24, typename T25, typename T26, typename T27,
383 typename T28, typename T29, class K>
384 static void dbgs (const MultiTypeBlockMatrix<T11,T12,T13,T14,T15,T16,T17,T18,T19>& A,
385 MultiTypeBlockVector<T21,T22,T23,T24,T25,T26,T27,T28,T29>& x,
386 const MultiTypeBlockVector<T21,T22,T23,T24,T25,T26,T27,T28,T29>& b,
387 const K& w)
388 {
389 const int rowcount =
390 boost::mpl::size<MultiTypeBlockMatrix<T11,T12,T13,T14,T15,T16,T17,T18,T19> >::value;
391 Dune::MultiTypeBlockMatrix_Solver<I,0,rowcount>::dbgs(A, x, b, w);
392 }
393#endif
394#endif
395
396 template<class M, class X, class Y, class K>
397 static void dbgs (const M& A, X& x, const Y& b, const K& w)
398 {
399 typedef typename M::ConstRowIterator rowiterator;
400 typedef typename M::ConstColIterator coliterator;
401 typedef typename Y::block_type bblock;
402 bblock rhs;
403
404 X xold(x); // remember old x
405
406 rowiterator endi=A.end();
407 for (rowiterator i=A.begin(); i!=endi; ++i)
408 {
409 rhs = b[i.index()]; // rhs = b_i
410 coliterator endj=(*i).end();
411 coliterator j=(*i).begin();
412 for (; j.index()<i.index(); ++j) // iterate over a_ij with j < i
413 (*j).mmv(x[j.index()],rhs); // rhs -= sum_{j<i} a_ij * xnew_j
414 coliterator diag=j++; // *diag = a_ii and increment coliterator j from a_ii to a_i+1,i to skip diagonal
415 for (; j != endj; ++j) // iterate over a_ij with j > i
416 (*j).mmv(x[j.index()],rhs); // rhs -= sum_{j>i} a_ij * xold_j
417 algmeta_itsteps<I-1>::dbgs(*diag,x[i.index()],rhs,w); // if I==1: xnew_i = rhs/a_ii
418 }
419 // 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;
420 x *= w;
421 x.axpy(K(1)-w,xold);
422 }
423
424#if HAVE_DUNE_BOOST
425#ifdef HAVE_BOOST_FUSION
426
427 template<typename T11, typename T12, typename T13, typename T14,
428 typename T15, typename T16, typename T17, typename T18,
429 typename T19, typename T21, typename T22, typename T23,
430 typename T24, typename T25, typename T26, typename T27,
431 typename T28, typename T29, class K>
432 static void bsorf (const MultiTypeBlockMatrix<T11,T12,T13,T14,T15,T16,T17,T18,T19>& A,
433 MultiTypeBlockVector<T21,T22,T23,T24,T25,T26,T27,T28,T29>& x,
434 const MultiTypeBlockVector<T21,T22,T23,T24,T25,T26,T27,T28,T29>& b,
435 const K& w)
436 {
437 const int rowcount =
438 boost::mpl::size<MultiTypeBlockMatrix<T11,T12,T13,T14,T15,T16,T17,T18,T19> >::value;
439 Dune::MultiTypeBlockMatrix_Solver<I,0,rowcount>::bsorf(A, x, b, w);
440 }
441#endif
442#endif
443
444 template<class M, class X, class Y, class K>
445 static void bsorf (const M& A, X& x, const Y& b, const K& w)
446 {
447 typedef typename M::ConstRowIterator rowiterator;
448 typedef typename M::ConstColIterator coliterator;
449 typedef typename Y::block_type bblock;
450 typedef typename X::block_type xblock;
451 bblock rhs;
452 xblock v;
453
454 // Initialize nested data structure if there are entries
455 if(A.begin()!=A.end())
456 v=x[0];
457
458 rowiterator endi=A.end();
459 for (rowiterator i=A.begin(); i!=endi; ++i)
460 {
461 rhs = b[i.index()]; // rhs = b_i
462 coliterator endj=(*i).end(); // iterate over a_ij with j < i
463 coliterator j=(*i).begin();
464 for (; j.index()<i.index(); ++j)
465 (*j).mmv(x[j.index()],rhs); // rhs -= sum_{j<i} a_ij * xnew_j
466 coliterator diag=j; // *diag = a_ii
467 for (; j!=endj; ++j)
468 (*j).mmv(x[j.index()],rhs); // rhs -= sum_{j<i} a_ij * xnew_j
469 algmeta_itsteps<I-1>::bsorf(*diag,v,rhs,w); // if blocksize I==1: v = rhs/a_ii
470 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)
471 }
472 }
473
474#if HAVE_DUNE_BOOST
475#ifdef HAVE_BOOST_FUSION
476
477 template<typename T11, typename T12, typename T13, typename T14,
478 typename T15, typename T16, typename T17, typename T18,
479 typename T19, typename T21, typename T22, typename T23,
480 typename T24, typename T25, typename T26, typename T27,
481 typename T28, typename T29, class K>
482 static void bsorb (const MultiTypeBlockMatrix<T11,T12,T13,T14,T15,T16,T17,T18,T19>& A,
483 MultiTypeBlockVector<T21,T22,T23,T24,T25,T26,T27,T28,T29>& x,
484 const MultiTypeBlockVector<T21,T22,T23,T24,T25,T26,T27,T28,T29>& b,
485 const K& w)
486 {
487 const int rowcount =
488 mpl::size<MultiTypeBlockMatrix<T11,T12,T13,T14,T15,T16,T17,T18,T19> >::value;
489 Dune::MultiTypeBlockMatrix_Solver<I,rowcount-1,rowcount>::bsorb(A, x, b, w);
490 }
491#endif
492#endif
493
494 template<class M, class X, class Y, class K>
495 static void bsorb (const M& A, X& x, const Y& b, const K& w)
496 {
497 typedef typename M::ConstRowIterator rowiterator;
498 typedef typename M::ConstColIterator coliterator;
499 typedef typename Y::block_type bblock;
500 typedef typename X::block_type xblock;
501 bblock rhs;
502 xblock v;
503
504 // Initialize nested data structure if there are entries
505 if(A.begin()!=A.end())
506 v=x[0];
507
508 rowiterator endi=A.beforeBegin();
509 for (rowiterator i=A.beforeEnd(); i!=endi; --i)
510 {
511 rhs = b[i.index()];
512 coliterator endj=(*i).end();
513 coliterator j=(*i).begin();
514 for (; j.index()<i.index(); ++j)
515 (*j).mmv(x[j.index()],rhs);
516 coliterator diag=j;
517 for (; j!=endj; ++j)
518 (*j).mmv(x[j.index()],rhs);
519 algmeta_itsteps<I-1>::bsorb(*diag,v,rhs,w);
520 x[i.index()].axpy(w,v);
521 }
522 }
523
524#if HAVE_DUNE_BOOST
525#ifdef HAVE_BOOST_FUSION
526
527 template<typename T11, typename T12, typename T13, typename T14,
528 typename T15, typename T16, typename T17, typename T18,
529 typename T19, typename T21, typename T22, typename T23,
530 typename T24, typename T25, typename T26, typename T27,
531 typename T28, typename T29, class K>
532 static void dbjac (const MultiTypeBlockMatrix<T11,T12,T13,T14,T15,T16,T17,T18,T19>& A,
533 MultiTypeBlockVector<T21,T22,T23,T24,T25,T26,T27,T28,T29>& x,
534 const MultiTypeBlockVector<T21,T22,T23,T24,T25,T26,T27,T28,T29>& b,
535 const K& w)
536 {
537 const int rowcount =
538 boost::mpl::size<MultiTypeBlockMatrix<T11,T12,T13,T14,T15,T16,T17,T18,T19> >::value;
539 Dune::MultiTypeBlockMatrix_Solver<I,0,rowcount >::dbjac(A, x, b, w);
540 }
541#endif
542#endif
543
544 template<class M, class X, class Y, class K>
545 static void dbjac (const M& A, X& x, const Y& b, const K& w)
546 {
547 typedef typename M::ConstRowIterator rowiterator;
548 typedef typename M::ConstColIterator coliterator;
549 typedef typename Y::block_type bblock;
550 bblock rhs;
551
552 X v(x); // allocate with same size
553
554 rowiterator endi=A.end();
555 for (rowiterator i=A.begin(); i!=endi; ++i)
556 {
557 rhs = b[i.index()];
558 coliterator endj=(*i).end();
559 coliterator j=(*i).begin();
560 for (; j.index()<i.index(); ++j)
561 (*j).mmv(x[j.index()],rhs);
562 coliterator diag=j;
563 for (; j!=endj; ++j)
564 (*j).mmv(x[j.index()],rhs);
565 algmeta_itsteps<I-1>::dbjac(*diag,v[i.index()],rhs,w);
566 }
567 x.axpy(w,v);
568 }
569 };
570 // end of recursion
571 template<>
572 struct algmeta_itsteps<0> {
573 template<class M, class X, class Y, class K>
574 static void dbgs (const M& A, X& x, const Y& b, const K& /*w*/)
575 {
576 A.solve(x,b);
577 }
578 template<class M, class X, class Y, class K>
579 static void bsorf (const M& A, X& x, const Y& b, const K& /*w*/)
580 {
581 A.solve(x,b);
582 }
583 template<class M, class X, class Y, class K>
584 static void bsorb (const M& A, X& x, const Y& b, const K& /*w*/)
585 {
586 A.solve(x,b);
587 }
588 template<class M, class X, class Y, class K>
589 static void dbjac (const M& A, X& x, const Y& b, const K& /*w*/)
590 {
591 A.solve(x,b);
592 }
593 };
594
595
596 // user calls
597
599 template<class M, class X, class Y, class K>
600 void dbgs (const M& A, X& x, const Y& b, const K& w)
601 {
602 algmeta_itsteps<1>::dbgs(A,x,b,w);
603 }
605 template<class M, class X, class Y, class K, int l>
606 void dbgs (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
607 {
608 algmeta_itsteps<l>::dbgs(A,x,b,w);
609 }
611 template<class M, class X, class Y, class K>
612 void bsorf (const M& A, X& x, const Y& b, const K& w)
613 {
614 algmeta_itsteps<1>::bsorf(A,x,b,w);
615 }
617 template<class M, class X, class Y, class K, int l>
618 void bsorf (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
619 {
620 algmeta_itsteps<l>::bsorf(A,x,b,w);
621 }
623 template<class M, class X, class Y, class K>
624 void bsorb (const M& A, X& x, const Y& b, const K& w)
625 {
626 algmeta_itsteps<1>::bsorb(A,x,b,w);
627 }
629 template<class M, class X, class Y, class K, int l>
630 void bsorb (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
631 {
632 algmeta_itsteps<l>::bsorb(A,x,b,w);
633 }
635 template<class M, class X, class Y, class K>
636 void dbjac (const M& A, X& x, const Y& b, const K& w)
637 {
638 algmeta_itsteps<1>::dbjac(A,x,b,w);
639 }
641 template<class M, class X, class Y, class K, int l>
642 void dbjac (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
643 {
644 algmeta_itsteps<l>::dbjac(A,x,b,w);
645 }
646
647
650} // end namespace
651
652#endif
Dune::bltsolve
void bltsolve(const M &A, X &v, const Y &d)
block lower triangular solve
Definition: gsetc.hh:170
Dune::bsorb
void bsorb(const M &A, X &x, const Y &b, const K &w)
SSOR step.
Definition: gsetc.hh:624
Dune::ubltsolve
void ubltsolve(const M &A, X &v, const Y &d)
unit block lower triangular solve
Definition: gsetc.hh:183
Dune::dbjac
void dbjac(const M &A, X &x, const Y &b, const K &w)
Jacobi step.
Definition: gsetc.hh:636
Dune::dbgs
void dbgs(const M &A, X &x, const Y &b, const K &w)
GS step.
Definition: gsetc.hh:600
Dune::bsorf
void bsorf(const M &A, X &x, const Y &b, const K &w, BL< l >)
SOR step.
Definition: gsetc.hh:618
Dune::dbjac
void dbjac(const M &A, X &x, const Y &b, const K &w, BL< l >)
Jacobi step.
Definition: gsetc.hh:642
Dune::dbgs
void dbgs(const M &A, X &x, const Y &b, const K &w, BL< l >)
GS step.
Definition: gsetc.hh:606
Dune::bltsolve
void bltsolve(const M &A, X &v, const Y &d, const K &w, BL< l >)
relaxed block lower triangular solve
Definition: gsetc.hh:233
Dune::butsolve
void butsolve(const M &A, X &v, const Y &d, const K &w, BL< l > bl)
relaxed block upper triangular solve
Definition: gsetc.hh:260
Dune::bdsolve
void bdsolve(const M &A, X &v, const Y &d)
block diagonal solve, no relaxation
Definition: gsetc.hh:332
Dune::bsorb
void bsorb(const M &A, X &x, const Y &b, const K &w, BL< l >)
Backward SOR step.
Definition: gsetc.hh:630
Dune::bdsolve
void bdsolve(const M &A, X &v, const Y &d, const K &w, BL< l >)
block diagonal solve, with relaxation
Definition: gsetc.hh:355
Dune::butsolve
void butsolve(const M &A, X &v, const Y &d)
block upper triangular solve
Definition: gsetc.hh:197
Dune::bsorf
void bsorf(const M &A, X &x, const Y &b, const K &w)
SOR step.
Definition: gsetc.hh:612
Dune::ubutsolve
void ubutsolve(const M &A, X &v, const Y &d)
unit block upper triangular solve
Definition: gsetc.hh:210
Dune
Dune namespace.
Definition: alignment.hh:10
Dune::BL
compile-time parameter for block recursion depth
Definition: gsetc.hh:40
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.111.3 (Dec 22, 23:30, 2024)