MBDyn-1.7.3
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups
evaluator_impl.h
Go to the documentation of this file.
1 /* $Header: /var/cvs/mbdyn/mbdyn/mbdyn-1.0/libraries/libmbutil/evaluator_impl.h,v 1.4 2017/01/12 14:44:04 masarati Exp $ */
2 /*
3  * MBDyn (C) is a multibody analysis code.
4  * http://www.mbdyn.org
5  *
6  * Copyright (C) 1996-2017
7  *
8  * Pierangelo Masarati <masarati@aero.polimi.it>
9  * Paolo Mantegazza <mantegazza@aero.polimi.it>
10  *
11  * Dipartimento di Ingegneria Aerospaziale - Politecnico di Milano
12  * via La Masa, 34 - 20156 Milano, Italy
13  * http://www.aero.polimi.it
14  *
15  * Changing this copyright notice is forbidden.
16  *
17  * This program is free software; you can redistribute it and/or modify
18  * it under the terms of the GNU General Public License as published by
19  * the Free Software Foundation (version 2 of the License).
20  *
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, write to the Free Software
29  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30  */
31 
32 /*
33  * With the contribution of Ankit Aggarwal <ankit.ankit.aggarwal@gmail.com>
34  * during Google Summer of Code 2015
35  */
36 
37 #ifndef EVALUATOR_IMPL_H
38 #define EVALUATOR_IMPL_H
39 
40 #include <iostream>
41 #include <sstream>
42 #include <cmath>
43 #include <limits>
44 
45 // "evaluator.h" must be explicitly included
46 
47 // for storing constant values like "1","1.23"
48 class EE_Value : public ExpressionElement {
49 private:
51 
52 public:
53  EE_Value(TypedValue Val) : m_Val(Val) { m_Val.SetConst(true); };
54  // nothing to destroy
55  ~EE_Value(void) {};
56 
58  Eval(void) const
59  {
60  return m_Val;
61  };
62 
63  std::ostream&
64  Output(std::ostream& out) const
65  {
66  return out << m_Val;
67  };
68 };
69 
70 // for storing non const variable like "a", "b"
71 // FIXME: probably needs to know about its namespace
72 class EE_Var : public ExpressionElement {
73 private:
75  // NOTE: probably the string would suffice, but just in case...
77 
78 public:
79  EE_Var(NamedValue *var, MathParser::NameSpace *ns = 0) : m_Var(var), m_ns(ns) {};
80  // nothing to destroy (Var belongs to the symbol table)
81  virtual ~EE_Var(void) {};
82 
83  virtual TypedValue
84  Eval(void) const
85  {
86  // NOTE: this should not be const,
87  // otherwise it would have been turned into a EE_Value
88  return m_Var->GetVal();
89  };
90 
91  virtual std::ostream&
92  Output(std::ostream& out) const
93  {
94  if (m_ns) {
95  out << m_ns->sGetName() << "::";
96  }
97 
98  return out << m_Var->GetName();
99  };
100 };
101 
102 class EE_Plus : public ExpressionElement {
103 private:
105 
106 public:
107  EE_Plus(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
108  ~EE_Plus(void) { delete m_pEE1; delete m_pEE2; };
109 
110  TypedValue
111  Eval(void) const
112  {
113  // FIXME: check integer overflow?
114  return m_pEE1->Eval() + m_pEE2->Eval();
115  };
116 
117  std::ostream&
118  Output(std::ostream& out) const
119  {
120  return out << "(", m_pEE1->Output(out) << " + ", m_pEE2->Output(out) << ")";
121  };
122 };
123 
124 class EE_Minus : public ExpressionElement {
125 private:
127 
128 public:
129  EE_Minus(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
130  ~EE_Minus(void) { delete m_pEE1; delete m_pEE2; };
131 
132  TypedValue
133  Eval(void) const
134  {
135  // FIXME: check integer overflow?
136  return m_pEE1->Eval() - m_pEE2->Eval();
137  };
138 
139  std::ostream&
140  Output(std::ostream& out) const
141  {
142  return out << "(", m_pEE1->Output(out) << " - ", m_pEE2->Output(out) << ")";
143  };
144 };
145 
147 private:
149 
150 #if 0 // TODO: check correctness whenever possible
151  bool
152  Check_int(const TypedValue& value)
153  {
154  switch (value.GetType()) {
156  case TypedValue::VAR_INT:
157  if (value.GetInt() == 0) {
158  return false;
159  }
160  break;
161 
162  default:
163  return false;
164  }
165  };
166 #endif
167 
168 public:
169  EE_Modulus(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
170  ~EE_Modulus(void) { delete m_pEE1; delete m_pEE2; };
171 
172 #if 0 // TODO: check correctness whenever possible
173  bool
174  Check(void) const
175  {
176  if (dynamic_cast<EE_Value *>(m_pEE2)) {
177  return Check_int(m_pEE2->Eval());
178  }
179  return true;
180  };
181 #endif
182 
183  TypedValue
184  Eval(void) const
185  {
186  // FIXME: the check on types should be done while parsing, if possible...
187  TypedValue a = m_pEE2->Eval();
189  ASSERT(a.GetInt() != 0);
190  return m_pEE1->Eval() % a;
191  }
193  };
194 
195  std::ostream&
196  Output(std::ostream& out) const
197  {
198  return out << "(", m_pEE1->Output(out) << " % ", m_pEE2->Output(out) << ")";
199  };
200 };
201 
203 private:
205 
206 public:
208  ~EE_Multiply(void) { delete m_pEE1; delete m_pEE2; };
209 
210  TypedValue
211  Eval(void) const
212  {
213  return m_pEE1->Eval() * m_pEE2->Eval();
214  };
215 
216  std::ostream&
217  Output(std::ostream& out) const
218  {
219  return out << "(", m_pEE1->Output(out) << " * ", m_pEE2->Output(out) << ")";
220  };
221 };
222 
223 class EE_Divide : public ExpressionElement {
224 private:
226 
227 public:
228  EE_Divide(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
229  ~EE_Divide(void) { delete m_pEE1; delete m_pEE2; };
230  // need to take care of zero denominator
231 
232  TypedValue
233  Eval(void) const
234  {
235  TypedValue den = m_pEE2->Eval();
236  if (den.GetType() == TypedValue::VAR_BOOL) {
237  ASSERT(den.GetBool() != 0);
238 
239  } else if (den.GetType() == TypedValue::VAR_INT) {
240  ASSERT(den.GetInt() != 0);
241 
242  } else if (den.GetType() == TypedValue::VAR_REAL) {
243  Real value = den.GetReal();
244  if (std::abs(value) < std::numeric_limits<double>::epsilon()) {
245  // need to throw exception over here
246  std::cout << "denominator cannot be zero" << std::endl;
247  }
248  }
249 
250  return m_pEE1->Eval() / den;
251  };
252 
253  std::ostream&
254  Output(std::ostream& out) const
255  {
256  return out << "(", m_pEE1->Output(out) << " / ", m_pEE2->Output(out) << ")";
257  };
258 };
259 
261 private:
263 
264 public:
266  ~EE_Unary_minus(void) { delete m_pEE1; };
267 
268  TypedValue
269  Eval(void) const
270  {
271  return -m_pEE1->Eval();
272  };
273 
274  std::ostream&
275  Output(std::ostream& out) const
276  {
277  return out << "(-", m_pEE1->Output(out) << ")";
278  };
279 };
280 
281 class EE_AND : public ExpressionElement {
282 private:
284 
285 public:
286  EE_AND(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
287  ~EE_AND(void) { delete m_pEE1; delete m_pEE2; };
288 
289  TypedValue
290  Eval(void) const
291  {
292  return m_pEE1->Eval() && m_pEE2->Eval();
293  };
294 
295  std::ostream&
296  Output(std::ostream& out) const
297  {
298  return out << "(", m_pEE1->Output(out) << " && ", m_pEE2->Output(out) << ")";
299  };
300 };
301 
302 class EE_OR : public ExpressionElement {
303 private:
305 
306 public:
307  EE_OR(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
308  ~EE_OR(void) { delete m_pEE1; delete m_pEE2; };
309 
310  TypedValue
311  Eval(void) const
312  {
313  return m_pEE1->Eval() || m_pEE2->Eval();
314  };
315 
316  std::ostream&
317  Output(std::ostream& out) const
318  {
319  return out << "(", m_pEE1->Output(out) << " || ", m_pEE2->Output(out) << ")";
320  };
321 };
322 
323 class EE_NOT : public ExpressionElement {
324 private:
326 
327 public:
328  EE_NOT(ExpressionElement *pEE1) : m_pEE1(pEE1) {};
329  ~EE_NOT(void) { delete m_pEE1; };
330 
331  TypedValue
332  Eval(void) const
333  {
334  return !(m_pEE1->Eval());
335  };
336 
337  std::ostream&
338  Output(std::ostream& out) const
339  {
340  return out << "(!", m_pEE1->Output(out) << ")";
341  };
342 };
343 
344 // need to implement ~= as overloaded operator in mathp.cc
345 class EE_XOR : public ExpressionElement {
346 private:
348 
349 public:
350  EE_XOR(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
351  ~EE_XOR(void) { delete m_pEE1; delete m_pEE2; };
352 
353  TypedValue
354  Eval(void) const
355  {
356  TypedValue v1 = m_pEE1->Eval();
357  TypedValue v2 = m_pEE2->Eval();
358  return ((!(v1 && v2)) && (v1 || v2));
359  };
360 
361  std::ostream&
362  Output(std::ostream& out) const
363  {
364  return out << "(", m_pEE1->Output(out) << " ~| ", m_pEE2->Output(out) << ")";
365  };
366 };
367 
369 private:
371 
372 public:
373  EE_Greater(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
374  ~EE_Greater(void) { delete m_pEE1; delete m_pEE2; };
375 
376  TypedValue
377  Eval(void) const
378  {
379  return m_pEE1->Eval() > m_pEE2->Eval();
380  };
381 
382  std::ostream&
383  Output(std::ostream& out) const
384  {
385  return out << "(", m_pEE1->Output(out) << " > ", m_pEE2->Output(out) << ")";
386  };
387 };
388 
390 private:
392 
393 public:
395  ~EE_Greater_Equal(void) { delete m_pEE1; delete m_pEE2; };
396 
397  TypedValue
398  Eval(void) const
399  {
400  return m_pEE1->Eval() >= m_pEE2->Eval();
401  };
402 
403  std::ostream&
404  Output(std::ostream& out) const
405  {
406  return out << "(", m_pEE1->Output(out) << " >= ", m_pEE2->Output(out) << ")";
407  };
408 };
409 
410 class EE_Lesser : public ExpressionElement {
411 private:
413 
414 public:
415  EE_Lesser(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
416  ~EE_Lesser(void) { delete m_pEE1; delete m_pEE2; };
417 
418  TypedValue
419  Eval(void) const
420  {
421  return m_pEE1->Eval() < m_pEE2->Eval();
422  };
423 
424  std::ostream&
425  Output(std::ostream& out) const
426  {
427  return out << "(", m_pEE1->Output(out) << " < ", m_pEE2->Output(out) << ")";
428  };
429 };
430 
432 private:
434 
435 public:
437  ~EE_Lesser_Equal(void) { delete m_pEE1; delete m_pEE2; };
438 
439  TypedValue
440  Eval(void) const
441  {
442  return m_pEE1->Eval() <= m_pEE2->Eval();
443  };
444 
445  std::ostream&
446  Output(std::ostream& out) const
447  {
448  return out << "(", m_pEE1->Output(out) << " <= ", m_pEE2->Output(out) << ")";
449  };
450 };
451 
453 private:
455 
456 public:
458  ~EE_Equal_Equal(void) { delete m_pEE1; delete m_pEE2; };
459 
460  TypedValue
461  Eval(void) const
462  {
463  return (m_pEE1->Eval()) == (m_pEE2->Eval());
464  };
465 
466  std::ostream&
467  Output(std::ostream& out) const
468  {
469  return out << "(", m_pEE1->Output(out) << " == ", m_pEE2->Output(out) << ")";
470  };
471 };
472 
474 private:
476 
477 public:
479  ~EE_Not_Equal(void) { delete m_pEE1; delete m_pEE2; };
480 
481  TypedValue
482  Eval(void) const
483  {
484  return (m_pEE1->Eval()) != (m_pEE2->Eval());
485  };
486 
487  std::ostream&
488  Output(std::ostream& out) const
489  {
490  return out << "(", m_pEE1->Output(out) << " != ", m_pEE2->Output(out) << ")";
491  };
492 };
493 
494 class EE_Power : public ExpressionElement {
495 private:
497 
498 public:
499  EE_Power(ExpressionElement *pEE1, ExpressionElement *pEE2) : m_pEE1(pEE1), m_pEE2(pEE2) {};
500  ~EE_Power(void) { delete m_pEE1; delete m_pEE2; };
501 
502  TypedValue
503  Eval(void) const
504  {
505  TypedValue a = m_pEE1->Eval();
506  TypedValue b = m_pEE2->Eval();
508  silent_cerr(" power undefined between string " << a << " and " << b << std::endl);
510 
511  } else if ((a.GetType() == TypedValue::VAR_INT && b.GetType() == TypedValue::VAR_INT)
513  {
514  Real value = std::pow(a.GetInt(), b.GetInt());
515  if (Real(Int(value)) != value) {
516  silent_cerr(" power(" << a.GetInt() << ", " << b.GetInt() << ") overflows (use explicit/implicit cast?)" << std::endl);
518  }
519  return value;
520 
521  } else {
522  return std::pow(a.GetReal(), b.GetReal());
523  }
524  };
525 
526  std::ostream&
527  Output(std::ostream& out) const
528  {
529  return out << "(", m_pEE1->Output(out) << " ^ ", m_pEE2->Output(out) << ")";
530  };
531 };
532 
533 #if 1
534 // FIXME: needs review
535 // for storing value that is which is evaluated first then assigned
536 
537 class EE_Assign : public ExpressionElement {
538 private:
539  mutable Var *m_Var;
542 
543 public:
544  EE_Assign(Var *var, MathParser::NameSpace *ns, ExpressionElement *pEE) : m_Var(var), m_ns(ns), m_pEE(pEE) {};
545  ~EE_Assign(void) { delete m_pEE; };
546 
547  TypedValue
548  Eval(void) const
549  {
550  TypedValue v(m_pEE->Eval());
551  m_Var->SetVal(v);
552  return v;
553  };
554 
555  std::ostream&
556  Output(std::ostream& out) const
557  {
558  out << "(";
559  if (m_ns) {
560  out << m_ns->sGetName() << "::";
561  }
562 
563  return out << m_Var->GetName() << " = ", m_pEE->Output(out) << ")";
564  };
565 };
566 
567 /* the variable is pre-declared */
569 private:
570  mutable Var *m_Var;
573  mutable bool m_bEvaluated;
574 
575 public:
577  ~EE_DeclareAssign(void) { if (m_pEE) { delete m_pEE; } };
578 
579  TypedValue
580  Eval(void) const
581  {
582  if (m_bEvaluated) {
583  silent_cerr(" variable " << m_Var->GetName() << " already declared" << std::endl);
585  }
586 
587  m_bEvaluated = true;
588 
589  if (m_pEE) {
590  TypedValue v(m_pEE->Eval());
591  m_Var->SetVal(v);
592  return v;
593  }
594 
595  return TypedValue(0, true);
596  };
597 
598  std::ostream&
599  Output(std::ostream& out) const
600  {
601  out << "(";
602  if (m_Var->Const()) {
603  out << "const ";
604  }
605 
606  out << m_Var->GetTypeName() << " ";
607 
608  if (m_ns) {
609  out << m_ns->sGetName() << "::";
610  }
611 
612  return out << m_Var->GetName() << " = ", m_pEE->Output(out) << ")";
613  };
614 };
615 #endif
616 
617 // for storing like <stmt>;<stmt>
619 private:
621 
622 public:
624  ~EE_StmtList(void) { delete m_pEE1; delete m_pEE2; };
625 
626  TypedValue
627  Eval(void) const
628  {
629  // FIXME: the first expression must exist
630  ASSERT(m_pEE1 != 0);
631 
632  if (m_pEE1 != 0) {
633  m_pEE1->Eval();
634  }
635 
636  return m_pEE2->Eval();
637  };
638 
639  std::ostream&
640  Output(std::ostream& out) const
641  {
642  return out << "(", m_pEE1->Output(out) << " ; ", m_pEE2->Output(out) << ")";
643  };
644 };
645 
646 class EE_Func : public ExpressionElement {
647 private:
648  // pointer to MathParser only needed for exception handling
651 
652 public:
654  : m_p(p), m_f(f)
655  {
656  };
657 
658  ~EE_Func(void)
659  {
660  for (unsigned i = 0; i < m_f->args.size(); ++i) {
661  const ExpressionElement *ee = m_f->args[i]->GetExpr();
662  if (ee) {
663  delete ee;
664  }
665  }
666  delete m_f;
667  };
668 
669  TypedValue
670  Eval(void) const
671  {
672  // sure args[0] does not need to be evaluated: it's the return value
673  for (unsigned i = 1; i < m_f->args.size(); i++) {
674  m_f->args[i]->Eval();
675  }
676 
677  if (m_f->t != 0) {
678  if (m_f->t(m_f->args)) {
679  DEBUGCERR("error in function "
680  << m_f->ns->sGetName() << "::" << m_f->fname
681  << " " "(msg: " << m_f->errmsg << ")"
682  << " in EE_Func()" << std::endl);
684  m_f->fname + ": error " + m_f->errmsg);
685  }
686  }
687 
688  TypedValue val = m_f->ns->EvalFunc(m_f);
689 
690  return val;
691  };
692 
693  std::ostream&
694  Output(std::ostream& out) const
695  {
696  if (m_f->ns) {
697  out << m_f->ns->sGetName() << "::";
698  }
699 
700  out << m_f->fname << "(";
701  const ExpressionElement *ee = m_f->args[1]->GetExpr();
702  if (ee != 0) {
703  ee->Output(out);
704  for (unsigned i = 2; i < m_f->args.size(); ++i) {
705  ee = m_f->args[i]->GetExpr();
706  if (ee == 0) {
707  break;
708  }
709  out << ", ", ee->Output(out);
710  }
711  }
712  out << ")";
713 
714  return out;
715  };
716 };
717 
718 // unary operator construction helper with optimization
719 template <class T>
722 {
723  ExpressionElement *out = new T(e1);
725  if (dynamic_cast<EE_Value *>(e1)) {
726  ExpressionElement *tmp = new EE_Value(out->Eval());
727  delete out;
728  return tmp;
729  }
730  }
731  return out;
732 }
733 
734 // binary operator construction helper with optimization
735 template <class T>
738 {
739  ExpressionElement *out = new T(e1, e2);
741  if (dynamic_cast<EE_Value *>(e1) && dynamic_cast<EE_Value *>(e2)) {
742  ExpressionElement *tmp = new EE_Value(out->Eval());
743  delete out;
744  return tmp;
745  }
746  }
747  return out;
748 }
749 
750 // ternary operator construction helper with optimization
751 template <class T>
754 {
755  ExpressionElement *out = new T(e1, e2, e3);
757  if (dynamic_cast<EE_Value *>(e1) && dynamic_cast<EE_Value *>(e2) && dynamic_cast<EE_Value *>(e3)) {
758  ExpressionElement *tmp = new EE_Value(out->Eval());
759  delete out;
760  return tmp;
761  }
762  }
763  return out;
764 }
765 
766 #endif // EVALUATOR_IMPL_H
ExpressionElement * m_pEE1
TypedValue Eval(void) const
TypedValue Eval(void) const
std::ostream & Output(std::ostream &out) const
std::ostream & Output(std::ostream &out) const
TypedValue Eval(void) const
EE_Lesser_Equal(ExpressionElement *pEE1, ExpressionElement *pEE2)
TypedValue Eval(void) const
std::ostream & Output(std::ostream &out) const
ExpressionElement * m_pEE2
EE_XOR(ExpressionElement *pEE1, ExpressionElement *pEE2)
ExpressionElement * EECreate(ExpressionElement *e1)
ExpressionElement * m_pEE1
EE_Equal_Equal(ExpressionElement *pEE1, ExpressionElement *pEE2)
ExpressionElement * m_pEE1
Definition: mathtyp.h:175
Real GetReal(void) const
Definition: mathp.cc:1228
ExpressionElement * m_pEE2
EE_StmtList(ExpressionElement *pEE1, ExpressionElement *pEE2)
~EE_Func(void)
GradientExpression< BinaryExpr< FuncPow, LhsExpr, RhsExpr > > pow(const GradientExpression< LhsExpr > &u, const GradientExpression< RhsExpr > &v)
Definition: gradient.h:2961
~EE_NOT(void)
#define MBDYN_EXCEPT_ARGS
Definition: except.h:63
std::ostream & Output(std::ostream &out) const
TypedValue::Type GetType(void) const
Definition: mathp.cc:1155
EE_NOT(ExpressionElement *pEE1)
EE_OR(ExpressionElement *pEE1, ExpressionElement *pEE2)
bool Const(void) const
Definition: mathp.cc:1811
~EE_Greater(void)
~EE_Value(void)
virtual TypedValue GetVal(void) const =0
EE_Not_Equal(ExpressionElement *pEE1, ExpressionElement *pEE2)
ExpressionElement * m_pEE1
ExpressionElement * m_pEE1
~EE_Lesser(void)
std::ostream & Output(std::ostream &out) const
EE_AND(ExpressionElement *pEE1, ExpressionElement *pEE2)
ExpressionElement * m_pEE1
const ExpressionElement * m_pEE
MathParser::NameSpace * m_ns
std::string errmsg
Definition: mathp.h:172
TypedValue Eval(void) const
MathParser * m_p
std::ostream & Output(std::ostream &out) const
~EE_Divide(void)
ExpressionElement * m_pEE2
MathParser::MathFunc_t * m_f
TypedValue Eval(void) const
ExpressionElement * m_pEE1
TypedValue Eval(void) const
ExpressionElement * m_pEE2
TypedValue Eval(void) const
#define DEBUGCERR(msg)
Definition: myassert.h:235
TypedValue Eval(void) const
virtual TypedValue Eval(void) const =0
~EE_Plus(void)
std::ostream & Output(std::ostream &out) const
ExpressionElement * m_pEE2
~EE_StmtList(void)
EE_Multiply(ExpressionElement *pEE1, ExpressionElement *pEE2)
ExpressionElement * m_pEE2
std::ostream & Output(std::ostream &out) const
int Int
Definition: mathtyp.h:40
ExpressionElement * m_pEE2
TypedValue Eval(void) const
ExpressionElement * m_pEE1
ExpressionElement * m_pEE2
MathParser::NameSpace * m_ns
TypedValue Eval(void) const
~EE_Modulus(void)
~EE_XOR(void)
const ExpressionElement * m_pEE
ExpressionElement * m_pEE1
ExpressionElement * m_pEE1
MathFuncTest_f t
Definition: mathp.h:171
std::ostream & Output(std::ostream &out) const
static bool IsFlag(EEFlags f)
Definition: evaluator.h:66
EE_Value(TypedValue Val)
ExpressionElement * m_pEE1
~EE_Assign(void)
TypedValue Eval(void) const
virtual std::ostream & Output(std::ostream &out) const =0
ExpressionElement * m_pEE2
ExpressionElement * m_pEE2
Definition: mbdyn.h:76
std::ostream & Output(std::ostream &out) const
~EE_Power(void)
TypedValue Eval(void) const
~EE_Multiply(void)
virtual const std::string & sGetName(void) const
Definition: mathp.cc:2001
NamedValue * m_Var
ExpressionElement * m_pEE1
std::ostream & Output(std::ostream &out) const
EE_Divide(ExpressionElement *pEE1, ExpressionElement *pEE2)
ExpressionElement * m_pEE2
ExpressionElement * m_pEE1
ExpressionElement * m_pEE2
ExpressionElement * m_pEE2
ExpressionElement * m_pEE1
std::ostream & Output(std::ostream &out) const
MathParser::NameSpace * m_ns
std::ostream & Output(std::ostream &out) const
std::ostream & Output(std::ostream &out) const
std::ostream & Output(std::ostream &out) const
#define ASSERT(expression)
Definition: colamd.c:977
virtual TypedValue EvalFunc(MathParser::MathFunc_t *f) const =0
ExpressionElement * m_pEE1
ExpressionElement * m_pEE2
std::ostream & Output(std::ostream &out) const
TypedValue Eval(void) const
TypedValue Eval(void) const
std::ostream & Output(std::ostream &out) const
EE_Plus(ExpressionElement *pEE1, ExpressionElement *pEE2)
EE_Assign(Var *var, MathParser::NameSpace *ns, ExpressionElement *pEE)
EE_Greater(ExpressionElement *pEE1, ExpressionElement *pEE2)
EE_Power(ExpressionElement *pEE1, ExpressionElement *pEE2)
TypedValue Eval(void) const
EE_Lesser(ExpressionElement *pEE1, ExpressionElement *pEE2)
EE_Greater_Equal(ExpressionElement *pEE1, ExpressionElement *pEE2)
TypedValue Eval(void) const
TypedValue Eval(void) const
std::ostream & Output(std::ostream &out) const
EE_DeclareAssign(Var *var, MathParser::NameSpace *ns, ExpressionElement *pEE=0)
EE_Func(MathParser *p, MathParser::MathFunc_t *f)
EE_Var(NamedValue *var, MathParser::NameSpace *ns=0)
ExpressionElement * m_pEE1
NameSpace * ns
Definition: mathp.h:168
TypedValue Eval(void) const
virtual std::ostream & Output(std::ostream &out) const
~EE_Minus(void)
TypedValue m_Val
TypedValue Eval(void) const
EE_Unary_minus(ExpressionElement *pEE1)
TypedValue Eval(void) const
~EE_OR(void)
ExpressionElement * m_pEE1
static const doublereal a
Definition: hfluid_.h:289
std::ostream & Output(std::ostream &out) const
virtual const char *const GetTypeName(void) const
Definition: mathp.cc:1758
void SetConst(bool isConst=true, bool bForce=false)
Definition: mathp.cc:1275
virtual ~EE_Var(void)
EE_Minus(ExpressionElement *pEE1, ExpressionElement *pEE2)
const char * GetName(void) const
Definition: mathp.cc:1751
Int GetInt(void) const
Definition: mathp.cc:1209
std::ostream & Output(std::ostream &out) const
EE_Modulus(ExpressionElement *pEE1, ExpressionElement *pEE2)
~EE_AND(void)
ExpressionElement * m_pEE2
void SetVal(const bool &b)
Definition: mathp.cc:1829
bool GetBool(void) const
Definition: mathp.cc:1188
double Real
Definition: mathtyp.h:39
std::ostream & Output(std::ostream &out) const
ExpressionElement * m_pEE1
std::string fname
Definition: mathp.h:167
virtual TypedValue Eval(void) const
TypedValue Eval(void) const
std::ostream & Output(std::ostream &out) const
ExpressionElement * m_pEE2