Index: trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs	(revision 17902)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs	(revision 18132)
@@ -57,5 +57,5 @@
   /// </summary>
   public sealed class InfixExpressionParser {
-    private enum TokenType { Operator, Identifier, Number, LeftPar, RightPar, LeftBracket, RightBracket, Comma, Eq, End, NA };
+    private enum TokenType { Operator, Identifier, Number, LeftPar, RightPar, LeftBracket, RightBracket, LeftAngleBracket, RightAngleBracket, Comma, Eq, End, NA };
     private class Token {
       internal double doubleVal;
@@ -82,4 +82,5 @@
       knownSymbols = new BidirectionalLookup<string, ISymbol>(StringComparer.InvariantCulture, new SymbolComparer());
 
+    private Number number = new Number();
     private Constant constant = new Constant();
     private Variable variable = new Variable();
@@ -180,5 +181,6 @@
             && str[pos] != ']'
             && str[pos] != '}'
-            && str[pos] != ',') {
+            && str[pos] != ','
+            && str[pos] != '>') {
             sb.Append(str[pos]);
             pos++;
@@ -265,4 +267,10 @@
           pos++;
           yield return new Token { TokenType = TokenType.Comma, strVal = "," };
+        } else if (str[pos] == '<') {
+          pos++;
+          yield return new Token {TokenType = TokenType.LeftAngleBracket, strVal = "<"};
+        } else if (str[pos] == '>') {
+          pos++;
+          yield return new Token {TokenType = TokenType.RightAngleBracket, strVal = ">"};
         } else {
           throw new ArgumentException("Invalid character: " + str[pos]);
@@ -326,5 +334,5 @@
           foreach (var negTerm in negTerms) sumNeg.AddSubtree(negTerm);
 
-          var constNode = (ConstantTreeNode)constant.CreateTreeNode();
+          var constNode = (NumberTreeNode)number.CreateTreeNode();
           constNode.Value = -1.0;
           var prod = GetSymbol("*").CreateTreeNode();
@@ -524,9 +532,35 @@
           }
         }
+      } else if (next.TokenType == TokenType.LeftAngleBracket) {
+        Token numberTok = null;
+        var leftAngleBracket = tokens.Dequeue();
+        if (leftAngleBracket.TokenType != TokenType.LeftAngleBracket)
+          throw new ArgumentException("opening bracket < expected");
+
+        var idTok = tokens.Dequeue();
+        if (idTok.TokenType != TokenType.Identifier || idTok.strVal.ToLower() != "num")
+          throw new ArgumentException("string 'num' expected");
+
+        if (tokens.Peek().TokenType == TokenType.Eq) {
+          var equalTok = tokens.Dequeue();
+          if (tokens.Peek().TokenType != TokenType.Number)
+            throw new ArgumentException("No value for number specified.");
+
+          numberTok = tokens.Dequeue();
+        }
+
+        var rightAngleBracket = tokens.Dequeue();
+        if (rightAngleBracket.TokenType != TokenType.RightAngleBracket)
+          throw new ArgumentException("closing bracket > expected");
+        var numNode = (NumberTreeNode)number.CreateTreeNode();
+        if (numberTok != null) numNode.Value = numberTok.doubleVal;
+        return numNode;
       } else if (next.TokenType == TokenType.Number) {
         var numTok = tokens.Dequeue();
-        var constNode = (ConstantTreeNode)constant.CreateTreeNode();
+        var constSy = new Constant {Value = numTok.doubleVal};
+        return constSy.CreateTreeNode();
+        /*var constNode = (ConstantTreeNode)constant.CreateTreeNode();
         constNode.Value = numTok.doubleVal;
-        return constNode;
+        return constNode;*/
       } else {
         throw new ArgumentException(string.Format("unexpected token in expression {0}", next.strVal));
Index: trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs	(revision 17902)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs	(revision 18132)
@@ -85,5 +85,5 @@
       };
 
-    Constant constant = new Constant();
+    Number number = new Number();
     Variable variable = new Variable();
     LaggedVariable laggedVariable = new LaggedVariable();
@@ -91,5 +91,4 @@
     TimeLag timeLag = new TimeLag();
     Integral integral = new Integral();
-    FactorVariable factorVar = new FactorVariable();
     BinaryFactorVariable binFactorVar = new BinaryFactorVariable();
 
