anchor.diff:        /* 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.
          */
  -      if(tempToken.type == TokenType.MINUS && operatorBuffer.last.type == TokenType.LBRACE){
  +      if(tempToken.type == TokenType.MINUS && operatorBuffer.last.type == TokenType.LBRACE) {
           Token newToken = new Token(tempToken.text, TokenType.UNMINUS);
           operatorBuffer.add(newToken);
           continue;
  
positive.code:   static final TokenType LN = const TokenType("LN",3);
    static final TokenType EFUNC = const TokenType("EFUNC",3);
  
  
    final String value;
    final int priority;
    const TokenType(String this.value, int this.priority);
  
    String toString(){
      return value;
    }
  }
  
negative.code:        * 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) {
            outputStream.add(operatorBuffer.last);
            operatorBuffer.removeLast();
          }
          operatorBuffer.add(tempToken);
          continue;
        } else {
          operatorBuffer.add(tempToken);
          continue;
        }
      }
      /*
       * when the algorithm reached the end of the input stream, then we add the tokens in the
       * operatorBuffer to the outputStream.
       */
      while(!operatorBuffer.isEmpty) {
        outputStream.add(operatorBuffer.last);
        operatorBuffer.removeLast();
      }
  
      return outputStream;
    }
  
    /**
     * This method invokes the createTokenStream methode to create an infix token stream and then invokes the shunting
     * yards method to transform this stream into an UPN token stream.
     *
     * Returns  List<Token>.
     */
    createUPNStream(String inputString) {
      List<Token> infixStream = createTokenStream(inputString);
      _tokenStream = shuntingYard(infixStream);
    }
  }
  
  class Token {
    //TODO
    var text;
    final TokenType type;
  
    bool operator==(Token token) => (token.text == this.text) && (token.type == this.type);
  
    Token(var this.text, TokenType this.type);
  
    String toString(){
      return "( $type , $text )";
    }
  }
  
  class TokenType {
    static final TokenType VAR = const TokenType("VAR",10);
    static final TokenType VAL = const TokenType("VAL",10);
  
    //Braces
    static final TokenType LBRACE = const TokenType("LBRACE",-1);
    static final TokenType RBRACE = const TokenType("RBRACE",-1);
  
    //Simple Operators
    static final TokenType PLUS = const TokenType("PLUS",1);
    static final TokenType MINUS = const TokenType("MINUS",1);
    static final TokenType UNMINUS = const TokenType("UNMINUS",1);
    static final TokenType TIMES = const TokenType("TIMES",2);
    static final TokenType DIV = const TokenType("DIV",2);
  
    //Complex Operators
    static final TokenType POW = const TokenType("POW",3);
    static final TokenType SQRT = const TokenType("SQRT",3);
  