Dune Core Modules (2.7.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 
12 #include <dune/common/hybridutilities.hh>
13 
14 #include "multitypeblockvector.hh"
15 #include "multitypeblockmatrix.hh"
16 
17 #include "istlexception.hh"
18 
19 
25 namespace Dune {
26 
37  //============================================================
38  // parameter types
39  //============================================================
40 
42  template<int l>
43  struct BL {
44  enum {recursion_level = l};
45  };
46 
47  enum WithDiagType {
48  withdiag=1,
49  nodiag=0
50  };
51 
52  enum WithRelaxType {
53  withrelax=1,
54  norelax=0
55  };
56 
57  //============================================================
58  // generic triangular solves
59  // consider block decomposition A = L + D + U
60  // we can invert L, L+D, U, U+D
61  // we can apply relaxation or not
62  // we can recurse over a fixed number of levels
63  //============================================================
64 
65  // template meta program for triangular solves
66  template<int I, WithDiagType diag, WithRelaxType relax>
67  struct algmeta_btsolve {
68  template<class M, class X, class Y, class K>
69  static void bltsolve (const M& A, X& v, const Y& d, const K& w)
70  {
71  // iterator types
72  typedef typename M::ConstRowIterator rowiterator;
73  typedef typename M::ConstColIterator coliterator;
74  typedef typename Y::block_type bblock;
75 
76  // local solve at each block and immediate update
77  rowiterator endi=A.end();
78  for (rowiterator i=A.begin(); i!=endi; ++i)
79  {
80  bblock rhs(d[i.index()]);
81  coliterator j;
82  for (j=(*i).begin(); j.index()<i.index(); ++j)
83  (*j).mmv(v[j.index()],rhs);
84  algmeta_btsolve<I-1,diag,relax>::bltsolve(*j,v[i.index()],rhs,w);
85  }
86  }
87  template<class M, class X, class Y, class K>
88  static void butsolve (const M& A, X& v, const Y& d, const K& w)
89  {
90  // iterator types
91  typedef typename M::ConstRowIterator rowiterator;
92  typedef typename M::ConstColIterator coliterator;
93  typedef typename Y::block_type bblock;
94 
95  // local solve at each block and immediate update
96  rowiterator rendi=A.beforeBegin();
97  for (rowiterator i=A.beforeEnd(); i!=rendi; --i)
98  {
99  bblock rhs(d[i.index()]);
100  coliterator j;
101  for (j=(*i).beforeEnd(); j.index()>i.index(); --j)
102  (*j).mmv(v[j.index()],rhs);
103  algmeta_btsolve<I-1,diag,relax>::butsolve(*j,v[i.index()],rhs,w);
104  }
105  }
106  };
107 
108  // recursion end ...
109  template<>
110  struct algmeta_btsolve<0,withdiag,withrelax> {
111  template<class M, class X, class Y, class K>
112  static void bltsolve (const M& A, X& v, const Y& d, const K& w)
113  {
114  A.solve(v,d);
115  v *= w;
116  }
117  template<class M, class X, class Y, class K>
118  static void butsolve (const M& A, X& v, const Y& d, const K& w)
119  {
120  A.solve(v,d);
121  v *= w;
122  }
123  };
124  template<>
125  struct algmeta_btsolve<0,withdiag,norelax> {
126  template<class M, class X, class Y, class K>
127  static void bltsolve (const M& A, X& v, const Y& d, const K& /*w*/)
128  {
129  A.solve(v,d);
130  }
131  template<class M, class X, class Y, class K>
132  static void butsolve (const M& A, X& v, const Y& d, const K& /*w*/)
133  {
134  A.solve(v,d);
135  }
136  };
137  template<>
138  struct algmeta_btsolve<0,nodiag,withrelax> {
139  template<class M, class X, class Y, class K>
140  static void bltsolve (const M& /*A*/, X& v, const Y& d, const K& w)
141  {
142  v = d;
143  v *= w;
144  }
145  template<class M, class X, class Y, class K>
146  static void butsolve (const M& /*A*/, X& v, const Y& d, const K& w)
147  {
148  v = d;
149  v *= w;
150  }
151  };
152  template<>
153  struct algmeta_btsolve<0,nodiag,norelax> {
154  template<class M, class X, class Y, class K>
155  static void bltsolve (const M& /*A*/, X& v, const Y& d, const K& /*w*/)
156  {
157  v = d;
158  }
159  template<class M, class X, class Y, class K>
160  static void butsolve (const M& /*A*/, X& v, const Y& d, const K& /*w*/)
161  {
162  v = d;
163  }
164  };
165 
166 
167  // user calls
168 
169  // default block recursion level = 1
170 
172  template<class M, class X, class Y>
173  void bltsolve (const M& A, X& v, const Y& d)
174  {
175  typename X::field_type w=1;
176  algmeta_btsolve<1,withdiag,norelax>::bltsolve(A,v,d,w);
177  }
179  template<class M, class X, class Y, class K>
180  void bltsolve (const M& A, X& v, const Y& d, const K& w)
181  {
182  algmeta_btsolve<1,withdiag,withrelax>::bltsolve(A,v,d,w);
183  }
185  template<class M, class X, class Y>
186  void ubltsolve (const M& A, X& v, const Y& d)
187  {
188  typename X::field_type w=1;
189  algmeta_btsolve<1,nodiag,norelax>::bltsolve(A,v,d,w);
190  }
192  template<class M, class X, class Y, class K>
193  void ubltsolve (const M& A, X& v, const Y& d, const K& w)
194  {
195  algmeta_btsolve<1,nodiag,withrelax>::bltsolve(A,v,d,w);
196  }
197 
199  template<class M, class X, class Y>
200  void butsolve (const M& A, X& v, const Y& d)
201  {
202  typename X::field_type w=1;
203  algmeta_btsolve<1,withdiag,norelax>::butsolve(A,v,d,w);
204  }
206  template<class M, class X, class Y, class K>
207  void butsolve (const M& A, X& v, const Y& d, const K& w)
208  {
209  algmeta_btsolve<1,withdiag,withrelax>::butsolve(A,v,d,w);
210  }
212  template<class M, class X, class Y>
213  void ubutsolve (const M& A, X& v, const Y& d)
214  {
215  typename X::field_type w=1;
216  algmeta_btsolve<1,nodiag,norelax>::butsolve(A,v,d,w);
217  }
219  template<class M, class X, class Y, class K>
220  void ubutsolve (const M& A, X& v, const Y& d, const K& w)
221  {
222  algmeta_btsolve<1,nodiag,withrelax>::butsolve(A,v,d,w);
223  }
224 
225  // general block recursion level >= 0
226 
228  template<class M, class X, class Y, int l>
229  void bltsolve (const M& A, X& v, const Y& d, BL<l> /*bl*/)
230  {
231  typename X::field_type w=1;
232  algmeta_btsolve<l,withdiag,norelax>::bltsolve(A,v,d,w);
233  }
235  template<class M, class X, class Y, class K, int l>
236  void bltsolve (const M& A, X& v, const Y& d, const K& w, BL<l> /*bl*/)
237  {
238  algmeta_btsolve<l,withdiag,withrelax>::bltsolve(A,v,d,w);
239  }
241  template<class M, class X, class Y, int l>
242  void ubltsolve (const M& A, X& v, const Y& d, BL<l> /*bl*/)
243  {
244  typename X::field_type w=1;
245  algmeta_btsolve<l,nodiag,norelax>::bltsolve(A,v,d,w);
246  }
248  template<class M, class X, class Y, class K, int l>
249  void ubltsolve (const M& A, X& v, const Y& d, const K& w, BL<l> /*bl*/)
250  {
251  algmeta_btsolve<l,nodiag,withrelax>::bltsolve(A,v,d,w);
252  }
253 
255  template<class M, class X, class Y, int l>
256  void butsolve (const M& A, X& v, const Y& d, BL<l> bl)
257  {
258  typename X::field_type w=1;
259  algmeta_btsolve<l,withdiag,norelax>::butsolve(A,v,d,w);
260  }
262  template<class M, class X, class Y, class K, int l>
263  void butsolve (const M& A, X& v, const Y& d, const K& w, BL<l> bl)
264  {
265  algmeta_btsolve<l,withdiag,withrelax>::butsolve(A,v,d,w);
266  }
268  template<class M, class X, class Y, int l>
269  void ubutsolve (const M& A, X& v, const Y& d, BL<l> bl)
270  {
271  typename X::field_type w=1;
272  algmeta_btsolve<l,nodiag,norelax>::butsolve(A,v,d,w);
273  }
275  template<class M, class X, class Y, class K, int l>
276  void ubutsolve (const M& A, X& v, const Y& d, const K& w, BL<l> bl)
277  {
278  algmeta_btsolve<l,nodiag,withrelax>::butsolve(A,v,d,w);
279  }
280 
281 
282 
283  //============================================================
284  // generic block diagonal solves
285  // consider block decomposition A = L + D + U
286  // we can apply relaxation or not
287  // we can recurse over a fixed number of levels
288  //============================================================
289 
290  // template meta program for diagonal solves
291  template<int I, WithRelaxType relax>
292  struct algmeta_bdsolve {
293  template<class M, class X, class Y, class K>
294  static void bdsolve (const M& A, X& v, const Y& d, const K& w)
295  {
296  // iterator types
297  typedef typename M::ConstRowIterator rowiterator;
298  typedef typename M::ConstColIterator coliterator;
299 
300  // local solve at each block and immediate update
301  rowiterator rendi=A.beforeBegin();
302  for (rowiterator i=A.beforeEnd(); i!=rendi; --i)
303  {
304  coliterator ii=(*i).find(i.index());
305  algmeta_bdsolve<I-1,relax>::bdsolve(*ii,v[i.index()],d[i.index()],w);
306  }
307  }
308  };
309 
310  // recursion end ...
311  template<>
312  struct algmeta_bdsolve<0,withrelax> {
313  template<class M, class X, class Y, class K>
314  static void bdsolve (const M& A, X& v, const Y& d, const K& w)
315  {
316  A.solve(v,d);
317  v *= w;
318  }
319  };
320  template<>
321  struct algmeta_bdsolve<0,norelax> {
322  template<class M, class X, class Y, class K>
323  static void bdsolve (const M& A, X& v, const Y& d, const K& /*w*/)
324  {
325  A.solve(v,d);
326  }
327  };
328 
329  // user calls
330 
331  // default block recursion level = 1
332 
334  template<class M, class X, class Y>
335  void bdsolve (const M& A, X& v, const Y& d)
336  {
337  typename X::field_type w=1;
338  algmeta_bdsolve<1,norelax>::bdsolve(A,v,d,w);
339  }
341  template<class M, class X, class Y, class K>
342  void bdsolve (const M& A, X& v, const Y& d, const K& w)
343  {
344  algmeta_bdsolve<1,withrelax>::bdsolve(A,v,d,w);
345  }
346 
347  // general block recursion level >= 0
348 
350  template<class M, class X, class Y, int l>
351  void bdsolve (const M& A, X& v, const Y& d, BL<l> /*bl*/)
352  {
353  typename X::field_type w=1;
354  algmeta_bdsolve<l,norelax>::bdsolve(A,v,d,w);
355  }
357  template<class M, class X, class Y, class K, int l>
358  void bdsolve (const M& A, X& v, const Y& d, const K& w, BL<l> /*bl*/)
359  {
360  algmeta_bdsolve<l,withrelax>::bdsolve(A,v,d,w);
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  // template meta program for iterative solver steps
372  template<int I, typename M>
373  struct algmeta_itsteps {
374 
375  template<class X, class Y, class K>
376  static void dbgs (const M& A, X& x, const Y& b, const K& w)
377  {
378  typedef typename M::ConstRowIterator rowiterator;
379  typedef typename M::ConstColIterator coliterator;
380  typedef typename Y::block_type bblock;
381  bblock rhs;
382 
383  X xold(x); // remember old x
384 
385  rowiterator endi=A.end();
386  for (rowiterator i=A.begin(); i!=endi; ++i)
387  {
388  rhs = b[i.index()]; // rhs = b_i
389  coliterator endj=(*i).end();
390  coliterator j=(*i).begin();
391  Hybrid::ifElse(IsNumber<typename M::block_type>(),
392  [&](auto id) {
393  for (; j.index()<i.index(); ++j)
394  rhs -= id(*j) * x[j.index()];
395  coliterator diag=j++; // *diag = a_ii and increment coliterator j from a_ii to a_i+1,i to skip diagonal
396  for (; j != endj; ++j)
397  rhs -= id(*j) * x[j.index()];
398  x[i.index()] = rhs / id(*diag);
399  },
400  [&](auto id) {
401  for (; j.index()<i.index(); ++j) // iterate over a_ij with j < i
402  id(*j).mmv(x[j.index()],rhs); // rhs -= sum_{j<i} a_ij * xnew_j
403  coliterator diag=j++; // *diag = a_ii and increment coliterator j from a_ii to a_i+1,i to skip diagonal
404  for (; j != endj; ++j) // iterate over a_ij with j > i
405  id(*j).mmv(x[j.index()],rhs); // rhs -= sum_{j>i} a_ij * xold_j
406  algmeta_itsteps<I-1,typename M::block_type>::dbgs(*diag,x[i.index()],rhs,w); // if I==1: xnew_i = rhs/a_ii
407  });
408  }
409  // 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;
410  x *= w;
411  x.axpy(K(1)-w,xold);
412  }
413 
414  template<class X, class Y, class K>
415  static void bsorf (const M& A, X& x, const Y& b, const K& w)
416  {
417  typedef typename M::ConstRowIterator rowiterator;
418  typedef typename M::ConstColIterator coliterator;
419  typedef typename Y::block_type bblock;
420  typedef typename X::block_type xblock;
421  bblock rhs;
422  xblock v;
423 
424  // Initialize nested data structure if there are entries
425  if(A.begin()!=A.end())
426  v=x[0];
427 
428  rowiterator endi=A.end();
429  for (rowiterator i=A.begin(); i!=endi; ++i)
430  {
431  rhs = b[i.index()]; // rhs = b_i
432  coliterator endj=(*i).end(); // iterate over a_ij with j < i
433  coliterator j=(*i).begin();
434  Hybrid::ifElse(IsNumber<typename M::block_type>(),
435  [&](auto id) {
436  for (; j.index()<i.index(); ++j)
437  rhs -= id(*j) * x[j.index()]; // rhs -= sum_{j<i} a_ij * xnew_j
438  coliterator diag=j; // *diag = a_ii
439  for (; j!=endj; ++j)
440  rhs -= id(*j) * x[j.index()]; // rhs -= sum_{j<i} a_ij * xnew_j
441  v = rhs / id(*diag);
442  id(x[i.index()]) += w*id(v); // x_i = w / a_ii * (b_i - sum_{j<i} a_ij * xnew_j - sum_{j>=i} a_ij * xold_j)
443  },
444  [&](auto id) {
445  for (; j.index()<i.index(); ++j)
446  id(*j).mmv(x[j.index()],rhs); // rhs -= sum_{j<i} a_ij * xnew_j
447  coliterator diag=j; // *diag = a_ii
448  for (; j!=endj; ++j)
449  id(*j).mmv(x[j.index()],rhs); // rhs -= sum_{j<i} a_ij * xnew_j
450  algmeta_itsteps<I-1,typename M::block_type>::bsorf(*diag,v,rhs,w); // if blocksize I==1: v = rhs/a_ii
451  id(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)
452  });
453  }
454  }
455 
456  template<class X, class Y, class K>
457  static void bsorb (const M& A, X& x, const Y& b, const K& w)
458  {
459  typedef typename M::ConstRowIterator rowiterator;
460  typedef typename M::ConstColIterator coliterator;
461  typedef typename Y::block_type bblock;
462  typedef typename X::block_type xblock;
463  bblock rhs;
464  xblock v;
465 
466  // Initialize nested data structure if there are entries
467  if(A.begin()!=A.end())
468  v=x[0];
469 
470  rowiterator endi=A.beforeBegin();
471  for (rowiterator i=A.beforeEnd(); i!=endi; --i)
472  {
473  rhs = b[i.index()];
474  coliterator endj=(*i).end();
475  coliterator j=(*i).begin();
476  Hybrid::ifElse(IsNumber<typename M::block_type>(),
477  [&](auto id) {
478  for (; j.index()<i.index(); ++j)
479  rhs -= id(*j) * x[j.index()];
480  coliterator diag=j;
481  for (; j!=endj; ++j)
482  rhs -= id(*j) * x[j.index()];
483  v = rhs / id(*diag);
484  x[i.index()] += w*id(v);
485  },
486  [&](auto id) {
487  for (; j.index()<i.index(); ++j)
488  id(*j).mmv(x[j.index()],rhs);
489  coliterator diag=j;
490  for (; j!=endj; ++j)
491  id(*j).mmv(x[j.index()],rhs);
492  algmeta_itsteps<I-1,typename M::block_type>::bsorb(*diag,v,rhs,w);
493  id(x[i.index()]).axpy(w,v);
494  });
495  }
496  }
497 
498  template<class X, class Y, class K>
499  static void dbjac (const M& A, X& x, const Y& b, const K& w)
500  {
501  typedef typename M::ConstRowIterator rowiterator;
502  typedef typename M::ConstColIterator coliterator;
503  typedef typename Y::block_type bblock;
504  bblock rhs;
505 
506  X v(x); // allocate with same size
507 
508  rowiterator endi=A.end();
509  for (rowiterator i=A.begin(); i!=endi; ++i)
510  {
511  rhs = b[i.index()];
512  coliterator endj=(*i).end();
513  coliterator j=(*i).begin();
514  Hybrid::ifElse(IsNumber<typename M::block_type>(),
515  [&](auto id) {
516  for (; j.index()<i.index(); ++j)
517  rhs -= id(*j) * x[j.index()];
518  coliterator diag=j;
519  for (; j!=endj; ++j)
520  rhs -= id(*j) * x[j.index()];
521  v[i.index()] = rhs / id(*diag);
522  },
523  [&](auto id) {
524  for (; j.index()<i.index(); ++j)
525  id(*j).mmv(x[j.index()],rhs);
526  coliterator diag=j;
527  for (; j!=endj; ++j)
528  id(*j).mmv(x[j.index()],rhs);
529  algmeta_itsteps<I-1,typename M::block_type>::dbjac(*diag,v[i.index()],rhs,w);
530  });
531  }
532  x.axpy(w,v);
533  }
534  };
535  // end of recursion
536  template<typename M>
537  struct algmeta_itsteps<0,M> {
538  template<class X, class Y, class K>
539  static void dbgs (const M& A, X& x, const Y& b, const K& /*w*/)
540  {
541  A.solve(x,b);
542  }
543  template<class X, class Y, class K>
544  static void bsorf (const M& A, X& x, const Y& b, const K& /*w*/)
545  {
546  A.solve(x,b);
547  }
548  template<class X, class Y, class K>
549  static void bsorb (const M& A, X& x, const Y& b, const K& /*w*/)
550  {
551  A.solve(x,b);
552  }
553  template<class X, class Y, class K>
554  static void dbjac (const M& A, X& x, const Y& b, const K& /*w*/)
555  {
556  A.solve(x,b);
557  }
558  };
559 
560  template<int I, typename T1, typename... MultiTypeMatrixArgs>
561  struct algmeta_itsteps<I,MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>> {
562  template<
563  typename... MultiTypeVectorArgs,
564  class K>
565  static void dbgs (const MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>& A,
566  MultiTypeBlockVector<MultiTypeVectorArgs...>& x,
567  const MultiTypeBlockVector<MultiTypeVectorArgs...>& b,
568  const K& w)
569  {
570  static const int N = MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>::N();
571  Dune::MultiTypeBlockMatrix_Solver<I,0,N>::dbgs(A, x, b, w);
572  }
573 
574  template<
575  typename... MultiTypeVectorArgs,
576  class K>
577  static void bsorf (const MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>& A,
578  MultiTypeBlockVector<MultiTypeVectorArgs...>& x,
579  const MultiTypeBlockVector<MultiTypeVectorArgs...>& b,
580  const K& w)
581  {
582  static const int N = MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>::N();
583  Dune::MultiTypeBlockMatrix_Solver<I,0,N>::bsorf(A, x, b, w);
584  }
585 
586  template<
587  typename... MultiTypeVectorArgs,
588  class K>
589  static void bsorb (const MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>& A,
590  MultiTypeBlockVector<MultiTypeVectorArgs...>& x,
591  const MultiTypeBlockVector<MultiTypeVectorArgs...>& b,
592  const K& w)
593  {
594  static const int N = MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>::N();
595  Dune::MultiTypeBlockMatrix_Solver<I,N-1,N>::bsorb(A, x, b, w);
596  }
597 
598  template<
599  typename... MultiTypeVectorArgs,
600  class K
601  >
602  static void dbjac (const MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>& A,
603  MultiTypeBlockVector<MultiTypeVectorArgs...>& x,
604  const MultiTypeBlockVector<MultiTypeVectorArgs...>& b,
605  const K& w)
606  {
607  static const int N = MultiTypeBlockMatrix<T1, MultiTypeMatrixArgs...>::N();
608  Dune::MultiTypeBlockMatrix_Solver<I,0,N>::dbjac(A, x, b, w);
609  }
610  };
611 
612  // user calls
613 
615  template<class M, class X, class Y, class K>
616  void dbgs (const M& A, X& x, const Y& b, const K& w)
617  {
618  algmeta_itsteps<1,M>::dbgs(A,x,b,w);
619  }
621  template<class M, class X, class Y, class K, int l>
622  void dbgs (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
623  {
624  algmeta_itsteps<l,M>::dbgs(A,x,b,w);
625  }
627  template<class M, class X, class Y, class K>
628  void bsorf (const M& A, X& x, const Y& b, const K& w)
629  {
630  algmeta_itsteps<1,M>::bsorf(A,x,b,w);
631  }
633  template<class M, class X, class Y, class K, int l>
634  void bsorf (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
635  {
636  algmeta_itsteps<l,M>::bsorf(A,x,b,w);
637  }
639  template<class M, class X, class Y, class K>
640  void bsorb (const M& A, X& x, const Y& b, const K& w)
641  {
642  algmeta_itsteps<1,M>::bsorb(A,x,b,w);
643  }
645  template<class M, class X, class Y, class K, int l>
646  void bsorb (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
647  {
648  algmeta_itsteps<l,typename std::remove_cv<M>::type>::bsorb(A,x,b,w);
649  }
651  template<class M, class X, class Y, class K>
652  void dbjac (const M& A, X& x, const Y& b, const K& w)
653  {
654  algmeta_itsteps<1,M>::dbjac(A,x,b,w);
655  }
657  template<class M, class X, class Y, class K, int l>
658  void dbjac (const M& A, X& x, const Y& b, const K& w, BL<l> /*bl*/)
659  {
660  algmeta_itsteps<l,M>::dbjac(A,x,b,w);
661  }
662 
663 
666 } // end namespace
667 
668 #endif
Dune::Hybrid::ifElse
decltype(auto) ifElse(const Condition &condition, IfFunc &&ifFunc, ElseFunc &&elseFunc)
A conditional expression.
Definition: hybridutilities.hh:355
Dune::bltsolve
void bltsolve(const M &A, X &v, const Y &d)
block lower triangular solve
Definition: gsetc.hh:173
Dune::bsorb
void bsorb(const M &A, X &x, const Y &b, const K &w)
SSOR step.
Definition: gsetc.hh:640
Dune::ubltsolve
void ubltsolve(const M &A, X &v, const Y &d)
unit block lower triangular solve
Definition: gsetc.hh:186
Dune::dbjac
void dbjac(const M &A, X &x, const Y &b, const K &w)
Jacobi step.
Definition: gsetc.hh:652
Dune::dbgs
void dbgs(const M &A, X &x, const Y &b, const K &w)
GS step.
Definition: gsetc.hh:616
Dune::bsorf
void bsorf(const M &A, X &x, const Y &b, const K &w, BL< l >)
SOR step.
Definition: gsetc.hh:634
Dune::dbjac
void dbjac(const M &A, X &x, const Y &b, const K &w, BL< l >)
Jacobi step.
Definition: gsetc.hh:658
Dune::dbgs
void dbgs(const M &A, X &x, const Y &b, const K &w, BL< l >)
GS step.
Definition: gsetc.hh:622
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:236
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:263
Dune::bdsolve
void bdsolve(const M &A, X &v, const Y &d)
block diagonal solve, no relaxation
Definition: gsetc.hh:335
Dune::bsorb
void bsorb(const M &A, X &x, const Y &b, const K &w, BL< l >)
Backward SOR step.
Definition: gsetc.hh:646
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:358
Dune::butsolve
void butsolve(const M &A, X &v, const Y &d)
block upper triangular solve
Definition: gsetc.hh:200
Dune::bsorf
void bsorf(const M &A, X &x, const Y &b, const K &w)
SOR step.
Definition: gsetc.hh:628
Dune::ubutsolve
void ubutsolve(const M &A, X &v, const Y &d)
unit block upper triangular solve
Definition: gsetc.hh:213
Dune::MultiTypeBlockMatrix_Solver::dbjac
static void dbjac(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition: multitypeblockmatrix.hh:557
Dune::MultiTypeBlockMatrix_Solver::dbgs
static void dbgs(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition: multitypeblockmatrix.hh:473
Dune::MultiTypeBlockMatrix_Solver::bsorb
static void bsorb(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition: multitypeblockmatrix.hh:529
Dune::MultiTypeBlockMatrix::N
static constexpr size_type N()
Return the number of matrix rows.
Definition: multitypeblockmatrix.hh:58
Dune::MultiTypeBlockMatrix_Solver::bsorf
static void bsorf(const TMatrix &A, TVector &x, const TVector &b, const K &w)
Definition: multitypeblockmatrix.hh:502
Dune
Dune namespace.
Definition: alignedallocator.hh:14
Dune::BL
compile-time parameter for block recursion depth
Definition: gsetc.hh:43
Creative Commons License   |  Legal Statements / Impressum  |  Hosted by TU Dresden  |  generated with Hugo v0.80.0 (May 9, 22:29, 2024)