compositions.hh

Go to the documentation of this file.
1 
6 #ifndef compositions_hh
7 #define compositions_hh
8 
9 #include "basics/outputOperator.hh"
10 #include "basics/exceptions.hh"
11 #include "space/space.hh"
12 #include "function/basis.hh"
13 #include "function/vector.hh"
14 #include "basics/debug.hh"
15 
16 // debugging
17 #define ComposeConstr_D 0
18 #define ComposeAppl_D 0
19 #define SchurComplContr_D 0
20 
21 namespace concepts {
22 
23  // forward declaration
24  template<class F>
25  class SparseMatrix;
26 
27  template<class F>
28  class DenseMatrix;
29 
30  template<class F>
31  class Matrix;
32 
33  template<class F>
34  class HashedSparseMatrix;
35 
36  // ************************************************************** Operator **
37 
41  template<class F>
42  class Operator : public virtual OutputOperator {
43  public:
45  typedef F type;
47  typedef typename Realtype<F>::type r_type;
49  typedef typename Cmplxtype<F>::type c_type;
50 
51  Operator(uint dimX, uint dimY) : dimX_(dimX), dimY_(dimY) {}
52  virtual ~Operator() {}
53 
69  virtual void operator()(const Function<r_type>& fncY, Function<F>& fncX);
84  virtual void operator()(const Function<c_type>& fncY, Function<c_type>& fncX);
85 
88  virtual void operator()();
89 
93  virtual inline const uint dimX() const { return dimX_; }
94 
98  virtual inline const uint dimY() const { return dimY_; }
99 
100  virtual void show_messages() { }
101  protected:
102  virtual std::ostream& info(std::ostream& os) const;
104  uint dimX_, dimY_;
105  };
106 
107  // *********************************************************** VecOperator **
108 
114  template<class F>
115  class VecOperator : public Operator<F> {
116  public:
118  typedef typename Realtype<F>::type r_type;
120  typedef typename Cmplxtype<F>::type c_type;
121 
122  VecOperator(uint dimX, uint dimY) : Operator<F>(dimY, dimX) {}
123 
124  virtual void operator()(const Function<r_type>& fncY, Function<F>& fncX);
125  virtual void operator()(const Function<c_type>& fncY,
126  Function<c_type>& fncX);
127 
143  virtual void operator()(const Vector<r_type>& fncY, Vector<F>& fncX);
158  virtual void operator()(const Vector<c_type>& fncY, Vector<c_type>& fncX);
159 
161  void operator()(const Matrix<r_type>& mX, Matrix<F>& mY);
163  void operator()(const Matrix<c_type>& mX, Matrix<c_type>& mY);
165  void operator()();
166  protected:
167  virtual std::ostream& info(std::ostream& os) const;
171  virtual void apply_(const Vector<F>& fncY, Vector<F>& fncX) = 0;
174  virtual void apply_() = 0;
175  };
176 
177  // *************************************************************** Compose **
178 
189  template<class F, class H = F>
190  class Compose : public Operator<F> {
191  public:
193  inline Compose(Operator<F>& A, Operator<H>& B);
194 
197  inline void operator()(const Function<F>& fncY, Function<F>& fncX);
198 
207  bool collapse(Matrix<F>& dest) const;
208  protected:
209  virtual std::ostream& info(std::ostream& os) const;
210  private:
212  Operator<F>& A_;
214  Operator<H>& B_;
216  Vector<F> f_;
217 
218  void collapse_(DenseMatrix<F>& A, DenseMatrix<H>& B, Matrix<F>& dest) const;
219  };
220 
221  template<class F, class H>
222  Compose<F,H>::Compose(Operator<F>& A, Operator<H>& B)
223  : Operator<F>(A.dimX(), B.dimY()), A_(A), B_(B), f_(B.dimX()) {
224  DEBUGL(ComposeConstr_D,
225  "A is (" << A.dimX() << "x" << A.dimY() << ") *" <<
226  "B is (" << B.dimX() << "x" << B.dimY() << ")");
227  conceptsAssert(A.dimY() == B.dimX(), Assertion());
228  }
229 
230  template<class F, class H>
231  void Compose<F,H>::operator()(const Function<F>& fncY, Function<F>& fncX)
232  {
233  DEBUGL(ComposeAppl_D, *this);
234  conceptsAssert3(fncY.dim() == this->dimY_, Assertion(),
235  "fncY.dim = " << fncY.dim() << ", dimY = " << this->dimY());
236  conceptsAssert3(fncX.dim() == this->dimX(), Assertion(),
237  "fncX.dim = " << fncX.dim() << ", dimX = " << this->dimX());
238  DEBUGL(ComposeAppl_D, "y = " << fncY);
239  B_(fncY, f_);
240  DEBUGL(ComposeAppl_D, "f = " << f_);
241  A_(f_, fncX);
242  DEBUGL(ComposeAppl_D, "x = " << fncX);
243  }
244 
245  // ************************************************************** Multiple **
246 
250  template<class F>
251  class Multiple : public Operator<F> {
252  public:
254  typedef typename Realtype<F>::type r_type;
256  typedef typename Cmplxtype<F>::type c_type;
257 
258  Multiple(Operator<F>& A, F a)
259  : Operator<F>(A.dimX(), A.dimY()), A_(A), a_(a) {}
260 
268  inline void operator()(const Function<r_type>& fncY, Function<F>& fncX)
269  {
270  apply_(fncY, fncX);
271  }
272  inline void operator()(const Function<c_type>& fncY,
273  Function<c_type>& fncX) {
274  apply_(fncY, fncX);
275  }
276 
277  protected:
278  virtual std::ostream& info(std::ostream& os) const;
279  private:
281  Operator<F>& A_;
283  F a_;
284 
285  template<class H, class I>
286  inline void apply_(const Function<H>& fncY, Function<I>& fncX);
287  };
288 
289  template<class F>
290  template<class H, class I>
291  void Multiple<F>:: apply_(const Function<H>& fncY, Function<I>& fncX) {
292  conceptsAssert(fncY.dim() == this->dimY(), Assertion());
293  conceptsAssert(fncX.dim() == this->dimX(), Assertion());
294  A_(fncY, fncX);
295  if (a_ != 1.0)
296  fncX *= a_;
297  }
298 
299  // ***************************************************************** LiCoI **
300 
305  template<class F>
306  class LiCoI : public Operator<F> {
307  public:
309  typedef typename Realtype<F>::type r_type;
311  typedef typename Cmplxtype<F>::type c_type;
312 
313  LiCoI(Operator<F>& A, F a = 1.0, F b = 1.0)
314  : Operator<F>(A.dimX(), A.dimY()), A_(A), a_(a), b_(b) {}
315 
323  virtual void operator()(const Function<r_type>& fncY, Function<F>& fncX);
324  virtual void operator()(const Function<c_type>& fncY,
325  Function<c_type>& fncX);
326 
343  bool collapse(Matrix<F>& dest, const F fact = 1.0) const;
344  protected:
345  virtual std::ostream& info(std::ostream& os) const;
346  private:
348  Operator<F>& A_;
350  F a_;
352  F b_;
353  };
354 
355  // ****************************************************************** LiCo **
356 
363  template<class F>
364  class LiCo : public Operator<F> {
365  public:
367  typedef typename Realtype<F>::type r_type;
369  typedef typename Cmplxtype<F>::type c_type;
370 
379  LiCo(Operator<F>& A, Operator<F>& B, F a = 1.0, F b = 1.0) :
380  Operator<F>(A.dimX(), A.dimY()), A_(A), B_(B), a_(a), b_(b) {
381  conceptsAssert(A.dimX() == B.dimX(), Assertion());
382  conceptsAssert(A.dimY() == B.dimY(), Assertion());
383  }
384 
393  inline void operator()(const Function<r_type>& fncY, Function<F>& fncX)
394  {
395  apply_(fncY, fncX);
396  }
397  inline void operator()(const Function<c_type>& fncY, Function<c_type>& fncX)
398  {
399  apply_(fncY, fncX);
400  }
401 
417  bool collapse(Matrix<F>& dest, const F fact = 1.0) const;
418  protected:
419  virtual std::ostream& info(std::ostream& os) const;
420  private:
422  Operator<F>& A_;
424  Operator<F>& B_;
426  F a_;
428  F b_;
429 
430  template<class H, class I>
431  inline void apply_(const Function<H>& fncY, Function<I>& fncX);
432  };
433 
434  template<class F>
435  template<class H, class I>
436  void LiCo<F>::apply_(const Function<H>& fncY, Function<I>& fncX) {
437  conceptsAssert(this->dimX() == fncX.dim(), Assertion());
438  conceptsAssert(this->dimY() == fncY.dim(), Assertion());
439  A_(fncY, fncX);
440  fncX *= a_;
441  Vector<I> f(this->dimX()); // Intermediate vector
442  B_(fncY, f);
443  fncX.add(f, b_);
444  }
445 
446  // ************************************************************ SchurCompl **
447 
456  template<class F>
457  class SchurCompl : public LiCo<F> {
458  public:
460  SchurCompl(Operator<F>& A_II_inv, Operator<F>& A_IB,
461  Operator<F>& A_BI, Operator<F>& A_BB);
462  virtual ~SchurCompl() {
463  delete D_; delete C_;
464  }
465  private:
467  Compose<F> *C_, *D_;
468  };
469 
470  template<class F>
471  SchurCompl<F>::SchurCompl(Operator<F>& A_II_inv, Operator<F>& A_IB,
472  Operator<F>& A_BI, Operator<F>& A_BB)
473  : LiCo<F>(A_BB,
474  *(D_ = new Compose<F>(A_BI,
475  *(C_ = new Compose<F>(A_II_inv, A_IB)))
476  ), 1.0, -1.0)
477  {
478  DEBUGL(SchurComplContr_D, "A_II_inv = " <<
479  (DenseMatrix<F>(SparseMatrix<F>(A_II_inv, true))));
480  DEBUGL(SchurComplContr_D, "A_IB = " <<
481  (DenseMatrix<F>(SparseMatrix<F>(A_IB, true))));
482  DEBUGL(SchurComplContr_D, "A_BI = " <<
483  (DenseMatrix<F>(SparseMatrix<F>(A_BI, true))));
484  DEBUGL(SchurComplContr_D, "A_BB = " <<
485  (DenseMatrix<F>(SparseMatrix<F>(A_BB, true))));
486  DEBUGL(SchurComplContr_D, "C_ = AII^-1 * AIB = " <<
487  (DenseMatrix<F>(SparseMatrix<F>(*C_, true))));
488  DEBUGL(SchurComplContr_D, "D_ = ABI * AII^-1 * AIB = " <<
489  (DenseMatrix<F>(SparseMatrix<F>(*D_, true))));
490  DEBUGL(SchurComplContr_D, "S_ = A_BB - A_BI * A_II^-1 * A_IB = " <<
491  (DenseMatrix<F>(SparseMatrix<F>(*this, true))));
492  }
493 
494 } // namespace concepts
495 
496 #endif // compositions_hh
ComposeConstr_D
#define ComposeConstr_D
Definition: compositions.hh:17
concepts::LiCo::LiCo
LiCo(Operator< F > &A, Operator< F > &B, F a=1.0, F b=1.0)
Constructor.
Definition: compositions.hh:379
concepts::LiCo::info
virtual std::ostream & info(std::ostream &os) const
concepts::Multiple::c_type
Cmplxtype< F >::type c_type
Real type of data type.
Definition: compositions.hh:256
concepts::Compose::collapse_
void collapse_(DenseMatrix< F > &A, DenseMatrix< H > &B, Matrix< F > &dest) const
concepts::VecOperator::r_type
Realtype< F >::type r_type
Real type of data type.
Definition: compositions.hh:118
concepts::Operator::Operator
Operator(uint dimX, uint dimY)
Definition: compositions.hh:51
concepts::Compose::B_
Operator< H > & B_
Second operator.
Definition: compositions.hh:214
concepts::Operator::r_type
Realtype< F >::type r_type
Real type of data type.
Definition: compositions.hh:47
concepts::LiCo::operator()
void operator()(const Function< c_type > &fncY, Function< c_type > &fncX)
Application operator for complex function fncY.
Definition: compositions.hh:397
concepts::Operator::type
F type
Type of data, e.g. matrix entries.
Definition: compositions.hh:45
concepts::LiCoI::c_type
Cmplxtype< F >::type c_type
Real type of data type.
Definition: compositions.hh:311
concepts::VecOperator::operator()
void operator()()
Application method without second argument. Used for parallel solvers.
concepts::Multiple::operator()
void operator()(const Function< c_type > &fncY, Function< c_type > &fncX)
Application operator for complex function fncY.
Definition: compositions.hh:272
concepts::LiCo::r_type
Realtype< F >::type r_type
Real type of data type.
Definition: compositions.hh:367
concepts::LiCoI::collapse
bool collapse(Matrix< F > &dest, const F fact=1.0) const
Collapses the linear combination of matrices into one matrix.
concepts::SchurCompl
Schur complement.
Definition: compositions.hh:457
concepts::Function
Abstract class for a function.
Definition: basis.hh:21
concepts::VecOperator::c_type
Cmplxtype< F >::type c_type
Real type of data type.
Definition: compositions.hh:120
concepts::Operator::dimX
virtual const uint dimX() const
Returns the size of the image space of the operator (number of rows of the corresponding matrix)
Definition: compositions.hh:93
concepts::LiCo::b_
F b_
Scalar b.
Definition: compositions.hh:428
concepts::Operator::dimX_
uint dimX_
Dimension of image space and the source space.
Definition: compositions.hh:104
concepts::Multiple::Multiple
Multiple(Operator< F > &A, F a)
Definition: compositions.hh:258
concepts::Compose::info
virtual std::ostream & info(std::ostream &os) const
concepts::Operator::show_messages
virtual void show_messages()
Definition: compositions.hh:100
conceptsAssert
#define conceptsAssert(cond, exc)
Assert that a certain condition is fulfilled.
Definition: exceptions.hh:394
concepts::LiCo::apply_
void apply_(const Function< H > &fncY, Function< I > &fncX)
Definition: compositions.hh:436
concepts::Operator::operator()
virtual void operator()()
Application operator without argument.
concepts::LiCoI::info
virtual std::ostream & info(std::ostream &os) const
concepts::LiCo::a_
F a_
Scalar a.
Definition: compositions.hh:426
concepts::VecOperator::operator()
void operator()(const Matrix< c_type > &mX, Matrix< c_type > &mY)
Application method to complex matrices. Calls apply_()
concepts::Multiple::A_
Operator< F > & A_
Operator A.
Definition: compositions.hh:281
DEBUGL
#define DEBUGL(doit, msg)
concepts::Compose::f_
Vector< F > f_
Intermediate vector to store result after application of B.
Definition: compositions.hh:216
SchurComplContr_D
#define SchurComplContr_D
Definition: compositions.hh:19
concepts::Multiple
Multiple of an operator.
Definition: compositions.hh:251
concepts::Function::add
virtual Function< F > & add(const Function< F > &fnc, F a)
Adds a times fnc to this function.
concepts::VecOperator::apply_
virtual void apply_()=0
Intrinsic application method without argument.
concepts::Multiple::apply_
void apply_(const Function< H > &fncY, Function< I > &fncX)
Definition: compositions.hh:291
concepts::LiCoI::r_type
Realtype< F >::type r_type
Real type of data type.
Definition: compositions.hh:309
concepts::Operator::c_type
Cmplxtype< F >::type c_type
Real type of data type.
Definition: compositions.hh:49
concepts::Assertion
Exception class for assertions.
Definition: exceptions.hh:258
concepts::Matrix
Abstract class for an operator.
Definition: compositions.hh:31
concepts::Compose
Computes the product of two operators.
Definition: compositions.hh:190
concepts::Multiple::operator()
void operator()(const Function< r_type > &fncY, Function< F > &fncX)
Application operator.
Definition: compositions.hh:268
concepts::Operator
Abstract class for an operator.
Definition: ARPACK.hh:16
concepts::LiCoI
Linear combination of an operator with the identity.
Definition: compositions.hh:306
ComposeAppl_D
#define ComposeAppl_D
Definition: compositions.hh:18
concepts::Compose::A_
Operator< F > & A_
First operator.
Definition: compositions.hh:212
concepts::LiCo::B_
Operator< F > & B_
Operator B.
Definition: compositions.hh:424
concepts::VecOperator::operator()
virtual void operator()(const Function< c_type > &fncY, Function< c_type > &fncX)
Application operator for complex function fncY.
concepts::Compose::collapse
bool collapse(Matrix< F > &dest) const
Collapses the composition of matrices into one matrix.
concepts::VecOperator::VecOperator
VecOperator(uint dimX, uint dimY)
Definition: compositions.hh:122
concepts::VecOperator::operator()
virtual void operator()(const Function< r_type > &fncY, Function< F > &fncX)
Application operator for real function fncY.
concepts::Multiple::info
virtual std::ostream & info(std::ostream &os) const
concepts::LiCo::operator()
void operator()(const Function< r_type > &fncY, Function< F > &fncX)
Application operator.
Definition: compositions.hh:393
concepts::VecOperator::operator()
virtual void operator()(const Vector< c_type > &fncY, Vector< c_type > &fncX)
Application operator for complex function fncY.
concepts::HashedSparseMatrix
A matrix in sparse storage using hashes.
Definition: compositions.hh:34
concepts::VecOperator::apply_
virtual void apply_(const Vector< F > &fncY, Vector< F > &fncX)=0
Intrinsic application method, i.e.
concepts::LiCo::c_type
Cmplxtype< F >::type c_type
Real type of data type.
Definition: compositions.hh:369
concepts::VecOperator::operator()
virtual void operator()(const Vector< r_type > &fncY, Vector< F > &fncX)
Application operator for real vector fncY.
concepts::LiCoI::operator()
virtual void operator()(const Function< c_type > &fncY, Function< c_type > &fncX)
Application operator for complex function fncY.
concepts::Function::dim
uint dim() const
Returns the dimension of the function.
Definition: basis.hh:53
concepts::VecOperator
Abstract class for an operator acting on vectors only, not arbitrary functions.
Definition: compositions.hh:115
concepts::Compose::Compose
Compose(Operator< F > &A, Operator< H > &B)
Constructor.
Definition: compositions.hh:222
concepts::LiCoI::LiCoI
LiCoI(Operator< F > &A, F a=1.0, F b=1.0)
Definition: compositions.hh:313
concepts::LiCo::collapse
bool collapse(Matrix< F > &dest, const F fact=1.0) const
Collapses the linear combination of matrices into one matrix.
concepts::SchurCompl::D_
Compose< F > * D_
Definition: compositions.hh:467
concepts::LiCo::A_
Operator< F > & A_
Operator A.
Definition: compositions.hh:422
concepts::LiCoI::operator()
virtual void operator()(const Function< r_type > &fncY, Function< F > &fncX)
Application operator.
concepts::Multiple::r_type
Realtype< F >::type r_type
Real type of data type.
Definition: compositions.hh:254
concepts::VecOperator::operator()
void operator()(const Matrix< r_type > &mX, Matrix< F > &mY)
Application method to real matrices. Calls function apply()
concepts::Cmplxtype::type
std::complex< F > type
Definition: typedefs.hh:116
concepts::Operator::operator()
virtual void operator()(const Function< r_type > &fncY, Function< F > &fncX)
Application operator for real function fncY.
concepts::Operator::dimY
virtual const uint dimY() const
Returns the size of the source space of the operator (number of columns of the corresponding matrix)
Definition: compositions.hh:98
conceptsAssert3
#define conceptsAssert3(cond, exc, msg)
Assert that a certain condition is fulfilled.
Definition: exceptions.hh:442
concepts::LiCoI::A_
Operator< F > & A_
Operator A.
Definition: compositions.hh:348
concepts::Operator::info
virtual std::ostream & info(std::ostream &os) const
concepts::LiCo
Linear combination of two operators.
Definition: compositions.hh:364
concepts::VecOperator::info
virtual std::ostream & info(std::ostream &os) const
concepts::Compose::operator()
void operator()(const Function< F > &fncY, Function< F > &fncX)
Application operator.
Definition: compositions.hh:231
concepts::OutputOperator
Class providing an output operator.
Definition: outputOperator.hh:42
concepts::Operator::operator()
virtual void operator()(const Function< c_type > &fncY, Function< c_type > &fncX)
Application operator for complex function fncY.
concepts::SchurCompl::SchurCompl
SchurCompl(Operator< F > &A_II_inv, Operator< F > &A_IB, Operator< F > &A_BI, Operator< F > &A_BB)
Constructor.
Definition: compositions.hh:471
concepts
Basic namespace for Concepts-2.
Definition: pml_formula.h:16
concepts::SchurCompl::C_
Compose< F > * C_
Product of A_II^-1 * A_IB or A_BI * A_II^-1 * A_IB respectivly.
Definition: compositions.hh:467
Page URL: http://wiki.math.ethz.ch/bin/view/Concepts/WebHome
21 August 2020
© 2020 Eidgenössische Technische Hochschule Zürich