@@ -98,5 +97,7 @@
 
     public ISymbolicExpressionTree Import(string str) {
-      str = str.Replace("(", " ( ").Replace(")", " ) ");
+      str = str.Replace("(", " ( ").Replace(")", " ) ")
+        .Replace("<", " < ").Replace(">", " > ")
+        .Replace("=", " = ");
       ISymbolicExpressionTreeNode root = programRootSymbol.CreateTreeNode();
       ISymbolicExpressionTreeNode start = startSymbol.CreateTreeNode();
@@ -160,9 +161,24 @@
         Expect(Token.RPAR, tokens);
         return tree;
-      } else if (tokens.Peek().Symbol == TokenSymbol.NUMBER) {
-        ConstantTreeNode t = (ConstantTreeNode)constant.CreateTreeNode();
+      } else if (tokens.Peek().Symbol == TokenSymbol.CONSTANT) {
+        var t = (INumericTreeNode)number.CreateTreeNode();
         t.Value = tokens.Dequeue().DoubleValue;
         return t;
-      } else throw new FormatException("Expected function or constant symbol");
+      } else if (tokens.Peek().Symbol == TokenSymbol.LBRACKET) {
+        Expect(Token.LBRACKET, tokens);
+        Expect(Token.NUM, tokens);
+        var t = (INumericTreeNode)number.CreateTreeNode();
+        if (tokens.Peek().Symbol == TokenSymbol.EQ) {
+          Expect(Token.EQ, tokens);
+          var initValToken = tokens.Dequeue();
+          if(initValToken.Symbol == TokenSymbol.CONSTANT) {
+            t.Value = initValToken.DoubleValue;
+          } else {
+            throw new FormatException("Expected a real value");
+          }
+        }
+        Expect(Token.RBRACKET, tokens);
+        return t;
+      } else throw new FormatException("Expected function or number symbol");
     }
 
@@ -225,5 +241,5 @@
 
       var weights = new List<double>();
-      while (tokens.Peek().Symbol == TokenSymbol.NUMBER) {
+      while (tokens.Peek().Symbol == TokenSymbol.CONSTANT) {
         weights.Add(tokens.Dequeue().DoubleValue);
       }
@@ -253,5 +269,5 @@
 
       var weightTok = tokens.Dequeue();
-      Debug.Assert(weightTok.Symbol == TokenSymbol.NUMBER);
+      Debug.Assert(weightTok.Symbol == TokenSymbol.CONSTANT);
       t.Weight = weightTok.DoubleValue;
 
@@ -271,5 +287,8 @@
 
     private ISymbolicExpressionTreeNode CreateTree(Token token) {
-      if (token.Symbol != TokenSymbol.SYMB) throw new FormatException("Expected function symbol, but got: " + token.StringValue);
+      if (token.Symbol != TokenSymbol.SYMB &&
+          token.Symbol != TokenSymbol.LBRACKET &&  // LBRACKET and RBRACKET are used for <num=..> and as LT, GT operators
+          token.Symbol != TokenSymbol.RBRACKET  
+          ) throw new FormatException("Expected function symbol, but got: " + token.StringValue);
       return knownSymbols[token.StringValue].CreateTreeNode();
     }
Index: trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/Token.cs
===================================================================
--- trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/Token.cs	(revision 17902)
+++ trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/Token.cs	(revision 18132)
@@ -23,8 +23,18 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  internal enum TokenSymbol { LPAR, RPAR, SYMB, NUMBER };
+  internal enum TokenSymbol {
+    LPAR, RPAR, SYMB, CONSTANT,
+    NUM, // num
+    EQ,  // =
+    LBRACKET, // <
+    RBRACKET  // >
+  };
   internal class Token {
     public static readonly Token LPAR = Token.Parse("(");
     public static readonly Token RPAR = Token.Parse(")");
+    public static readonly Token LBRACKET = Token.Parse("<");
+    public static readonly Token RBRACKET = Token.Parse(">");
+    public static readonly Token EQ = Token.Parse("=");
+    public static readonly Token NUM = Token.Parse("num");
 
     public TokenSymbol Symbol { get; set; }
@@ -46,7 +56,6 @@
     public static Token Parse(string strToken) {
       strToken = strToken.Trim();
-      Token t = new Token();
+      var t = new Token();
       t.StringValue = strToken.Trim();
-      double temp;
       if (strToken == "") {
         t = null;
@@ -55,7 +64,15 @@
       } else if (strToken == ")") {
         t.Symbol = TokenSymbol.RPAR;
-      } else if (double.TryParse(strToken, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out temp)) {
-        t.Symbol = TokenSymbol.NUMBER;
-        t.DoubleValue = double.Parse(strToken, CultureInfo.InvariantCulture.NumberFormat);
+      } else if (strToken == "<") {
+        t.Symbol = TokenSymbol.LBRACKET;
+      } else if (strToken == ">") {
+        t.Symbol = TokenSymbol.RBRACKET;
+      } else if (strToken == "=") {
+        t.Symbol = TokenSymbol.EQ;
+      } else if (strToken.ToLower() == "num") {
+        t.Symbol = TokenSymbol.NUM;
+      } else if (double.TryParse(strToken, NumberStyles.Float, CultureInfo.InvariantCulture.NumberFormat, out var val)) {
+        t.Symbol = TokenSymbol.CONSTANT;
+        t.DoubleValue = val;
       } else {
         t.Symbol = TokenSymbol.SYMB;
