Description

This repository features 2 programs that can solve mathematical expressions. Both projects were planned and thought out before writing, and my partner, Andrew Diab, and I each wrote one implementation. The first one, under the subdirectory /Dijkstra was completed by Andrew Diab - this implements the Shunting-Yard Algorithm by Edsger Dijkstra, and the simpleSolve() method created by myself. I created the second implementation found under the subdirectory Recursive. This program contains a class which can solve unordered mathematical expressions folling PEMDAS (no brackets or parentheses) under the method simpleSolve(). Within this same class, the solve() method “searches” for parenthetical expressions and recursively solves the general equation by calling simpleSolve() multiple times.

Github Repository

The Github repository can be found here

What were my goals with this project?

  • Design/write under an efficient workflow with my partner
  • Create an expression solver without external resources
  • Make the driver code relatively easy to use
  • Have the solution be as efficient as possible
  • Accounts for a wide variety of statements. Allows for negative numbers, PEMDAS, and is precise.

Project Images

calculator1.jpg

Driver code

e = new Equation("("+input+")");
System.out.println("Output: " + e.solve());

Testing outputs

Your expression (+ - / * ^ !): 
    (-2)((((2+2)*3/9-4)*3-1) + (3) + -1^3)/9 + (-10 - (-3))
---------------------
Evaluating: ((-2)((((2+2)*3/9-4)*3-1) + (3) + -1^3)/9 + (-10 - (-3))) >>>
---------------------
Output: -5.444444444444445
Calculation time (ms): 2
Would you like to exit? (y/n) :
    yes

Recursive solve() code

public double solve() {
        if (this.equation.contains("(")) {
            /* This 'portion' of the method, recursively breaks down parenthetical statements
            into simple expressions. It then takes the outputs of all the
            parenthetical statements and calculates the rest of the expression using
            simpleSolve() */
            
            int parenthesisCount = 0;
            char[] charEquation = this.equation.toCharArray();
            String finalEquation = "";
            int index1 = -1;
            int index2 = -1;

            for (int i=0; i < charEquation.length; i++) {
                if (charEquation[i] == '(') {
                    if (index1 == -1) {
                        index1 = i;
                    }
                    parenthesisCount ++;
                }
                else if (charEquation[i] == ')') {
                    parenthesisCount --;
                    /* When the parenthesis count is at 0 on a closed parenthesis
                    that means that a parenthetical expression has ended. This is to
                    be parsed, and solved in a new Equation object */
                    if (parenthesisCount == 0) {
                        index2 = i;  
                        // Recursive statement
                        finalEquation += new Equation(this.equation.substring(index1, index2+1), this.printOperations).solve();  
                        index1 = -1;
                    }
                }
                else if (parenthesisCount == 0) {
                    finalEquation += charEquation[i];
                }
            }
            return simpleSolve(finalEquation);
        }
        // If there are no parentheses, "order" does not matter
        else {
            return simpleSolve(this.equation);
        }
    }