Expression.h

Go to the documentation of this file.

 
#ifndef KIDS_EXPRESSION_H
#define KIDS_EXPRESSION_H
 
#include <string>
#include <vector>
 
#ifdef KIDS_EXPRESSION_USE_EXPRTK
#include "exprtk/exprtk.hpp"               
#elif defined(KIDS_EXPRESSION_USE_LEPTON)  // LEPTON is a math parser by OPENMM-team
#else                                      // by default using fparser.h
#include "fparser/fparser.hh"              
#endif                                     // KIDS_EXPRESSION_USE_EXPRTK
 
namespace PROJECT_NS {
 
template <typename T>
class Expression {
   public:
    static std::vector<Expression<T>>& getExpressions() {
        static std::vector<Expression<T>> _GLOBAL_EXPRESSIONS;
        return _GLOBAL_EXPRESSIONS;
    }
 
    static int registerExpression(const std::string& expression, const std::vector<std::string>& variables) {
        auto& allExpressions = getExpressions();
        int   index          = 0;
        for (auto it = allExpressions.begin(); it != allExpressions.end(); ++it, ++index) {
            if (expression == it->expressionString) return index;  // Check if expression already exists
        }
        allExpressions.push_back(Expression<T>(expression, variables));
        return allExpressions.size() - 1;
    }
 
    inline T evaluate(T* data) { return _evaluate(data); }
 
   private:
#ifdef KIDS_EXPRESSION_USE_EXPRTK
    std::string              expressionString;  
    std::vector<std::string> variablesString;   
    exprtk::expression<T>    expressionValue;   
    std::vector<T>           variablesValue;    
 
    Expression(const std::string& expressionStr, const std::vector<std::string>& varsStr)
        : expressionString{expressionStr}, variablesString{varsStr} {
        exprtk::symbol_table<T> symbolTable;
        for (int i = 0; i < variablesString.size(); ++i)
            symbolTable.add_variable(variablesString[i], variablesValue[i]);
        symbolTable.add_constants();
        expressionValue.register_symbol_table(symbolTable);
        exprtk::parser<T>{}.compile(expressionString, expressionValue);
    }
 
    T _evaluate(T* data) {
        for (int i = 0; i < variablesValue.size(); ++i) variablesValue[i] = data[i];
        return expressionValue.value();
    }
 
#elif defined(KIDS_EXPRESSION_USE_LEPTON)  // LEPTON is a math parser by OPENMM-team
#else
    std::string           expressionString;  
    std::string           variablesString;   
    FunctionParserBase<T> parser;            
 
    Expression(const std::string& expressionStr, const std::vector<std::string>& varsStr)
        : expressionString{expressionStr} {
        variablesString = "";
        for (int i = 0; i < varsStr.size(); ++i) {
            variablesString += (i == 0) ? varsStr[i] : (std::string(",") + varsStr[i]);
        }
        int res = parser.Parse(expressionString, variablesString);
        if (res != -1) throw std::runtime_error(parser.ErrorMsg());
    }
 
    T _evaluate(T* data) { return parser.Eval(data); }
 
#endif  // KIDS_EXPRESSION_USE_EXPRTK
};
 
};  // namespace PROJECT_NS
 
#endif  //  KIDS_EXPRESSION_H