Changeset 14823


Ignore:
Timestamp:
04/04/17 16:53:00 (2 years ago)
Author:
gkronber
Message:

#2650: fixed round-trip for binary factor variables (and formatting changes)

Location:
branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs

    r14761 r14823  
    6060
    6161    private void FormatRecursively(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
    62       if(node.SubtreeCount > 1) {
     62      if (node.SubtreeCount > 1) {
    6363        var token = GetToken(node.Symbol);
    64         if(token == "+" || token == "-" || token == "OR" || token == "XOR") {
     64        if (token == "+" || token == "-" || token == "OR" || token == "XOR") {
    6565          strBuilder.Append("(");
    6666          FormatRecursively(node.Subtrees.First(), strBuilder);
    6767
    68           foreach(var subtree in node.Subtrees.Skip(1)) {
     68          foreach (var subtree in node.Subtrees.Skip(1)) {
    6969            strBuilder.Append(" ").Append(token).Append(" ");
    7070            FormatRecursively(subtree, strBuilder);
     
    7272          strBuilder.Append(")");
    7373
    74         } else if(token == "*" || token == "/" || token == "AND") {
     74        } else if (token == "*" || token == "/" || token == "AND") {
    7575          strBuilder.Append("(");
    7676          FormatRecursively(node.Subtrees.First(), strBuilder);
    7777
    78           foreach(var subtree in node.Subtrees.Skip(1)) {
     78          foreach (var subtree in node.Subtrees.Skip(1)) {
    7979            strBuilder.Append(" ").Append(token).Append(" ");
    8080            FormatRecursively(subtree, strBuilder);
     
    8585          strBuilder.Append(token).Append("(");
    8686          FormatRecursively(node.Subtrees.First(), strBuilder);
    87           foreach(var subtree in node.Subtrees.Skip(1)) {
     87          foreach (var subtree in node.Subtrees.Skip(1)) {
    8888            strBuilder.Append(", ");
    8989            FormatRecursively(subtree, strBuilder);
     
    9191          strBuilder.Append(")");
    9292        }
    93       } else if(node.SubtreeCount == 1) {
     93      } else if (node.SubtreeCount == 1) {
    9494        var token = GetToken(node.Symbol);
    95         if(token == "-" || token == "NOT") {
     95        if (token == "-" || token == "NOT") {
    9696          strBuilder.Append("(").Append(token).Append("(");
    9797          FormatRecursively(node.GetSubtree(0), strBuilder);
    9898          strBuilder.Append("))");
    99         } else if(token == "/") {
     99        } else if (token == "/") {
    100100          strBuilder.Append("1/");
    101101          FormatRecursively(node.GetSubtree(0), strBuilder);
    102         } else if(token == "+" || token == "*") {
     102        } else if (token == "+" || token == "*") {
    103103          FormatRecursively(node.GetSubtree(0), strBuilder);
    104104        } else {
     
    110110      } else {
    111111        // no subtrees
    112         if(node.Symbol is LaggedVariable) {
     112        if (node.Symbol is LaggedVariable) {
    113113          var varNode = node as LaggedVariableTreeNode;
    114           if(!varNode.Weight.IsAlmost(1.0)) {
     114          if (!varNode.Weight.IsAlmost(1.0)) {
    115115            strBuilder.Append("(");
    116116            strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", varNode.Weight);
     
    118118          }
    119119          strBuilder.Append("LAG(");
    120           if(varNode.VariableName.Contains("'")) {
     120          if (varNode.VariableName.Contains("'")) {
    121121            strBuilder.AppendFormat("\"{0}\"", varNode.VariableName);
    122122          } else {
     
    126126            .AppendFormat(CultureInfo.InvariantCulture, "{0}", varNode.Lag)
    127127            .Append(")");
    128         } else if(node.Symbol is Variable) {
     128        } else if (node.Symbol is Variable) {
    129129          var varNode = node as VariableTreeNode;
    130           if(!varNode.Weight.IsAlmost(1.0)) {
     130          if (!varNode.Weight.IsAlmost(1.0)) {
    131131            strBuilder.Append("(");
    132132            strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", varNode.Weight);
    133133            strBuilder.Append("*");
    134134          }
    135           if(varNode.VariableName.Contains("'")) {
     135          if (varNode.VariableName.Contains("'")) {
    136136            strBuilder.AppendFormat("\"{0}\"", varNode.VariableName);
    137137          } else {
    138138            strBuilder.AppendFormat("'{0}'", varNode.VariableName);
    139139          }
    140           if(!varNode.Weight.IsAlmost(1.0)) {
     140          if (!varNode.Weight.IsAlmost(1.0)) {
    141141            strBuilder.Append(")");
    142142          }
    143         } else if(node.Symbol is FactorVariable) {
     143        } else if (node.Symbol is FactorVariable) {
    144144          var factorNode = node as FactorVariableTreeNode;
    145           if(factorNode.VariableName.Contains("'")) {
     145          if (factorNode.VariableName.Contains("'")) {
    146146            strBuilder.AppendFormat("\"{0}\"", factorNode.VariableName);
    147147          } else {
     
    150150          strBuilder.AppendFormat("[{0}]",
    151151            string.Join(", ", factorNode.Weights.Select(w => w.ToString(CultureInfo.InvariantCulture))));
    152         } else if(node.Symbol is BinaryFactorVariable) {
     152        } else if (node.Symbol is BinaryFactorVariable) {
    153153          var factorNode = node as BinaryFactorVariableTreeNode;
    154           if(!factorNode.Weight.IsAlmost(1.0)) {
     154          if (!factorNode.Weight.IsAlmost(1.0)) {
    155155            strBuilder.Append("(");
    156156            strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", factorNode.Weight);
    157157            strBuilder.Append("*");
    158158          }
    159           if(factorNode.VariableName.Contains("'")) {
    160             strBuilder.AppendFormat("\"{0}={1}\"", factorNode.VariableName, factorNode.VariableValue);
     159          if (factorNode.VariableName.Contains("'")) {
     160            strBuilder.AppendFormat("\"{0}\"", factorNode.VariableName);
    161161          } else {
    162             strBuilder.AppendFormat("'{0}={1}'", factorNode.VariableName, factorNode.VariableValue);
     162            strBuilder.AppendFormat("'{0}'", factorNode.VariableName);
    163163          }
    164           if(!factorNode.Weight.IsAlmost(1.0)) {
     164          strBuilder.Append(" = ");
     165          if (factorNode.VariableValue.Contains("'")) {
     166            strBuilder.AppendFormat("\"{0}\"", factorNode.VariableValue);
     167          } else {
     168            strBuilder.AppendFormat("'{0}'", factorNode.VariableValue);
     169          }
     170
     171          if (!factorNode.Weight.IsAlmost(1.0)) {
    165172            strBuilder.Append(")");
    166173          }
    167174
    168         } else if(node.Symbol is Constant) {
     175        } else if (node.Symbol is Constant) {
    169176          var constNode = node as ConstantTreeNode;
    170           if(constNode.Value >= 0.0)
     177          if (constNode.Value >= 0.0)
    171178            strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", constNode.Value);
    172179          else
     
    178185    private string GetToken(ISymbol symbol) {
    179186      var tok = InfixExpressionParser.knownSymbols.GetBySecond(symbol).SingleOrDefault();
    180       if(tok == null)
     187      if (tok == null)
    181188        throw new ArgumentException(string.Format("Unknown symbol {0} found.", symbol.Name));
    182189      return tok;
  • branches/symbreg-factors-2650/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs

    r14765 r14823  
    132132
    133133
    134       foreach(var kvp in dict) {
     134      foreach (var kvp in dict) {
    135135        knownSymbols.Add(kvp.Key, kvp.Value);
    136136      }
     
    151151    private IEnumerable<Token> GetAllTokens(string str) {
    152152      int pos = 0;
    153       while(true) {
    154         while(pos < str.Length && Char.IsWhiteSpace(str[pos])) pos++;
    155         if(pos >= str.Length) {
     153      while (true) {
     154        while (pos < str.Length && Char.IsWhiteSpace(str[pos])) pos++;
     155        if (pos >= str.Length) {
    156156          yield return new Token { TokenType = TokenType.End, strVal = "" };
    157157          yield break;
    158158        }
    159         if(char.IsDigit(str[pos])) {
     159        if (char.IsDigit(str[pos])) {
    160160          // read number (=> read until white space or operator or comma)
    161161          var sb = new StringBuilder();
    162162          sb.Append(str[pos]);
    163163          pos++;
    164           while(pos < str.Length && !char.IsWhiteSpace(str[pos])
     164          while (pos < str.Length && !char.IsWhiteSpace(str[pos])
    165165            && (str[pos] != '+' || str[pos - 1] == 'e' || str[pos - 1] == 'E')     // continue reading exponents
    166166            && (str[pos] != '-' || str[pos - 1] == 'e' || str[pos - 1] == 'E')
     
    174174          }
    175175          double dblVal;
    176           if(double.TryParse(sb.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out dblVal))
     176          if (double.TryParse(sb.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out dblVal))
    177177            yield return new Token { TokenType = TokenType.Number, strVal = sb.ToString(), doubleVal = dblVal };
    178178          else yield return new Token { TokenType = TokenType.NA, strVal = sb.ToString() };
    179         } else if(char.IsLetter(str[pos]) || str[pos] == '_') {
     179        } else if (char.IsLetter(str[pos]) || str[pos] == '_') {
    180180          // read ident
    181181          var sb = new StringBuilder();
    182182          sb.Append(str[pos]);
    183183          pos++;
    184           while(pos < str.Length &&
     184          while (pos < str.Length &&
    185185            (char.IsLetter(str[pos]) || str[pos] == '_' || char.IsDigit(str[pos]))) {
    186186            sb.Append(str[pos]);
     
    188188          }
    189189          yield return new Token { TokenType = TokenType.Identifier, strVal = sb.ToString() };
    190         } else if(str[pos] == '"') {
     190        } else if (str[pos] == '"') {
    191191          // read to next "
    192192          pos++;
    193193          var sb = new StringBuilder();
    194           while(pos < str.Length && str[pos] != '"') {
     194          while (pos < str.Length && str[pos] != '"') {
    195195            sb.Append(str[pos]);
    196196            pos++;
    197197          }
    198           if(pos < str.Length && str[pos] == '"') {
     198          if (pos < str.Length && str[pos] == '"') {
    199199            pos++; // skip "
    200200            yield return new Token { TokenType = TokenType.Identifier, strVal = sb.ToString() };
     
    202202            yield return new Token { TokenType = TokenType.NA };
    203203
    204         } else if(str[pos] == '\'') {
     204        } else if (str[pos] == '\'') {
    205205          // read to next '
    206206          pos++;
    207207          var sb = new StringBuilder();
    208           while(pos < str.Length && str[pos] != '\'') {
     208          while (pos < str.Length && str[pos] != '\'') {
    209209            sb.Append(str[pos]);
    210210            pos++;
    211211          }
    212           if(pos < str.Length && str[pos] == '\'') {
     212          if (pos < str.Length && str[pos] == '\'') {
    213213            pos++; // skip '
    214214            yield return new Token { TokenType = TokenType.Identifier, strVal = sb.ToString() };
    215215          } else
    216216            yield return new Token { TokenType = TokenType.NA };
    217         } else if(str[pos] == '+') {
     217        } else if (str[pos] == '+') {
    218218          pos++;
    219219          yield return new Token { TokenType = TokenType.Operator, strVal = "+" };
    220         } else if(str[pos] == '-') {
     220        } else if (str[pos] == '-') {
    221221          pos++;
    222222          yield return new Token { TokenType = TokenType.Operator, strVal = "-" };
    223         } else if(str[pos] == '/') {
     223        } else if (str[pos] == '/') {
    224224          pos++;
    225225          yield return new Token { TokenType = TokenType.Operator, strVal = "/" };
    226         } else if(str[pos] == '*') {
     226        } else if (str[pos] == '*') {
    227227          pos++;
    228228          yield return new Token { TokenType = TokenType.Operator, strVal = "*" };
    229         } else if(str[pos] == '(') {
     229        } else if (str[pos] == '(') {
    230230          pos++;
    231231          yield return new Token { TokenType = TokenType.LeftPar, strVal = "(" };
    232         } else if(str[pos] == ')') {
     232        } else if (str[pos] == ')') {
    233233          pos++;
    234234          yield return new Token { TokenType = TokenType.RightPar, strVal = ")" };
    235         } else if(str[pos] == '[') {
     235        } else if (str[pos] == '[') {
    236236          pos++;
    237237          yield return new Token { TokenType = TokenType.LeftBracket, strVal = "[" };
    238         } else if(str[pos] == ']') {
     238        } else if (str[pos] == ']') {
    239239          pos++;
    240240          yield return new Token { TokenType = TokenType.RightBracket, strVal = "]" };
    241         } else if(str[pos] == '=') {
     241        } else if (str[pos] == '=') {
    242242          pos++;
    243243          yield return new Token { TokenType = TokenType.Eq, strVal = "=" };
    244         } else if(str[pos] == ',') {
     244        } else if (str[pos] == ',') {
    245245          pos++;
    246246          yield return new Token { TokenType = TokenType.Comma, strVal = "," };
     
    255255
    256256      var endTok = tokens.Dequeue();
    257       if(endTok.TokenType != TokenType.End)
     257      if (endTok.TokenType != TokenType.End)
    258258        throw new ArgumentException(string.Format("Expected end of expression (got {0})", endTok.strVal));
    259259
     
    267267      var negTerms = new List<ISymbolicExpressionTreeNode>();
    268268      bool negateFirstTerm = false;
    269       if(next.TokenType == TokenType.Operator && (next.strVal == "+" || next.strVal == "-")) {
     269      if (next.TokenType == TokenType.Operator && (next.strVal == "+" || next.strVal == "-")) {
    270270        tokens.Dequeue();
    271         if(next.strVal == "-")
     271        if (next.strVal == "-")
    272272          negateFirstTerm = true;
    273273      }
    274274      var t = ParseTerm(tokens);
    275       if(negateFirstTerm) negTerms.Add(t);
     275      if (negateFirstTerm) negTerms.Add(t);
    276276      else posTerms.Add(t);
    277277
    278278      next = tokens.Peek();
    279       while(next.strVal == "+" || next.strVal == "-") {
    280         switch(next.strVal) {
     279      while (next.strVal == "+" || next.strVal == "-") {
     280        switch (next.strVal) {
    281281          case "+": {
    282282              tokens.Dequeue();
     
    296296
    297297      var sum = GetSymbol("+").CreateTreeNode();
    298       foreach(var posTerm in posTerms) sum.AddSubtree(posTerm);
    299       if(negTerms.Any()) {
    300         if(negTerms.Count == 1) {
     298      foreach (var posTerm in posTerms) sum.AddSubtree(posTerm);
     299      if (negTerms.Any()) {
     300        if (negTerms.Count == 1) {
    301301          var sub = GetSymbol("-").CreateTreeNode();
    302302          sub.AddSubtree(negTerms.Single());
     
    304304        } else {
    305305          var sumNeg = GetSymbol("+").CreateTreeNode();
    306           foreach(var negTerm in negTerms) sumNeg.AddSubtree(negTerm);
     306          foreach (var negTerm in negTerms) sumNeg.AddSubtree(negTerm);
    307307
    308308          var constNode = (ConstantTreeNode)constant.CreateTreeNode();
     
    315315        }
    316316      }
    317       if(sum.SubtreeCount == 1) return sum.Subtrees.First();
     317      if (sum.SubtreeCount == 1) return sum.Subtrees.First();
    318318      else return sum;
    319319    }
     
    321321    private ISymbol GetSymbol(string tok) {
    322322      var symb = knownSymbols.GetByFirst(tok).FirstOrDefault();
    323       if(symb == null) throw new ArgumentException(string.Format("Unknown token {0} found.", tok));
     323      if (symb == null) throw new ArgumentException(string.Format("Unknown token {0} found.", tok));
    324324      return symb;
    325325    }
     
    332332
    333333      var next = tokens.Peek();
    334       while(next.strVal == "*" || next.strVal == "/") {
    335         switch(next.strVal) {
     334      while (next.strVal == "*" || next.strVal == "/") {
     335        switch (next.strVal) {
    336336          case "*": {
    337337              tokens.Dequeue();
     
    352352        next = tokens.Peek();
    353353      }
    354       if(factors.Count == 1) return factors.First();
     354      if (factors.Count == 1) return factors.First();
    355355      else {
    356356        var prod = GetSymbol("*").CreateTreeNode();
    357         foreach(var f in factors) prod.AddSubtree(f);
     357        foreach (var f in factors) prod.AddSubtree(f);
    358358        return prod;
    359359      }
     
    372372    private ISymbolicExpressionTreeNode ParseFact(Queue<Token> tokens) {
    373373      var next = tokens.Peek();
    374       if(next.TokenType == TokenType.LeftPar) {
     374      if (next.TokenType == TokenType.LeftPar) {
    375375        tokens.Dequeue();
    376376        var expr = ParseExpr(tokens);
    377377        var rPar = tokens.Dequeue();
    378         if(rPar.TokenType != TokenType.RightPar)
     378        if (rPar.TokenType != TokenType.RightPar)
    379379          throw new ArgumentException("expected )");
    380380        return expr;
    381       } else if(next.TokenType == TokenType.Identifier) {
     381      } else if (next.TokenType == TokenType.Identifier) {
    382382        var idTok = tokens.Dequeue();
    383         if(tokens.Peek().TokenType == TokenType.LeftPar) {
     383        if (tokens.Peek().TokenType == TokenType.LeftPar) {
    384384          // function identifier or LAG
    385385          var funcId = idTok.strVal.ToUpperInvariant();
     
    387387          var funcNode = GetSymbol(funcId).CreateTreeNode();
    388388          var lPar = tokens.Dequeue();
    389           if(lPar.TokenType != TokenType.LeftPar)
     389          if (lPar.TokenType != TokenType.LeftPar)
    390390            throw new ArgumentException("expected (");
    391391
    392392          // handle 'lag' specifically
    393           if(funcNode.Symbol is LaggedVariable) {
     393          if (funcNode.Symbol is LaggedVariable) {
    394394            var varId = tokens.Dequeue();
    395             if(varId.TokenType != TokenType.Identifier) throw new ArgumentException("Identifier expected. Format for lagged variables: \"lag(x, -1)\"");
     395            if (varId.TokenType != TokenType.Identifier) throw new ArgumentException("Identifier expected. Format for lagged variables: \"lag(x, -1)\"");
    396396            var comma = tokens.Dequeue();
    397             if(comma.TokenType != TokenType.Comma) throw new ArgumentException("',' expected, Format for lagged variables: \"lag(x, -1)\"");
     397            if (comma.TokenType != TokenType.Comma) throw new ArgumentException("',' expected, Format for lagged variables: \"lag(x, -1)\"");
    398398            double sign = 1.0;
    399             if(tokens.Peek().strVal == "+" || tokens.Peek().strVal == "-") {
     399            if (tokens.Peek().strVal == "+" || tokens.Peek().strVal == "-") {
    400400              // read sign
    401401              var signTok = tokens.Dequeue();
    402               if(signTok.strVal == "-") sign = -1.0;
     402              if (signTok.strVal == "-") sign = -1.0;
    403403            }
    404404            var lagToken = tokens.Dequeue();
    405             if(lagToken.TokenType != TokenType.Number) throw new ArgumentException("Number expected, Format for lagged variables: \"lag(x, -1)\"");
    406             if(!lagToken.doubleVal.IsAlmost(Math.Round(lagToken.doubleVal)))
     405            if (lagToken.TokenType != TokenType.Number) throw new ArgumentException("Number expected, Format for lagged variables: \"lag(x, -1)\"");
     406            if (!lagToken.doubleVal.IsAlmost(Math.Round(lagToken.doubleVal)))
    407407              throw new ArgumentException("Time lags must be integer values");
    408408            var laggedVarNode = funcNode as LaggedVariableTreeNode;
     
    414414            var args = ParseArgList(tokens);
    415415            // check number of arguments
    416             if(funcNode.Symbol.MinimumArity > args.Length || funcNode.Symbol.MaximumArity < args.Length) {
     416            if (funcNode.Symbol.MinimumArity > args.Length || funcNode.Symbol.MaximumArity < args.Length) {
    417417              throw new ArgumentException(string.Format("Symbol {0} requires between {1} and  {2} arguments.", funcId,
    418418                funcNode.Symbol.MinimumArity, funcNode.Symbol.MaximumArity));
    419419            }
    420             foreach(var arg in args) funcNode.AddSubtree(arg);
     420            foreach (var arg in args) funcNode.AddSubtree(arg);
    421421          }
    422422
    423423          var rPar = tokens.Dequeue();
    424           if(rPar.TokenType != TokenType.RightPar)
     424          if (rPar.TokenType != TokenType.RightPar)
    425425            throw new ArgumentException("expected )");
    426426
     
    428428        } else {
    429429          // variable
    430           if(tokens.Peek().TokenType == TokenType.Eq) {
     430          if (tokens.Peek().TokenType == TokenType.Eq) {
    431431            // binary factor
    432432            tokens.Dequeue(); // skip Eq
    433433            var valTok = tokens.Dequeue();
    434             if(valTok.TokenType != TokenType.Identifier) throw new ArgumentException("expected identifier");
     434            if (valTok.TokenType != TokenType.Identifier) throw new ArgumentException("expected identifier");
    435435            var binFactorNode = (BinaryFactorVariableTreeNode)binaryFactorVar.CreateTreeNode();
    436436            binFactorNode.Weight = 1.0;
     
    438438            binFactorNode.VariableValue = valTok.strVal;
    439439            return binFactorNode;
    440           } else if(tokens.Peek().TokenType == TokenType.LeftBracket) {
     440          } else if (tokens.Peek().TokenType == TokenType.LeftBracket) {
    441441            // factor variable
    442442            var factorVariableNode = (FactorVariableTreeNode)factorVar.CreateTreeNode();
     
    447447            // at least one weight is necessary
    448448            var sign = 1.0;
    449             if(tokens.Peek().TokenType == TokenType.Operator) {
     449            if (tokens.Peek().TokenType == TokenType.Operator) {
    450450              var opToken = tokens.Dequeue();
    451               if(opToken.strVal == "+") sign = 1.0;
    452               else if(opToken.strVal == "-") sign = -1.0;
     451              if (opToken.strVal == "+") sign = 1.0;
     452              else if (opToken.strVal == "-") sign = -1.0;
    453453              else throw new ArgumentException();
    454454            }
    455             if(tokens.Peek().TokenType != TokenType.Number) throw new ArgumentException("number expected");
     455            if (tokens.Peek().TokenType != TokenType.Number) throw new ArgumentException("number expected");
    456456            var weightTok = tokens.Dequeue();
    457457            weights.Add(sign * weightTok.doubleVal);
    458             while(tokens.Peek().TokenType == TokenType.Comma) {
     458            while (tokens.Peek().TokenType == TokenType.Comma) {
    459459              // skip comma
    460460              tokens.Dequeue();
    461               if(tokens.Peek().TokenType == TokenType.Operator) {
     461              if (tokens.Peek().TokenType == TokenType.Operator) {
    462462                var opToken = tokens.Dequeue();
    463                 if(opToken.strVal == "+") sign = 1.0;
    464                 else if(opToken.strVal == "-") sign = -1.0;
     463                if (opToken.strVal == "+") sign = 1.0;
     464                else if (opToken.strVal == "-") sign = -1.0;
    465465                else throw new ArgumentException();
    466466              }
    467467              weightTok = tokens.Dequeue();
    468               if(weightTok.TokenType != TokenType.Number) throw new ArgumentException("number expected");
     468              if (weightTok.TokenType != TokenType.Number) throw new ArgumentException("number expected");
    469469              weights.Add(sign * weightTok.doubleVal);
    470470            }
    471471            var rightBracketToken = tokens.Dequeue();
    472             if(rightBracketToken.TokenType != TokenType.RightBracket) throw new ArgumentException("closing bracket ] expected");
     472            if (rightBracketToken.TokenType != TokenType.RightBracket) throw new ArgumentException("closing bracket ] expected");
    473473            factorVariableNode.Weights = weights.ToArray();
    474474            return factorVariableNode;
     
    481481          }
    482482        }
    483       } else if(next.TokenType == TokenType.Number) {
     483      } else if (next.TokenType == TokenType.Number) {
    484484        var numTok = tokens.Dequeue();
    485485        var constNode = (ConstantTreeNode)constant.CreateTreeNode();
     
    495495      var exprList = new List<ISymbolicExpressionTreeNode>();
    496496      exprList.Add(ParseExpr(tokens));
    497       while(tokens.Peek().TokenType != TokenType.RightPar) {
     497      while (tokens.Peek().TokenType != TokenType.RightPar) {
    498498        var comma = tokens.Dequeue();
    499         if(comma.TokenType != TokenType.Comma) throw new ArgumentException("expected ',' ");
     499        if (comma.TokenType != TokenType.Comma) throw new ArgumentException("expected ',' ");
    500500        exprList.Add(ParseExpr(tokens));
    501501      }
Note: See TracChangeset for help on using the changeset viewer.