frmE_sum.hh

Go to the documentation of this file.
1 
8 #ifndef sumelementformula_hh
9 #define sumelementformula_hh
10 
11 #include "basics/typedefs.hh"
12 #include "basics/output.hh"
13 #include "basics/vectorsMatricesForward.hh"
14 #include "elementFormulaContainer.hh"
15 #include "exceptions.hh"
16 
17 #define SumElemFormConstr_D 0
18 #define SumElemFormDestr_D 0
19 #define SumElemFormClone_D 0
20 
21 namespace concepts {
22 
23 
24  // **************************************************************** FrmE_Sum **
25 
34  template<class F, class H = F, class J = F,
35  class G = typename Realtype<F>::type>
36  class FrmE_Sum : public ElementFormula<F,G> {
37  public:
38  FrmE_Sum(const ElementFormulaContainer<H> frm1,
39  const ElementFormulaContainer<J> frm2)
40  : frm1_(frm1), frm2_(frm2), a_(0.0)
41  {
42  if (frm1.empty()) throw(PointerToEmptyElementFormula());
43  if (frm2.empty()) throw(PointerToEmptyElementFormula());
44  }
45  FrmE_Sum(const ElementFormulaContainer<H> frm1,
46  const F a)
47  : frm1_(frm1), frm2_(), a_(a)
48  {
49  DEBUGL(SumElemFormConstr_D, "frm1 = " << frm1);
50  if (frm1.empty()) throw(PointerToEmptyElementFormula());
51  }
52  virtual ~FrmE_Sum() {
53  DEBUGL(SumElemFormDestr_D, "Delete " << *this)
54  }
55 
56 
57  virtual F operator() (const ElementWithCell<G>& elm, const Real p,
58  const Real t = 0.0) const
59  {
60  F v = frm1_(elm, p,t);
61  if (!frm2_.empty())
62  v += frm2_(elm, p,t);
63 
64  return v + a_;
65  }
66  virtual F operator() (const ElementWithCell<G>& elm, const Real2d& p,
67  const Real t = 0.0) const
68  {
69  F v = frm1_(elm, p,t);
70  if (!frm2_.empty())
71  v += frm2_(elm, p,t);
72 
73  return v + a_;
74  }
75  virtual F operator() (const ElementWithCell<G>& elm, const Real3d& p,
76  const Real t = 0.0) const
77  {
78  F v = frm1_(elm, p,t);
79  if (!frm2_.empty())
80  v += frm2_(elm, p,t);
81 
82  return v + a_;
83  }
84 
85  virtual FrmE_Sum<F,H,J,G>* clone() const {
86  DEBUGL(SumElemFormClone_D, *this << " = *" << this);
87  return new FrmE_Sum<F,H,J,G>(frm1_, frm2_, a_);
88  }
89  protected:
90  virtual std::ostream& info(std::ostream& os) const {
91  os << typeOf(*this) << "(" << frm1_;
92  if (!frm2_.empty())
93  os << " + " << frm2_;
94  if (!(a_ == F(0.0)))
95  os << " + " << a_;
96  return os << ")";
97  }
98  private:
100  ElementFormulaContainer<H> frm1_;
102  ElementFormulaContainer<J> frm2_;
104  F a_;
105 
107  FrmE_Sum(const ElementFormulaContainer<H> frm1,
108  const ElementFormulaContainer<J> frm2,
109  const F a)
110  : frm1_(frm1), frm2_(frm2), a_(a)
111  {
112  DEBUGL(SumElemFormConstr_D,
113  "frm1 = " << frm1 << ", frm2 = " << frm2 << ", a = " << a);
114  if (frm1.empty()) throw(PointerToEmptyElementFormula());
115  }
116  };
117 
118 
119  // ************************************************************ operator+ **
120 
122 
123  ElementFormulaContainer<Real>
124  operator+(const ElementFormulaContainer<Real> frm, const Real a);
125 
126  ElementFormulaContainer<Cmplx>
127  operator+(const ElementFormulaContainer<Cmplx> frm, const Real a);
128 
129  ElementFormulaContainer<Cmplx>
130  operator+(const ElementFormulaContainer<Cmplx> frm, const Cmplx a);
131 
132  ElementFormulaContainer<Cmplx>
133  operator+(const ElementFormulaContainer<Real> frm, const Cmplx a);
134 
135  // ************
136 
137  ElementFormulaContainer<Real2d>
138  operator+(const ElementFormulaContainer<Real2d> frm, const Real2d a);
139 
140  ElementFormulaContainer<Cmplx2d>
141  operator+(const ElementFormulaContainer<Cmplx2d> frm, const Real2d a);
142 
143  ElementFormulaContainer<Cmplx2d>
144  operator+(const ElementFormulaContainer<Cmplx2d> frm, const Cmplx2d a);
145 
146  ElementFormulaContainer<Cmplx2d>
147  operator+(const ElementFormulaContainer<Real2d> frm, const Cmplx2d a);
148 
149 
152  ElementFormulaContainer<Real>
153  operator+(const ElementFormulaContainer<Real> frm1,
154  const ElementFormulaContainer<Real> frm2);
155 
156  ElementFormulaContainer<Cmplx>
157  operator+(const ElementFormulaContainer<Cmplx> frm1,
158  const ElementFormulaContainer<Real> frm2);
159 
160  ElementFormulaContainer<Cmplx>
161  operator+(const ElementFormulaContainer<Real> frm1,
162  const ElementFormulaContainer<Cmplx> frm2);
163 
164  ElementFormulaContainer<Cmplx>
165  operator+(const ElementFormulaContainer<Cmplx> frm1,
166  const ElementFormulaContainer<Cmplx> frm2);
167 
168  // ************
169 
170  ElementFormulaContainer<Real2d>
171  operator+(const ElementFormulaContainer<Real2d> frm1,
172  const ElementFormulaContainer<Real2d> frm2);
173 
174  ElementFormulaContainer<Cmplx2d>
175  operator+(const ElementFormulaContainer<Cmplx2d> frm1,
176  const ElementFormulaContainer<Real2d> frm2);
177 
178  ElementFormulaContainer<Cmplx2d>
179  operator+(const ElementFormulaContainer<Real2d> frm1,
180  const ElementFormulaContainer<Cmplx2d> frm2);
181 
182  ElementFormulaContainer<Cmplx2d>
183  operator+(const ElementFormulaContainer<Cmplx2d> frm1,
184  const ElementFormulaContainer<Cmplx2d> frm2);
185 
187 
188  ElementFormulaContainer<Real>
189  operator-(const ElementFormulaContainer<Real> frm, const Real a);
190 
191  ElementFormulaContainer<Cmplx>
192  operator-(const ElementFormulaContainer<Cmplx> frm, const Real a);
193 
194  ElementFormulaContainer<Cmplx>
195  operator-(const ElementFormulaContainer<Cmplx> frm, const Cmplx a);
196 
197  ElementFormulaContainer<Cmplx>
198  operator-(const ElementFormulaContainer<Real> frm, const Cmplx a);
199 
200  // ************
201 
202  ElementFormulaContainer<Real2d>
203  operator-(const ElementFormulaContainer<Real2d> frm, const Real2d a);
204 
205  ElementFormulaContainer<Cmplx2d>
206  operator-(const ElementFormulaContainer<Cmplx2d> frm, const Real2d a);
207 
208  ElementFormulaContainer<Cmplx2d>
209  operator-(const ElementFormulaContainer<Cmplx2d> frm, const Cmplx2d a);
210 
211  ElementFormulaContainer<Cmplx2d>
212  operator-(const ElementFormulaContainer<Real2d> frm, const Cmplx2d a);
213 
216  ElementFormulaContainer<Real>
217  operator-(const ElementFormulaContainer<Real> frm1,
218  const ElementFormulaContainer<Real> frm2);
219 
220  ElementFormulaContainer<Cmplx>
221  operator-(const ElementFormulaContainer<Cmplx> frm1,
222  const ElementFormulaContainer<Real> frm2);
223 
224  ElementFormulaContainer<Cmplx>
225  operator-(const ElementFormulaContainer<Real> frm1,
226  const ElementFormulaContainer<Cmplx> frm2);
227 
228  ElementFormulaContainer<Cmplx>
229  operator-(const ElementFormulaContainer<Cmplx> frm1,
230  const ElementFormulaContainer<Cmplx> frm2);
231 
232  // ************
233 
234  ElementFormulaContainer<Real2d>
235  operator-(const ElementFormulaContainer<Real2d> frm1,
236  const ElementFormulaContainer<Real2d> frm2);
237 
238  ElementFormulaContainer<Cmplx2d>
239  operator-(const ElementFormulaContainer<Cmplx2d> frm1,
240  const ElementFormulaContainer<Real2d> frm2);
241 
242  ElementFormulaContainer<Cmplx2d>
243  operator-(const ElementFormulaContainer<Real2d> frm1,
244  const ElementFormulaContainer<Cmplx2d> frm2);
245 
246  ElementFormulaContainer<Cmplx2d>
247  operator-(const ElementFormulaContainer<Cmplx2d> frm1,
248  const ElementFormulaContainer<Cmplx2d> frm2);
249 
250 } // namespace concepts
251 
252 
253 #endif // sumelementformula_hh
concepts::FrmE_Sum::FrmE_Sum
FrmE_Sum(const ElementFormulaContainer< H > frm1, const ElementFormulaContainer< J > frm2)
Definition: frmE_sum.hh:38
concepts::FrmE_Sum::frm1_
ElementFormulaContainer< H > frm1_
First element formula.
Definition: frmE_sum.hh:100
concepts::FrmE_Sum::frm2_
ElementFormulaContainer< J > frm2_
Second element formula.
Definition: frmE_sum.hh:102
SumElemFormConstr_D
#define SumElemFormConstr_D
Definition: frmE_sum.hh:17
SumElemFormDestr_D
#define SumElemFormDestr_D
Definition: frmE_sum.hh:18
concepts::operator-
ElementFormulaContainer< Real > operator-(const ElementFormulaContainer< Real > frm, const Real a)
Simple subtracting of a element formulas and a constant via –operator.
concepts::FrmE_Sum::info
virtual std::ostream & info(std::ostream &os) const
Returns information in an output stream.
Definition: frmE_sum.hh:90
concepts::ElementWithCell
Element with cell.
Definition: elementFormula.hh:19
DEBUGL
#define DEBUGL(doit, msg)
concepts::ElementFormulaContainer::empty
bool empty() const
Returns true if no formula is stored.
Definition: elementFormulaContainer.hh:72
concepts::ElementFormula
Interface for a formula defined element by element.
Definition: elementFormula.hh:35
concepts::FrmE_Sum::FrmE_Sum
FrmE_Sum(const ElementFormulaContainer< H > frm1, const F a)
Definition: frmE_sum.hh:45
concepts::FrmE_Sum::operator()
virtual F operator()(const ElementWithCell< G > &elm, const Real p, const Real t=0.0) const
Definition: frmE_sum.hh:57
concepts::Cmplx
std::complex< Real > Cmplx
Type for a complex number. It also depends on the setting of Real.
Definition: typedefs.hh:39
concepts::FrmE_Sum::a_
F a_
Summand.
Definition: frmE_sum.hh:104
concepts::FrmE_Sum
Class for a sum of element formulas.
Definition: frmE_sum.hh:36
concepts::FrmE_Sum::clone
virtual FrmE_Sum< F, H, J, G > * clone() const
Virtual constructor.
Definition: frmE_sum.hh:85
concepts::FrmE_Sum::FrmE_Sum
FrmE_Sum(const ElementFormulaContainer< H > frm1, const ElementFormulaContainer< J > frm2, const F a)
Private constructor.
Definition: frmE_sum.hh:107
SumElemFormClone_D
#define SumElemFormClone_D
Definition: frmE_sum.hh:19
concepts::FrmE_Sum::~FrmE_Sum
virtual ~FrmE_Sum()
Definition: frmE_sum.hh:52
concepts::operator+
Frm_Sum< Real > operator+(const Formula< Real > &frm, const Real a)
Simple adding two formulas by +-operator.
concepts::typeOf
std::string typeOf(const T &t)
Return the typeid name of a class object.
Definition: output.hh:43
concepts::Real
double Real
Type normally used for a floating point number.
Definition: typedefs.hh:36
concepts::PointerToEmptyElementFormula
Exception class to express that the RCP pointer points to 0.
Definition: exceptions.hh:55
concepts
Basic namespace for Concepts-2.
Definition: pml_formula.h:16
Page URL: http://wiki.math.ethz.ch/bin/view/Concepts/WebHome
21 August 2020
© 2020 Eidgenössische Technische Hochschule Zürich