Concrete implementation of the interface defined in Interpreter. More...

Classes
class	AnalyticExpression

struct	CopyState

struct	EvalAbs

struct	EvalAcos

struct	EvalAng

struct	EvalAsin

struct	EvalAtan

struct	EvalAtan2

struct	EvalAWGN

struct	EvalBessel

struct	EvalCeil

struct	EvalCos

struct	EvalCosh

struct	EvalDiv

struct	EvalExp

struct	EvalFabs

struct	EvalFloor

struct	EvalFmod

struct	EvalLog

struct	EvalLog10

struct	EvalLogicalEqual

struct	EvalLogicalGeq

struct	EvalLogicalGreater

struct	EvalLogicalLeq

struct	EvalLogicalLess

struct	EvalMax

struct	EvalMin

struct	EvalMod

struct	EvalMul

struct	EvalNeg

struct	EvalPow

struct	EvalRad

struct	EvalSign

struct	EvalSin

struct	EvalSinh

struct	EvalSqrt

struct	EvalSub

struct	EvalSum

struct	EvalTan

struct	EvalTanh

struct	EvaluationStep
	Function objects (functors) More...

struct	StoreConst

struct	StorePrm

struct	StoreVar

Public Types
typedef std::map< std::string, int >	VariableMap

typedef std::map< std::string, int >	ConstantMap

typedef std::map< std::string, int >	ParameterMap

typedef std::map< std::string, int >	ExpressionMap

typedef std::map< std::string, int >	FunctionNameMap

typedef std::vector< EvaluationStep * >	ExecutionStack

typedef std::pair< bool, NekDouble >	PrecomputedValue

typedef NekDouble(*	OneArgFunc) (NekDouble)

typedef NekDouble(*	TwoArgFunc) (NekDouble, NekDouble)

typedef bsp::tree_parse_info< std::string::const_iterator, bsp::node_val_data_factory< NekDouble > >	ParsedTreeInfo

typedef bsp::tree_match< std::string::const_iterator, bsp::node_val_data_factory< NekDouble > >::tree_iterator	ParsedTreeIterator

typedef std::vector< const Array< OneD, const NekDouble > * >	VariableArray

Public Member Functions
	ExpressionEvaluator ()
	Initializes the evaluator. More...

	~ExpressionEvaluator (void)
	Destructor that removes all entries from the execution stack. More...

void	SetRandomSeed (unsigned int seed)
	Sets the random seed for the pseudorandom number generator. More...

void	AddConstants (std::map< std::string, NekDouble > const &constants)
	Set constants to be evaluated. More...

int	AddConstant (std::string const &name, NekDouble value)
	Set constants to be evaluated. More...

NekDouble	GetConstant (std::string const &name)
	Return the value of a constant. More...

void	SetParameters (std::map< std::string, NekDouble > const &params)
	Set parameter values. More...

void	SetParameter (std::string const &name, NekDouble value)
	Set parameter values. More...

NekDouble	GetParameter (std::string const &name)
	Get the value of a parameter. More...

NekDouble	GetTime () const
	Returns the total walltime spent in evaluation procedures in seconds. More...

int	DefineFunction (const std::string &vlist, const std::string &expr)
	Defines a function for the purposes of evaluation. More...

NekDouble	Evaluate (const int id)
	Evaluate a function which depends only on constants and/or parameters. More...

NekDouble	Evaluate (const int id, const NekDouble x, const NekDouble y, const NekDouble z, const NekDouble t)
	Evaluate a function which depends only on constants and/or parameters. More...

NekDouble	EvaluateAtPoint (const int id, const std::vector< NekDouble > point)
	Evaluate a function which depends on zero or more variables. More...

void	Evaluate (const int id, const Array< OneD, const NekDouble > &x, const Array< OneD, const NekDouble > &y, const Array< OneD, const NekDouble > &z, const Array< OneD, const NekDouble > &t, Array< OneD, NekDouble > &result)
	Evaluate a function which depends only on constants and/or parameters. More...

void	Evaluate (const int id, const std::vector< Array< OneD, const NekDouble > > &points, Array< OneD, NekDouble > &result)
	Evaluate a function which depends only on constants and/or parameters. More...

PrecomputedValue	PrepareExecutionAsYouParse (const ParsedTreeIterator &location, ExecutionStack &stack, VariableMap &variableMap, int stateIndex)
	Prepares an execution stack for the evaluation of a function. More...

Public Attributes
bsp::symbols< NekDouble >	m_constantsParser

Private Types
enum	EvaluationStepType { E_ABS , E_ASIN , E_ACOS , E_ATAN , E_ATAN2 , E_ANG , E_CEIL , E_COS , E_COSH , E_EXP , E_FABS , E_FLOOR , E_FMOD , E_LOG , E_LOG10 , E_MAX , E_MIN , E_POW , E_RAD , E_SIN , E_SINH , E_SQRT , E_TAN , E_TANH , E_SIGN , E_AWGN , E_BESSEL }

typedef std::vector< NekDouble > &	vr
	Short names to minimise the infractructural code mess in defining functors below. More...

typedef const std::vector< NekDouble > &	cvr

typedef const int	ci

typedef std::mt19937 &	rgt

Private Member Functions
template<typename StepType >
EvaluationStep *	makeStep (ci dest, ci src_left=0, ci src_right=0)
	Factory method which makes code little less messy. More...

Private Attributes
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. More...

std::vector< ExecutionStack >	m_executionStack

std::vector< VariableMap >	m_stackVariableMap
	Keeping map of variables individually per each analytic expression allows correctly handling expressions which depend on different number of variables. More...

ParameterMap	m_parameterMapNameToId
	The following data structures hold input data to be used on evaluation stage. There are three types of input data: More...

ConstantMap	m_constantMapNameToId

VariableMap	m_expressionVariableMap

std::vector< NekDouble >	m_parameter

std::vector< NekDouble >	m_constant

std::vector< NekDouble >	m_variable

std::vector< NekDouble >	m_state
	This vector stores the execution state (memory) used by the sequential execution process. More...

std::vector< int >	m_state_sizes
	Vector of state sizes per each. More...

int	m_state_size
	This counter is used by PrepareExecutionAsYouParse for finding the minimal state size necessary for evaluation of function parsed. More...

Timer	m_timer
	Timer and sum of evaluation times. More...

NekDouble	m_total_eval_time

std::mt19937	m_generator

FunctionNameMap	m_functionMapNameToInstanceType

std::map< int, OneArgFunc >	m_function

std::map< int, TwoArgFunc >	m_function2

Detailed Description

Concrete implementation of the interface defined in Interpreter.

Definition at line 156 of file Interpreter/Interpreter.cpp.

Member Typedef Documentation

◆ ci

typedef const int Nektar::LibUtilities::Interpreter::ExpressionEvaluator::ci

private

Definition at line 1327 of file Interpreter/Interpreter.cpp.

◆ ConstantMap

typedef std::map<std::string, int> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::ConstantMap

Definition at line 163 of file Interpreter/Interpreter.cpp.

◆ cvr

typedef const std::vector<NekDouble>& Nektar::LibUtilities::Interpreter::ExpressionEvaluator::cvr

private

Definition at line 1326 of file Interpreter/Interpreter.cpp.

◆ ExecutionStack

typedef std::vector<EvaluationStep *> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::ExecutionStack

Definition at line 167 of file Interpreter/Interpreter.cpp.

