EquationParser.h

Go to the documentation of this file.

#pragma once
 
#include <utility>
 
#include "MathNode.h"
#include "Operand.h"
#include "Operator.h"
 
 
class EquationParser
{
  std::string processString;
 
 
  bool prevWasOperator = true;
  bool nextIsNegative = false;
  std::vector<std::string> operatorStack;
  std::vector<std::shared_ptr<MathNode>> operandStack;
 
public:
  std::vector<std::shared_ptr<Symbolic>> symbols;
 
  explicit EquationParser(std::string in)
    : processString(std::move(in)) { }
 
  static std::vector<std::shared_ptr<Symbolic>> buildSymbolSuperSet(
  const std::vector<std::shared_ptr<Symbolic>>& a, const std::vector<std::shared_ptr<Symbolic>>& b) {
    std::vector<std::shared_ptr<Symbolic>> out = a;
    auto testIsInContainer                     = [&out](const std::shared_ptr<Symbolic>& sym) {
      for(const auto& elem : out) {
        if(bool(strcmp(elem->value, sym->value) == 0) && elem->isNegative == sym->isNegative) return true;
      }
      return false;
    };
 
    size_t numElements = out.size();
    for(const auto& i : b) {
      if(!testIsInContainer(i)) {
        out.push_back(i);
        numElements++;
      }
    }
 
    return out;
  }
 
  std::shared_ptr<MathNode> createAST();
 
  static std::shared_ptr<Operator> GetOperator(const std::string& valString) {
    if(valString.empty()) { return {}; }
    if(valString.size() > 1) { return GetFunction(valString); }
    switch(int(strip(valString).c_str()[0])) {
      case int(OperatorValue::VALUE_MULTIPLICATION): return GenerateOperator(OperatorType::TYPE_MULTIPLICATION);
      case int(OperatorValue::VALUE_DIVISION): return GenerateOperator(OperatorType::TYPE_DIVISION);
      case int(OperatorValue::VALUE_ADDITION): return GenerateOperator(OperatorType::TYPE_ADDITION);
      case int(OperatorValue::VALUE_SUBTRACTION): return GenerateOperator(OperatorType::TYPE_SUBTRACTION);
      case int(OperatorValue::VALUE_POWER): return GenerateOperator(OperatorType::TYPE_POWER);
      case int(OperatorValue::VALUE_PARENTHESES_OPEN): return GenerateOperator(OperatorType::TYPE_PARENTHESES_OPEN);
      case int(OperatorValue::VALUE_PARENTHESES_CLOSE): return GenerateOperator(OperatorType::TYPE_PARENTHESES_CLOSE);
    }
    return {};
  }
 
private:
  bool parseSequence(const std::string& c) {
    std::string copy = c;
    if(isNumber(copy)) {
      auto sym        = std::make_shared<Number>(copy);
      sym->isNegative = nextIsNegative;
      nextIsNegative  = false;
      operandStack.push_back(sym);
    } else if(isConstant(copy)) {
      auto sym        = DefaultSymbols[copy];
      sym->isNegative = nextIsNegative;
      nextIsNegative  = false;
      operandStack.push_back(sym);
    } else if(isSymbol(copy)) {
      auto symbol        = std::make_shared<Symbolic>(copy);
      symbol->isNegative = nextIsNegative;
      nextIsNegative     = false;
      operandStack.push_back(symbol);
      if(!hasSymbol(symbols, symbol)) symbols.push_back(symbol);
    } else if(isParenthesesOpen(copy) || isFunction(copy)) {
      operatorStack.push_back(copy);
    } else if(isOperator(copy)) {
      auto currentOp = GetOperator(copy);
      if(prevWasOperator && currentOp->value[0] == '-') {
        nextIsNegative = !nextIsNegative;
      } else {
        if(currentOp->value[0] == '-') {
          currentOp      = GetOperator("+");
          copy           = "+";
          nextIsNegative = !nextIsNegative;
        }
        processCurrentOP(currentOp, operatorStack, operandStack);
        operatorStack.push_back(copy);
      }
    } else if(isParenthesesClose(copy)) {
      rearrangeStack(operatorStack, operandStack);
    } else if(isAny(copy)) {
      // ignore
    } else {
      // error
      std::cerr << "Error detecting character " << copy << std::endl;
      return false;
    }
    prevWasOperator = isOperator(copy);
    return true;
  }
 
  static std::shared_ptr<Function> GetFunction(const std::string& valString) {
    auto elem = DefaultFunctions.find(valString);
    return (elem != DefaultFunctions.end()) ? elem->second : nullptr;
  }
 
  std::vector<std::string> splitFunctionsOrElementwise(const std::string& in) {
    std::vector<std::string> out;
    auto eq = in;
 
    std::vector<std::string> functionNames;
    functionNames.reserve(DefaultFunctions.size());
    for(const auto& elem : DefaultFunctions) { functionNames.push_back(elem.first); }
    auto res = extractObjects(eq, functionNames);
    out.insert(out.end(), res.begin(), res.end());
 
    std::vector<std::string> constantNames;
    constantNames.reserve(DefaultSymbols.size());
    for(const auto& elem : DefaultSymbols) { constantNames.push_back(elem.first); }
    res = extractObjects(eq, constantNames);
    out.insert(out.end(), res.begin(), res.end());
 
    if(!eq.empty()) {
      auto remainingPart = split_by_regex(eq, GetRegex(MathNodeType::NodeType_Operator_or_Parentheses));
      out.insert(out.end(), remainingPart.begin(), remainingPart.end());
    }
    return out;
  }
 
  std::vector<std::string> splitEquation(const std::string& eqString);
 
  static bool isNumber(const std::string& in) {
    static auto numberRegex = GetRegex(MathNodeType::NodeType_Numeric);
    std::cmatch m;
    return std::regex_match(in.c_str(), m, numberRegex);
  };
  static bool isSymbol(const std::string& in) {
    static auto symbolRegex = GetRegex(MathNodeType::NodeType_Symbolic);
    std::cmatch m;
    return std::regex_match(in.c_str(), m, symbolRegex);
  };
  static bool isOperator(const std::string& in) {
    static auto operatorRegex = GetRegex(MathNodeType::NodeType_Operator);
    std::cmatch m;
    return std::regex_match(in.c_str(), m, operatorRegex);
  };
  static bool isAny(const std::string& in) {
    static auto anyRegex = GetRegex(MathNodeType::NodeType_Any);
    std::cmatch m;
    return std::regex_match(in.c_str(), m, anyRegex);
  };
  static bool isParenthesesOpen(const std::string& in) { return in.find('(') != std::string::npos; };
  static bool isParenthesesClose(const std::string& in) { return in.find(')') != std::string::npos; };
 
  static void processCurrentOP(
  const std::shared_ptr<Operator>& currentOp,
  std::vector<std::string>& operatorStack,
  std::vector<std::shared_ptr<MathNode>>& operandStack);
 
  static void
  rearrangeStack(std::vector<std::string>& operatorStack, std::vector<std::shared_ptr<MathNode>>& operandStack);
 
 
  std::vector<std::string> extractObjects(std::string& eq, const std::vector<std::string>& container);
};