Changeset 18100 for branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic

Timestamp:

12/01/21 13:40:55 (3 years ago)

Author:

chaider

Message:

#3140

• some more refactoring
• added possibility to set value of num nodes in infix parser
• changed displaying style of number

Location:

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs (modified) (2 diffs)
• Converters/LinearModelToTreeConverter.cs (modified) (3 diffs)
• Converters/TreeToAutoDiffTermConverter.cs (modified) (4 diffs)
• Formatters/InfixExpressionFormatter.cs (modified) (3 diffs)
• Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs (modified) (1 diff)
• Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs (modified) (1 diff)
• Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs (modified) (2 diffs)
• Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs (modified) (1 diff)
• Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs (modified) (1 diff)
• Formatters/SymbolicDataAnalysisExpressionPythonFormatter.cs (modified) (2 diffs)
• Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs (modified) (1 diff)
• Formatters/TSQLExpressionFormatter.cs (modified) (1 diff)
• Grammars/ArithmeticExpressionGrammar.cs (modified) (2 diffs)
• Grammars/FullFunctionalExpressionGrammar.cs (modified) (3 diffs)
• Grammars/LinearScalingGrammar.cs (modified) (4 diffs)
• Grammars/TypeCoherentExpressionGrammar.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (3 diffs)
• Importer/InfixExpressionParser.cs (modified) (5 diffs)
• Interfaces/INumericSymbol.cs (added)
• Interfaces/INumericTreeNode.cs (added)

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs

@@ -88 +88 @@
       StringBuilder builder = new StringBuilder();
       var varTreeNode = tree as VariableTreeNode;
+      var numTreeNode = tree as NumberTreeNode;
       var constTreeNode = tree as ConstantTreeNode;
       var factorVarTreeNode = tree as FactorVariableTreeNode;