◆ ExpressionMap

typedef std::map<std::string, int> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::ExpressionMap

Definition at line 165 of file Interpreter/Interpreter.cpp.

◆ FunctionNameMap

typedef std::map<std::string, int> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::FunctionNameMap

Definition at line 166 of file Interpreter/Interpreter.cpp.

◆ OneArgFunc

typedef NekDouble(* Nektar::LibUtilities::Interpreter::ExpressionEvaluator::OneArgFunc) (NekDouble)

Definition at line 169 of file Interpreter/Interpreter.cpp.

◆ ParameterMap

typedef std::map<std::string, int> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::ParameterMap

Definition at line 164 of file Interpreter/Interpreter.cpp.

◆ ParsedTreeInfo

typedef bsp::tree_parse_info<std::string::const_iterator, bsp::node_val_data_factory<NekDouble> > Nektar::LibUtilities::Interpreter::ExpressionEvaluator::ParsedTreeInfo

Definition at line 174 of file Interpreter/Interpreter.cpp.

◆ ParsedTreeIterator

typedef bsp::tree_match<std::string::const_iterator,bsp::node_val_data_factory<NekDouble>>::tree_iterator Nektar::LibUtilities::Interpreter::ExpressionEvaluator::ParsedTreeIterator

Definition at line 177 of file Interpreter/Interpreter.cpp.

◆ PrecomputedValue

typedef std::pair<bool, NekDouble> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::PrecomputedValue

Definition at line 168 of file Interpreter/Interpreter.cpp.

◆ rgt

typedef std::mt19937& Nektar::LibUtilities::Interpreter::ExpressionEvaluator::rgt

private

Definition at line 1328 of file Interpreter/Interpreter.cpp.

◆ TwoArgFunc

typedef NekDouble(* Nektar::LibUtilities::Interpreter::ExpressionEvaluator::TwoArgFunc) (NekDouble, NekDouble)

Definition at line 170 of file Interpreter/Interpreter.cpp.

◆ VariableArray

typedef std::vector<const Array<OneD, const NekDouble> *> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::VariableArray

Definition at line 179 of file Interpreter/Interpreter.cpp.

◆ VariableMap

typedef std::map<std::string, int> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::VariableMap

Definition at line 162 of file Interpreter/Interpreter.cpp.

◆ vr

typedef std::vector<NekDouble>& Nektar::LibUtilities::Interpreter::ExpressionEvaluator::vr

private

Short names to minimise the infractructural code mess in defining functors below.

Definition at line 1325 of file Interpreter/Interpreter.cpp.

Member Enumeration Documentation

◆ EvaluationStepType

enum Nektar::LibUtilities::Interpreter::ExpressionEvaluator::EvaluationStepType

private

Enumerator
E_ABS
E_ASIN
E_ACOS
E_ATAN
E_ATAN2
E_ANG
E_CEIL
E_COS
E_COSH
E_EXP
E_FABS
E_FLOOR
E_FMOD
E_LOG
E_LOG10
E_MAX
E_MIN
E_POW
E_RAD
E_SIN
E_SINH
E_SQRT
E_TAN
E_TANH
E_SIGN
E_AWGN
E_BESSEL

Definition at line 1338 of file Interpreter/Interpreter.cpp.

    {
        E_ABS,
        E_ASIN,
        E_ACOS,
        E_ATAN,
        E_ATAN2,
        E_ANG,
        E_CEIL,
        E_COS,
        E_COSH,
        E_EXP,
        E_FABS,
        E_FLOOR,
        E_FMOD,
        E_LOG,
        E_LOG10,
        E_MAX,
        E_MIN,
        E_POW,
        E_RAD,
        E_SIN,
        E_SINH,
        E_SQRT,
        E_TAN,
        E_TANH,
        E_SIGN,
        E_AWGN,
        E_BESSEL
    };

Constructor & Destructor Documentation

◆ ExpressionEvaluator()

Nektar::LibUtilities::Interpreter::ExpressionEvaluator::ExpressionEvaluator ( )

inline

Initializes the evaluator.

This routine will initialize the evaluator with some basic default constants,

Definition at line 187 of file Interpreter/Interpreter.cpp.

                          : m_timer(), m_total_eval_time(0)
    {
        m_state_size = 1;
 
        // Constant definitions.
        AddConstant("MEANINGLESS", 0.0);
        AddConstant("E", M_E);                        // Natural logarithm
        AddConstant("LOG2E", M_LOG2E);                // log_2 e
        AddConstant("LOG10E", M_LOG10E);              // log_10 e
        AddConstant("LN2", M_LN2);                    // log_e 2
        AddConstant("LN10", M_LN10);                  // log_e 10
        AddConstant("PI", M_PI);                      // pi
        AddConstant("PI_2", M_PI_2);                  // pi/2
        AddConstant("PI_4", M_PI_4);                  // pi/4
        AddConstant("1_PI", M_1_PI);                  // 1/pi
        AddConstant("2_PI", M_2_PI);                  // 2/pi
        AddConstant("2_SQRTPI", M_2_SQRTPI);          // 2/sqrt(pi)
        AddConstant("SQRT2", M_SQRT2);                // sqrt(2)
        AddConstant("SQRT1_2", M_SQRT1_2);            // 1/sqrt(2)
        AddConstant("GAMMA", 0.57721566490153286060); // Euler
        AddConstant("DEG", 57.2957795130823208768);   // deg/radian
        AddConstant("PHI", 1.61803398874989484820);   // golden ratio
 
        // Function definitions.
        m_functionMapNameToInstanceType["abs"]    = E_ABS;
        m_functionMapNameToInstanceType["asin"]   = E_ASIN;
        m_functionMapNameToInstanceType["acos"]   = E_ACOS;
        m_functionMapNameToInstanceType["atan"]   = E_ATAN;
        m_functionMapNameToInstanceType["atan2"]  = E_ATAN2;
        m_functionMapNameToInstanceType["ang"]    = E_ANG;
        m_functionMapNameToInstanceType["bessel"] = E_BESSEL;
        m_functionMapNameToInstanceType["ceil"]   = E_CEIL;
        m_functionMapNameToInstanceType["cos"]    = E_COS;
        m_functionMapNameToInstanceType["cosh"]   = E_COSH;
        m_functionMapNameToInstanceType["exp"]    = E_EXP;
        m_functionMapNameToInstanceType["fabs"]   = E_FABS;
        m_functionMapNameToInstanceType["floor"]  = E_FLOOR;
        m_functionMapNameToInstanceType["fmax"]   = E_MAX;
        m_functionMapNameToInstanceType["fmin"]   = E_MIN;
        m_functionMapNameToInstanceType["fmod"]   = E_FMOD;
        m_functionMapNameToInstanceType["log"]    = E_LOG;
        m_functionMapNameToInstanceType["log10"]  = E_LOG10;
        m_functionMapNameToInstanceType["max"]    = E_MAX;
        m_functionMapNameToInstanceType["min"]    = E_MIN;
        m_functionMapNameToInstanceType["rad"]    = E_RAD;
        m_functionMapNameToInstanceType["sin"]    = E_SIN;
        m_functionMapNameToInstanceType["sinh"]   = E_SINH;
        m_functionMapNameToInstanceType["sqrt"]   = E_SQRT;
        m_functionMapNameToInstanceType["tan"]    = E_TAN;
        m_functionMapNameToInstanceType["tanh"]   = E_TANH;
        m_functionMapNameToInstanceType["sign"]   = E_SIGN;
        m_functionMapNameToInstanceType["awgn"]   = E_AWGN;
 
        m_function[E_ABS]     = std::abs;
        m_function[E_ASIN]    = asin;
        m_function[E_ACOS]    = acos;
        m_function[E_ATAN]    = atan;
        m_function[E_CEIL]    = ceil;
        m_function[E_COS]     = cos;
        m_function[E_COSH]    = cosh;
        m_function[E_EXP]     = exp;
        m_function[E_FABS]    = fabs;
        m_function[E_FLOOR]   = floor;
        m_function[E_LOG]     = log;
        m_function[E_LOG10]   = log10;
        m_function2[E_MAX]    = fmax;
        m_function2[E_MIN]    = fmin;
        m_function[E_SIN]     = sin;
        m_function[E_SINH]    = sinh;
        m_function[E_SQRT]    = sqrt;
        m_function[E_TAN]     = tan;
        m_function[E_TANH]    = tanh;
        m_function[E_SIGN]    = sign;
        m_function2[E_ATAN2]  = atan2;
        m_function2[E_ANG]    = ang;
        m_function2[E_RAD]    = rad;
        m_function2[E_BESSEL] = boost::math::cyl_bessel_j;
        m_function2[E_FMOD]   = static_cast<double (*)(double, double)>(&fmod);
 
        // Note that there is no entry in m_function that corresponds to the
        // awgn function. This is intentional as this function need not be
        // pre-evaluated once!
    }

