import java.util.*;
import java.io.*;

/**
 * Write a description of class main here.
 */
public class main
{
    public static void main(String args[]) // This is the main method.
    // It takes a string array(=args) (not used)
    // and returns nothing (void).
    // A static function called 'main' with String array is needed in order
    // to run as a commandline program under 'java' etc.  Since this is is
    // static, no instance variables (fields) or constructor methods are used.
    {
        String Equation = "";
        InputStreamReader isr = new InputStreamReader(System.in);
        BufferedReader stdin = new BufferedReader(isr);
        
        while (true) { // This means that the loop continues forever.
        // Normally this would cause the while loop to go on forever, which would be bad...
        // However, this loop is broken when the user types 'end'.
            try {
                System.out.println("--------------------------------------");
                System.out.print("Please enter an equation or 'end' to exit this program: ");
                Equation = stdin.readLine(); // This reads all the lines that the user inputs
                if ( Equation.compareTo("end") == 0 ) {  // apparently the compareTo method should be used to compare strings.
                    break;  // break escapes from the while{} loop, hence ending the program.
                }
                double answer = Evaluate(Equation);  // calls the Evaluate method to solve the equation
                System.out.println("the answer is "+answer);
            }
            catch (Exception exp) {
                System.out.println("Error");
            }
        }
    System.out.println("thankyou for using the java calculator.");
    }
   /**
     * This is a method that evaluates the equation.
     */
    public static double Evaluate(String Equation)
    { // double means a number that can take numbers of any length
      // and also floating point numbers
        char charArray[];
        charArray = Equation.toCharArray(); // java's method to convert a String to an array of characters
        int EquationLength = Equation.length(); // takes the length of an equation into account

        boolean done[] = new boolean[100]; // boolean array which sees if these parts have been calculated or not
        char operators[] = new char[100];  // character array with operators used
        String parts[] = new String[100];  // String array with parts of the equation
        Arrays.fill(parts,""); // fill parts with empty strings -- for some reason java seems
                               //  to create String arrays with null (0) characters.
        int countParts=0;
        
        // for loop starts with charPosition=0, adds 1 to charPosition each loop,
        //   while charPosition is still less than EquationLength.  (1 loop for each character)
        for(int charPosition=0; charPosition<EquationLength; charPosition=charPosition+1) {
            char character=charArray[charPosition];  // read the character  into 'character'
            if (character == '-') {
                if ( parts[countParts].length()==0 ) {
                    parts[countParts]=parts[countParts]+character;
                }                                       // if operator='-' on the left of a part (0 chars in part so far)
                                                        // then add the - to the part, instead of treating as an operator.
                                                        // (This allows negative numbers to work properly).
                else {
                    countParts = countParts + 1;
                    operators[countParts] = character;  // fills operator into operators array "on the RIGHT"
                }
            }
            else if (character == '^' || character == '*' || character == '/' || character == '+') {
                countParts = countParts + 1;
                operators[countParts] = character;      // fills operator into operators array "on the RIGHT"
            }
            else {
                if ( ! Character.isWhitespace(character) ) {      // ignore whitespace (tab space etc.) in order there are
                   parts[countParts]=parts[countParts]+character; // no silly problems with spaces before - etc.
                }
            }
        }
        countParts = countParts+1;  // expect 1 more part than the number of operators
        
        // debugging printout of created parallel arrays
//        System.out.println("____ countParts="+countParts);
//        System.out.print(":x\td:done\to:operators\tp:parts\n");
//        for (int x=0; x<countParts; x++) {
//            System.out.print("x:"+x+"\t");
//            System.out.print("d:"+done[x]+"\t");
//            System.out.print("o:"+operators[x]+"\t\t");
//            System.out.print("p:"+parts[x]+"\n");
//        }
//        System.out.println("~~~~");

        // run the operator parser on all the available operators in
        //   precedence matching java language -- Exponent Multiply
        //   Divide Add Subtract.
        char runningOperator;
        runningOperator='^';
        runOperation(done, operators, parts, runningOperator, countParts);
        runningOperator='*';
        runOperation(done, operators, parts, runningOperator, countParts);
        runningOperator='/';
        runOperation(done, operators, parts, runningOperator, countParts);
        runningOperator='+';
        runOperation(done, operators, parts, runningOperator, countParts);
        runningOperator='-';
        runOperation(done, operators, parts, runningOperator, countParts);
        return Double.parseDouble(parts[0]);  // return the part on the left as the answer
    }

    /**
     * This is a method that evaluates all 'parts' of the equation
     *   which match runningOperator
     */
    public static void runOperation(boolean done[], char operators[], String parts[], char runningOperator, int countParts)
    {
        for (int r=1; r<countParts; r++) {
            if ( done[r]==false ) {
                if ( operators[r]==runningOperator ) {
                    // at this point r will be pointing to the RIGHT side of an operator to be evaluated
                    //   as the operators are stored 'on the right'

                    int l=-1;                   //
                    for (int x=0; x<r; x=x+1) { // Discover the 'l' LEFT side of the
                        if ( done[x]==false ) { //   same equation.  This will be the
                            l=x;                //   closest part which has done==false
                        }                       //   on the left of the r
                    }                           //
                    
               
                    double leftNumber = Double.parseDouble(parts[l]);   // convert String to double
                    double rightNumber = Double.parseDouble(parts[r]);  // convert String to double
                    double answer;
                    if (runningOperator == '^') {
                        answer = Math.pow(leftNumber,rightNumber);
                    }
                    else if (runningOperator == '*') {
                        answer = leftNumber * rightNumber;
                    }
                    else if (runningOperator == '/') {
                        answer = leftNumber / rightNumber;
                    }
                    else if (runningOperator == '+') {
                        answer = leftNumber + rightNumber;
                    }
                    else if (runningOperator == '-') {
                        answer = leftNumber - rightNumber;
                    }
                    else {
                        System.out.println("unexpected operator -- this message should never appear");
                        answer = 0;
                    }
                    System.out.println(leftNumber+" "+runningOperator+" "+rightNumber+" = "+answer);
                    parts[l] = ""+answer;  // store answer on the left-hand-side converted back to a string
                                           //   --notice that java converts to a string automanically in
                                           //   this case by adding a string to double number.
                    done[r] = true;  // mark operator done, on the right-hand-side
                }
            }
        }
        return;
    }
}

// Example of processing the Equation  "22*66/2"
//
// These arrays should be created:-
//                           0       1        2  
// boolean done       [  false  ; false ;  false                ]
// char    operators  [      '' ;   '*' ;    '/'                ]
// String  parts      [    "22" ;  "66" ;    "2"                ]
// countParts=3
// Notice that the operators are to the right.
// 
// It should then process multiply, and the values show as "----"
//   will not be used.
//                            0       1       2  
// boolean done       [  false  ;  true ;  false                ]
// char    operators  [     ''  ; ----- ;    '/'                ]
// String  parts      [  "1452" ; ----- ;    "2"                ]
// countParts=2
// Notice that the answer is stored on the left and the
//   right hand side is marked as done=true.
// 
//                           0         1       2  
// boolean done       [  false  ;   true ;  true                ]
// char    operators  [      '' ;  ----- ; -----                ]
// String  parts      [   "726" ;  ----- ; -----                ]
// countParts=1
// At the end, the answer is always on the left,
//   hence answer=parts[0]