36 #ifndef _ANALYTIC_EXPRESSION_EVALUATOR_HPP
37 #define _ANALYTIC_EXPRESSION_EVALUATOR_HPP
43 #include <boost/version.hpp>
44 #include <boost/random/mersenne_twister.hpp>
45 #include <boost/random/variate_generator.hpp>
46 #include <boost/random/normal_distribution.hpp>
48 #define BOOST_SPIRIT_THREADSAFE
49 #if( BOOST_VERSION / 100 % 1000 >= 36 )
50 #include <boost/spirit/include/classic_core.hpp>
51 #include <boost/spirit/include/classic_ast.hpp>
52 #include <boost/spirit/include/classic_symbols.hpp>
53 #include <boost/spirit/include/classic_assign_actor.hpp>
54 #include <boost/spirit/include/classic_push_back_actor.hpp>
58 #include <boost/spirit/core.hpp>
59 #include <boost/spirit/tree/ast.hpp>
60 #include <boost/spirit/symbols/symbols.hpp>
61 #include <boost/spirit/actor/assign_actor.hpp>
62 #include <boost/spirit/actor/push_back_actor.hpp>
70 #if defined(__INTEL_COMPILER)
78 namespace LibUtilities
82 if (x != 0. || y != 0.)
83 return sqrt (x*x + y*y);
91 if ((x != 0.) || (y != 0.))
132 typedef boost_spirit::tree_parse_info<
133 std::string::const_iterator,
134 boost_spirit::node_val_data_factory<NekDouble>
136 typedef boost_spirit::tree_match<
137 std::string::const_iterator,
138 boost_spirit::node_val_data_factory<NekDouble>
228 const int AnalyticExpression_id,
239 const int AnalyticExpression_id,
240 std::vector<NekDouble> point);
244 const int expression_id,
256 const int expression_id,
296 const ParsedTreeIterator& root,
297 ExecutionStack& stack,
326 for (std::vector<std::string>::const_iterator it = vars.begin(); it != vars.end(); it++)
352 template <
typename ScannerT>
361 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<constantID> >
constant;
362 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<numberID> >
number;
363 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<variableID> >
variable;
364 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<parameterID> >
parameter;
365 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<functionID> >
function;
366 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<factorID> >
factor;
367 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
exponential;
368 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
mult_div;
369 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
add_sub;
370 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
lt_gt;
371 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
equality;
372 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
logical_and;
373 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
logical_or;
374 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
expression;
375 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
op;
377 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
const&
466 typedef std::vector<NekDouble>&
vr;
467 typedef const std::vector<NekDouble>&
cvr;
468 typedef const int ci;
469 typedef RandomGeneratorType&
rgt;
472 template<
typename StepType>
475 return (
new StepType ( m_generator,m_state,m_constant,m_parameter,m_variable,dest,src_left,src_right ) );
506 rng(rn), state(s), consts(c), params(p), vars(v), storeIdx(i), argIdx1(l), argIdx2(r) {};
516 CopyState(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
522 StoreConst(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
528 StoreVar(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
534 StorePrm(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
540 EvalSum(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
546 EvalSub(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
552 EvalMul(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
558 EvalDiv(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
564 EvalPow(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
570 EvalNeg(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
576 EvalLogicalEqual(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
582 EvalLogicalLeq(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
588 EvalLogicalLess(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
594 EvalLogicalGeq(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
595 virtual void run_many(ci n) {
for(
int i=0;i<n;i++) state[storeIdx*n+i] = ( state[argIdx1*n+i] >=
state[
argIdx2*n+i] ); }
600 EvalLogicalGreater(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
601 virtual void run_many(ci n) {
for(
int i=0;i<n;i++) state[storeIdx*n+i] = ( state[argIdx1*n+i] >
state[
argIdx2*n+i] ); }
606 EvalAbs(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
612 EvalSign(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
613 virtual void run_many(ci n) {
for(
int i=0;i<n;i++) state[storeIdx*n+i] = ((state[argIdx1*n+i] > 0.0) - (
state[
argIdx1*n+i] < 0.0)); }
618 EvalAsin(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
624 EvalAcos(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
630 EvalAtan(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
636 EvalAtan2(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
642 EvalAng(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
648 EvalCeil(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
654 EvalCos(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
660 EvalCosh(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
666 EvalExp(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
672 EvalFabs(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
678 EvalFloor(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
684 EvalLog(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
690 EvalLog10(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
696 EvalRad(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
702 EvalSin(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
708 EvalSinh(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
714 EvalSqrt(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
720 EvalTan(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
726 EvalTanh(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
732 EvalAWGN(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r):
EvaluationStep(rn,i,l,r,s,c,p,v) {}
736 boost::variate_generator<RandomGeneratorType&, boost::normal_distribution<> >
742 boost::variate_generator<RandomGeneratorType&, boost::normal_distribution<> >
752 #endif // _ANALYTIC_EXPRESSION_EVALUATOR_HPP
static NekDouble ang(NekDouble x, NekDouble y)
EvalLogicalGreater(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
NekDouble GetTime() const
Returns the total time spent in evaluation procedures, seconds.
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< operatorID > > logical_or
std::vector< NekDouble > & vr
Short names to minimise the infractructural code mess in defining functors below. ...
void AddConstants(std::map< std::string, NekDouble > const &constants)
Constants are evaluated and inserted into the function at the time it is parsed when calling the Defi...
FunctionNameMap m_functionMapNameToInstanceType
Function objects (functors)
boost_spirit::tree_parse_info< std::string::const_iterator, boost_spirit::node_val_data_factory< NekDouble > > ParsedTreeInfo
static const int constantID
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
std::map< std::string, int > ExpressionMap
ExpressionMap m_parsedMapExprToExecStackId
These vector and map store pre-processed evaluation sequences for the analytic expressions. Each ExecutionStack is an ordered container of steps of sequential execution process which evaluates an analytic expression.
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< operatorID > > exponential
EvalTanh(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
EvalLogicalLess(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
StorePrm(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
EvalSinh(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< operatorID > > const & start() const
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
NekDouble m_total_eval_time
std::vector< VariableMap > m_stackVariableMap
Keeping map of variables individually per each analytic expression allows correctly handling expressi...
AnalyticExpression(const boost_spirit::symbols< NekDouble > *constants, const std::vector< std::string > &variables)
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< operatorID > > op
std::vector< NekDouble > m_parameter
EvalLog(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
void SetParameter(std::string const &name, NekDouble value)
This function behaves in the same way as SetParameters, but it only adds one parameter and it does no...
std::vector< const Array< OneD, const NekDouble > * > VariableArray
std::map< std::string, int > VariableMap
EvalFloor(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
int AddConstant(std::string const &name, NekDouble value)
This function behaves in the same way as AddConstants, but it only adds one constant at a time...
static const int parameterID
static const int variableID
EvalExp(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
StoreConst(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
EvalCos(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< parameterID > > parameter
EvalAsin(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
EvaluationStep * makeStep(ci dest, ci src_left=0, ci src_right=0)
Factory method which makes code little less messy.
NekDouble Evaluate(const int AnalyticExpression_id)
Evaluation method for expressions depending on parameters only.
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
std::vector< NekDouble > m_state
This vector stores the execution state (memory) used by the sequential execution process.
rgt rng
reference to random number generator
EvalRad(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
definition(AnalyticExpression const &self)
EvalNeg(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
EvalTan(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
boost_spirit::symbols< NekDouble > m_constantsParser
EvalAbs(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
RandomGeneratorType m_generator
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
std::map< int, TwoArgFunc > m_function2
AnalyticExpressionEvaluator(void)
Initializes the evaluator to a state where it is ready to accept input from the DefineFunction functi...
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
NekDouble EvaluateAtPoint(const int AnalyticExpression_id, std::vector< NekDouble > point)
Evaluation method for expressions depending on unspecified number of variables. This suitable for exp...
EvalDiv(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
std::map< std::string, int > ParameterMap
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
EvalAtan2(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
void SetRandomSeed(unsigned int seed=123u)
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< operatorID > > mult_div
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
Nektar::LibUtilities::AnalyticExpressionEvaluator::AnalyticExpression::variables variables_p
PrecomputedValue PrepareExecutionAsYouParse(const ParsedTreeIterator &root, ExecutionStack &stack, VariableMap &varMap, int stateIndex)
This method prepares the execution stack (an ordered sequence of operators that perform the evaluatio...
std::map< std::string, int > ConstantMap
NekDouble GetConstant(std::string const &name)
If a constant with the specified name exists, it returns the NekDouble value that the constant stores...
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
int m_state_size
This counter is used by PrepareExecutionAsYouParse for finding the minimal state size necessary for e...
virtual ~EvaluationStep()
ParameterMap m_parameterMapNameToId
The following data structures hold input data to be used on evaluation stage. There are three types o...
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
EvalCosh(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< constantID > > constant
variables(std::vector< std::string > const &vars)
StoreVar(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
virtual void run_many(ci n)=0
declaring this guy pure virtual shortens virtual table. It saves some execution time.
#define LIB_UTILITIES_EXPORT
EvalAWGN(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< variableID > > variable
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
static const int functionID
RandomGeneratorType & rgt
EvalAcos(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
std::map< std::string, int > FunctionNameMap
const boost_spirit::symbols< NekDouble > * constants_p
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
EvalLogicalEqual(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
EvalPow(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< operatorID > > equality
EvalMul(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
This class defines evaluator of analytic (symbolic) mathematical expressions. Expressions are allowed...
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< factorID > > factor
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< operatorID > > expression
std::map< int, OneArgFunc > m_function
EvalFabs(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
Timer m_timer
Timer and sum of evaluation times.
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
static const int operatorID
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
static const int factorID
NekDouble(* TwoArgFunc)(NekDouble, NekDouble)
std::vector< NekDouble > m_variable
static NekDouble rad(NekDouble x, NekDouble y)
EvalCeil(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
std::pair< bool, NekDouble > PrecomputedValue
int DefineFunction(const std::string &vlist, const std::string &function)
This function allows one to define a function to evaluate. The first argument (vlist) is a list of va...
std::vector< ExecutionStack > m_executionStack
virtual void run_once()=0
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< numberID > > number
EvalSin(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
EvalLog10(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
std::vector< int > m_state_sizes
Vector of state sizes per each.
std::vector< EvaluationStep * > ExecutionStack
EvalLogicalLeq(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
EvalAng(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
std::vector< NekDouble > m_constant
NekDouble GetParameter(std::string const &name)
If a parameter with the specified name exists, it returns the NekDouble value that the parameter stor...
EvalSub(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
EvalSum(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
const std::vector< NekDouble > & cvr
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
EvalAtan(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
EvalSign(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
EvalLogicalGeq(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< operatorID > > add_sub
CopyState(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
~AnalyticExpressionEvaluator(void)
Destroys the execution stack.
boost_spirit::tree_match< std::string::const_iterator, boost_spirit::node_val_data_factory< NekDouble > >::tree_iterator ParsedTreeIterator
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
EvaluationStep(rgt rn, ci i, ci l, ci r, vr s, cvr c, cvr p, cvr v)
vr state
references to arrays holding the common state
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
ConstantMap m_constantMapNameToId
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< operatorID > > logical_and
void SetParameters(std::map< std::string, NekDouble > const ¶ms)
Parameters are like constants, but they are inserted into the function at the time Evaluate is called...
EvalSqrt(rgt rn, vr s, cvr c, cvr p, cvr v, ci i, ci l, ci r)
boost::mt19937 RandomGeneratorType
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
static const int numberID
NekDouble(* OneArgFunc)(NekDouble)
VariableMap m_expressionVariableMap
boost_spirit::rule< ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag< operatorID > > lt_gt
ci storeIdx
indices in the above arrays uniquely defining actual command arguments
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.