References tinysimd::abs(), AddConstant(), Nektar::LibUtilities::ang(), E_ABS, E_ACOS, E_ANG, E_ASIN, E_ATAN, E_ATAN2, E_AWGN, E_BESSEL, E_CEIL, E_COS, E_COSH, E_EXP, E_FABS, E_FLOOR, E_FMOD, E_LOG, E_LOG10, E_MAX, E_MIN, E_RAD, E_SIGN, E_SIN, E_SINH, E_SQRT, E_TAN, E_TANH, tinysimd::log(), m_function, m_function2, m_functionMapNameToInstanceType, m_state_size, Nektar::LibUtilities::rad(), Nektar::LibUtilities::sign(), and tinysimd::sqrt().

◆ ~ExpressionEvaluator()

Nektar::LibUtilities::Interpreter::ExpressionEvaluator::~ExpressionEvaluator ( void )

inline

Destructor that removes all entries from the execution stack.

Definition at line 274 of file Interpreter/Interpreter.cpp.

    {
        for (auto &it_es : m_executionStack)
        {
            for (auto &it : it_es)
            {
                delete it;
            }
            it_es.clear();
        }
        m_executionStack.clear();
    }

References m_executionStack.

Member Function Documentation

◆ AddConstant()

int Nektar::LibUtilities::Interpreter::ExpressionEvaluator::AddConstant	(	std::string const &	name,
		NekDouble	value
	)

inline

Set constants to be evaluated.

This function behaves in the same way as AddConstants, but it only adds one constant at a time. If the constant existed previously, an exception will be thrown stating the fact. If it did not exist previously, it will be added to the global constants and will be used the next time DefineFunction is called.

Returns: Total number of constants after this one has been added.

Definition at line 309 of file Interpreter/Interpreter.cpp.

    {
        ConstantMap::const_iterator it = m_constantMapNameToId.find(name);
        if (it == m_constantMapNameToId.end())
        {
            // We are trying to avoid duplicating entries in m_constantParser
            // and m_constants.
            m_constantsParser.add(name.c_str(), value);
            int index                   = m_constant.size();
            m_constantMapNameToId[name] = index;
            m_constant.push_back(value);
            return index;
        }
        else
        {
            if (m_constant[it->second] != value)
            {
                std::string errormsg =
                    "Attempt to add numerically different constants under the "
                    "same name: " +
                    name;
                std::cout << errormsg << std::endl;
            }
        }
        return it->second;
    }

References m_constant, m_constantMapNameToId, m_constantsParser, and CellMLToNektar.pycml::name.

Referenced by AddConstants(), DefineFunction(), ExpressionEvaluator(), and PrepareExecutionAsYouParse().

◆ AddConstants()

void Nektar::LibUtilities::Interpreter::ExpressionEvaluator::AddConstants ( std::map< std::string, NekDouble > const & constants )

inline

Set constants to be evaluated.

Constants are evaluated and inserted into the function at the time it is parsed when calling the DefineFunction function. After parsing, if a constant is changed, it will not be reflected in the function when Evaluate is called. This also means that if a function with an unknown constant is added, and then the constant is added, the function will not see the added constant and through an exception.

This function will add all of the constants in the constants parameter to the global internal constants. If a constant was already loaded previously, it will throw an exception stating which constants in the map had this issue. It will add all of the constants it can from constants and output the constants it couldn't add in the string exception.

Parameters

constants A std::map with string names for the constants (which will be evalauted in the expression) and their NekDouble value.

Definition at line 298 of file Interpreter/Interpreter.cpp.

    {
        for (auto const &it : constants)
        {
            AddConstant(it.first, it.second);
        }
    }

References AddConstant().

◆ DefineFunction()

int Nektar::LibUtilities::Interpreter::ExpressionEvaluator::DefineFunction	(	const std::string &	vlist,
		const std::string &	expr
	)

inline

Defines a function for the purposes of evaluation.

This function allows one to define a function to evaluate. The vlist argument should define a list of space-separated variables that the expression defined in function is dependent upon. For example, if function is defined as the string x + y, then vlist should most likely be x y, unless you are defining x or y as parameters with the SetParameters function.

Parameters

vlist	List of variable names separated with spaces.
expr	String definition of the function to be evaluated.

Returns: An integer denoting the unique ID of this function. This should be passed into Evaluate functions for later evaluation.

