add compilation

Author: H5JKey

include/mathparser.hpp

@@ -61,9 +61,7 @@ class MathParser {
 
     bool isConstant(const std::string& symbol);
 
-    
-    double evaluateRPN(const std::vector<Token>& RPN);  //evaluate Reverse Polish notation
-    std::vector<Token> toRPN(const std::string& expression);  //make Reverse Polish notation
+    std::vector<Token> toRPN(const std::string& expression);
 
 public:
     MathParser();
@@ -72,6 +70,8 @@ class MathParser {
     void registerOperator(const std::string& symbol, Operator op);
     void registerConstant(const std::string& symbol, double value);
     double evaluate(const std::string& expression);
+    std::vector<Token> compile(const std::string& expression);
+    double evaluate(const std::vector<Token>& complied);
     double tokenToDouble(const Token& token);
     double getVariableValue(const std::string& varName);
 };

src/mathparser.cpp

@@ -281,12 +281,11 @@ std::vector<MathParser::Token> MathParser::toRPN(const std::string& expression)
 
 }
 
-double MathParser::evaluateRPN(const std::vector<Token>& RPN) {
+double MathParser::evaluate(const std::vector<Token>& compiled) {
     std::stack<Token> numStack;
-    for (const Token& token: RPN) {
+    for (const Token& token: compiled) {
         if (token.type == Token::Type::OPERATOR) {
             Operator op = operators[std::get<std::string>(token.value)];
-            if (op.type==Operator::Type::COMMA) continue;
             std::vector<Token> operands;
             for (int i=0; i<op.operandCount; i++) {
                 operands.insert(operands.begin(),numStack.top());
@@ -295,17 +294,52 @@ double MathParser::evaluateRPN(const std::vector<Token>& RPN) {
             numStack.push(op.evaluate(operands));
         }
         else {
-            if (token.type == Token::Type::CONSTANT) 
-                numStack.push(Token{Token::Type::NUMBER, tokenToDouble(token)});
-            else
-                numStack.push(token);
+            numStack.push(token);
         }
     }
     return tokenToDouble(numStack.top());
 }
 
+#include <iostream>
 double MathParser::evaluate(const std::string& expression) {
-    return evaluateRPN(toRPN(expression));
+    auto compiled = compile(expression);
+    return evaluate(compiled);
+}
+
+std::vector<MathParser::Token>  MathParser::compile(const std::string& expression) {
+    auto RPN = toRPN(expression);
+    std::vector<Token> compiled;
+    for (const Token& token: RPN) {
+        if (token.type == Token::Type::OPERATOR) {
+            Operator op = operators[std::get<std::string>(token.value)];
+            if (op.type==Operator::Type::COMMA) continue;
+            bool allConstants = true;
+            for (int i=0; i<op.operandCount; i++) {
+                if ((compiled.end()-1-i)->type!=Token::Type::NUMBER) {
+                    allConstants = false;
+                    break;
+                }
+            }
+            if (allConstants) {
+                std::vector<Token> operands;
+                for (int i=0; i<op.operandCount; i++) {
+                    operands.insert(operands.begin(),compiled.back());
+                    compiled.pop_back();
+                }
+                compiled.push_back(op.evaluate(operands));
+            }
+            else {
+                compiled.push_back(token);
+            }
+        }
+        else {
+            if (token.type==Token::Type::CONSTANT)
+                compiled.push_back(Token{Token::Type::NUMBER, constants[std::get<std::string>(token.value)]});
+            else
+                compiled.push_back(token);
+        }
+    }
+    return compiled;
 }
 
 double MathParser::getVariableValue(const std::string& varName) {