Shunting Yard Algorithm

shunting yard algorithm calculator, can only accept these symbols: +-/*()^

Author: AbePineda

Diff for: Shunting Yard Algorithm

@@ -0,0 +1,148 @@
+#include <iostream>
+#include <stack>
+#include <string>
+#include <cctype>
+#include <sstream>
+#include <map>
+#include <stdexcept>
+#include <math.h>
+#include <regex>
+using namespace std;
+    stack<string> postfixVec;
+    stack<string> shuffleVec;
+    vector<string> postEvaVec;
+    
+class classCalc {
+    public:
+    classCalc() {
+        string userInput;
+        getline(cin, userInput);
+        cout << userInput << endl;
+        classCalcBrain(userInput);
+        evaluatorFunc(postfixVec);
+    }
+int precedence(string op);
+void classCalcBrain(string userInput);
+void evaluatorFunc (stack<string>& inputStack);
+void printStack(stack<string> stack);
+double operations(double num1, double num2, char oper);
+};
+
+//sets the level of importance according to PEMDAS
+int classCalc::precedence(string op) {
+    if (op == "+" || op == "-") return 1;
+    if (op == "*" || op == "/") return 2;
+    if (op == "^") return 3;
+    else return 0;
+}
+
+void classCalc::classCalcBrain(const string userInput) {
+        stringstream ss(userInput);
+        string currentToken;
+    for(auto i = 0; i < userInput.length() + 1; i++) {
+        char part = userInput[i];
+        if (isspace(part)) continue;
+        //pushes and creates tokenized digits
+        if (isdigit(part) || part == '.') {
+            currentToken += part;  
+        } else {
+            if (!currentToken.empty()) {
+            postfixVec.push(currentToken);
+            currentToken.clear(); 
+            }
+        }
+
+        //what to do when theres parenthesis
+        if(part == '(') {
+            string str(1, part);
+            shuffleVec.push(str);
+        } else if (part == ')') {
+            //loop that pushes all symbols onto main when the closing parenthesis is found
+            while(!shuffleVec.empty() && shuffleVec.top() != "(") {
+                postfixVec.push(shuffleVec.top());
+                shuffleVec.pop();
+            }
+            if (!shuffleVec.empty()) shuffleVec.pop();
+        }
+            
+        //what happens with symbols
+        if(part == '+' || part == '-' || part == '*' || part == '/' || part == '^') {
+            string part1(1, part);
+            //if its empty, it pushes whatever   
+            if (shuffleVec.empty() || precedence(shuffleVec.top()) <= precedence(part1)) {
+                shuffleVec.push(part1);
+            } else {
+                //if its not, precedence comes into play
+                while (!shuffleVec.empty() && precedence(shuffleVec.top()) >= precedence(part1)) {
+                postfixVec.push(shuffleVec.top()); 
+                shuffleVec.pop();
+                }
+                shuffleVec.push(part1);
+            }
+        }
+            
+            
+
+    }
+    //after everything, pushes all left overs onto main
+    if (!currentToken.empty()) postfixVec.push(currentToken);
+            
+    while(!shuffleVec.empty()) {
+    postfixVec.push(shuffleVec.top());
+    shuffleVec.pop();
+    }
+}
+
+
+void classCalc::evaluatorFunc (stack<string>& inputStack) {
+vector<double> numHold;
+
+    //pushes everything from the stack onto a vector for better calculation handling
+    while(!inputStack.empty()) {
+    postEvaVec.push_back(inputStack.top());
+    inputStack.pop();
+    }
+
+for (int i = postEvaVec.size() - 1; i >= 0; i--) {
+        string token = postEvaVec[i];
+        
+        //if its a digit, it pushes it onto a vector
+        if (isdigit(token[0])) {  
+            numHold.push_back(stod(token));  
+        } else { 
+            //if its a symbol, it pops the latest 2 elements and creates them into numerical values
+            //and the symbol gets converted into a character so it can be used in switch cases
+            char oper = token[0];  
+
+            double num2 = numHold.back(); numHold.pop_back();  
+            double num1 = numHold.back(); numHold.pop_back();  
+
+            double result = operations(num1, num2, oper); 
+            //pushes the result back into the holding vector
+            numHold.push_back(result); 
+        }
+    }
+    //prints the remaining element of the holding vector which is the resultant
+    cout << "= " << numHold.back() << endl;
+}
+
+//does the actual calculations
+double classCalc::operations(double num1, double num2, char oper) {
+    switch(oper) {
+        case '+': return num1 + num2;
+        case '-': return num1 - num2;
+        case '*': return num1 * num2;
+        case '^': return pow(num1, num2);
+        case '/': if (num2 == 0) {
+                    cout << "Error - dividing by zeros" << endl; break;
+                    }
+                  else return num1 / num2;
+    }
+}
+
+int main() {
+    classCalc obj;
+}
+
+
+