Definition at line 397 of file Interpreter/Interpreter.cpp.

    {
        // If we have previously parsed an identical expression, return its ID.
        auto it = m_parsedMapExprToExecStackId.find(expr);
        if (it != m_parsedMapExprToExecStackId.end())
        {
            // If this function is already defined, don't do anything but return
            // its ID.
            return it->second;
        }
 
        // Otherwise, prepare an iterator that allows to walk along the string
        // representing an analytic expression in the order that respects its
        // recursive structure (thanks to boost::spirit).
 
        // Parse the vlist input and separate the variables into ordered entries
        // in a vector<string> object. These need to be ordered because this is
        // the order the variables will get assigned to in the Map when
        // Evaluate(...)  is called.
        std::vector<std::string> variableNames;
        bsp::parse((char *)vlist.c_str(),
                   (*bsp::space_p >>
                    *(+(+bsp::graph_p)[bsp::push_back_a(variableNames)] >>
                      +bsp::space_p)));
 
        // Set up our grammar.
        AnalyticExpression myGrammar(&m_constantsParser, variableNames);
 
        // Do the actual parsing with boost::spirit and alert the user if there
        // was an error with an exception.
        ParsedTreeInfo parseInfo =
            bsp::ast_parse<bsp::node_val_data_factory<NekDouble>,
                           std::string::const_iterator, AnalyticExpression,
                           bsp::space_parser>(expr.begin(), expr.end(),
                                              myGrammar, bsp::space_p);
 
        ASSERTL1(parseInfo.full != false,
                 "Unable to fully parse function. Stopped just before: " +
                     std::string(parseInfo.stop, parseInfo.stop + 15));
 
        if (!parseInfo.full)
        {
            throw std::runtime_error(
                "Unable to fully parse function at: " +
                std::string(parseInfo.stop, parseInfo.stop + 15));
        }
 
        // ----------------------------------------------
        // Data parsed, start setting up internal data structures.
        // ----------------------------------------------
 
        ExecutionStack stack;
        VariableMap variableMap;
 
        int stackId  = m_executionStack.size();
        m_state_size = 1;
 
        // Register all variables declared in the expression
        for (int i = 0; i < variableNames.size(); i++)
        {
            variableMap[variableNames[i]] = i;
        }
 
        // Then prepare an execution stack. This method also calculates a
        // length of internal state storage (m_state_size) for this function.
        PrecomputedValue v = PrepareExecutionAsYouParse(parseInfo.trees.begin(),
                                                        stack, variableMap, 0);
 
        // Constant expression, fully evaluated already.
        if (true == v.first)
        {
            ASSERTL1(stack.size() == 0,
                     "Constant expression yeilds non-empty execution stack. "
                     "Bug in PrepareExecutionAsYouParse()");
 
            int const_index = AddConstant(
                std::string("EXPRESSION_") + std::to_string(stackId), v.second);
            stack.push_back(makeStep<StoreConst>(0, const_index));
        }
 
        m_parsedMapExprToExecStackId[expr] = stackId;
 
        // The execution stack and its corresponding variable index map are two
        // parallel std::vectors that share their ids. This split helps to
        // achieve some performance improvement.
        m_executionStack.push_back(stack);
        m_stackVariableMap.push_back(variableMap);
        m_state_sizes.push_back(m_state_size);
 
        return stackId;
    }

References AddConstant(), ASSERTL1, m_constantsParser, m_executionStack, m_parsedMapExprToExecStackId, m_stackVariableMap, m_state_size, m_state_sizes, and PrepareExecutionAsYouParse().

◆ Evaluate() [1/4]

NekDouble Nektar::LibUtilities::Interpreter::ExpressionEvaluator::Evaluate ( const int id )

inline

Evaluate a function which depends only on constants and/or parameters.

Parameters

id	The ID returned from DefineFunction representing the function to be evaluated.

Definition at line 492 of file Interpreter/Interpreter.cpp.

    {
        m_timer.Start();
 
        ASSERTL1(m_executionStack.size() > id,
                 "unknown analytic expression, it must first be defined "
                 "with DefineFunction(...)");
 
        ExecutionStack &stack = m_executionStack[id];
 
        m_state.resize(m_state_sizes[id]);
        for (int i = 0; i < stack.size(); i++)
        {
            (*stack[i]).run_once();
        }
 
        m_timer.Stop();
        m_total_eval_time += m_timer.TimePerTest(1);
 
        return m_state[0];
    }

References ASSERTL1, m_executionStack, m_state, m_state_sizes, m_timer, m_total_eval_time, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Nektar::LibUtilities::Timer::TimePerTest().

Referenced by Evaluate().

◆ Evaluate() [2/4]

void Nektar::LibUtilities::Interpreter::ExpressionEvaluator::Evaluate	(	const int	id,
		const Array< OneD, const NekDouble > &	x,
		const Array< OneD, const NekDouble > &	y,
		const Array< OneD, const NekDouble > &	z,
		const Array< OneD, const NekDouble > &	t,
		Array< OneD, NekDouble > &	result
	)

inline

Evaluate a function which depends only on constants and/or parameters.

Parameters

id	The ID returned from DefineFunction representing the function to be evaluated.

Definition at line 599 of file Interpreter/Interpreter.cpp.

    {
        std::vector<Array<OneD, const NekDouble>> points = {x, y, z, t};
        Evaluate(id, points, result);
    }

References Evaluate(), and Nektar::UnitTests::z().

◆ Evaluate() [3/4]

NekDouble Nektar::LibUtilities::Interpreter::ExpressionEvaluator::Evaluate	(	const int	id,
		const NekDouble	x,
		const NekDouble	y,
		const NekDouble	z,
		const NekDouble	t
	)

inline

Evaluate a function which depends only on constants and/or parameters.

Parameters

id	The ID returned from DefineFunction representing the function to be evaluated.

Definition at line 517 of file Interpreter/Interpreter.cpp.

    {
        m_timer.Start();
 
        ASSERTL1(m_executionStack.size() > id,
                 "unknown analytic expression, it must first be defined with "
                 "DefineFunction(...)");
 
        ExecutionStack &stack = m_executionStack[id];
 
        // initialise internal vector of variable values
        m_state.resize(m_state_sizes[id]);
 
        if (m_variable.size() < 4)
        {
            m_variable.resize(4);
        }
 
        // no flexibility, no change of variable ordering in m_variable
        // container depending on their names ordering in the input vlist
        // argument of DefineFunction. Ordering convention (x,y,z,t) is assumed.
        m_variable[0] = x;
        m_variable[1] = y;
        m_variable[2] = z;
        m_variable[3] = t;
 
        // main execution cycle is hidden here
        for (int i = 0; i < stack.size(); i++)
        {
            (*stack[i]).run_once();
        }
 
        m_timer.Stop();
        m_total_eval_time += m_timer.TimePerTest(1);
 
        return m_state[0];
    }

References ASSERTL1, m_executionStack, m_state, m_state_sizes, m_timer, m_total_eval_time, m_variable, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), Nektar::LibUtilities::Timer::TimePerTest(), and Nektar::UnitTests::z().

◆ Evaluate() [4/4]

void Nektar::LibUtilities::Interpreter::ExpressionEvaluator::Evaluate	(	const int	id,
		const std::vector< Array< OneD, const NekDouble > > &	points,
		Array< OneD, NekDouble > &	result
	)

inline

Evaluate a function which depends only on constants and/or parameters.

Parameters

id	The ID returned from DefineFunction representing the function to be evaluated.

If number of points tends to 10^6, one may end up with up to ~0.5Gb data allocated for m_state only. Lets split the work into cache-sized chunks. Ahtung, magic constant!

Definition at line 612 of file Interpreter/Interpreter.cpp.

    {
        m_timer.Start();
 
        const int num_points = points[0].size();
        ASSERTL1(m_executionStack.size() > id,
                 "unknown analytic expression, it must first be defined "
                 "with DefineFunction(...)");
        ASSERTL1(result.size() >= num_points,
                 "destination array must have enough capacity to store "
                 "expression values at each given point");
 
        ExecutionStack &stack = m_executionStack[id];
 
        /// If number of points tends to 10^6, one may end up with up to ~0.5Gb
        /// data allocated for m_state only.  Lets split the work into
        /// cache-sized chunks.  Ahtung, magic constant!
        const int max_chunk_size = 1024;
        const int nvals          = points.size();
        const int chunk_size     = (std::min)(max_chunk_size, num_points);
 
        if (m_state.size() < chunk_size * m_state_sizes[id])
        {
            m_state.resize(m_state_sizes[id] * chunk_size, 0.0);
        }
        if (m_variable.size() < nvals * chunk_size)
        {
            m_variable.resize(nvals * chunk_size, 0.0);
        }
        if (result.size() < num_points)
        {
            result = Array<OneD, NekDouble>(num_points, 0.0);
        }
 
        int offset    = 0;
        int work_left = num_points;
        while (work_left > 0)
        {
            const int this_chunk_size = (std::min)(work_left, 1024);
            for (int i = 0; i < this_chunk_size; i++)
            {
                for (int j = 0; j < nvals; ++j)
                {
                    m_variable[i + this_chunk_size * j] = points[j][offset + i];
                }
            }
            for (int i = 0; i < stack.size(); i++)
            {
                (*stack[i]).run_many(this_chunk_size);
            }
            for (int i = 0; i < this_chunk_size; i++)
            {
                result[offset + i] = m_state[i];
            }
            work_left -= this_chunk_size;
            offset += this_chunk_size;
        }
        m_timer.Stop();
        m_total_eval_time += m_timer.TimePerTest(1);
    }

