public class model implements sorting{
private Stack<Character> stackOperator;
private Stack<Double> stackOperand;
public String hasil;
public String infixExp = "";
public String postfixExp = "";
public Double doubhasil;

public model() {
stackOperator = new Stack<Character>();
stackOperand = new Stack<Double>();
}

public boolean isOperator(String token) {
return (token.equalsIgnoreCase("^") || token.equalsIgnoreCase("*") || token.equalsIgnoreCase("/")  ||
token.equalsIgnoreCase("%") || token.equalsIgnoreCase("+") || token.equalsIgnoreCase("-"));
}

public boolean isOperand(String token) {
//sudah menangani kasus bilangan negatif
return (!isOperator(token) && ((Character.isDigit(token.charAt(0))) || (token.charAt(0) == '-')));
}

//mengembalikan prioritas operator saat evaluasi
public int prioritas(char opr) {
int retval;
switch (opr) {
case '^':   {   retval = 3; break;  }
case '*':   {   retval = 2; break;  }
case '/':   {   retval = 2; break;  }
case '%':   {   retval = 2; break;  }
case '+':   {   retval = 1; break;  }
case '-':   {   retval = 1; break;  }
default:    {   retval = 0; break;  }
}
return retval;
}

public String convertToPostfix(String infixExp) throws Exception {
StringTokenizer st = new StringTokenizer(infixExp);
String curToken = "", postfixExp = "";
int nKurungBuka = 0, nKurungTutup = 0;
Character temp;

while(st.hasMoreTokens()) {
//mengambil token
curToken = st.nextToken();
if(isOperand(curToken)) {
//jika currentToken adalah operand, maka kembalikan sebagai ekspresi postfix
postfixExp = postfixExp + " " + (Double.parseDouble(curToken));
} else if(curToken.equals("(")) {
//jika currentToken adalah kurung buka, maka push tanda kurung buka ke stack operator
Character opr = new Character('(');
stackOperator.push(opr);
nKurungBuka++;
} else if(curToken.equals(")")) {
//jika currentToken adalah kurung tutup, maka pop stack operator sampai ketemu kurung buka
while(((Character)stackOperator.peek()).charValue() != '(') {
postfixExp = postfixExp + " " + stackOperator.pop();
}
temp = stackOperator.pop();
nKurungTutup++;
} else if(isOperator(curToken)) {
//jika currentToken adalah operator
if(stackOperator.isEmpty()) {
//stack operator masih kosong, maka push currentToken ke stack operator
Character opr = new Character(curToken.charAt(0));
stackOperator.push(opr);
} else {
/*
stack operator sudah ada isinya
ambil puncak stack, lalu bandingkan presedensinya dengan currentToken
jika precendence(puncak) > prioritas(currentToken) maka pop stack
*/
Character opr = new Character(curToken.charAt(0));
if (prioritas(((Character)stackOperator.peek()).charValue()) > prioritas(opr)) {
postfixExp = postfixExp + " " + stackOperator.pop();
}
else if(prioritas(((Character)stackOperator.peek()).charValue()) == prioritas(opr)){
postfixExp = postfixExp + " " + stackOperator.pop();
}

//push currentToken
stackOperator.push(opr);
}
}
else {
//ekspresi tidak valid
throw new MyInfixToPostfixException("Operator lebih Banyak dari Operand");
}
}

//ekspresi tidak valid
if(nKurungBuka != nKurungTutup)
throw new MyInfixToPostfixException("Kurung nya ga pas!!");

//pop terus stack operator sampai kosong
while (!stackOperator.isEmpty()) {
postfixExp = postfixExp + " " + stackOperator.pop();
}
return postfixExp;
}

public double evaluate(String postfixExp) throws Exception {
StringTokenizer st = new StringTokenizer(postfixExp);
double retval;
String curToken = "";

while (st.hasMoreTokens()) {
//mengambil token
curToken = st.nextToken();
if(isOperand(curToken)) {
//jika currentToken adalah operand, maka push ke stack operand
Double opn = new Double(Double.parseDouble(curToken));
stackOperand.push(opn);
}
else {
//jika currentToken adalah operator, maka evaluasi dua operan sebelumnya
double opn2 = ((Double)stackOperand.pop()).doubleValue();
double opn1 = ((Double)stackOperand.pop()).doubleValue();
double result = 0;
switch(curToken.charAt(0)) {
case '*':   {   result = opn1 * opn2;   break;  }
case '+':   {   result = opn1 + opn2;   break;  }
case '-':   {   result = opn1 - opn2;   break;  }
case '/':   {   result = opn1 / opn2;   break;  }
case '%':   {   result = opn1 % opn2;   break;  }
case '^':   {   result = Math.pow(opn1, opn2);  break;  }
}
Double opn = new Double(result);
stackOperand.push(opn);
}
}
retval = ((Double)stackOperand.pop()).doubleValue();
return retval;
}

public void getInputan(String infix){

try {
infixExp = infix;
postfixExp = convertToPostfix(infixExp);
doubhasil = evaluate(postfixExp);
hasil = String.valueOf(doubhasil);
}
catch (Exception e){
e.printStackTrace();
}
}

public static void main(String []args){
String ar=JOptionPane.showInputDialog("Masukkan infix");
model ari=new model();
ari.getInputan(ar);
JOptionPane.showMessageDialog(null, ari.hasil);
}
}

/**
*  @see    java.lang.Exception
*/
class MyInfixToPostfixException extends Exception {
private String message;

public MyInfixToPostfixException(String _message) {
super(_message);
message = _message;
}

public String getMessage() {
return message;
}

public String toString() {
return "MyInfixToPostfixException: " + getMessage();
}