InFixToPostFix Java с уравнениями

Question

Использование одного входного файла в качестве карты для значения переменной, а затем файл с уравнениями. Моя проблема с уравнением такого ((A+B)-(C-D))/(E-F) правильно рассчитывает до (A+B)-(C-D) Я знаю, что это связано с map.put('z', temp) а также as.push('z') Я просто не знаю, как еще заставить это работать должным образом.

входной файл один:

A = 8.0
B = -1.0
C = 7.0
D = -4.0
E = 11.0 
F = 9.0 
G = 3.2
H = 6.325
I = 8
J = -3.333894

входной файл два:

(((A + B) - (C - D)) / (E - F))
(((A)))
(A)
((A
(B
D)
D))

Программа:

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

public class InfixToPostfix {

    static final String P_ERROR = "Parenthesis Match Error";
    static final String E_ERROR = "Empty Infix Expression Error";

    static Map<Character, Integer> out_stack = new HashMap<Character, Integer>(); 
    static Map<Character, Integer> in_stack = new HashMap<Character, Integer>(); 

    public static void main(String[] args) {

        Map<Character, Double> map = null; 

        try {
            map = populate();
        }catch(IOException e) {
            e.printStackTrace();
        }

        generate();

        System.out.print("Load infix file: ");
        try {
            BufferedReader in = new BufferedReader(new FileReader(getFile()));
            String line = "";
            while((line = in.readLine()) != null) {


                if(!match(line)) {
                    System.out.println(line + " --> " + P_ERROR);
                    continue;
                }

                String expression = convert(line, map);

                if(expression.equals("")) {
                    System.out.println(line + " --> " + E_ERROR);
                    continue;
                }

                System.out.println(line + " --> " + expression + " --> " + evaluate(expression, map));              

            }
            in.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch(IOException e) {
            e.printStackTrace();
        }


    }

    static boolean isOperand(char operand, Map<Character, Double> map) {
        if(map.containsKey(operand))
                return true;
        return false;
    }

    static String convert(String infix, Map<Character, Double> map) {

        ArrayStack<Character> as = new ArrayStack<Character>(infix.length());

        String post_expression = "";
        int index = 0;

        while(index < infix.length()) { 

            char current = infix.charAt(index);

            if(current == ' ') {
            index++;
                continue;
            }
            if(isOperand(current, map)) {
                post_expression += current;
            }
            else if(current == '(') {
                as.push(current);
            }
            else if(current == ')') {
                while(as.top() != '(') {
                    post_expression += as.pop();
                }
                as.pop(); 
            }

            else {

                while(!as.isEmpty() && in_stack.get(as.top()) > out_stack.get(current)) {
                    post_expression += as.pop();
                }
                as.push(current);
            }

            index++;

        }

        while(!as.isEmpty()) {
            post_expression += as.pop();
        }

        return post_expression;

    }

    static double evaluate(String postfix, Map<Character, Double> map) {

        ArrayStack as = new ArrayStack(postfix.length());

        int index = 0;
        double temp = 0.00;

        while(index < postfix.length()) {

            char current = postfix.charAt(index);

         if(current == ' ') {
            index++;
                continue;
         }
            if(isOperand(current, map)) {
                as.push(current);
            temp = map.get(current);
            }
            else {
                char a = (char) as.pop();
                char b = (char) as.pop();
                switch(current) {
                case '+' :
                    temp = map.get(b) + map.get(a);
                    break;
                case '-' :
                    temp = map.get(b) - map.get(a);
                    break;
                case '*' :
                    temp = map.get(b) * map.get(a);
                    break;
                case '/' :
                    temp = map.get(b) / map.get(a);
                    break;
                case '%' :
                    temp = map.get(b) % map.get(a);
                    break;
                }
                map.put('z', temp);
                as.push('z');
            }

            index++;
        }
        if(as.size() == 1) {
            as.pop(); 
        }
        else {
            System.out.println("There is an error");
        }
      return temp;

    }

    static Map<Character, Double> populate() throws IOException{
        Map<Character, Double> map = new HashMap<Character, Double>();
        System.out.print("Load Map File: ");
        BufferedReader in = new BufferedReader(new FileReader(getFile()));
        String line = "";
        while((line = in.readLine()) != null) {
            String parts[] = line.split(" = ");
            char c = parts[0].charAt(0);
            map.put(c, Double.parseDouble(parts[1].trim()));
        }
        in.close();

        return map;

    }

    static void generate() {

        out_stack.put('(', 100);
        out_stack.put('(', 0);
        out_stack.put('^', 6);
        out_stack.put('*', 3);
        out_stack.put('/', 3);
        out_stack.put('%', 3);
        out_stack.put('+', 1);
        out_stack.put('-', 1);

        in_stack.put('(', 0);
        in_stack.put(')', null);
        in_stack.put('^', 5);
        in_stack.put('*', 4);
        in_stack.put('/', 4);
        in_stack.put('%', 4);
        in_stack.put('+', 2);
        in_stack.put('-', 2);

    }

    static String getFile() {
        Scanner kb = new Scanner(System.in);
        return kb.nextLine();
    }

    static boolean match(String s) {

        ParenMatch p = new ParenMatch();

        return p.parenMatch(s);

    }

}