www.mooseframework.org
ExpressionBuilder.h
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #pragma once
11 
12 #include <vector>
13 #include <ostream>
14 #include <sstream>
15 #include <iomanip>
16 
17 #include "MooseError.h"
18 #include "libmesh/libmesh_common.h"
19 
20 using namespace libMesh;
21 
48 {
49 public:
51 
52  // forward delcarations
53  class EBTerm;
54  class EBTermNode;
55  class EBFunction;
57  typedef std::vector<EBTerm> EBTermList;
58  typedef std::vector<EBTermNode *> EBTermNodeList;
59  typedef std::vector<const EBSubstitutionRule *> EBSubstitutionRuleList;
60 
62  class EBTermNode
63  {
64  public:
65  virtual ~EBTermNode(){};
66  virtual EBTermNode * clone() const = 0;
67 
68  virtual std::string stringify() const = 0;
69  virtual unsigned int substitute(const EBSubstitutionRuleList & /*rule*/) { return 0; }
70  virtual int precedence() const = 0;
71  friend std::ostream & operator<<(std::ostream & os, const EBTermNode & node)
72  {
73  return os << node.stringify();
74  }
75  };
76 
78  template <typename T>
79  class EBNumberNode : public EBTermNode
80  {
81  T _value;
82 
83  public:
84  EBNumberNode(T value) : _value(value){};
85  virtual EBNumberNode<T> * clone() const { return new EBNumberNode(_value); }
86 
87  virtual std::string stringify() const;
88  virtual int precedence() const { return 0; }
89  };
90 
92  class EBSymbolNode : public EBTermNode
93  {
94  std::string _symbol;
95 
96  public:
97  EBSymbolNode(std::string symbol) : _symbol(symbol){};
98  virtual EBSymbolNode * clone() const { return new EBSymbolNode(_symbol); }
99 
100  virtual std::string stringify() const;
101  virtual int precedence() const { return 0; }
102  };
103 
108  class EBTempIDNode : public EBTermNode
109  {
110  unsigned long _id;
111 
112  public:
113  EBTempIDNode(unsigned int id) : _id(id){};
114  virtual EBTempIDNode * clone() const { return new EBTempIDNode(_id); }
115 
116  virtual std::string stringify() const; // returns "[idnumber]"
117  virtual int precedence() const { return 0; }
118  };
119 
122  {
123  public:
124  EBUnaryTermNode(EBTermNode * subnode) : _subnode(subnode){};
125  virtual ~EBUnaryTermNode() { delete _subnode; };
126 
127  virtual unsigned int substitute(const EBSubstitutionRuleList & rule);
128  const EBTermNode * getSubnode() const { return _subnode; }
129 
130  protected:
132  };
133 
136  {
137  public:
138  enum NodeType
139  {
150  TANH
151  } _type;
152 
154  : EBUnaryTermNode(subnode), _type(type){};
155  virtual EBUnaryFuncTermNode * clone() const
156  {
157  return new EBUnaryFuncTermNode(_subnode->clone(), _type);
158  };
159 
160  virtual std::string stringify() const;
161  virtual int precedence() const { return 2; }
162  };
163 
166  {
167  public:
168  enum NodeType
169  {
171  LOGICNOT
172  } _type;
173 
175  : EBUnaryTermNode(subnode), _type(type){};
176  virtual EBUnaryOpTermNode * clone() const
177  {
178  return new EBUnaryOpTermNode(_subnode->clone(), _type);
179  };
180 
181  virtual std::string stringify() const;
182  virtual int precedence() const { return 3; }
183  };
184 
187  {
188  public:
189  EBBinaryTermNode(EBTermNode * left, EBTermNode * right) : _left(left), _right(right){};
191  {
192  delete _left;
193  delete _right;
194  };
195 
196  virtual unsigned int substitute(const EBSubstitutionRuleList & rule);
197 
198  protected:
201  };
202 
205  {
206  public:
207  enum NodeType
208  {
219  EQ,
220  NOTEQ
221  };
222 
224  : EBBinaryTermNode(left, right), _type(type){};
225  virtual EBBinaryOpTermNode * clone() const
226  {
227  return new EBBinaryOpTermNode(_left->clone(), _right->clone(), _type);
228  };
229 
230  virtual std::string stringify() const;
231  virtual int precedence() const;
232 
233  protected:
235  };
236 
239  {
240  public:
241  enum NodeType
242  {
247  PLOG
248  } _type;
249 
251  : EBBinaryTermNode(left, right), _type(type){};
252  virtual EBBinaryFuncTermNode * clone() const
253  {
254  return new EBBinaryFuncTermNode(_left->clone(), _right->clone(), _type);
255  };
256 
257  virtual std::string stringify() const;
258  virtual int precedence() const { return 2; }
259  };
260 
263  {
264  public:
266  : EBBinaryTermNode(left, right), _middle(middle){};
267  virtual ~EBTernaryTermNode() { delete _middle; };
268 
269  virtual unsigned int substitute(const EBSubstitutionRuleList & rule);
270 
271  protected:
273  };
274 
277  {
278  public:
279  enum NodeType
280  {
281  CONDITIONAL
282  } _type;
283 
285  : EBTernaryTermNode(left, middle, right), _type(type){};
286  virtual EBTernaryFuncTermNode * clone() const
287  {
288  return new EBTernaryFuncTermNode(_left->clone(), _middle->clone(), _right->clone(), _type);
289  };
290 
291  virtual std::string stringify() const;
292  virtual int precedence() const { return 2; }
293  };
294 
299  {
300  public:
301  virtual EBTermNode * apply(const EBTermNode *) const = 0;
302  virtual ~EBSubstitutionRule() {}
303  };
304 
308  template <class Node_T>
310  {
311  public:
312  virtual EBTermNode * apply(const EBTermNode *) const;
313 
314  protected:
315  // on successful substitution this returns a new node to replace the old one, otherwise it
316  // returns NULL
317  virtual EBTermNode * substitute(const Node_T &) const = 0;
318  };
319 
324  class EBTermSubstitution : public EBSubstitutionRuleTyped<EBSymbolNode>
325  {
326  public:
327  EBTermSubstitution(const EBTerm & find, const EBTerm & replace);
328  virtual ~EBTermSubstitution() { delete _replace; }
329 
330  protected:
331  virtual EBTermNode * substitute(const EBSymbolNode &) const;
332  std::string _find;
334  };
335 
340  class EBLogPlogSubstitution : public EBSubstitutionRuleTyped<EBUnaryFuncTermNode>
341  {
342  public:
343  EBLogPlogSubstitution(const EBTerm & epsilon) : _epsilon(epsilon.cloneRoot())
344  {
345  mooseAssert(_epsilon != NULL, "Epsilon must not be an empty term in EBLogPlogSubstitution");
346  }
347  virtual ~EBLogPlogSubstitution() { delete _epsilon; }
348 
349  protected:
350  virtual EBTermNode * substitute(const EBUnaryFuncTermNode &) const;
352  };
353 
360  class EBTerm
361  {
362  public:
363  // the default constructor assigns a temporary id node to root we use the address of the
364  // current EBTerm object as the ID. This could be problematic if we create and destroy terms,
365  // but then we should not expect the substitution to do sane things anyways.
366  EBTerm() : _root(new EBTempIDNode(reinterpret_cast<unsigned long long>(this))){};
367 
368  EBTerm(const EBTerm & term) : _root(term.cloneRoot()){};
369  ~EBTerm() { delete _root; };
370 
371  private:
372  // construct a term from a node
373  EBTerm(EBTermNode * root) : _root(root){};
374 
375  public:
376  // construct from number or string
377  EBTerm(int number) : _root(new EBNumberNode<int>(number)) {}
378  EBTerm(Real number) : _root(new EBNumberNode<Real>(number)) {}
379  EBTerm(const char * symbol) : _root(new EBSymbolNode(symbol)) {}
380 
381  // concatenate terms to form a parameter list with (()) syntax (those need to be out-of-class!)
382  friend EBTermList operator,(const ExpressionBuilder::EBTerm & larg,
383  const ExpressionBuilder::EBTerm & rarg);
384  friend EBTermList operator,(const ExpressionBuilder::EBTerm & larg,
385  const ExpressionBuilder::EBTermList & rargs);
387  const ExpressionBuilder::EBTerm & rarg);
388 
389  // dump term as FParser expression
390  friend std::ostream & operator<<(std::ostream & os, const EBTerm & term);
391  // cast into a string
392  operator std::string() const { return _root->stringify(); }
393 
394  // assign a term
395  EBTerm & operator=(const EBTerm & term)
396  {
397  delete _root;
398  _root = term.cloneRoot();
399  return *this;
400  }
401 
402  // perform a substitution (returns substituton count)
403  unsigned int substitute(const EBSubstitutionRule & rule);
404  unsigned int substitute(const EBSubstitutionRuleList & rules);
405 
406  const EBTermNode * getRoot() const { return _root; }
407  EBTermNode * cloneRoot() const { return _root == NULL ? NULL : _root->clone(); }
408 
409  protected:
411 
412  public:
416 #define UNARY_OP_IMPLEMENT(op, OP) \
417  EBTerm operator op() const \
418  { \
419  mooseAssert(_root != NULL, "Empty term provided for unary operator " #op); \
420  return EBTerm(new EBUnaryOpTermNode(cloneRoot(), EBUnaryOpTermNode::OP)); \
421  }
422  UNARY_OP_IMPLEMENT(-, NEG)
423  UNARY_OP_IMPLEMENT(!, LOGICNOT)
424 
425 
428  friend EBTerm sin(const EBTerm &);
429  friend EBTerm cos(const EBTerm &);
430  friend EBTerm tan(const EBTerm &);
431  friend EBTerm abs(const EBTerm &);
432  friend EBTerm log(const EBTerm &);
433  friend EBTerm log2(const EBTerm &);
434  friend EBTerm log10(const EBTerm &);
435  friend EBTerm exp(const EBTerm &);
436  friend EBTerm sinh(const EBTerm &);
437  friend EBTerm cosh(const EBTerm &);
438  friend EBTerm tanh(const EBTerm &);
439 
440 /*
441  * Binary operators (including number,term operations)
442  */
443 #define BINARY_OP_IMPLEMENT(op, OP) \
444  EBTerm operator op(const EBTerm & term) const \
445  { \
446  mooseAssert(_root != NULL, "Empty term provided on left side of operator " #op); \
447  mooseAssert(term._root != NULL, "Empty term provided on right side of operator " #op); \
448  return EBTerm(new EBBinaryOpTermNode(cloneRoot(), term.cloneRoot(), EBBinaryOpTermNode::OP)); \
449  } \
450  friend EBTerm operator op(int left, const EBTerm & right) \
451  { \
452  mooseAssert(right._root != NULL, "Empty term provided on right side of operator " #op); \
453  return EBTerm(new EBBinaryOpTermNode( \
454  new EBNumberNode<int>(left), right.cloneRoot(), EBBinaryOpTermNode::OP)); \
455  } \
456  friend EBTerm operator op(Real left, const EBTerm & right) \
457  { \
458  mooseAssert(right._root != NULL, "Empty term provided on right side of operator " #op); \
459  return EBTerm(new EBBinaryOpTermNode( \
460  new EBNumberNode<Real>(left), right.cloneRoot(), EBBinaryOpTermNode::OP)); \
461  } \
462  friend EBTerm operator op(const EBFunction & left, const EBTerm & right) \
463  { \
464  mooseAssert(EBTerm(left)._root != NULL, "Empty term provided on left side of operator " #op); \
465  mooseAssert(right._root != NULL, "Empty term provided on right side of operator " #op); \
466  return EBTerm(new EBBinaryOpTermNode( \
467  EBTerm(left).cloneRoot(), right.cloneRoot(), EBBinaryOpTermNode::OP)); \
468  } \
469  friend EBTerm operator op(const EBFunction & left, const EBFunction & right); \
470  friend EBTerm operator op(int left, const EBFunction & right); \
471  friend EBTerm operator op(Real left, const EBFunction & right);
472  BINARY_OP_IMPLEMENT(+, ADD)
473  BINARY_OP_IMPLEMENT(-, SUB)
474  BINARY_OP_IMPLEMENT(*, MUL)
475  BINARY_OP_IMPLEMENT(/, DIV)
476  BINARY_OP_IMPLEMENT(%, MOD)
477  BINARY_OP_IMPLEMENT(<, LESS)
478  BINARY_OP_IMPLEMENT(>, GREATER)
479  BINARY_OP_IMPLEMENT(<=, LESSEQ)
480  BINARY_OP_IMPLEMENT(>=, GREATEREQ)
481  BINARY_OP_IMPLEMENT(==, EQ)
482  BINARY_OP_IMPLEMENT(!=, NOTEQ)
483 
484 /*
485  * Compound assignment operators
486  */
487 #define BINARYCOMP_OP_IMPLEMENT(op, OP) \
488  EBTerm & operator op(const EBTerm & term) \
489  { \
490  mooseAssert(_root != NULL, "Empty term provided on left side of operator " #op); \
491  mooseAssert(term._root != NULL, "Empty term provided on right side of operator " #op); \
492  if (dynamic_cast<EBTempIDNode *>(_root)) \
493  mooseError("Using compound assignment operator on anonymous term. Set it to 0 first!"); \
494  _root = new EBBinaryOpTermNode(_root, term.cloneRoot(), EBBinaryOpTermNode::OP); \
495  return *this; \
496  }
497  BINARYCOMP_OP_IMPLEMENT(+=, ADD)
498  BINARYCOMP_OP_IMPLEMENT(-=, SUB)
499  BINARYCOMP_OP_IMPLEMENT(*=, MUL)
500  BINARYCOMP_OP_IMPLEMENT(/=, DIV)
501  BINARYCOMP_OP_IMPLEMENT(%=, MOD)
502 
503 
507  friend EBTerm min(const EBTerm &, const EBTerm &);
508  friend EBTerm max(const EBTerm &, const EBTerm &);
509  friend EBTerm pow(const EBTerm &, const EBTerm &);
510  template <typename T>
511  friend EBTerm pow(const EBTerm &, T exponent);
512  friend EBTerm atan2(const EBTerm &, const EBTerm &);
513  friend EBTerm hypot(const EBTerm &, const EBTerm &);
514  friend EBTerm plog(const EBTerm &, const EBTerm &);
516 
520  friend EBTerm conditional(const EBTerm &, const EBTerm &, const EBTerm &);
521  };
522 
525  {
526  public:
528 
532  EBFunction & operator()(const EBTerm & arg);
533  EBFunction & operator()(const EBTermList & args);
535 
538  EBFunction & operator()(const EBTerm & a1, const EBTerm & a2) { return (*this)((a1, a2)); }
539  EBFunction & operator()(const EBTerm & a1, const EBTerm & a2, const EBTerm & a3)
540  {
541  return (*this)((a1, a2, a3));
542  }
543  EBFunction &
544  operator()(const EBTerm & a1, const EBTerm & a2, const EBTerm & a3, const EBTerm & a4)
545  {
546  return (*this)((a1, a2, a3, a4));
547  }
549  const EBTerm & a2,
550  const EBTerm & a3,
551  const EBTerm & a4,
552  const EBTerm & a5)
553  {
554  return (*this)((a1, a2, a3, a4, a5));
555  }
557  const EBTerm & a2,
558  const EBTerm & a3,
559  const EBTerm & a4,
560  const EBTerm & a5,
561  const EBTerm & a6)
562  {
563  return (*this)((a1, a2, a3, a4, a5, a6));
564  }
566  const EBTerm & a2,
567  const EBTerm & a3,
568  const EBTerm & a4,
569  const EBTerm & a5,
570  const EBTerm & a6,
571  const EBTerm & a7)
572  {
573  return (*this)((a1, a2, a3, a4, a5, a6, a7));
574  }
576  const EBTerm & a2,
577  const EBTerm & a3,
578  const EBTerm & a4,
579  const EBTerm & a5,
580  const EBTerm & a6,
581  const EBTerm & a7,
582  const EBTerm & a8)
583  {
584  return (*this)((a1, a2, a3, a4, a5, a6, a7, a8));
585  }
587  const EBTerm & a2,
588  const EBTerm & a3,
589  const EBTerm & a4,
590  const EBTerm & a5,
591  const EBTerm & a6,
592  const EBTerm & a7,
593  const EBTerm & a8,
594  const EBTerm & a9)
595  {
596  return (*this)((a1, a2, a3, a4, a5, a6, a7, a8, a9));
597  }
599 
601  operator EBTerm() const;
602 
604  operator std::string() const;
605 
608  EBFunction & operator=(const EBTerm &);
609  EBFunction & operator=(const EBFunction &);
611 
613  std::string args();
614 
617  EBTerm operator-() { return -EBTerm(*this); }
618  EBTerm operator!() { return !EBTerm(*this); }
620 
621  // perform a substitution (returns substituton count)
622  unsigned int substitute(const EBSubstitutionRule & rule);
623  unsigned int substitute(const EBSubstitutionRuleList & rules);
624 
625  protected:
630 
631  // underlying term that the _eval_arguments are substituted in
633  };
634 
635 /*
636  * Binary operators
637  */
638 #define BINARYFUNC_OP_IMPLEMENT(op, OP) \
639  friend EBTerm operator op(const EBFunction & left, const EBFunction & right) \
640  { \
641  mooseAssert(EBTerm(left)._root != NULL, "Empty term provided on left side of operator " #op); \
642  mooseAssert(EBTerm(right)._root != NULL, \
643  "Empty term provided on right side of operator " #op); \
644  return EBTerm(new EBBinaryOpTermNode( \
645  EBTerm(left).cloneRoot(), EBTerm(right).cloneRoot(), EBBinaryOpTermNode::OP)); \
646  } \
647  friend EBTerm operator op(int left, const EBFunction & right) \
648  { \
649  mooseAssert(EBTerm(right)._root != NULL, \
650  "Empty term provided on right side of operator " #op); \
651  return EBTerm(new EBBinaryOpTermNode( \
652  new EBNumberNode<int>(left), EBTerm(right).cloneRoot(), EBBinaryOpTermNode::OP)); \
653  } \
654  friend EBTerm operator op(Real left, const EBFunction & right) \
655  { \
656  mooseAssert(EBTerm(right)._root != NULL, \
657  "Empty term provided on right side of operator " #op); \
658  return EBTerm(new EBBinaryOpTermNode( \
659  new EBNumberNode<Real>(left), EBTerm(right).cloneRoot(), EBBinaryOpTermNode::OP)); \
660  }
661  BINARYFUNC_OP_IMPLEMENT(+, ADD)
662  BINARYFUNC_OP_IMPLEMENT(-, SUB)
663  BINARYFUNC_OP_IMPLEMENT(*, MUL)
664  BINARYFUNC_OP_IMPLEMENT(/, DIV)
665  BINARYFUNC_OP_IMPLEMENT(%, MOD)
666  BINARYFUNC_OP_IMPLEMENT(<, LESS)
667  BINARYFUNC_OP_IMPLEMENT(>, GREATER)
668  BINARYFUNC_OP_IMPLEMENT(<=, LESSEQ)
669  BINARYFUNC_OP_IMPLEMENT(>=, GREATEREQ)
670  BINARYFUNC_OP_IMPLEMENT(==, EQ)
671  BINARYFUNC_OP_IMPLEMENT(!=, NOTEQ)
672 };
673 
674 // convenience function for numeric exponent
675 template <typename T>
677 pow(const ExpressionBuilder::EBTerm & left, T exponent)
678 {
683 }
684 
685 // convert a number node into a string
686 template <typename T>
687 std::string
689 {
690  std::ostringstream s;
691  s << std::setprecision(12) << _value;
692  return s.str();
693 }
694 
695 template <class Node_T>
698  const ExpressionBuilder::EBTermNode * node) const
699 {
700  const Node_T * match_node = dynamic_cast<const Node_T *>(node);
701  if (match_node == NULL)
702  return NULL;
703  else
704  return substitute(*match_node);
705 }
Node representing a function with three arguments.
User facing host object for an expression tree.
virtual EBNumberNode< T > * clone() const
Base class for nodes with two sub nodes (i.e. functions or operators taking two arguments) ...
virtual EBUnaryOpTermNode * clone() const
virtual EBBinaryOpTermNode * clone() const
EBFunction & operator()(const EBTerm &a1, const EBTerm &a2, const EBTerm &a3, const EBTerm &a4, const EBTerm &a5, const EBTerm &a6)
Node representing a unary operator.
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template * sin(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(tan
EBFunction & operator()(const EBTerm &a1, const EBTerm &a2, const EBTerm &a3, const EBTerm &a4)
Template class for leaf nodes holding anonymous IDs in the expression tree.
auto exp(const T &)
Node representing a binary operator.
ExpressionBuilder::EBTermList operator,(const ExpressionBuilder::EBTerm &larg, const ExpressionBuilder::EBTerm &rarg)
Base class for nodes with a single sub node (i.e. functions or operators taking one argument) ...
virtual EBUnaryFuncTermNode * clone() const
const EBTermNode * getSubnode() const
std::ostream & operator<<(std::ostream &os, const OrderWrapper &order)
EBTermList _eval_arguments
argument list passed in when evaluating the function
Node representing a function with two arguments.
EBFunction & operator()(const EBTerm &a1, const EBTerm &a2, const EBTerm &a3, const EBTerm &a4, const EBTerm &a5, const EBTerm &a6, const EBTerm &a7, const EBTerm &a8, const EBTerm &a9)
virtual EBTermNode * clone() const =0
std::vector< EBTerm > EBTermList
The following methods are specializations for using the Parallel::packed_range_* routines for a vecto...
std::basic_ostream< charT, traits > * os
ExpressionBuilder adds an interface to derived classes that enables convenient construction of FParse...
EBFunction & operator()(const EBTerm &a1, const EBTerm &a2, const EBTerm &a3)
virtual std::string stringify() const
virtual EBSymbolNode * clone() const
Substitution rule base class that applies to nodes of type Node_T.
EBBinaryTermNode(EBTermNode *left, EBTermNode *right)
Base class for nodes in the expression tree.
auto max(const L &left, const R &right)
virtual EBTempIDNode * clone() const
ADRealEigenVector< T, D, asd > abs(const ADRealEigenVector< T, D, asd > &)
friend std::ostream & operator<<(std::ostream &os, const EBTermNode &node)
Template class for leaf nodes holding symbols (i.e. variables) in the expression tree.
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template cos(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(cos
Template class for leaf nodes holding numbers in the expression tree.
Real value(unsigned n, unsigned alpha, unsigned beta, Real x)
virtual unsigned int substitute(const EBSubstitutionRuleList &)
Node representing a function with two arguments.
EBUnaryOpTermNode(EBTermNode *subnode, NodeType type)
EBUnaryFuncTermNode(EBTermNode *subnode, NodeType type)
Real root(std::function< Real(Real)> const &f, Real x1, Real x2, Real tol=1.0e-12)
Finds the root of a function using Brent&#39;s method.
Definition: BrentsMethod.C:61
auto conditional(const C &, const L &, const R &)
std::string stringify(const T &t)
virtual EBBinaryFuncTermNode * clone() const
auto log(const T &)
EBFunction & operator()(const EBTerm &a1, const EBTerm &a2)
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template sinh(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(erf
virtual std::string stringify() const =0
std::vector< const EBSubstitutionRule * > EBSubstitutionRuleList
virtual EBTernaryFuncTermNode * clone() const
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)
const EBTermNode * getRoot() const
Substitution rule to replace all occurences of log(x) with plog(x, epsilon) with a user defined term ...
infix_ostream_iterator< T, charT, traits > & operator=(T const &item)
EBFunction & operator()(const EBTerm &a1, const EBTerm &a2, const EBTerm &a3, const EBTerm &a4, const EBTerm &a5, const EBTerm &a6, const EBTerm &a7, const EBTerm &a8)
DIE A HORRIBLE DEATH HERE typedef LIBMESH_DEFAULT_SCALAR_TYPE Real
std::vector< EBTermNode * > EBTermNodeList
User facing host object for a function. This combines a term with an argument list.
EBTerm(const char *symbol)
EBTernaryFuncTermNode(EBTermNode *left, EBTermNode *middle, EBTermNode *right, NodeType type)
EBTermList _arguments
argument list the function is declared with
EBTernaryTermNode(EBTermNode *left, EBTermNode *middle, EBTermNode *right)
virtual EBTermNode * apply(const EBTermNode *) const
CTSub CT_OPERATOR_BINARY CTMul CTCompareLess CTCompareGreater CTCompareEqual _arg template cosh(_arg) *_arg.template D< dtag >()) CT_SIMPLE_UNARY_FUNCTION(cosh
Generic Substitution rule to replace all occurences of a given symbol node term with a user defined t...
EBFunction & operator()(const EBTerm &a1, const EBTerm &a2, const EBTerm &a3, const EBTerm &a4, const EBTerm &a5)
EBTerm(const EBTerm &term)
auto min(const L &left, const R &right)
Substitution rule functor base class to perform flexible term substitutions.
void ErrorVector unsigned int
EBBinaryFuncTermNode(EBTermNode *left, EBTermNode *right, NodeType type)
EBFunction & operator()(const EBTerm &a1, const EBTerm &a2, const EBTerm &a3, const EBTerm &a4, const EBTerm &a5, const EBTerm &a6, const EBTerm &a7)
EBTermNode * cloneRoot() const
EBBinaryOpTermNode(EBTermNode *left, EBTermNode *right, NodeType type)
Base class for nodes with two sub nodes (i.e. functions or operators taking two arguments) ...
EBTerm & operator=(const EBTerm &term)