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 #include <boost/math/special_functions/bessel.hpp>
50 #define BOOST_SPIRIT_THREADSAFE
51 #if( BOOST_VERSION / 100 % 1000 >= 36 )
52 #include <boost/spirit/include/classic_core.hpp>
53 #include <boost/spirit/include/classic_ast.hpp>
54 #include <boost/spirit/include/classic_symbols.hpp>
55 #include <boost/spirit/include/classic_assign_actor.hpp>
56 #include <boost/spirit/include/classic_push_back_actor.hpp>
60 #include <boost/spirit/core.hpp>
61 #include <boost/spirit/tree/ast.hpp>
62 #include <boost/spirit/symbols/symbols.hpp>
63 #include <boost/spirit/actor/assign_actor.hpp>
64 #include <boost/spirit/actor/push_back_actor.hpp>
72 #if defined(__INTEL_COMPILER)
80 namespace LibUtilities
84 if (x != 0. || y != 0.)
85 return sqrt (x*x + y*y);
93 if ((x != 0.) || (y != 0.))
134 typedef boost_spirit::tree_parse_info<
135 std::string::const_iterator,
136 boost_spirit::node_val_data_factory<NekDouble>
138 typedef boost_spirit::tree_match<
139 std::string::const_iterator,
140 boost_spirit::node_val_data_factory<NekDouble>
230 const int AnalyticExpression_id,
241 const int AnalyticExpression_id,
242 std::vector<NekDouble>
point);
246 const int expression_id,
258 const int expression_id,
298 const ParsedTreeIterator& root,
299 ExecutionStack& stack,
328 for (std::vector<std::string>::const_iterator it = vars.begin(); it != vars.end(); it++)
354 template <
typename ScannerT>
363 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<constantID> >
constant;
364 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<numberID> >
number;
365 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<variableID> >
variable;
366 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<parameterID> >
parameter;
367 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<functionID> >
function;
368 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<factorID> >
factor;
369 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
exponential;
370 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
mult_div;
371 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
add_sub;
372 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
lt_gt;
373 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
equality;
374 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
logical_and;
375 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
logical_or;
376 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
expression;
377 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
op;
379 boost_spirit::rule<ScannerT, boost_spirit::parser_context<>, boost_spirit::parser_tag<operatorID> >
const&
467 typedef std::vector<NekDouble>&
vr;
468 typedef const std::vector<NekDouble>&
cvr;
469 typedef const int ci;
470 typedef RandomGeneratorType&
rgt;
473 template<
typename StepType>
476 return (
new StepType ( m_generator,m_state,m_constant,m_parameter,m_variable,dest,src_left,src_right ) );
507 rng(rn), state(s), consts(c), params(p), vars(v), storeIdx(i), argIdx1(l), argIdx2(r) {};
517 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) {}
523 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) {}
529 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) {}
535 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) {}
541 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) {}
547 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) {}
553 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) {}
559 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) {}
565 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) {}
571 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) {}
577 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) {}
583 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) {}
589 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) {}
595 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) {}
596 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] ); }
601 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) {}
602 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] ); }
607 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) {}
613 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) {}
614 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)); }
619 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) {}
625 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) {}
631 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) {}
637 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) {}
643 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) {}
649 EvalBessel(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) {}
655 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) {}
661 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) {}
667 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) {}
673 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) {}
679 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) {}
685 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) {}
691 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) {}
697 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) {}
703 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) {}
709 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) {}
715 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) {}
721 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) {}
727 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) {}
733 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) {}
739 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) {}
743 boost::variate_generator<RandomGeneratorType&, boost::normal_distribution<> >
749 boost::variate_generator<RandomGeneratorType&, boost::normal_distribution<> >
759 #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.
EvalBessel(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.
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)
virtual void run_many(ci n)
declaring this guy pure virtual shortens virtual table. It saves some execution time.
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
bg::model::point< double, 3, bg::cs::cartesian > point
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
#define dest(otri, vertexptr)
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.