/** * This program evaluates postfix expressions entered by the * user. The expressions can use non-negative real numbers and * the operators +, -, *, /, and ^ (where ^ represents exponentiation). * Numbers must begin with a digit. That is, you have to say * 0.7 rather than just .7. The value of an expression might * be given as infinity or NaN. * * A stack is used to evaluate the expression. The stack is represented * by an object of type StackOfDouble. This program depends on the non-standard * classes StackOfDouble and TextIO. * * For demonstration purposes, the stack operations are reported as * they are performed. */ public class PostfixEval { public static void main(String[] args) { System.out.println("This program can evaluate postfix expressions such as\n"); System.out.println(" 2 2 +"); System.out.println("or"); System.out.println(" 7.3 89.2 + 9 1.83 * 2 + /\n"); System.out.println("The operators +, -, *, /, and ^ can be used."); while (true) { // Get and process one line of input from the user. System.out.println("\n\n\nEnter a postfix expression or press return to end:\n"); System.out.print("? "); TextIO.skipBlanks(); if (TextIO.peek() == '\n') { // If the line is empty (except for spaces), we are done. break; } readAndEvaluate(); // Process the input. TextIO.getln(); // Discard the end-of-line. } System.out.println("\n\nExiting program."); } // end main(); /** * Read one line of input and process it as a postfix expression. * If the input is not a legal postfix expression, then an error * message is displayed. Otherwise, the value of the expression * is displayed. It is assumed that the first character on * the input line is a non-blank. (This is checked in the * main() routine.) */ private static void readAndEvaluate() { StackOfDouble stack; // For evaluating the expression. stack = new StackOfDouble(); // Make a new, empty stack. System.out.println(); while (TextIO.peek() != '\n') { if ( Character.isDigit(TextIO.peek()) ) { // The next item in input is a number. Read it and // save it on the stack. double num = TextIO.getDouble(); stack.push(num); System.out.println(" Pushed constant " + num); } else { // Since the next item is not a number, the only thing // it can legally be is an operator. Get the operator // and perform the operation. char op; // The operator, which must be +, -, *, /, or ^. double x,y; // The operands, from the stack, for the operation. double answer; // The result, to be pushed onto the stack. op = TextIO.getChar(); if (op != '+' && op != '-' && op != '*' && op != '/' && op != '^') { // The character is not one of the acceptable operations. System.out.println("\nIllegal operator found in input: " + op); return; } if (stack.isEmpty()) { System.out.println(" Stack is empty while trying to evaluate " + op); System.out.println("\nNot enough numbers in expression!"); return; } y = stack.pop(); if (stack.isEmpty()) { System.out.println(" Stack is empty while trying to evaluate " + op); System.out.println("\nNot enough numbers in expression!"); return; } x = stack.pop(); switch (op) { case '+': answer = x + y; break; case '-': answer = x - y; break; case '*': answer = x * y; break; case '/': answer = x / y; break; default: answer = Math.pow(x,y); // (op must be '^'.) } stack.push(answer); System.out.println(" Evaluated " + op + " and pushed " + answer); } TextIO.skipBlanks(); } // end while // If we get to this point, the input has been read successfully. // If the expression was legal, then the value of the expression is // on the stack, and it is the only thing on the stack. if (stack.isEmpty()) { // Impossible if the input is really non-empty. System.out.println("No expression provided."); return; } double value = stack.pop(); // Value of the expression. System.out.println(" Popped " + value + " at end of expression."); if (stack.isEmpty() == false) { System.out.println(" Stack is not empty."); System.out.println("\nNot enough operators for all the numbers!"); return; } System.out.println("\nValue = " + value); } // end readAndEvaluate() } // end class PostfixEval