//Evan Warner
   //This class evaluates postfix form and numerical evaluations of a complex-valued function of z
    
   import java.util.*;
    public class ComplexFunction
   {
      public static final String ops2 = "+-*/^";		//Two-argument operators
      public static final String ops1 = "scteonlmp";	//One-argument operators
      private static String myPostfixString;
      private static String myInfixString;
       public ComplexFunction(String s)	//The variable for a ComplexFunction must be named 'z'
      {
         myInfixString = s.replaceAll(" ","");
         myPostfixString = convert(myInfixString);
         Complex dummy = value(new Complex(0,0));		//To provide an extra check for syntax problems
      }
      
   	//Returns the function in infix form
       public String toString()
      {
         return myInfixString;
      }
      
   	//Returns the function in postfix form
       public String postfixString()
      {
         return myPostfixString;
      }
      
   	//Returns whether the function has a syntax error or not
       public boolean isValid()
      {
         return myPostfixString!="Syntax Error";
      }
      
   	//Calls private "eval" method if this is a valid function, otherwise returns zero
       public Complex value(Complex a)
      {
         if(!myPostfixString.equals("Syntax Error"))
            return eval(myPostfixString, a);
         return new Complex(0,0);
      }
      
   	//Converts infix form to postfix form
       private static String convert(String str)
      {
         try
         {
            if(str.length()>0&&str.substring(0,1).equals("-"))	//Checks for leading minus sign
               str="0"+str;
            int index = 0;
            int l = str.length();
            String postfix = "";
            Stack<String> stack = new Stack<String>();
            while(index<l)
            {
               char currentChar = str.charAt(index);
               boolean operatorOrParenthesis = (isOperator(currentChar)||currentChar==')'||currentChar=='(');
               int endOfBlock = index+1;
               if(!operatorOrParenthesis)
               {
                  while(endOfBlock<l&&isNumberOrVarPart(str.charAt(endOfBlock)))
                     endOfBlock++;
                  postfix = postfix + str.substring(index,endOfBlock) + " ";
               }
               else if(currentChar=='(')
                  stack.push(str.substring(index,endOfBlock));
               else if(currentChar==')')
               {
                  while(!stack.peek().equals("("))
                     postfix = postfix + stack.pop() + " ";
                  stack.pop();
               }
               else
               {
                  while(!stack.isEmpty()&&!stack.peek().equals("(")&&!isLower(currentChar,stack.peek().charAt(0)))
                     postfix = postfix + stack.pop() + " ";
                  if(index<(l-4)&&currentChar=='s'&&str.charAt(index+1)=='i'&&str.charAt(index+2)=='n')
                  {
                     stack.push("s");
                     index+=2;
                  }
                  else if(index<(l-4)&&currentChar=='c'&&str.charAt(index+1)=='o'&&str.charAt(index+2)=='s')
                  {
                     stack.push("c");
                     index+=2;
                  }
                  else if(index<(l-4)&&currentChar=='t'&&str.charAt(index+1)=='a'&&str.charAt(index+2)=='n')
                  {
                     stack.push("t");
                     index+=2;
                  }
                  else if(index<(l-4)&&currentChar=='s'&&str.charAt(index+1)=='e'&&str.charAt(index+2)=='c')
                  {
                     stack.push("e");
                     index+=2;
                  }
                  else if(index<(l-4)&&currentChar=='c'&&str.charAt(index+1)=='s'&&str.charAt(index+2)=='c')
                  {
                     stack.push("o");
                     index+=2;
                  }
                  else if(index<(l-4)&&currentChar=='c'&&str.charAt(index+1)=='o'&&str.charAt(index+2)=='t')
                  {
                     stack.push("n");
                     index+=2;
                  }
                  else if(index<(l-3)&&currentChar=='l'&&str.charAt(index+1)=='n')
                  {
                     stack.push("l");
                     index+=1;
                  }
                  else if(index<(l-4)&&currentChar=='l'&&str.charAt(index+1)=='o'&&str.charAt(index+2)=='g')
                  {
                     stack.push("g");
                     index+=2;
                  }
                  else if(index<(l-4)&&currentChar=='a'&&str.charAt(index+1)=='b'&&str.charAt(index+2)=='s')
                  {
                     stack.push("a");
                     index+=2;
                  }
                  else if(index<(l-4)&&currentChar=='e'&&str.charAt(index+1)=='x'&&str.charAt(index+2)=='p')
                  {
                     stack.push("p");
                     index+=2;
                  }
                  else
                     stack.push(Character.toString(currentChar));
               }
               index++;
               if(!operatorOrParenthesis)
                  while(index<l&&isNumberOrVarPart(str.charAt(index)))
                     index++;
            }
            while(!stack.isEmpty())
               postfix = postfix + stack.pop() + " ";
            return postfix.substring(0,postfix.length()-1);
         }
             catch(Exception e)	//Catches any parsing/syntax error in infix evaluation
            {
               if(!(myInfixString.length()>16&&myInfixString.substring(myInfixString.length()-16,myInfixString.length()).equals("!!SYNTAX_ERROR!!")))
                  myInfixString+="!!SYNTAX_ERROR!!";
               return "Syntax Error";
            }
      }
      
   	//Checks whether a character is part of a number or variable
       private static boolean isNumberOrVarPart(char c)
      {
         if(Character.isDigit(c)||c=='.'||c=='z'||c=='i')
            return true;
         return false;
      }
      
   	//Compares the order of operations precedence of two characters
       private static boolean isLower(char c1, char c2)
      {
         int input1 = assignPref(c1);
         int input2 = assignPref(c2);
         if(input1<input2)
            return true;
         return false;
      }
      
   	//Assigns an order of operations value to a character
       public static int assignPref(char c)
      {
         if(c=='^')
            return 1;
         if(c=='*')
            return 2;
         else if(c=='/')
            return 2;
         else if(c=='+')
            return 3;
         else if(c=='-')
            return 3;
         return 0;
      }
      
   	//Parses a complex number of either the form {x,y} given by Complex.toString() or of a single real or imaginary number
       private static Complex parseComplex(String str, Complex a)
      {
         if(str.charAt(0)=='{'&&str.charAt(str.length()-1)=='}')
         {
            int bk = str.indexOf(44);    //index of ","
            return new Complex(Double.parseDouble(str.substring(1,bk)),Double.parseDouble(str.substring(bk+1,str.length()-1)));
         }
         int index = str.indexOf(105);   //Index of "i"
         if(index==-1)
         {
            try
            {
               return new Complex(Double.parseDouble(str),0);
            }
                catch(NumberFormatException e)
               {
                  if(str.equals("z"))
                     return new Complex(a.real(),a.imag());
                  else
                  {
                     myPostfixString="Syntax Error";
                     if(!(myInfixString.length()>16&&myInfixString.substring(myInfixString.length()-16,myInfixString.length()).equals("!!SYNTAX_ERROR!!")))
                        myInfixString+="!!SYNTAX_ERROR!!";
                     return new Complex(0,0);
                  }
               } 
         }
         else
         {
            str=str.replace("i","");
            try
            {
               if(str.equals(""))
                  return new Complex(0,1);
               return new Complex(0,Double.parseDouble(str));
            }
                catch(NumberFormatException e)
               {
                  if(str.equals("z"))
                     return new Complex(a.real(),a.imag());
                  else
                  {
                     myPostfixString="Syntax Error";
                     if(!(myInfixString.length()>16&&myInfixString.substring(myInfixString.length()-16,myInfixString.length()).equals("!!SYNTAX_ERROR!!")))
                        myInfixString+="!!SYNTAX_ERROR!!";
                     return new Complex(0,0);
                  }
               }
         }
      }
      
   	//
       private static Complex eval(String str, Complex a)
      {
         try
         {
            if(str.equals("z"))
               return a;
            int index = 0;
            int lengthOfString = str.length();
            Stack<String> stack = new Stack<String>();
            while(index<lengthOfString)
            {
               char currentChar = str.charAt(index);
               if(!isOperator(currentChar))
               {
                  int endOfBlock = index+1;
                  while(endOfBlock<lengthOfString&&str.charAt(endOfBlock)!=' ')
                     endOfBlock++;
                  stack.push(str.substring(index,endOfBlock));
               }
               else
               {
                  if(isTwoArgOperator(currentChar))
                  {
                     Complex input1=new Complex(0,0);
                     Complex input2=new Complex(0,0);
                     String currentString = stack.pop();
                     input1 = parseComplex(currentString,a);
                     currentString = stack.pop();  
                     input2 = parseComplex(currentString,a);
                     if(currentChar=='+')
                        stack.push(input1.add(input2).toString());
                     else if(currentChar=='-')
                        stack.push(input2.subtract(input1).toString());
                     else if(currentChar=='/')
                        stack.push(input2.divide(input1).toString());
                     else if(currentChar=='*')
                        stack.push(input1.multiply(input2).toString());
                     else if(currentChar=='^')
                        stack.push(input2.power(input1).toString());
                  }
                  else
                  {
                     Complex input = new Complex(0,0);
                     String currentString = stack.pop();
                     try
                     {
                        input = parseComplex(currentString,a);
                     }
                         catch(NumberFormatException e)
                        {
                           if(currentString.equals("z"))
                              return new Complex(a.real(),a.imag());
                           else
                           {
                              myPostfixString="Syntax Error";
                              if(!(myInfixString.length()>16&&myInfixString.substring(myInfixString.length()-16,myInfixString.length()).equals("!!SYNTAX_ERROR!!")))
                                 myInfixString+="!!SYNTAX_ERROR!!";
                              return new Complex(0,0);
                           }
                        } 
                     if(currentChar=='s')
                        stack.push(input.sin().toString());
                     else if(currentChar=='c')
                        stack.push(input.cos().toString());
                     else if(currentChar=='t')
                        stack.push(input.tan().toString());
                     else if(currentChar=='e')
                        stack.push(input.sec().toString());
                     else if(currentChar=='o')
                        stack.push(input.csc().toString());
                     else if(currentChar=='n')
                        stack.push(input.cot().toString());
                     else if(currentChar=='l')
                        stack.push(input.ln().toString());
                     else if(currentChar=='m')
                        stack.push(""+input.modulus());
                     else if(currentChar=='p')
                        stack.push(input.exp().toString());
                  }
               }
               while(index<lengthOfString&&str.charAt(index)!=' ')
                  index++;
               index++;
            }
            return parseComplex(stack.pop(),a);
         }
             catch(Exception e)	//Catches any parsing/syntax error in function evaluation
            {
               if(!(myInfixString.length()>16&&myInfixString.substring(myInfixString.length()-16,myInfixString.length()).equals("!!SYNTAX_ERROR!!")))
                  myInfixString+="!!SYNTAX_ERROR!!";
               myPostfixString= "Syntax Error";
               return new Complex(0,0);
            }
      }
      
   	//Checks whether a given character is a two-argument operator
       private static boolean isTwoArgOperator(char c)
      {
         int l = ops2.length();
         for(int i=0; i<l; i++)
            if(ops2.charAt(i)==c)
               return true;
         return false;
      }
      
   	//Checks whether a given character is an operator
       private static boolean isOperator(char c)
      {
         int l = ops1.length();
         for(int i=0; i<l; i++)
            if(ops1.charAt(i)==c)
               return true;
         l = ops2.length();
         for(int i=0; i<l; i++)
            if(ops2.charAt(i)==c)
               return true;
         return false;
      }
   }