References ASSERTL1, m_executionStack, m_state, m_state_sizes, m_timer, m_total_eval_time, m_variable, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Nektar::LibUtilities::Timer::TimePerTest().

◆ EvaluateAtPoint()

NekDouble Nektar::LibUtilities::Interpreter::ExpressionEvaluator::EvaluateAtPoint	(	const int	id,
		const std::vector< NekDouble >	point
	)

inline

Evaluate a function which depends on zero or more variables.

This is suitable for expressions depending on more than 4 variables or for the dynamic setting of some variables as parameters (there is currently no interface method for removing a variable from parameter map however).

Parameters

id	The ID returned from DefineFunction representing the function to be evaluated.
point	A std::vector of points to be evaluated.

Definition at line 559 of file Interpreter/Interpreter.cpp.

    {
        m_timer.Start();
 
        ASSERTL1(m_executionStack.size() > id,
                 "unknown analytic expression, it must first be defined with "
                 "DefineFunction(...)");
 
        ExecutionStack &stack    = m_executionStack[id];
        VariableMap &variableMap = m_stackVariableMap[id];
 
        ASSERTL1(point.size() == variableMap.size(),
                 "The number of variables used to define this expression should"
                 " match the point dimensionality.");
 
        // initialise internal vector of variable values
        m_state.resize(m_state_sizes[id]);
        m_variable.resize(point.size());
        VariableMap::const_iterator it;
 
        for (it = variableMap.begin(); it != variableMap.end(); ++it)
        {
            m_variable[it->second] = point[it->second];
        }
 
        // main execution cycle is hidden here
        for (int i = 0; i < stack.size(); i++)
        {
            (*stack[i]).run_once();
        }
 
        m_timer.Stop();
        m_total_eval_time += m_timer.TimePerTest(1);
 
        return m_state[0];
    }

References ASSERTL1, m_executionStack, m_stackVariableMap, m_state, m_state_sizes, m_timer, m_total_eval_time, m_variable, Nektar::LibUtilities::Timer::Start(), Nektar::LibUtilities::Timer::Stop(), and Nektar::LibUtilities::Timer::TimePerTest().

◆ GetConstant()

NekDouble Nektar::LibUtilities::Interpreter::ExpressionEvaluator::GetConstant ( std::string const & name )

inline

Return the value of a constant.

If a constant with the specified name name exists, this function returns the NekDouble value that the constant stores. If the constant doesn't exist, this throws an exception.

Parameters

name	Name of constant to return.

Definition at line 339 of file Interpreter/Interpreter.cpp.

    {
        NekDouble *value = find(m_constantsParser, name.c_str());
        ASSERTL1(value != nullptr, "Constant variable not found: " + name);
        return *value;
    }

References ASSERTL1, Nektar::StdRegions::find(), m_constantsParser, and CellMLToNektar.pycml::name.

◆ GetParameter()

NekDouble Nektar::LibUtilities::Interpreter::ExpressionEvaluator::GetParameter ( std::string const & name )

inline

Get the value of a parameter.

If a parameter with the specified name exists, it returns the NekDouble value that the parameter stores. If the parameter doesn't exist, it throws an exception.

Parameters

name	Name of the parameter to query.

Definition at line 378 of file Interpreter/Interpreter.cpp.

    {
        ParameterMap::const_iterator it = m_parameterMapNameToId.find(name);
        ASSERTL1(it != m_parameterMapNameToId.end(),
                 "Parameter not found: " + name);
        return m_parameter[it->second];
    }

References ASSERTL1, m_parameter, m_parameterMapNameToId, and CellMLToNektar.pycml::name.

◆ GetTime()

NekDouble Nektar::LibUtilities::Interpreter::ExpressionEvaluator::GetTime ( ) const

inline

Returns the total walltime spent in evaluation procedures in seconds.

Definition at line 389 of file Interpreter/Interpreter.cpp.

    {
        return m_total_eval_time;
    }

References m_total_eval_time.

◆ makeStep()

template<typename StepType >

EvaluationStep * Nektar::LibUtilities::Interpreter::ExpressionEvaluator::makeStep	(	ci	dest,
		ci	src_left = `0`,
		ci	src_right = `0`
	)

inlineprivate

Factory method which makes code little less messy.

Definition at line 1332 of file Interpreter/Interpreter.cpp.

    {
        return (new StepType(m_generator, m_state, m_constant, m_parameter,
                             m_variable, dest, src_left, src_right));
    }

References m_constant, m_generator, m_parameter, m_state, and m_variable.

◆ PrepareExecutionAsYouParse()

PrecomputedValue Nektar::LibUtilities::Interpreter::ExpressionEvaluator::PrepareExecutionAsYouParse	(	const ParsedTreeIterator &	location,
		ExecutionStack &	stack,
		VariableMap &	variableMap,
		int	stateIndex
	)

inline

Prepares an execution stack for the evaluation of a function.

This method prepares the execution stack (an ordered sequence of operators that perform the evaluation) for the parsed evaluation tree. In order to do this, it unrolls the binary tree representing the recursive evaluation into an ordered sequence of commands. That ordered sequence of commands is equivalent to a bottom-up walk up the evaluation tree, but this allows not to form tree explicitly.

This approach requires to introduce explicitly an execution state (memory) shared by commands in the evaluation sequence: recursively dependent commands need to pass data between each other. Such state for the recursive evaluation is passed via return values of a recursive evaluation function — which is bad if one wants to implement vectorized evaluator.

On the other hand, to run through a sequential container of functors is faster than to walk the tree and at each node to check the node type.

Parameters

root	Iterator generated by boost::spirit.
stack	Initially empty sequential container of evaluation steps.
varMap	Maps variable names to their ids.
stateIndex	An index in the state[] array where an evaluation step corresponding to the current tree node is allowed to write.

Returns: A std::pair<bool, NekDouble> which encodes fully pre-evaluated NekDouble values as (true, value) if all sub-tree down the current node evaluates to constant, or flags the opposite via (false, 0).