@@ -97 +98 @@
       } else if (binFactorVarTreeNode != null) {
         builder.Append("(factor " + binFactorVarTreeNode.VariableName + "=" + binFactorVarTreeNode.VariableValue);
-      } else if (constTreeNode != null) {
+      } else if (numTreeNode != null || constTreeNode != null) {
         builder.Append("(const");
       } else {

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/LinearModelToTreeConverter.cs

@@ -58 +58 @@
 
       if (@const!=0.0) {
-        NumTreeNode cNode = (NumTreeNode)new Num().CreateTreeNode();
+        NumberTreeNode cNode = (NumberTreeNode)new Number().CreateTreeNode();
         cNode.Value = @const;
         add.AddSubtree(cNode);
@@ -99 +99 @@
 
       if (!@const.IsAlmost(0.0)) {
-        NumTreeNode cNode = (NumTreeNode)new Num().CreateTreeNode();
+        NumberTreeNode cNode = (NumberTreeNode)new Number().CreateTreeNode();
         cNode.Value = @const;
         addition.AddSubtree(cNode);
@@ -130 +130 @@
 
       if (!@const.IsAlmost(0.0)) {
-        NumTreeNode cNode = (NumTreeNode)new Num().CreateTreeNode();
+        NumberTreeNode cNode = (NumberTreeNode)new Number().CreateTreeNode();
         cNode.Value = @const;
         addition.AddSubtree(cNode);

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs

@@ -145 +145 @@
 
     private AutoDiff.Term ConvertToAutoDiff(ISymbolicExpressionTreeNode node) {
-      if (node.Symbol is Num) {
-        initialConstants.Add(((NumTreeNode)node).Value);
+      if (node.Symbol is Number) {
+        initialConstants.Add(((NumberTreeNode)node).Value);
         var var = new AutoDiff.Variable();
         variables.Add(var);
@@ -152 +152 @@
       }
 
-      if (node.Symbol is RealConstant) {
-        initialConstants.Add(((RealConstantTreeNode)node).Value);
+      if (node.Symbol is Constant) {
+        initialConstants.Add(((ConstantTreeNode)node).Value);
         var var = new AutoDiff.Variable();
         variables.Add(var);
@@ -267 +267 @@
       }
       if (node.Symbol is Power) {
-        var powerNode = node.GetSubtree(1) as NumTreeNode;
+        var powerNode = node.GetSubtree(1) as NumberTreeNode;
         if (powerNode == null)
           throw new NotSupportedException("Only integer powers are allowed in parameter optimization. Try to use exp() and log() instead of the power symbol.");
@@ -337 +337 @@
           !(n.Symbol is FactorVariable) &&
           !(n.Symbol is LaggedVariable) &&
-          !(n.Symbol is Num) &&
-          !(n.Symbol is RealConstant) &&
+          !(n.Symbol is Number) &&
+          !(n.Symbol is Constant) &&
           !(n.Symbol is Addition) &&
           !(n.Symbol is Subtraction) &&

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs

@@ -54 +54 @@
 
           var power = node.GetSubtree(1);
-          if(power is ConstantTreeNode constNode && Math.Truncate(constNode.Value) == constNode.Value) {
+          if(power is NumberTreeNode constNode && Math.Truncate(constNode.Value) == constNode.Value) {
             strBuilder.Append(" ").Append(token).Append(" ").Append(constNode.Value.ToString(formatString, numberFormat));
           } else {
@@ -141 +141 @@
 
           if (!factorNode.Weight.IsAlmost(1.0)) strBuilder.Append(")");
-        } else if (node.Symbol is Constant) {
-          var constNode = node as ConstantTreeNode;
+        } else if (node.Symbol is Number) {
+          var constNode = node as NumberTreeNode;
           if (constants == null && constNode.Value < 0) {
             strBuilder.Append("(").Append(constNode.Value.ToString(formatString, numberFormat))
@@ -204 +204 @@
     /// </summary>
     /// <param name="symbolicExpressionTree">The tree representation of the expression.</param>
-    /// <param name="numberFormat">Number format that should be used for numeric parameters (e.g. NumberFormatInfo.InvariantInfo (default)).</param>
+    /// <param name="numberFormat">Constant format that should be used for numeric parameters (e.g. NumberFormatInfo.InvariantInfo (default)).</param>
     /// <param name="formatString">The format string for numeric parameters (e.g. \"G4\" to limit to 4 digits, default is \"G\")</param>
     /// <returns>Infix expression</returns>

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs

@@ -162 +162 @@
           var varNode = node as VariableTreeNode;
           strBuilder.AppendFormat("{0} * {1}", VariableName2Identifier(varNode.VariableName), varNode.Weight.ToString("g17", CultureInfo.InvariantCulture));
-        } else if (node is ConstantTreeNode) {
-          var constNode = node as ConstantTreeNode;
-          strBuilder.Append(constNode.Value.ToString("g17", CultureInfo.InvariantCulture));
+        } else if (node is INumericTreeNode numNode) {
+          strBuilder.Append(numNode.Value.ToString("g17", CultureInfo.InvariantCulture));
         } else if (node.Symbol is FactorVariable) {
           var factorNode = node as FactorVariableTreeNode;

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs

@@ -134 +134 @@
         }
         stringBuilder.Append("))");
-      } else if (symbol is Constant) {
-        ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
-        stringBuilder.Append(constantTreeNode.Value.ToString(CultureInfo.InvariantCulture));
+      } else if (symbol is INumericSymbol numNode) {
+        var numTreeNode = node as INumericTreeNode;
+        stringBuilder.Append(numTreeNode.Value.ToString(CultureInfo.InvariantCulture));
       } else if (symbol is Cosine) {
         stringBuilder.Append("COS(");

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

@@ -189 +189 @@
       } else if (node.Symbol is IfThenElse) {
         strBuilder.Append(@" \operatorname{if}  \left( ");
-      } else if (node.Symbol is Constant) {
-        var constName = "c_{" + constIndex + "}";
+      } else if (node.Symbol is INumericSymbol numNode) {
+        var numName = "c_{" + constIndex + "}";
         constIndex++;
-        var constNode = node as ConstantTreeNode;
-        if (constNode.Value.IsAlmost(1.0)) {
+        var numericNode = node as INumericTreeNode;
+        if (numericNode.Value.IsAlmost(1.0)) {
           strBuilder.Append("1 ");
         } else {
-          strBuilder.Append(constName);
-          constants.Add(new KeyValuePair<string, double>(constName, constNode.Value));
-        }
-
+          strBuilder.Append(numName);
+          constants.Add(new KeyValuePair<string, double>(numName, numericNode.Value));
+        }
       } else if (node.Symbol is FactorVariable) {
         var factorNode = node as FactorVariableTreeNode;
@@ -471 +470 @@
       } else if (node.Symbol is IfThenElse) {
         strBuilder.Append(@" \right) ");
+      } else if (node.Symbol is Number) {
       } else if (node.Symbol is Constant) {
-      } else if (node.Symbol is LaggedVariable) {
+      }else if (node.Symbol is LaggedVariable) {
       } else if (node.Symbol is Variable) {
       } else if (node.Symbol is FactorVariable) {

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs

@@ -151 +151 @@
         }
         stringBuilder.Append(")");
-      } else if (symbol is Constant) {
-        ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
-        stringBuilder.Append(constantTreeNode.Value.ToString(CultureInfo.InvariantCulture));
+      } else if (symbol is INumericSymbol) {
+        var numberTreeNode = node as INumericTreeNode;
+        stringBuilder.Append(numberTreeNode?.Value.ToString(CultureInfo.InvariantCulture));
       } else if (symbol is Cosine) {
         stringBuilder.Append("cos(");

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs

@@ -130 +130 @@
           var varNode = node as VariableTreeNode;
           strBuilder.AppendFormat("Times[{0}, {1}]", varNode.VariableName, varNode.Weight.ToString("G17", CultureInfo.InvariantCulture));
-        } else if (node.Symbol is Constant) {
-          var constNode = node as ConstantTreeNode;
-          strBuilder.Append(constNode.Value.ToString("G17", CultureInfo.InvariantCulture));
+        } else if (node.Symbol is INumericSymbol) {
+          var numNode = node as INumericTreeNode;
+          strBuilder.Append(numNode?.Value.ToString("G17", CultureInfo.InvariantCulture));
         } else if (node.Symbol is FactorVariable) {
           var factorNode = node as FactorVariableTreeNode;

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionPythonFormatter.cs

@@ -202 +202 @@
       else if (node is VariableTreeNode)
         FormatVariableTreeNode(node, strBuilder);
-      else if (node is ConstantTreeNode)
-        FormatConstantTreeNode(node, strBuilder);
+      else if (node is INumericTreeNode)
+        FormatNumericTreeNode(node, strBuilder);
       else
         throw new NotSupportedException("Formatting of symbol: " + symbol + " not supported for Python symbolic expression tree formatter.");
@@ -227 +227 @@
     }
 
-    private static void FormatConstantTreeNode(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
-      var constNode = node as ConstantTreeNode;
-      strBuilder.Append(constNode.Value.ToString("g17", CultureInfo.InvariantCulture));
+    private static void FormatNumericTreeNode(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      var symbol = node.Symbol;
+      double value = 0.0;
+      if (symbol is INumericSymbol) {
+        var numNode = node as INumericTreeNode;
+        value = numNode.Value;
+      } else {
+        throw new NotSupportedException("Formatting of symbol: " + symbol + " not supported for Python symbolic expression tree formatter.");
+      }
+        
+
+      strBuilder.Append(value.ToString("g17", CultureInfo.InvariantCulture));
     }
 

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs

@@ -83 +83 @@
         }
         stringBuilder.Append(")");
-      } else if (symbol is Constant) {
-        ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
-        stringBuilder.Append(constantTreeNode.Value.ToString(CultureInfo.InvariantCulture));
-      } else if (symbol is Cosine) {
+      } else if (symbol is INumericSymbol) {
+        var numberTreeNode = node as INumericTreeNode;
+        stringBuilder.Append(numberTreeNode?.Value.ToString(CultureInfo.InvariantCulture));
+      }else if (symbol is Cosine) {
         stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         stringBuilder.Append(" cos");

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/TSQLExpressionFormatter.cs

@@ -164 +164 @@
           var varNode = node as VariableTreeNode;
           strBuilder.AppendFormat("{0} * {1}", VariableName2Identifier(varNode.VariableName), varNode.Weight.ToString("g17", CultureInfo.InvariantCulture));
-        } else if (node is ConstantTreeNode) {
-          var constNode = node as ConstantTreeNode;
-          strBuilder.Append(constNode.Value.ToString("g17", CultureInfo.InvariantCulture));
-        } else if (node.Symbol is FactorVariable) {
+        } else if (node is INumericTreeNode numNode) {
+          strBuilder.Append(numNode.Value.ToString("g17", CultureInfo.InvariantCulture));
+        }else if (node.Symbol is FactorVariable) {
           var factorNode = node as FactorVariableTreeNode;
           FormatFactor(level, factorNode, strBuilder);

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/ArithmeticExpressionGrammar.cs

@@ -49 +49 @@
       var mul = new Multiplication();
       var div = new Division();
-      var constant = new Num();
-      constant.MinValue = -20;
-      constant.MaxValue = 20;
-      var number = new RealConstant();
+      var number = new Number();
       number.MinValue = -20;
       number.MaxValue = 20;
+      var constant = new Constant();
       var variableSymbol = new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable();
       var binFactorVariableSymbol = new BinaryFactorVariable();
       var factorVariableSymbol = new FactorVariable();
 
-      var allSymbols = new List<Symbol>() { add, sub, mul, div, constant, number, variableSymbol, binFactorVariableSymbol, factorVariableSymbol };
+      var allSymbols = new List<Symbol>() { add, sub, mul, div, number, constant, variableSymbol, binFactorVariableSymbol, factorVariableSymbol };
       var functionSymbols = new List<Symbol>() { add, sub, mul, div };
 
@@ -68 +66 @@
         SetSubtreeCount(funSymb, 1, 3);
       }
+      SetSubtreeCount(number, 0, 0);
       SetSubtreeCount(constant, 0, 0);
-      SetSubtreeCount(number, 0, 0);
       SetSubtreeCount(variableSymbol, 0, 0);
       SetSubtreeCount(binFactorVariableSymbol, 0, 0);

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs

@@ -118 +118 @@
       variableCondition.InitialFrequency = 0.0;
 
-      var constant = new Num();
-      constant.MinValue = -20;
-      constant.MaxValue = 20;
+      var number = new Number();
+      number.MinValue = -20;
+      number.MaxValue = 20;
       var variableSymbol = new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable();
       var binFactorVariable = new BinaryFactorVariable();
@@ -130 +130 @@
       autoregressiveVariable.Enabled = false;
 
-      var number = new RealConstant();
-      number.MinValue = -20;
-      number.MaxValue = 20;
+      var constant = new Constant();
 
       var allSymbols = new List<Symbol>() { add, sub, mul, div, aq, mean, abs, sin, cos, tan, log, square, cube, pow, sqrt, cubeRoot, root, exp, tanh,
         airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi, fresnelCosineIntegral, fresnelSineIntegral, gamma, hypCosineIntegral, hypSineIntegral, norm, psi, sineIntegral,
-        @if, gt, lt, and, or, not,xor, timeLag, integral, derivative, constant, number, variableSymbol, binFactorVariable, factorVariable, laggedVariable,autoregressiveVariable, variableCondition };
+        @if, gt, lt, and, or, not,xor, timeLag, integral, derivative, number, constant, variableSymbol, binFactorVariable, factorVariable, laggedVariable,autoregressiveVariable, variableCondition };
       var unaryFunctionSymbols = new List<Symbol>() { abs, square, sqrt, cube, cubeRoot, sin, cos, tan, log, exp, tanh, not, timeLag, integral, derivative,
         airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi, fresnelCosineIntegral, fresnelSineIntegral, gamma, hypCosineIntegral, hypSineIntegral, norm, psi, sineIntegral
@@ -143 +141 @@
       var binaryFunctionSymbols = new List<Symbol>() { pow, root, gt, lt, aq, variableCondition };
       var ternarySymbols = new List<Symbol>() { add, sub, mul, div, mean, and, or, xor };
-      var terminalSymbols = new List<Symbol>() { variableSymbol, binFactorVariable, factorVariable, constant, number, laggedVariable, autoregressiveVariable };
+      var terminalSymbols = new List<Symbol>() { variableSymbol, binFactorVariable, factorVariable, number, constant, laggedVariable, autoregressiveVariable };
 
       foreach (var symb in allSymbols)

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/LinearScalingGrammar.cs

@@ -66 +66 @@
       var abs = new Absolute();
       var aq = new AnalyticQuotient();
-      var constant = new Num();
-      constant.MinValue = -20;
-      constant.MaxValue = 20;
-      var number = new RealConstant();
+      var number = new Number();
       number.MinValue = -20;
       number.MaxValue = 20;
+      var constant = new Constant();
       var variableSymbol = new Variable();
 
@@ -81 +79 @@
       //all other symbols
       var allSymbols = new List<Symbol> {
-        add, sub, mul, div, constant, number, variableSymbol, sin, cos, tan, log, square, sqrt, cube, cbrt, exp,
+        add, sub, mul, div, number, constant, variableSymbol, sin, cos, tan, log, square, sqrt, cube, cbrt, exp,
         tanh, aq, abs
       };
@@ -89 +87 @@
       var realValueSymbols = new List<Symbol> {
          add, sub, mul, div, sin, cos, tan, tanh, exp, log, aq, abs, square, cube, sqrt, cbrt,
-         variableSymbol, constant, number
+         variableSymbol, number, constant
         };
 
@@ -116 +114 @@
       //Define childs for offset
       AddAllowedChildSymbol(offset, scaling, 0);
-      AddAllowedChildSymbol(offset, constant, 1);
+      AddAllowedChildSymbol(offset, number, 1);
 
       //Define childs for scaling
       foreach (var symb in allSymbols) AddAllowedChildSymbol(scaling, symb, 0);
-      AddAllowedChildSymbol(scaling, constant, 1);
+      AddAllowedChildSymbol(scaling, number, 1);
 
       //Define childs for realvalue symbols

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs

@@ -105 +105 @@
       var derivative = new Derivative();
 
-      var constant = new Num();
-      constant.MinValue = -20;
-      constant.MaxValue = 20;
-      var number = new RealConstant();
+      var number = new Number();
       number.MinValue = -20;
       number.MaxValue = 20;
+      var constant = new Constant();
       var variableSymbol = new Variable();
       var binFactorVariable = new BinaryFactorVariable();
@@ -124 +122 @@
       var specialFunctions = new GroupSymbol(SpecialFunctionsName, new List<ISymbol> { abs, airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi,
         fresnelCosineIntegral,fresnelSineIntegral,gamma,hypCosineIntegral,hypSineIntegral,norm, psi, sineIntegral, analyticalQuotient});
-      var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { constant, number, variableSymbol, binFactorVariable, factorVariable });
+      var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { number, constant, variableSymbol, binFactorVariable, factorVariable });
       var realValuedSymbols = new GroupSymbol(RealValuedSymbolsName, new List<ISymbol>() { arithmeticSymbols, trigonometricSymbols, exponentialAndLogarithmicSymbols, specialFunctions, terminalSymbols });
 
@@ -196 +194 @@
       AddAllowedChildSymbol(powerSymbols, laggedVariable, 0);
       AddAllowedChildSymbol(powerSymbols, autoregressiveVariable, 0);
-      AddAllowedChildSymbol(powerSymbols, constant, 1);
+      AddAllowedChildSymbol(powerSymbols, number, 1);
 
       AddAllowedChildSymbol(square, realValuedSymbols, 0);

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -174 +174 @@
     <Compile Include="Interfaces\IBoundsEstimator.cs" />
     <Compile Include="Interfaces\IModelBacktransformator.cs" />
+    <Compile Include="Interfaces\INumericSymbol.cs" />
+    <Compile Include="Interfaces\INumericTreeNode.cs" />
     <Compile Include="Interfaces\IVariableTreeNode.cs" />
     <Compile Include="Interfaces\IVariableSymbol.cs" />
@@ -238 +240 @@
     <Compile Include="Symbols\AutoregressiveVariable.cs" />
     <Compile Include="Symbols\Average.cs" />
-    <Compile Include="Symbols\Num.cs" />
-    <Compile Include="Symbols\NumTreeNode.cs" />
+    <Compile Include="Symbols\Number.cs" />
+    <Compile Include="Symbols\NumberTreeNode.cs" />
     <Compile Include="Symbols\AiryA.cs" />
     <Compile Include="Symbols\AiryB.cs" />
@@ -251 +253 @@
     <Compile Include="Symbols\CubeRoot.cs" />
     <Compile Include="Symbols\HyperbolicTangent.cs" />
-    <Compile Include="Symbols\RealConstant.cs" />
-    <Compile Include="Symbols\RealConstantTreeNode.cs" />
+    <Compile Include="Symbols\Constant.cs" />
+    <Compile Include="Symbols\ConstantTreeNode.cs" />
     <Compile Include="Symbols\VariableBase.cs" />
     <Compile Include="Symbols\VariableTreeNodeBase.cs" />

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs

@@ -82 +82 @@
       knownSymbols = new BidirectionalLookup<string, ISymbol>(StringComparer.InvariantCulture, new SymbolComparer());
 
-    private Num num = new Num();
-    private RealConstant realConstant = new RealConstant();
+    private Number number = new Number();
+    private Constant constant = new Constant();
     private Variable variable = new Variable();
     private BinaryFactorVariable binaryFactorVar = new BinaryFactorVariable();
@@ -181 +181 @@
             && str[pos] != ']'
             && str[pos] != '}'
-            && str[pos] != ',') {
+            && str[pos] != ','
+            && str[pos] != '>') {
             sb.Append(str[pos]);
             pos++;
@@ -333 +334 @@
           foreach (var negTerm in negTerms) sumNeg.AddSubtree(negTerm);
 
-          var constNode = (NumTreeNode)num.CreateTreeNode();
+          var constNode = (NumberTreeNode)number.CreateTreeNode();
           constNode.Value = -1.0;
           var prod = GetSymbol("*").CreateTreeNode();
@@ -532 +533 @@
         }
       } else if (next.TokenType == TokenType.LeftAngleBracket) {
+        Token numberTok = null;
         var leftAngleBracket = tokens.Dequeue();
         if (leftAngleBracket.TokenType != TokenType.LeftAngleBracket)
@@ -539 +541 @@
         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 = (NumTreeNode)num.CreateTreeNode();
+        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 = (RealConstantTreeNode)realConstant.CreateTreeNode();
+        var constNode = (ConstantTreeNode)constant.CreateTreeNode();
         constNode.Value = numTok.doubleVal;
         return constNode;