anchor.diff:          operatorBuffer.removeLast();
           continue;
         }
  -
  +      /*
  +       * if there is no other operator in the operatorBuffer, than the current operator token ist added to the
  +       * operatorBuffer.
  +       */
         if(operatorBuffer.isEmpty){
           operatorBuffer.add(tempToken);
           continue;
         }
   
         /* if the current Tokens type is MINUS and the last Token in the operator buffer is of type LBRACE
  -       * the current Token is an unary minus, so the tokentype has to be changed
  +       * the current Token is an unary minus, so the tokentype has to be changed.
          */
         if(tempToken.type == TokenType.MINUS && operatorBuffer.last.type == TokenType.LBRACE){
           Token newToken = new Token(tempToken.text, TokenType.UNMINUS);
  
positive.code:       /* if the current token is an operator and it's priority is lower than the priority of the last
         * operator in the operator buffer, than put the operators from the operator buffer into the output
         * stream until you find an operator with a priority lower or equal as the current tokens.
         * Then add the current Token to the operator buffer
         */
        if(tempToken.type.priority < operatorBuffer.last.type.priority){
          while(operatorBuffer.length>0 && operatorBuffer.last.type.priority > tempToken.type.priority){
  
negative.code: 
  class Parser {
    Lexer lex;
    Parser(){
      lex = new Lexer();
    }
    
    Expression parse(String inputString){
      List<Expression> expressionStack = new List<Expression>();
      List<Token> inputStream;
      lex.createUPNStream(inputString);
      inputStream = lex.tokenStream;
      for (var i=0;i<inputStream.length;i++){
        Token currentToken = inputStream[i];
        
        
        if(currentToken.type == TokenType.VAL){
          Expression currentExpression = new Number(double.parse(currentToken.text));
          expressionStack.add(currentExpression);
          continue;
        }
        
        if(currentToken.type == TokenType.VAR){
          Expression currentExpression = new Variable(currentToken.text);
          expressionStack.add(currentExpression);
          continue;
        }
        
        if(currentToken.type == TokenType.PLUS){
          Expression rightOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression leftOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression currentExpression = leftOperand + rightOperand;
          expressionStack.add(currentExpression);
          continue;
        }
        
        if(currentToken.type == TokenType.MINUS){
          Expression rightOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression leftOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression currentExpression = leftOperand - rightOperand;
          expressionStack.add(currentExpression);
          continue;
        }
        
        if(currentToken.type == TokenType.TIMES){
          Expression rightOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression leftOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression currentExpression = leftOperand * rightOperand;
          expressionStack.add(currentExpression);
          continue;
        }
        
        if(currentToken.type == TokenType.DIV){
          Expression rightOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression leftOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression currentExpression = leftOperand / rightOperand;
          expressionStack.add(currentExpression);
          continue;
        }
        
        if(currentToken.type == TokenType.POW){
          Expression rightOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression leftOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression currentExpression = leftOperand ^ rightOperand;
          expressionStack.add(currentExpression);
          continue;
        }
        
        if(currentToken.type == TokenType.UNMINUS){
          Expression operand = expressionStack.last;
          expressionStack.removeLast();
          Expression currentExpression = - operand;
          expressionStack.add(currentExpression);
          continue;
        }
   
        if(currentToken.type == TokenType.LOG){
          Expression rightOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression leftOperand = expressionStack.last;
          expressionStack.removeLast();
          Expression currentExpression = new Log(leftOperand, rightOperand);
          expressionStack.add(currentExpression);
          continue;
        }
        
        if(currentToken.type == TokenType.LN){
          Expression operand = expressionStack.last;
          expressionStack.removeLast();
          Expression currentExpression = new Ln(operand);
          expressionStack.add(currentExpression);
          continue;
        }
        
        if(currentToken.type == TokenType.SQRT){
          Expression operand = expressionStack.last;
          expressionStack.removeLast();
          Expression currentExpression = new Sqrt(operand);
          expressionStack.add(currentExpression);
          continue;
        }
      }
      if(expressionStack.length>1){
        throw new StateError("The input String is not a correct expression");
      }
      return expressionStack.last;
    }
    
  }
  
  class Lexer{
    var keywords = new Map<String, TokenType>();
    List<Token> _tokenStream;
    String intBuffer ="";
    String varBuffer ="";
    Lexer(){
  