Definition at line 712 of file Interpreter/Interpreter.cpp.

    {
        std::string valueStr(location->value.begin(), location->value.end());
        boost::algorithm::trim(valueStr);
 
        const bsp::parser_id parserID = location->value.id();
#if defined(NEKTAR_DEBUG) || defined(NEKTAR_FULLDEBUG)
        const int num_children = location->children.size();
#endif
 
        if (parserID == AnalyticExpression::constantID)
        {
            ASSERTL1(num_children == 0,
                     "Illegal children under constant node: " + valueStr);
 
            auto it = m_constantMapNameToId.find(valueStr);
            ASSERTL1(it != m_constantMapNameToId.end(),
                     "Cannot find the value for the specified constant: " +
                         valueStr);
 
            return std::make_pair(true, m_constant[it->second]);
        }
        else if (parserID == AnalyticExpression::numberID)
        {
            ASSERTL1(num_children == 0,
                     "Illegal children under number node: " + valueStr);
            return std::make_pair(
                true, boost::lexical_cast<NekDouble>(valueStr.c_str()));
        }
        else if (parserID == AnalyticExpression::variableID)
        {
            ASSERTL1(num_children == 0,
                     "Illegal children under variable node: " + valueStr);
 
            VariableMap::const_iterator it = variableMap.find(valueStr);
            ASSERTL1(it != variableMap.end(),
                     "Unknown variable parsed: " + valueStr);
 
            // Variables are not defined at the time of this parse.
            stack.push_back(makeStep<StoreVar>(stateIndex, it->second));
            return std::make_pair(false, 0);
        }
        else if (parserID == AnalyticExpression::parameterID)
        {
            ASSERTL1(num_children == 0,
                     "Illegal children under parameter node: " + valueStr);
 
            auto it = m_parameterMapNameToId.find(valueStr);
            ASSERTL1(it != m_parameterMapNameToId.end(),
                     "Unknown parameter parsed: " + valueStr);
 
            // Parameters may change in between of evalutions.
            stack.push_back(makeStep<StorePrm>(stateIndex, it->second));
            return std::make_pair(false, 0);
        }
        else if (parserID == AnalyticExpression::functionID)
        {
            auto it = m_functionMapNameToInstanceType.find(valueStr);
            ASSERTL1(it != m_functionMapNameToInstanceType.end(),
                     "Invalid function specified: " + valueStr);
            ASSERTL1(num_children == 1 || num_children == 2,
                     "Function " + valueStr +
                         " has neither one or two "
                         "arguments: this is not implemented yet.");
 
            if (location->children.size() == 1)
            {
                PrecomputedValue v = PrepareExecutionAsYouParse(
                    location->children.begin(), stack, variableMap, stateIndex);
 
                // additive white gaussian noise function
                if (it->second == E_AWGN)
                {
                    int const_index =
                        AddConstant(std::string("SUB_EXPR_") +
                                        std::to_string(m_constant.size()),
                                    v.second);
                    stack.push_back(
                        makeStep<StoreConst>(stateIndex, const_index));
                    stack.push_back(makeStep<EvalAWGN>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                }
 
                if (true == v.first)
                {
                    return std::make_pair(true,
                                          m_function[it->second](v.second));
                }
            }
            else
            {
                PrecomputedValue v1 =
                    PrepareExecutionAsYouParse(location->children.begin() + 0,
                                               stack, variableMap, stateIndex);
                PrecomputedValue v2 = PrepareExecutionAsYouParse(
                    location->children.begin() + 1, stack, variableMap,
                    stateIndex + 1);
                m_state_size++;
 
                if (true == v1.first && true == v2.first)
                {
                    return std::make_pair(
                        true, m_function2[it->second](v1.second, v2.second));
                }
            }
 
            // if somewhere down the parse tree there is a variable or
            // parameter, set up an evaluation sequence.
            switch (it->second)
            {
                case E_ABS:
                    stack.push_back(makeStep<EvalAbs>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_ASIN:
                    stack.push_back(makeStep<EvalAsin>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_ACOS:
                    stack.push_back(makeStep<EvalAcos>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_ATAN:
                    stack.push_back(makeStep<EvalAtan>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_ATAN2:
                    stack.push_back(makeStep<EvalAtan2>(stateIndex, stateIndex,
                                                        stateIndex + 1));
                    return std::make_pair(false, 0);
                case E_ANG:
                    stack.push_back(makeStep<EvalAng>(stateIndex, stateIndex,
                                                      stateIndex + 1));
                    return std::make_pair(false, 0);
                case E_BESSEL:
                    stack.push_back(makeStep<EvalBessel>(stateIndex, stateIndex,
                                                         stateIndex + 1));
                    return std::make_pair(false, 0);
                case E_CEIL:
                    stack.push_back(makeStep<EvalCeil>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_COS:
                    stack.push_back(makeStep<EvalCos>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_COSH:
                    stack.push_back(makeStep<EvalCosh>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_EXP:
                    stack.push_back(makeStep<EvalExp>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_FABS:
                    stack.push_back(makeStep<EvalFabs>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_FLOOR:
                    stack.push_back(
                        makeStep<EvalFloor>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_FMOD:
                    stack.push_back(makeStep<EvalFmod>(stateIndex, stateIndex,
                                                       stateIndex + 1));
                    return std::make_pair(false, 0);
                case E_LOG:
                    stack.push_back(makeStep<EvalLog>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_LOG10:
                    stack.push_back(
                        makeStep<EvalLog10>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_MAX:
                    stack.push_back(makeStep<EvalMax>(stateIndex, stateIndex,
                                                      stateIndex + 1));
                    return std::make_pair(false, 0);
                case E_MIN:
                    stack.push_back(makeStep<EvalMin>(stateIndex, stateIndex,
                                                      stateIndex + 1));
                    return std::make_pair(false, 0);
                case E_RAD:
                    stack.push_back(makeStep<EvalRad>(stateIndex, stateIndex,
                                                      stateIndex + 1));
                    return std::make_pair(false, 0);
                case E_SIN:
                    stack.push_back(makeStep<EvalSin>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_SINH:
                    stack.push_back(makeStep<EvalSinh>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_SQRT:
                    stack.push_back(makeStep<EvalSqrt>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_TAN:
                    stack.push_back(makeStep<EvalTan>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_TANH:
                    stack.push_back(makeStep<EvalTanh>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                case E_SIGN:
                    stack.push_back(makeStep<EvalSign>(stateIndex, stateIndex));
                    return std::make_pair(false, 0);
                default:
                    ASSERTL0(false, "Evaluation of " + valueStr +
                                        " is not implemented yet");
            }
            return std::make_pair(false, 0);
        }
        else if (parserID == AnalyticExpression::unaryID)
        {
            ASSERTL1(*valueStr.begin() == '-',
                     "Illegal factor - it can only be '-' and it was: " +
                         valueStr);
            ASSERTL1(num_children == 1,
                     "Illegal number of children under factor node: " +
                         valueStr);
            PrecomputedValue v = PrepareExecutionAsYouParse(
                location->children.begin(), stack, variableMap, stateIndex);
 
            // if precomputed value is valid, process it further.
            if (true == v.first)
            {
                return std::make_pair(true, -v.second);
            }
            stack.push_back(makeStep<EvalNeg>(stateIndex, stateIndex));
            return std::make_pair(false, 0);
        }
        else if (parserID == AnalyticExpression::operatorID)
        {
            ASSERTL1(
                num_children == 2,
                "Too few or too many arguments for mathematical operator: " +
                    valueStr);
            PrecomputedValue left = PrepareExecutionAsYouParse(
                location->children.begin() + 0, stack, variableMap, stateIndex);
            PrecomputedValue right =
                PrepareExecutionAsYouParse(location->children.begin() + 1,
                                           stack, variableMap, stateIndex + 1);
            m_state_size++;
 
            // if both precomputed values are valid, process them further.
            if ((left.first == true) && (right.first == true))
            {
                switch (*valueStr.begin())
                {
                    case '+':
                        return std::make_pair(true, left.second + right.second);
                    case '-':
                        return std::make_pair(true, left.second - right.second);
                    case '*':
                        return std::make_pair(true, left.second * right.second);
                    case '/':
                        return std::make_pair(true, left.second / right.second);
                    case '%':
                        return std::make_pair(
                            true, std::fmod(left.second, right.second));
                    case '^':
                        return std::make_pair(
                            true, std::pow(left.second, right.second));
                    case '=':
                        return std::make_pair(true,
                                              left.second == right.second);
                    case '<':
                        if (*(valueStr.end() - 1) == '=')
                        {
                            return std::make_pair(true,
                                                  left.second <= right.second);
                        }
                        else
                        {
                            return std::make_pair(true,
                                                  left.second < right.second);
                        }
                        return std::make_pair(false, 0);
                    case '>':
                        if (*(valueStr.end() - 1) == '=')
                        {
                            return std::make_pair(true,
                                                  left.second >= right.second);
                        }
                        else
                        {
                            return std::make_pair(true,
                                                  left.second > right.second);
                        }
                        return std::make_pair(false, 0);
                    default:
                        ASSERTL0(false,
                                 "Invalid operator encountered: " + valueStr);
                }
                return std::make_pair(false, 0);
            }
 
            // either operator argument is not fully evaluated
            // add pre-evaluated value to the contaner of constants
            if (true == left.first)
            {
                int const_index =
                    AddConstant(std::string("SUB_EXPR_") +
                                    std::to_string(m_constant.size()),
                                left.second);
                stack.push_back(makeStep<StoreConst>(stateIndex, const_index));
            }
            if (true == right.first)
            {
                int const_index =
                    AddConstant(std::string("SUB_EXPR_") +
                                    std::to_string(m_constant.size()),
                                right.second);
                stack.push_back(
                    makeStep<StoreConst>(stateIndex + 1, const_index));
            }
 
            switch (*valueStr.begin())
            {
                case '+':
                    stack.push_back(makeStep<EvalSum>(stateIndex, stateIndex,
                                                      stateIndex + 1));
                    return std::make_pair(false, 0);
                case '-':
                    stack.push_back(makeStep<EvalSub>(stateIndex, stateIndex,
                                                      stateIndex + 1));
                    return std::make_pair(false, 0);
                case '*':
                    stack.push_back(makeStep<EvalMul>(stateIndex, stateIndex,
                                                      stateIndex + 1));
                    return std::make_pair(false, 0);
                case '/':
                    stack.push_back(makeStep<EvalDiv>(stateIndex, stateIndex,
                                                      stateIndex + 1));
                    return std::make_pair(false, 0);
                case '%':
                    stack.push_back(makeStep<EvalMod>(stateIndex, stateIndex,
                                                      stateIndex + 1));
                    return std::make_pair(false, 0);
                case '^':
                    stack.push_back(makeStep<EvalPow>(stateIndex, stateIndex,
                                                      stateIndex + 1));
                    return std::make_pair(false, 0);
                case '=':
                    stack.push_back(makeStep<EvalLogicalEqual>(
                        stateIndex, stateIndex, stateIndex + 1));
                    return std::make_pair(false, 0);
                case '<':
                    if (*(valueStr.end() - 1) == '=')
                    {
                        stack.push_back(makeStep<EvalLogicalLeq>(
                            stateIndex, stateIndex, stateIndex + 1));
                    }
                    else
                    {
                        stack.push_back(makeStep<EvalLogicalLess>(
                            stateIndex, stateIndex, stateIndex + 1));
                    }
                    return std::make_pair(false, 0);
 
                case '>':
                    if (*(valueStr.end() - 1) == '=')
                    {
                        stack.push_back(makeStep<EvalLogicalGeq>(
                            stateIndex, stateIndex, stateIndex + 1));
                    }
                    else
                    {
                        stack.push_back(makeStep<EvalLogicalGreater>(
                            stateIndex, stateIndex, stateIndex + 1));
                    }
                    return std::make_pair(false, 0);
 
                default:
                    ASSERTL0(false,
                             "Invalid operator encountered: " + valueStr);
            }
            return std::make_pair(false, 0);
        }
        else if (parserID == AnalyticExpression::operatorID)
        {
            ASSERTL1(
                false,
                "Too few or too many arguments for mathematical operator: " +
                    valueStr);
        }
        ASSERTL0(false, "Illegal expression encountered: " + valueStr);
        return std::make_pair(false, 0);
    }

References AddConstant(), ASSERTL0, ASSERTL1, Nektar::LibUtilities::Interpreter::ExpressionEvaluator::AnalyticExpression::constantID, E_ABS, E_ACOS, E_ANG, E_ASIN, E_ATAN, E_ATAN2, E_AWGN, E_BESSEL, E_CEIL, E_COS, E_COSH, E_EXP, E_FABS, E_FLOOR, E_FMOD, E_LOG, E_LOG10, E_MAX, E_MIN, E_RAD, E_SIGN, E_SIN, E_SINH, E_SQRT, E_TAN, E_TANH, Nektar::LibUtilities::Interpreter::ExpressionEvaluator::AnalyticExpression::functionID, m_constant, m_constantMapNameToId, m_function, m_function2, m_functionMapNameToInstanceType, m_parameterMapNameToId, m_state_size, Nektar::LibUtilities::Interpreter::ExpressionEvaluator::AnalyticExpression::numberID, Nektar::LibUtilities::Interpreter::ExpressionEvaluator::AnalyticExpression::operatorID, Nektar::LibUtilities::Interpreter::ExpressionEvaluator::AnalyticExpression::parameterID, PrepareExecutionAsYouParse(), Nektar::LibUtilities::Interpreter::ExpressionEvaluator::AnalyticExpression::unaryID, and Nektar::LibUtilities::Interpreter::ExpressionEvaluator::AnalyticExpression::variableID.

Referenced by DefineFunction(), and PrepareExecutionAsYouParse().

◆ SetParameter()

void Nektar::LibUtilities::Interpreter::ExpressionEvaluator::SetParameter	(	std::string const &	name,
		NekDouble	value
	)

inline

Set parameter values.

This function behaves in the same way as SetParameters, but it only adds one parameter and it does not delete the others. If the parameter name existed previously, it will be overridden and replaced with the new value. If it did not exist previously, it will be added to the current parameters.

Parameters

name	Name of the parameter to define.
value	The parameter's value.

Definition at line 360 of file Interpreter/Interpreter.cpp.

    {
        ParameterMap::const_iterator it = m_parameterMapNameToId.find(name);
        if (it == m_parameterMapNameToId.end())
        {
            m_parameterMapNameToId[name] = m_parameter.size();
            m_parameter.push_back(value);
        }
        else
        {
            // If parameter is known, change its value.
            m_parameter[it->second] = value;
        }
    }

References m_parameter, m_parameterMapNameToId, and CellMLToNektar.pycml::name.

Referenced by SetParameters().

◆ SetParameters()

void Nektar::LibUtilities::Interpreter::ExpressionEvaluator::SetParameters ( std::map< std::string, NekDouble > const & params )

inline

Set parameter values.

Parameters are functionally similar to constants, but they are inserted into the function at the time that Evaluate is called, instead of when the function is parsed. This function can therefore be called at any time, and it will take effect in the next call to Evaluate. This function will delete all of the parameters, and replace all of them with only the ones in the map argument.

Definition at line 349 of file Interpreter/Interpreter.cpp.

    {
        for (auto const &it : params)
        {
            SetParameter(it.first, it.second);
        }
    }

References SetParameter().

◆ SetRandomSeed()

void Nektar::LibUtilities::Interpreter::ExpressionEvaluator::SetRandomSeed ( unsigned int seed )

inline

Sets the random seed for the pseudorandom number generator.

This allows for e.g. different ranks to be given different seeds to ensure appropriate entropy in noise generation.

Definition at line 290 of file Interpreter/Interpreter.cpp.

    {
        m_generator.seed(seed);
    }

References m_generator.

Member Data Documentation

◆ m_constant

std::vector<NekDouble> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_constant

private

Definition at line 1291 of file Interpreter/Interpreter.cpp.

Referenced by AddConstant(), makeStep(), and PrepareExecutionAsYouParse().

◆ m_constantMapNameToId

ConstantMap Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_constantMapNameToId

private

Definition at line 1287 of file Interpreter/Interpreter.cpp.

Referenced by AddConstant(), and PrepareExecutionAsYouParse().

◆ m_constantsParser

bsp::symbols<NekDouble> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_constantsParser

This is a parser for spirit that parses the CONSTANT values. The default constants are those that are in math.h without the M_ prefix and they are initialized in the AnalyticExpressionEvaluator constructor.

Definition at line 1100 of file Interpreter/Interpreter.cpp.

Referenced by AddConstant(), DefineFunction(), and GetConstant().

◆ m_executionStack

std::vector<ExecutionStack> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_executionStack

private

Definition at line 1261 of file Interpreter/Interpreter.cpp.

Referenced by DefineFunction(), Evaluate(), EvaluateAtPoint(), and ~ExpressionEvaluator().

◆ m_expressionVariableMap

VariableMap Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_expressionVariableMap

private

Definition at line 1288 of file Interpreter/Interpreter.cpp.

◆ m_function

std::map<int, OneArgFunc> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_function

private

Definition at line 1316 of file Interpreter/Interpreter.cpp.

Referenced by ExpressionEvaluator(), and PrepareExecutionAsYouParse().

◆ m_function2

std::map<int, TwoArgFunc> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_function2

private

Definition at line 1317 of file Interpreter/Interpreter.cpp.

Referenced by ExpressionEvaluator(), and PrepareExecutionAsYouParse().

◆ m_functionMapNameToInstanceType

FunctionNameMap Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_functionMapNameToInstanceType

private

Definition at line 1315 of file Interpreter/Interpreter.cpp.

Referenced by ExpressionEvaluator(), and PrepareExecutionAsYouParse().

◆ m_generator

std::mt19937 Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_generator

private

Definition at line 1309 of file Interpreter/Interpreter.cpp.

Referenced by makeStep(), and SetRandomSeed().

◆ m_parameter

std::vector<NekDouble> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_parameter

private

Definition at line 1290 of file Interpreter/Interpreter.cpp.

Referenced by GetParameter(), makeStep(), and SetParameter().

◆ m_parameterMapNameToId

ParameterMap Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_parameterMapNameToId

private

The following data structures hold input data to be used on evaluation stage. There are three types of input data:

constants (never change their value)
parameters are allowed to change their values between evaluations (compared to constants)
variables always change their values at every evaluation call. First map looks like <parameter_name, parameter_id> while the second is <parameter_id, parameter_value>. The map is used at a preparation stage when the analytic expression is parsed. This associates an integer id with a parameter name in its string form. On evaluation stage the id and a std::vector constant lookup time make evaluation faster compared to permanent std::map<std::string, NekDouble> lookup.

Definition at line 1286 of file Interpreter/Interpreter.cpp.

Referenced by GetParameter(), PrepareExecutionAsYouParse(), and SetParameter().

◆ m_parsedMapExprToExecStackId

ExpressionMap Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_parsedMapExprToExecStackId

private

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.

Definition at line 1260 of file Interpreter/Interpreter.cpp.

Referenced by DefineFunction().

◆ m_stackVariableMap

std::vector<VariableMap> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_stackVariableMap

private

Keeping map of variables individually per each analytic expression allows correctly handling expressions which depend on different number of variables.

Definition at line 1267 of file Interpreter/Interpreter.cpp.

Referenced by DefineFunction(), and EvaluateAtPoint().

◆ m_state

std::vector<NekDouble> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_state

private

This vector stores the execution state (memory) used by the sequential execution process.

Definition at line 1296 of file Interpreter/Interpreter.cpp.

Referenced by Evaluate(), EvaluateAtPoint(), and makeStep().

◆ m_state_size

int Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_state_size

private

This counter is used by PrepareExecutionAsYouParse for finding the minimal state size necessary for evaluation of function parsed.

Definition at line 1303 of file Interpreter/Interpreter.cpp.

Referenced by DefineFunction(), ExpressionEvaluator(), and PrepareExecutionAsYouParse().

◆ m_state_sizes

std::vector<int> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_state_sizes

private

Vector of state sizes per each.

Definition at line 1299 of file Interpreter/Interpreter.cpp.

Referenced by DefineFunction(), Evaluate(), and EvaluateAtPoint().

◆ m_timer

Timer Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_timer

private

Timer and sum of evaluation times.

Definition at line 1306 of file Interpreter/Interpreter.cpp.

Referenced by Evaluate(), and EvaluateAtPoint().

◆ m_total_eval_time

NekDouble Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_total_eval_time

private

Definition at line 1307 of file Interpreter/Interpreter.cpp.

Referenced by Evaluate(), EvaluateAtPoint(), and GetTime().

◆ m_variable

std::vector<NekDouble> Nektar::LibUtilities::Interpreter::ExpressionEvaluator::m_variable

private

Definition at line 1292 of file Interpreter/Interpreter.cpp.

Referenced by Evaluate(), EvaluateAtPoint(), and makeStep().

Classes

Public Types

Public Member Functions

Public Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ci

◆ ConstantMap

◆ cvr

◆ ExecutionStack

◆ ExpressionMap

◆ FunctionNameMap

◆ OneArgFunc

◆ ParameterMap

◆ ParsedTreeInfo

◆ ParsedTreeIterator

◆ PrecomputedValue

◆ rgt

◆ TwoArgFunc

◆ VariableArray

◆ VariableMap

◆ vr

Member Enumeration Documentation

◆ EvaluationStepType

Constructor & Destructor Documentation

◆ ExpressionEvaluator()

◆ ~ExpressionEvaluator()

Member Function Documentation

◆ AddConstant()

◆ AddConstants()

◆ DefineFunction()

◆ Evaluate() [1/4]

◆ Evaluate() [2/4]

◆ Evaluate() [3/4]

◆ Evaluate() [4/4]

◆ EvaluateAtPoint()

◆ GetConstant()

◆ GetParameter()

◆ GetTime()

◆ makeStep()

◆ PrepareExecutionAsYouParse()

◆ SetParameter()

◆ SetParameters()

◆ SetRandomSeed()

Member Data Documentation

◆ m_constant

◆ m_constantMapNameToId

◆ m_constantsParser

◆ m_executionStack

◆ m_expressionVariableMap

◆ m_function

◆ m_function2

◆ m_functionMapNameToInstanceType

◆ m_generator

◆ m_parameter

◆ m_parameterMapNameToId

◆ m_parsedMapExprToExecStackId

◆ m_stackVariableMap

◆ m_state

◆ m_state_size

◆ m_state_sizes

◆ m_timer

◆ m_total_eval_time

◆ m_variable