Index: /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/GBM/GradientBoostingRegressionAlgorithm.cs
===================================================================
--- /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/GBM/GradientBoostingRegressionAlgorithm.cs	(revision 18131)
+++ /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/GBM/GradientBoostingRegressionAlgorithm.cs	(revision 18132)
@@ -417,5 +417,5 @@
       var addNode = new Addition().CreateTreeNode();
       var mulNode = new Multiplication().CreateTreeNode();
-      var scaleNode = (ConstantTreeNode)new Constant().CreateTreeNode(); // all models are scaled using the same nu
+      var scaleNode = (NumberTreeNode)new Number().CreateTreeNode(); // all models are scaled using the same nu
       scaleNode.Value = nu;
 
Index: /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessCovarianceOptimizationProblem.cs
===================================================================
--- /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessCovarianceOptimizationProblem.cs	(revision 18131)
+++ /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessCovarianceOptimizationProblem.cs	(revision 18132)
@@ -97,5 +97,5 @@
 
     private const string ProblemDataParameterName = "ProblemData";
-    private const string ConstantOptIterationsParameterName = "Constant optimization steps";
+    private const string ParameterOptIterationsParameterName = "Parameter optimization steps";
     private const string RestartsParameterName = "Restarts";
 
@@ -108,6 +108,6 @@
       get { return (IValueParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName]; }
     }
-    public IFixedValueParameter<IntValue> ConstantOptIterationsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[ConstantOptIterationsParameterName]; }
+    public IFixedValueParameter<IntValue> ParameterOptIterationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[ParameterOptIterationsParameterName]; }
     }
     public IFixedValueParameter<IntValue> RestartsParameter {
@@ -124,7 +124,7 @@
     IDataAnalysisProblemData IDataAnalysisProblem.ProblemData { get { return ProblemData; } }
 
-    public int ConstantOptIterations {
-      get { return ConstantOptIterationsParameter.Value.Value; }
-      set { ConstantOptIterationsParameter.Value.Value = value; }
+    public int ParameterOptIterations {
+      get { return ParameterOptIterationsParameter.Value.Value; }
+      set { ParameterOptIterationsParameter.Value.Value = value; }
     }
 
@@ -153,6 +153,6 @@
       : base() {
       Parameters.Add(new ValueParameter<IRegressionProblemData>(ProblemDataParameterName, "The data for the regression problem", new RegressionProblemData()));
-      Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptIterationsParameterName, "Number of optimization steps for hyperparameter values", new IntValue(50)));
-      Parameters.Add(new FixedValueParameter<IntValue>(RestartsParameterName, "The number of random restarts for constant optimization.", new IntValue(10)));
+      Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptIterationsParameterName, "Number of optimization steps for hyperparameter values", new IntValue(50)));
+      Parameters.Add(new FixedValueParameter<IntValue>(RestartsParameterName, "The number of random restarts for parameter optimization.", new IntValue(10)));
       Parameters["Restarts"].Hidden = true;
       var g = new SimpleSymbolicExpressionGrammar();
@@ -236,5 +236,5 @@
         double epsx = 0;
         double stpmax = 1;
-        int maxits = ConstantOptIterations;
+        int maxits = ParameterOptIterations;
         alglib.mincgstate state;
         alglib.mincgreport rep;
@@ -384,4 +384,12 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ParameterOptIterationsParameterName)) {
+        if (Parameters.ContainsKey("Constant optimization steps")) {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptIterationsParameterName, "Number of optimization steps for hyperparameter values", (IntValue)Parameters["Constant optimization steps"].ActualValue));
+          Parameters.Remove("Constant optimization steps");
+        } else {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptIterationsParameterName, "Number of optimization steps for hyperparameter values", new IntValue(50)));
+        }
+      }
     }
 
Index: /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs
===================================================================
--- /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs	(revision 18131)
+++ /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs	(revision 18132)
@@ -230,8 +230,8 @@
       var startSy = new StartSymbol();
       var varCondSy = new VariableCondition() { IgnoreSlope = true };
-      var constSy = new Constant();
+      var numSy = new Number();
 
       var startNode = startSy.CreateTreeNode();
-      startNode.AddSubtree(CreateSymbolicRegressionTreeRecursive(tree, 0, varCondSy, constSy));
+      startNode.AddSubtree(CreateSymbolicRegressionTreeRecursive(tree, 0, varCondSy, numSy));
       var rootNode = rootSy.CreateTreeNode();
       rootNode.AddSubtree(startNode);
@@ -239,8 +239,8 @@
     }
 
-    private ISymbolicExpressionTreeNode CreateSymbolicRegressionTreeRecursive(TreeNode[] treeNodes, int nodeIdx, VariableCondition varCondSy, Constant constSy) {
+    private ISymbolicExpressionTreeNode CreateSymbolicRegressionTreeRecursive(TreeNode[] treeNodes, int nodeIdx, VariableCondition varCondSy, Number numSy) {
       var curNode = treeNodes[nodeIdx];
       if (curNode.VarName == TreeNode.NO_VARIABLE) {
-        var node = (ConstantTreeNode)constSy.CreateTreeNode();
+        var node = (NumberTreeNode)numSy.CreateTreeNode();
         node.Value = curNode.Val;
         return node;
@@ -250,6 +250,6 @@
         node.Threshold = curNode.Val;
 
-        var left = CreateSymbolicRegressionTreeRecursive(treeNodes, curNode.LeftIdx, varCondSy, constSy);
-        var right = CreateSymbolicRegressionTreeRecursive(treeNodes, curNode.RightIdx, varCondSy, constSy);
+        var left = CreateSymbolicRegressionTreeRecursive(treeNodes, curNode.LeftIdx, varCondSy, numSy);
+        var right = CreateSymbolicRegressionTreeRecursive(treeNodes, curNode.RightIdx, varCondSy, numSy);
         node.AddSubtree(left);
         node.AddSubtree(right);
Index: /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs
===================================================================
--- /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs	(revision 18131)
+++ /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs	(revision 18132)
@@ -123,6 +123,10 @@
       : base() {
       Problem = new RegressionProblem();
-      Parameters.Add(new FixedValueParameter<StringValue>(ModelStructureParameterName, "The function for which the parameters must be fit (only numeric constants are tuned).", new StringValue("1.0 * x*x + 0.0")));
-      Parameters.Add(new FixedValueParameter<IntValue>(IterationsParameterName, "The maximum number of iterations for constants optimization.", new IntValue(200)));
+      Parameters.Add(new FixedValueParameter<StringValue>(ModelStructureParameterName, 
+        "The expression for which the <num> parameters should be fit.\n " +
+        "Defined constants will not be modified.\n " +
+        "Modifiable numbers are specified with <num>. To specify a default value within this number symbol, a default value can be declared by e.g. <num=1.0>.", 
+        new StringValue("<num> * x*x + 0.0")));
+      Parameters.Add(new FixedValueParameter<IntValue>(IterationsParameterName, "The maximum number of iterations for parameter optimization.", new IntValue(200)));
       Parameters.Add(new FixedValueParameter<IntValue>(RestartsParameterName, "The number of independent random restarts (>0)", new IntValue(10)));
       Parameters.Add(new FixedValueParameter<IntValue>(SeedParameterName, "The PRNG seed value.", new IntValue()));
@@ -210,13 +214,13 @@
 
     /// <summary>
-    /// Fits a model to the data by optimizing the numeric constants.
+    /// Fits a model to the data by optimizing parameters.
     /// Model is specified as infix expression containing variable names and numbers. 
-    /// The starting point for the numeric constants is initialized randomly if a random number generator is specified (~N(0,1)). Otherwise the user specified constants are
+    /// The starting values for the parameters are initialized randomly if a random number generator is specified (~N(0,1)). Otherwise the user specified values are
     /// used as a starting point. 
     /// </summary>-
     /// <param name="problemData">Training and test data</param>
     /// <param name="modelStructure">The function as infix expression</param>
-    /// <param name="maxIterations">Number of constant optimization iterations (using Levenberg-Marquardt algorithm)</param>
-    /// <param name="random">Optional random number generator for random initialization of numeric constants.</param>
+    /// <param name="maxIterations">Number of Levenberg-Marquardt iterations</param>
+    /// <param name="random">Optional random number generator for random initialization of parameters.</param>
     /// <returns></returns>
     public static ISymbolicRegressionSolution CreateRegressionSolution(IRegressionProblemData problemData, string modelStructure, int maxIterations, bool applyLinearScaling, IRandom rand = null) {
@@ -263,9 +267,9 @@
       }
 
-      if (!SymbolicRegressionConstantOptimizationEvaluator.CanOptimizeConstants(tree)) throw new ArgumentException("The optimizer does not support the specified model structure.");
-
-      // initialize constants randomly
+      if (!SymbolicRegressionParameterOptimizationEvaluator.CanOptimizeParameters(tree)) throw new ArgumentException("The optimizer does not support the specified model structure.");
+
+      // initialize parameters randomly
       if (rand != null) {
-        foreach (var node in tree.IterateNodesPrefix().OfType<ConstantTreeNode>()) {
+        foreach (var node in tree.IterateNodesPrefix().OfType<NumberTreeNode>()) {
           double f = Math.Exp(NormalDistributedRandom.NextDouble(rand, 0, 1));
           double s = rand.NextDouble() < 0.5 ? -1 : 1;
@@ -275,7 +279,7 @@
       var interpreter = new SymbolicDataAnalysisExpressionTreeLinearInterpreter();
 
-      SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, tree, problemData, problemData.TrainingIndices,
+      SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, tree, problemData, problemData.TrainingIndices,
         applyLinearScaling: applyLinearScaling, maxIterations: maxIterations,
-        updateVariableWeights: false, updateConstantsInTree: true);
+        updateVariableWeights: false, updateParametersInTree: true);
 
       var model = new SymbolicRegressionModel(problemData.TargetVariable, tree, (ISymbolicDataAnalysisExpressionTreeInterpreter)interpreter.Clone());
Index: /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModel.cs
===================================================================
--- /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModel.cs	(revision 18131)
+++ /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModel.cs	(revision 18132)
@@ -220,8 +220,8 @@
       }
 
-      var constSy = new Constant();
+      var numSy = new Number();
       var varCondSy = new VariableCondition() { IgnoreSlope = true };
 
-      var node = CreateRegressionTreeRec(rf.innerobj.trees, offset, offset + 1, constSy, varCondSy);
+      var node = CreateRegressionTreeRec(rf.innerobj.trees, offset, offset + 1, numSy, varCondSy);
 
       var startNode = new StartSymbol().CreateTreeNode();
@@ -232,5 +232,5 @@
     }
 
-    private ISymbolicExpressionTreeNode CreateRegressionTreeRec(double[] trees, int offset, int k, Constant constSy, VariableCondition varCondSy) {
+    private ISymbolicExpressionTreeNode CreateRegressionTreeRec(double[] trees, int offset, int k, Number numSy, VariableCondition varCondSy) {
 
       // alglib source for evaluation of one tree (dfprocessinternal)
@@ -262,7 +262,7 @@
 
       if ((double)(trees[k]) == (double)(-1)) {
-        var constNode = (ConstantTreeNode)constSy.CreateTreeNode();
-        constNode.Value = trees[k + 1];
-        return constNode;
+        var numNode = (NumberTreeNode)numSy.CreateTreeNode();
+        numNode.Value = trees[k + 1];
+        return numNode;
       } else {
         var condNode = (VariableConditionTreeNode)varCondSy.CreateTreeNode();
@@ -271,6 +271,6 @@
         condNode.Slope = double.PositiveInfinity;
 
-        var left = CreateRegressionTreeRec(trees, offset, k + 3, constSy, varCondSy);
-        var right = CreateRegressionTreeRec(trees, offset, offset + (int)Math.Round(trees[k + 2]), constSy, varCondSy);
+        var left = CreateRegressionTreeRec(trees, offset, k + 3, numSy, varCondSy);
+        var right = CreateRegressionTreeRec(trees, offset, offset + (int)Math.Round(trees[k + 2]), numSy, varCondSy);
 
         condNode.AddSubtree(left); // not 100% correct because interpreter uses: if(x <= thres) left() else right() and RF uses if(x < thres) left() else right() (see above)
Index: /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelAlglib_3_7.cs
===================================================================
--- /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelAlglib_3_7.cs	(revision 18131)
+++ /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelAlglib_3_7.cs	(revision 18132)
@@ -220,8 +220,8 @@
       }
 
-      var constSy = new Constant();
+      var numSy = new Number();
       var varCondSy = new VariableCondition() { IgnoreSlope = true };
 
-      var node = CreateRegressionTreeRec(rf.innerobj.trees, offset, offset + 1, constSy, varCondSy);
+      var node = CreateRegressionTreeRec(rf.innerobj.trees, offset, offset + 1, numSy, varCondSy);
 
       var startNode = new StartSymbol().CreateTreeNode();
@@ -232,5 +232,5 @@
     }
 
-    private ISymbolicExpressionTreeNode CreateRegressionTreeRec(double[] trees, int offset, int k, Constant constSy, VariableCondition varCondSy) {
+    private ISymbolicExpressionTreeNode CreateRegressionTreeRec(double[] trees, int offset, int k, Number numSy, VariableCondition varCondSy) {
 
       // alglib source for evaluation of one tree (dfprocessinternal)
@@ -261,8 +261,8 @@
       // }
 
-      if ((double)(trees[k]) == (double)(-1)) {
-        var constNode = (ConstantTreeNode)constSy.CreateTreeNode();
-        constNode.Value = trees[k + 1];
-        return constNode;
+      if (trees[k] == -1) {
+        var numNode = (NumberTreeNode)numSy.CreateTreeNode();
+        numNode.Value = trees[k + 1];
+        return numNode;
       } else {
         var condNode = (VariableConditionTreeNode)varCondSy.CreateTreeNode();
@@ -271,6 +271,6 @@
         condNode.Slope = double.PositiveInfinity;
 
-        var left = CreateRegressionTreeRec(trees, offset, k + 3, constSy, varCondSy);
-        var right = CreateRegressionTreeRec(trees, offset, offset + (int)Math.Round(trees[k + 2]), constSy, varCondSy);
+        var left = CreateRegressionTreeRec(trees, offset, k + 3, numSy, varCondSy);
+        var right = CreateRegressionTreeRec(trees, offset, offset + (int)Math.Round(trees[k + 2]), numSy, varCondSy);
 
         condNode.AddSubtree(left); // not 100% correct because interpreter uses: if(x <= thres) left() else right() and RF uses if(x < thres) left() else right() (see above)
Index: /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelFull.cs
===================================================================
--- /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelFull.cs	(revision 18131)
+++ /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelFull.cs	(revision 18132)
@@ -199,8 +199,8 @@
       }
 
-      var constSy = new Constant();
+      var numSy = new Number();
       var varCondSy = new VariableCondition() { IgnoreSlope = true };
 
-      var node = CreateRegressionTreeRec(rf.innerobj.trees, offset, offset + 1, constSy, varCondSy);
+      var node = CreateRegressionTreeRec(rf.innerobj.trees, offset, offset + 1, numSy, varCondSy);
 
       var startNode = new StartSymbol().CreateTreeNode();
@@ -211,5 +211,5 @@
     }
 
-    private ISymbolicExpressionTreeNode CreateRegressionTreeRec(double[] trees, int offset, int k, Constant constSy, VariableCondition varCondSy) {
+    private ISymbolicExpressionTreeNode CreateRegressionTreeRec(double[] trees, int offset, int k, Number numSy, VariableCondition varCondSy) {
 
       // alglib source for evaluation of one tree (dfprocessinternal)
@@ -240,8 +240,8 @@
       // }
 
-      if ((double)(trees[k]) == (double)(-1)) {
-        var constNode = (ConstantTreeNode)constSy.CreateTreeNode();
-        constNode.Value = trees[k + 1];
-        return constNode;
+      if (trees[k] == -1) {
+        var numNode = (NumberTreeNode)numSy.CreateTreeNode();
+        numNode.Value = trees[k + 1];
+        return numNode;
       } else {
         var condNode = (VariableConditionTreeNode)varCondSy.CreateTreeNode();
@@ -250,6 +250,6 @@
         condNode.Slope = double.PositiveInfinity;
 
-        var left = CreateRegressionTreeRec(trees, offset, k + 3, constSy, varCondSy);
-        var right = CreateRegressionTreeRec(trees, offset, offset + (int)Math.Round(trees[k + 2]), constSy, varCondSy);
+        var left = CreateRegressionTreeRec(trees, offset, k + 3, numSy, varCondSy);
+        var right = CreateRegressionTreeRec(trees, offset, offset + (int)Math.Round(trees[k + 2]), numSy, varCondSy);
 
         condNode.AddSubtree(left); // not 100% correct because interpreter uses: if(x <= thres) left() else right() and RF uses if(x < thres) left() else right() (see above)
Index: /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs
===================================================================
--- /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs	(revision 18131)
+++ /trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs	(revision 18132)
@@ -104,5 +104,5 @@
       int nRows = inputMatrix.GetLength(0);
       int nFeatures = inputMatrix.GetLength(1) - 1;
-      double[] coefficients = new double[nFeatures + 1]; // last coefficient is for the constant
+      double[] coefficients = new double[nFeatures + 1]; // last coefficient is for the offset
 
       int retVal = 1;
Index: /trunk/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNodeSimilarityComparer.cs
===================================================================
--- /trunk/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNodeSimilarityComparer.cs	(revision 18131)
+++ /trunk/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNodeSimilarityComparer.cs	(revision 18132)
@@ -6,5 +6,5 @@
   [StorableType("c4de8ab2-616d-4c73-9f9c-59545ac38199")]
   public interface ISymbolicExpressionTreeNodeSimilarityComparer : IEqualityComparer<ISymbolicExpressionTreeNode>, IItem {
-    bool MatchConstantValues { get; set; }
+    bool MatchParameterValues { get; set; }
     bool MatchVariableWeights { get; set; }
     bool MatchVariableNames { get; set; }
Index: /trunk/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/FullTreeShaker.cs
===================================================================
--- /trunk/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/FullTreeShaker.cs	(revision 18131)
+++ /trunk/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/FullTreeShaker.cs	(revision 18132)
@@ -47,5 +47,5 @@
     public FullTreeShaker()
       : base() {
-      Parameters.Add(new FixedValueParameter<DoubleValue>(ShakingFactorParameterName, "The shaking factor that should be used for the manipulation of constants (default=1.0).", new DoubleValue(1.0)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(ShakingFactorParameterName, "The shaking factor that should be used for the manipulation of parameters (default=1.0).", new DoubleValue(1.0)));
     }
 
Index: /trunk/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs
===================================================================
--- /trunk/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs	(revision 18131)
+++ /trunk/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs	(revision 18132)
@@ -49,5 +49,5 @@
     public OnePointShaker()
       : base() {
-      Parameters.Add(new FixedValueParameter<DoubleValue>(ShakingFactorParameterName, "The shaking factor that should be used for the manipulation of constants (default=1.0).", new DoubleValue(1.0)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(ShakingFactorParameterName, "The shaking factor that should be used for the manipulation of parameters (default=1.0).", new DoubleValue(1.0)));
     }
 
Index: /trunk/HeuristicLab.Optimizer/3.3/HeuristicLab.Optimizer-3.3.csproj
===================================================================
--- /trunk/HeuristicLab.Optimizer/3.3/HeuristicLab.Optimizer-3.3.csproj	(revision 18131)
+++ /trunk/HeuristicLab.Optimizer/3.3/HeuristicLab.Optimizer-3.3.csproj	(revision 18132)
@@ -153,5 +153,5 @@
     <EmbeddedResource Include="Documents\PSO_Rastrigin.hl" />
     <EmbeddedResource Include="Documents\OSGP_SymReg.hl" />
-    <EmbeddedResource Include="Documents\GA_Shape_Constrained_Regression.hl" />
+    <EmbeddedResource Include="Documents\GP_Shape_Constrained_Regression.hl" />
     <None Include="Plugin.cs.frame" />
     <Compile Include="ChangeNestingLevelDialog.cs">
Index: /trunk/HeuristicLab.Optimizer/3.3/StartPage.cs
===================================================================
--- /trunk/HeuristicLab.Optimizer/3.3/StartPage.cs	(revision 18131)
+++ /trunk/HeuristicLab.Optimizer/3.3/StartPage.cs	(revision 18132)
@@ -130,5 +130,5 @@
         };
       groupLookup[standardProblemsGroup] = standardProblems;
-      var dataAnalysisProblems = new List<string> { "ALPSGP_SymReg", "SGP_SymbClass", "SGP_SymbReg", "OSGP_SymReg", "OSGP_TimeSeries", "GE_SymbReg", "GPR", "GA_Shape_Constrained_Regression" };
+      var dataAnalysisProblems = new List<string> { "ALPSGP_SymReg", "SGP_SymbClass", "SGP_SymbReg", "OSGP_SymReg", "OSGP_TimeSeries", "GE_SymbReg", "GPR", "GP_Shape_Constrained_Regression" };
       groupLookup[dataAnalysisGroup] = dataAnalysisProblems;
       var scripts = new List<string> { "GA_QAP_Script", "GUI_Automation_Script", "OSGA_Rastrigin_Script",
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationPruningOperator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationPruningOperator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationPruningOperator.cs	(revision 18132)
@@ -101,16 +101,16 @@
       for (int i = 0; i < nodes.Count; ++i) {
         var node = nodes[i];
-        if (node is ConstantTreeNode) continue;
+        if (node is INumericTreeNode) continue;
 
-        double impactValue, replacementValue, newQualityForImpactsCalculation;
-        impactValuesCalculator.CalculateImpactAndReplacementValues(model, node, problemData, rows, out impactValue, out replacementValue, out newQualityForImpactsCalculation, qualityForImpactsCalculation);
+        impactValuesCalculator.CalculateImpactAndReplacementValues(model, node, problemData, rows, 
+          out double impactValue, out double replacementValue, out double newQualityForImpactsCalculation, qualityForImpactsCalculation);
 
         if (pruneOnlyZeroImpactNodes && !impactValue.IsAlmost(0.0)) continue;
         if (!pruneOnlyZeroImpactNodes && impactValue > nodeImpactThreshold) continue;
 
-        var constantNode = (ConstantTreeNode)node.Grammar.GetSymbol("Constant").CreateTreeNode();
-        constantNode.Value = replacementValue;
+        var numberNode = (NumberTreeNode)node.Grammar.GetSymbol("Number").CreateTreeNode();
+        numberNode.Value = replacementValue;
 
-        ReplaceWithConstant(node, constantNode);
+        ReplaceWithNumber(node, numberNode);
         i += node.GetLength() - 1; // skip subtrees under the node that was folded
 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.Designer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.Designer.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.Designer.cs	(revision 18132)
@@ -53,5 +53,5 @@
       this.Name = "InteractiveSymbolicRegressionSolutionSimplifierView";
       this.Size = new System.Drawing.Size(564, 348);
-      this.btnOptimizeConstants.Enabled = true;
+      this.btnOptimizeParameters.Enabled = true;
       this.ResumeLayout(false);
     }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs	(revision 18132)
@@ -42,5 +42,5 @@
 
       var tree = Content?.Model?.SymbolicExpressionTree;
-      btnOptimizeConstants.Enabled = tree != null && SymbolicRegressionConstantOptimizationEvaluator.CanOptimizeConstants(tree);
+      btnOptimizeParameters.Enabled = tree != null && SymbolicRegressionParameterOptimizationEvaluator.CanOptimizeParameters(tree);
     }
 
@@ -51,6 +51,6 @@
     }
 
-    protected override ISymbolicExpressionTree OptimizeConstants(ISymbolicExpressionTree tree, IProgress progress) {
-      const int constOptIterations = 50;
+    protected override ISymbolicExpressionTree OptimizeParameters(ISymbolicExpressionTree tree, IProgress progress) {
+      const int iterations = 50;
       const int maxRepetitions = 100;
       const double minimumImprovement = 1e-10;
@@ -64,8 +64,8 @@
       do {
         prevResult = result;
-        result = SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(model.Interpreter, tree, regressionProblemData, regressionProblemData.TrainingIndices,
-          applyLinearScaling: true, maxIterations: constOptIterations, updateVariableWeights: true, lowerEstimationLimit: model.LowerEstimationLimit, upperEstimationLimit: model.UpperEstimationLimit,
+        result = SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(model.Interpreter, tree, regressionProblemData, regressionProblemData.TrainingIndices,
+          applyLinearScaling: true, maxIterations: iterations, updateVariableWeights: true, lowerEstimationLimit: model.LowerEstimationLimit, upperEstimationLimit: model.UpperEstimationLimit,
           iterationCallback: (args, func, obj) => {
-            double newProgressValue = progress.ProgressValue + (1.0 / (constOptIterations + 2) / maxRepetitions); // (constOptIterations + 2) iterations are reported
+            double newProgressValue = progress.ProgressValue + (1.0 / (iterations + 2) / maxRepetitions); // (iterations + 2) iterations are reported
             progress.ProgressValue = Math.Min(newProgressValue, 1.0);
           });
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionResponseFunctionView.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionResponseFunctionView.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionResponseFunctionView.cs	(revision 18132)
@@ -120,6 +120,6 @@
 
     private void ChangeVariableValue(string variableName, double value) {
-      foreach (var constNode in variableNodes[variableName].Cast<ConstantTreeNode>())
-        constNode.Value = value;
+      foreach (var numNode in variableNodes[variableName].Cast<NumberTreeNode>())
+        numNode.Value = value;
 
       UpdateResponseSeries();
@@ -210,5 +210,5 @@
 
           int childIndex = varNode.Parent.IndexOfSubtree(varNode);
-          var replacementNode = MakeConstantTreeNode(medianValues[varNode.VariableName]);
+          var replacementNode = MakeNumberTreeNode(medianValues[varNode.VariableName]);
           var parent = varNode.Parent;
           parent.RemoveSubtree(childIndex);
@@ -223,19 +223,19 @@
     }
 
-    private ISymbolicExpressionTreeNode MakeProduct(ConstantTreeNode c, double weight) {
+    private ISymbolicExpressionTreeNode MakeProduct(NumberTreeNode c, double weight) {
       var mul = new Multiplication();
       var prod = mul.CreateTreeNode();
-      prod.AddSubtree(MakeConstantTreeNode(weight));
+      prod.AddSubtree(MakeNumberTreeNode(weight));
       prod.AddSubtree(c);
       return prod;
     }
 
-    private ConstantTreeNode MakeConstantTreeNode(double value) {
-      Constant constant = new Constant();
-      constant.MinValue = value - 1;
-      constant.MaxValue = value + 1;
-      ConstantTreeNode constantTreeNode = (ConstantTreeNode)constant.CreateTreeNode();
-      constantTreeNode.Value = value;
-      return constantTreeNode;
+    private NumberTreeNode MakeNumberTreeNode(double value) {
+      Number number = new Number();
+      number.MinValue = value - 1;
+      number.MaxValue = value + 1;
+      NumberTreeNode numberTreeNode = (NumberTreeNode)number.CreateTreeNode();
+      numberTreeNode.Value = value;
+      return numberTreeNode;
     }
   }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj	(revision 18132)
@@ -129,5 +129,5 @@
     <Compile Include="Plugin.cs" />
     <Compile Include="ShapeConstraintsAnalyzer.cs" />
-    <Compile Include="SingleObjective\ConstantOptimizationAnalyzer.cs" />
+    <Compile Include="SingleObjective\ParameterOptimizationAnalyzer.cs" />
     <Compile Include="SingleObjective\Evaluators\NMSESingleObjectiveConstraintsEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />
@@ -142,5 +142,5 @@
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveMeanAbsoluteErrorEvaluator.cs" />
-    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionConstantOptimizationEvaluator.cs" />
+    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionParameterOptimizationEvaluator.cs" />
     <Compile Include="SingleObjective\SymbolicRegressionSingleObjectiveOverfittingAnalyzer.cs" />
     <Compile Include="SymbolicRegressionModel.cs" />
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/IMultiObjectiveConstraintsEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/IMultiObjectiveConstraintsEvaluator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/Interfaces/IMultiObjectiveConstraintsEvaluator.cs	(revision 18132)
@@ -27,5 +27,4 @@
   [StorableType("F96C5253-5A78-491C-95AE-78F64BD1F3B1")]
   public interface IMultiObjectiveConstraintsEvaluator : ISymbolicRegressionMultiObjectiveEvaluator {
-
     IFixedValueParameter<IntValue> NumConstraintsParameter { get; }
   }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/NMSEMultiObjectiveConstraintsEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/NMSEMultiObjectiveConstraintsEvaluator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/NMSEMultiObjectiveConstraintsEvaluator.cs	(revision 18132)
@@ -90,9 +90,9 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, tree, problemData, rows,
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, tree, problemData, rows,
           false,
-          ConstantOptimizationIterations,
-          ConstantOptimizationUpdateVariableWeights,
+          ParameterOptimizationIterations,
+          ParameterOptimizationUpdateVariableWeights,
           estimationLimits.Lower,
           estimationLimits.Upper);
@@ -105,5 +105,5 @@
           var scaling = offset.GetSubtree(0);
 
-          //Check if tree contains offset and scaling nodes
+          // Check if tree contains offset and scaling nodes
           if (!(offset.Symbol is Addition) || !(scaling.Symbol is Multiplication))
             throw new ArgumentException($"{ItemName} can only be used with LinearScalingGrammar.");
@@ -115,5 +115,5 @@
           var newTree = new SymbolicExpressionTree(rootNode);
 
-          //calculate alpha and beta for scaling
+          // calculate alpha and beta for scaling
           var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(newTree, problemData.Dataset, rows);
 
@@ -122,8 +122,8 @@
             out var errorState);
           if (errorState == OnlineCalculatorError.None) {
-            //Set alpha and beta to the scaling nodes from ia grammar
-            var offsetParameter = offset.GetSubtree(1) as ConstantTreeNode;
+            // Set alpha and beta to the scaling nodes from linear scaling grammar
+            var offsetParameter = offset.GetSubtree(1) as NumberTreeNode;
             offsetParameter.Value = alpha;
-            var scalingParameter = scaling.GetSubtree(1) as ConstantTreeNode;
+            var scalingParameter = scaling.GetSubtree(1) as NumberTreeNode;
             scalingParameter.Value = beta;
           }
@@ -162,5 +162,4 @@
       double upperEstimationLimit,
       IRegressionProblemData problemData, IEnumerable<int> rows, IBoundsEstimator estimator, int decimalPlaces) {
-      OnlineCalculatorError errorState;
       var estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
       var targetValues = problemData.Dataset.GetDoubleValues(problemData.TargetVariable, rows);
@@ -174,5 +173,5 @@
 
       var boundedEstimatedValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
-      nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out errorState);
+      nmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(targetValues, boundedEstimatedValues, out OnlineCalculatorError errorState);
 
       if (errorState != OnlineCalculatorError.None) nmse = 1.0;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredAverageSimilarityEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredAverageSimilarityEvaluator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredAverageSimilarityEvaluator.cs	(revision 18132)
@@ -76,6 +76,6 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredNestedTreeSizeEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredNestedTreeSizeEvaluator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredNestedTreeSizeEvaluator.cs	(revision 18132)
@@ -54,6 +54,6 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights,lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights,lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredNumberOfVariablesEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredNumberOfVariablesEvaluator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredNumberOfVariablesEvaluator.cs	(revision 18132)
@@ -54,6 +54,6 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
       double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value, DecimalPlaces);
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredTreeComplexityEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredTreeComplexityEvaluator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredTreeComplexityEvaluator.cs	(revision 18132)
@@ -53,6 +53,6 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
       double[] qualities = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData, rows, applyLinearScaling, DecimalPlaces);
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveEvaluator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveEvaluator.cs	(revision 18132)
@@ -31,23 +31,23 @@
   public abstract class SymbolicRegressionMultiObjectiveEvaluator : SymbolicDataAnalysisMultiObjectiveEvaluator<IRegressionProblemData>, ISymbolicRegressionMultiObjectiveEvaluator {
     private const string DecimalPlacesParameterName = "Decimal Places";
-    private const string UseConstantOptimizationParameterName = "Use constant optimization";
-    private const string ConstantOptimizationIterationsParameterName = "Constant optimization iterations";
+    private const string UseParameterOptimizationParameterName = "Use parameter optimization";
+    private const string ParameterOptimizationIterationsParameterName = "Parameter optimization iterations";
 
-    private const string ConstantOptimizationUpdateVariableWeightsParameterName =
-      "Constant optimization update variable weights";
+    private const string ParameterOptimizationUpdateVariableWeightsParameterName =
+      "Parameter optimization update variable weights";
 
     public IFixedValueParameter<IntValue> DecimalPlacesParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[DecimalPlacesParameterName]; }
     }
-    public IFixedValueParameter<BoolValue> UseConstantOptimizationParameter {
-      get { return (IFixedValueParameter<BoolValue>)Parameters[UseConstantOptimizationParameterName]; }
+    public IFixedValueParameter<BoolValue> UseParameterOptimizationParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[UseParameterOptimizationParameterName]; }
     }
 
-    public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[ConstantOptimizationIterationsParameterName]; }
+    public IFixedValueParameter<IntValue> ParameterOptimizationIterationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[ParameterOptimizationIterationsParameterName]; }
     }
 
-    public IFixedValueParameter<BoolValue> ConstantOptimizationUpdateVariableWeightsParameter {
-      get { return (IFixedValueParameter<BoolValue>)Parameters[ConstantOptimizationUpdateVariableWeightsParameterName]; }
+    public IFixedValueParameter<BoolValue> ParameterOptimizationUpdateVariableWeightsParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[ParameterOptimizationUpdateVariableWeightsParameterName]; }
     }
 
@@ -56,15 +56,15 @@
       set { DecimalPlacesParameter.Value.Value = value; }
     }
-    public bool UseConstantOptimization {
-      get { return UseConstantOptimizationParameter.Value.Value; }
-      set { UseConstantOptimizationParameter.Value.Value = value; }
+    public bool UseParameterOptimization {
+      get { return UseParameterOptimizationParameter.Value.Value; }
+      set { UseParameterOptimizationParameter.Value.Value = value; }
     }
-    public int ConstantOptimizationIterations {
-      get { return ConstantOptimizationIterationsParameter.Value.Value; }
-      set { ConstantOptimizationIterationsParameter.Value.Value = value; }
+    public int ParameterOptimizationIterations {
+      get { return ParameterOptimizationIterationsParameter.Value.Value; }
+      set { ParameterOptimizationIterationsParameter.Value.Value = value; }
     }
-    public bool ConstantOptimizationUpdateVariableWeights {
-      get { return ConstantOptimizationUpdateVariableWeightsParameter.Value.Value; }
-      set { ConstantOptimizationUpdateVariableWeightsParameter.Value.Value = value; }
+    public bool ParameterOptimizationUpdateVariableWeights {
+      get { return ParameterOptimizationUpdateVariableWeightsParameter.Value.Value; }
+      set { ParameterOptimizationUpdateVariableWeightsParameter.Value.Value = value; }
     }
 
@@ -78,22 +78,39 @@
       : base() {
       Parameters.Add(new FixedValueParameter<IntValue>(DecimalPlacesParameterName, "The number of decimal places used for rounding the quality values.", new IntValue(5)) { Hidden = true });
-      Parameters.Add(new FixedValueParameter<BoolValue>(UseConstantOptimizationParameterName, "", new BoolValue(false)));
-      Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsParameterName, "The number of iterations constant optimization should be applied.", new IntValue(5)));
-      Parameters.Add(new FixedValueParameter<BoolValue>(ConstantOptimizationUpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be optimized during constant optimization.", new BoolValue(true)) { Hidden = true });
+      Parameters.Add(new FixedValueParameter<BoolValue>(UseParameterOptimizationParameterName, "", new BoolValue(false)));
+      Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "The number of iterations parameter optimization should be applied.", new IntValue(5)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(ParameterOptimizationUpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be optimized during parameter optimization.", new BoolValue(true)) { Hidden = true });
     }
 
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(UseConstantOptimizationParameterName)) {
-        Parameters.Add(new FixedValueParameter<BoolValue>(UseConstantOptimizationParameterName, "", new BoolValue(false)));
+      if (!Parameters.ContainsKey(UseParameterOptimizationParameterName)) {
+        if (Parameters.ContainsKey("Use constant optimization")) {
+          Parameters.Add(new FixedValueParameter<BoolValue>(UseParameterOptimizationParameterName, "", (BoolValue)Parameters["Use constant optimization"].ActualValue));
+          Parameters.Remove("Use constant optimization");
+        } else {
+          Parameters.Add(new FixedValueParameter<BoolValue>(UseParameterOptimizationParameterName, "", new BoolValue(false)));
+        }
       }
+
       if (!Parameters.ContainsKey(DecimalPlacesParameterName)) {
         Parameters.Add(new FixedValueParameter<IntValue>(DecimalPlacesParameterName, "The number of decimal places used for rounding the quality values.", new IntValue(-1)) { Hidden = true });
       }
-      if (!Parameters.ContainsKey(ConstantOptimizationIterationsParameterName)) {
-        Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsParameterName, "The number of iterations constant optimization should be applied.", new IntValue(5)));
+      if (!Parameters.ContainsKey(ParameterOptimizationIterationsParameterName)) {
+        if (Parameters.ContainsKey("Constant optimization iterations")) {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "The number of iterations parameter optimization should be applied.", (IntValue)Parameters["Constant optimization iterations"].ActualValue));
+          Parameters.Remove("Constant optimization iterations");
+        } else {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "The number of iterations parameter optimization should be applied.", new IntValue(5)));
+        }
       }
-      if (!Parameters.ContainsKey(ConstantOptimizationUpdateVariableWeightsParameterName)) {
-        Parameters.Add(new FixedValueParameter<BoolValue>(ConstantOptimizationUpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be optimized during constant optimization.", new BoolValue(true)));
+      if (!Parameters.ContainsKey(ParameterOptimizationUpdateVariableWeightsParameterName)) {
+        if (Parameters.ContainsKey("Constant optimization update variable weights")) {
+          Parameters.Add(new FixedValueParameter<BoolValue>(ParameterOptimizationUpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be optimized during parameter optimization.",
+            (BoolValue)Parameters["Constant optimization update variable weights"].ActualValue));
+          Parameters.Remove("Constant optimization update variable weights");
+        } else {
+          Parameters.Add(new FixedValueParameter<BoolValue>(ParameterOptimizationUpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be optimized during parameter optimization.", new BoolValue(true)));
+        }
       }
     }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 18132)
@@ -53,6 +53,6 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 18132)
@@ -53,6 +53,6 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
       double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value, DecimalPlaces);
Index: unk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/ConstantOptimizationAnalyzer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/ConstantOptimizationAnalyzer.cs	(revision 18131)
+++ 	(revision )
@@ -1,175 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Linq;
-using HeuristicLab.Analysis;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HEAL.Attic;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
-  /// <summary>
-  /// An operator that optimizes the constants for the best symbolic expression tress in the current generation.
-  /// </summary>
-  [Item("ConstantOptimizationAnalyzer", "An operator that performs a constant optimization on the best symbolic expression trees.")]
-  [StorableType("9FB87E7B-A9E2-49DD-A92A-78BD9FC17916")]
-  public sealed class ConstantOptimizationAnalyzer : SymbolicDataAnalysisSingleObjectiveAnalyzer, IStatefulItem {
-    private const string PercentageOfBestSolutionsParameterName = "PercentageOfBestSolutions";
-    private const string ConstantOptimizationEvaluatorParameterName = "ConstantOptimizationOperator";
-
-    private const string DataTableNameConstantOptimizationImprovement = "Constant Optimization Improvement";
-    private const string DataRowNameMinimumImprovement = "Minimum improvement";
-    private const string DataRowNameMedianImprovement = "Median improvement";
-    private const string DataRowNameAverageImprovement = "Average improvement";
-    private const string DataRowNameMaximumImprovement = "Maximum improvement";
-
-    #region parameter properties
-    public IFixedValueParameter<PercentValue> PercentageOfBestSolutionsParameter {
-      get { return (IFixedValueParameter<PercentValue>)Parameters[PercentageOfBestSolutionsParameterName]; }
-    }
-
-    public IFixedValueParameter<SymbolicRegressionConstantOptimizationEvaluator> ConstantOptimizationEvaluatorParameter {
-      get { return (IFixedValueParameter<SymbolicRegressionConstantOptimizationEvaluator>)Parameters[ConstantOptimizationEvaluatorParameterName]; }
-    }
-    #endregion
-
-    #region properties
-    public SymbolicRegressionConstantOptimizationEvaluator ConstantOptimizationEvaluator {
-      get { return ConstantOptimizationEvaluatorParameter.Value; }
-    }
-    public double PercentageOfBestSolutions {
-      get { return PercentageOfBestSolutionsParameter.Value.Value; }
-    }
-
-    private DataTable ConstantOptimizationImprovementDataTable {
-      get {
-        IResult result;
-        ResultCollection.TryGetValue(DataTableNameConstantOptimizationImprovement, out result);
-        if (result == null) return null;
-        return (DataTable)result.Value;
-      }
-    }
-    private DataRow MinimumImprovement {
-      get { return ConstantOptimizationImprovementDataTable.Rows[DataRowNameMinimumImprovement]; }
-    }
-    private DataRow MedianImprovement {
-      get { return ConstantOptimizationImprovementDataTable.Rows[DataRowNameMedianImprovement]; }
-    }
-    private DataRow AverageImprovement {
-      get { return ConstantOptimizationImprovementDataTable.Rows[DataRowNameAverageImprovement]; }
-    }
-    private DataRow MaximumImprovement {
-      get { return ConstantOptimizationImprovementDataTable.Rows[DataRowNameMaximumImprovement]; }
-    }
-    #endregion
-
-    [StorableConstructor]
-    private ConstantOptimizationAnalyzer(StorableConstructorFlag _) : base(_) { }
-    private ConstantOptimizationAnalyzer(ConstantOptimizationAnalyzer original, Cloner cloner) : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) { return new ConstantOptimizationAnalyzer(this, cloner); }
-    public ConstantOptimizationAnalyzer()
-      : base() {
-      Parameters.Add(new FixedValueParameter<PercentValue>(PercentageOfBestSolutionsParameterName, "The percentage of the top solutions which should be analyzed.", new PercentValue(0.1)));
-      Parameters.Add(new FixedValueParameter<SymbolicRegressionConstantOptimizationEvaluator>(ConstantOptimizationEvaluatorParameterName, "The operator used to perform the constant optimization"));
-
-      //Changed the ActualName of the EvaluationPartitionParameter so that it matches the parameter name of symbolic regression problems.
-      ConstantOptimizationEvaluator.EvaluationPartitionParameter.ActualName = "FitnessCalculationPartition";
-    }
-
-
-    private double[] qualitiesBeforeCoOp = null;
-    private int[] scopeIndexes = null;
-    void IStatefulItem.InitializeState() {
-      qualitiesBeforeCoOp = null;
-      scopeIndexes = null;
-    }
-    void IStatefulItem.ClearState() {
-      qualitiesBeforeCoOp = null;
-      scopeIndexes = null;
-    }
-
-    public override IOperation Apply() {
-      //code executed in the first call of analyzer
-      if (qualitiesBeforeCoOp == null) {
-        double[] trainingQuality;
-        // sort is ascending and we take the first n% => order so that best solutions are smallest
-        // sort order is determined by maximization parameter
-        if (Maximization.Value) {
-          // largest values must be sorted first
-          trainingQuality = Quality.Select(x => -x.Value).ToArray();
-        } else {
-          // smallest values must be sorted first
-          trainingQuality = Quality.Select(x => x.Value).ToArray();
-        }
-        // sort trees by training qualities
-        int topN = (int)Math.Max(trainingQuality.Length * PercentageOfBestSolutions, 1);
-        scopeIndexes = Enumerable.Range(0, trainingQuality.Length).ToArray();
-        Array.Sort(trainingQuality, scopeIndexes);
-        scopeIndexes = scopeIndexes.Take(topN).ToArray();
-        qualitiesBeforeCoOp = scopeIndexes.Select(x => Quality[x].Value).ToArray();
-
-        OperationCollection operationCollection = new OperationCollection();
-        operationCollection.Parallel = true;
-        foreach (var scopeIndex in scopeIndexes) {
-          var childOperation = ExecutionContext.CreateChildOperation(ConstantOptimizationEvaluator, ExecutionContext.Scope.SubScopes[scopeIndex]);
-          operationCollection.Add(childOperation);
-        }
-
-        return new OperationCollection { operationCollection, ExecutionContext.CreateOperation(this) };
-      }
-
-      //code executed to analyze results of constant optimization
-      double[] qualitiesAfterCoOp = scopeIndexes.Select(x => Quality[x].Value).ToArray();
-      var qualityImprovement = qualitiesBeforeCoOp.Zip(qualitiesAfterCoOp, (b, a) => a - b).ToArray();
-
-      if (!ResultCollection.ContainsKey(DataTableNameConstantOptimizationImprovement)) {
-        var dataTable = new DataTable(DataTableNameConstantOptimizationImprovement);
-        ResultCollection.Add(new Result(DataTableNameConstantOptimizationImprovement, dataTable));
-        dataTable.VisualProperties.YAxisTitle = "R²";
-
-        dataTable.Rows.Add(new DataRow(DataRowNameMinimumImprovement));
-        MinimumImprovement.VisualProperties.StartIndexZero = true;
-
-        dataTable.Rows.Add(new DataRow(DataRowNameMedianImprovement));
-        MedianImprovement.VisualProperties.StartIndexZero = true;
-
-        dataTable.Rows.Add(new DataRow(DataRowNameAverageImprovement));
-        AverageImprovement.VisualProperties.StartIndexZero = true;
-
-        dataTable.Rows.Add(new DataRow(DataRowNameMaximumImprovement));
-        MaximumImprovement.VisualProperties.StartIndexZero = true;
-      }
-
-      MinimumImprovement.Values.Add(qualityImprovement.Min());
-      MedianImprovement.Values.Add(qualityImprovement.Median());
-      AverageImprovement.Values.Add(qualityImprovement.Average());
-      MaximumImprovement.Values.Add(qualityImprovement.Max());
-
-      qualitiesBeforeCoOp = null;
-      scopeIndexes = null;
-      return base.Apply();
-    }
-  }
-}
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NMSESingleObjectiveConstraintsEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NMSESingleObjectiveConstraintsEvaluator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NMSESingleObjectiveConstraintsEvaluator.cs	(revision 18132)
@@ -46,5 +46,5 @@
       (IFixedValueParameter<BoolValue>)Parameters[OptimizeParametersParameterName];
 
-    public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter =>
+    public IFixedValueParameter<IntValue> ParameterOptimizationIterationsParameter =>
       (IFixedValueParameter<IntValue>)Parameters[ParameterOptimizationIterationsParameterName];
 
@@ -62,7 +62,7 @@
     }
 
-    public int ConstantOptimizationIterations {
-      get => ConstantOptimizationIterationsParameter.Value.Value;
-      set => ConstantOptimizationIterationsParameter.Value.Value = value;
+    public int ParameterOptimizationIterations {
+      get => ParameterOptimizationIterationsParameter.Value.Value;
+      set => ParameterOptimizationIterationsParameter.Value.Value = value;
     }
 
@@ -97,5 +97,5 @@
     public NMSESingleObjectiveConstraintsEvaluator() {
       Parameters.Add(new FixedValueParameter<BoolValue>(OptimizeParametersParameterName,
-        "Define whether optimization of numeric parameters is active or not (default: false).", new BoolValue(false)));
+        "Define whether optimization of parameters is active or not (default: false).", new BoolValue(false)));
       Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName,
         "Define how many parameter optimization steps should be performed (default: 10).", new IntValue(10)));
@@ -126,6 +126,6 @@
 
       if (OptimizeParameters) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, tree, problemData, rows,
-          false, ConstantOptimizationIterations, true,
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, tree, problemData, rows,
+          false, ParameterOptimizationIterations, true,
           estimationLimits.Lower, estimationLimits.Upper);
       } else {
@@ -155,7 +155,7 @@
           if (errorState == OnlineCalculatorError.None) {
             //Set alpha and beta to the scaling nodes from ia grammar
-            var offsetParameter = offset.GetSubtree(1) as ConstantTreeNode;
+            var offsetParameter = offset.GetSubtree(1) as NumberTreeNode;
             offsetParameter.Value = alpha;
-            var scalingParameter = scaling.GetSubtree(1) as ConstantTreeNode;
+            var scalingParameter = scaling.GetSubtree(1) as NumberTreeNode;
             scalingParameter.Value = beta;
           }
Index: unk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionConstantOptimizationEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionConstantOptimizationEvaluator.cs	(revision 18131)
+++ 	(revision )
@@ -1,346 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HEAL.Attic;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
-  [Item("Constant Optimization Evaluator", "Calculates Pearson R² of a symbolic regression solution and optimizes the constant used.")]
-  [StorableType("24B68851-036D-4446-BD6F-3823E9028FF4")]
-  public class SymbolicRegressionConstantOptimizationEvaluator : SymbolicRegressionSingleObjectiveEvaluator {
-    private const string ConstantOptimizationIterationsParameterName = "ConstantOptimizationIterations";
-    private const string ConstantOptimizationImprovementParameterName = "ConstantOptimizationImprovement";
-    private const string ConstantOptimizationProbabilityParameterName = "ConstantOptimizationProbability";
-    private const string ConstantOptimizationRowsPercentageParameterName = "ConstantOptimizationRowsPercentage";
-    private const string UpdateConstantsInTreeParameterName = "UpdateConstantsInSymbolicExpressionTree";
-    private const string UpdateVariableWeightsParameterName = "Update Variable Weights";
-
-    private const string FunctionEvaluationsResultParameterName = "Constants Optimization Function Evaluations";
-    private const string GradientEvaluationsResultParameterName = "Constants Optimization Gradient Evaluations";
-    private const string CountEvaluationsParameterName = "Count Function and Gradient Evaluations";
-
-    public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[ConstantOptimizationIterationsParameterName]; }
-    }
-    public IFixedValueParameter<DoubleValue> ConstantOptimizationImprovementParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters[ConstantOptimizationImprovementParameterName]; }
-    }
-    public IFixedValueParameter<PercentValue> ConstantOptimizationProbabilityParameter {
-      get { return (IFixedValueParameter<PercentValue>)Parameters[ConstantOptimizationProbabilityParameterName]; }
-    }
-    public IFixedValueParameter<PercentValue> ConstantOptimizationRowsPercentageParameter {
-      get { return (IFixedValueParameter<PercentValue>)Parameters[ConstantOptimizationRowsPercentageParameterName]; }
-    }
-    public IFixedValueParameter<BoolValue> UpdateConstantsInTreeParameter {
-      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateConstantsInTreeParameterName]; }
-    }
-    public IFixedValueParameter<BoolValue> UpdateVariableWeightsParameter {
-      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateVariableWeightsParameterName]; }
-    }
-
-    public IResultParameter<IntValue> FunctionEvaluationsResultParameter {
-      get { return (IResultParameter<IntValue>)Parameters[FunctionEvaluationsResultParameterName]; }
-    }
-    public IResultParameter<IntValue> GradientEvaluationsResultParameter {
-      get { return (IResultParameter<IntValue>)Parameters[GradientEvaluationsResultParameterName]; }
-    }
-    public IFixedValueParameter<BoolValue> CountEvaluationsParameter {
-      get { return (IFixedValueParameter<BoolValue>)Parameters[CountEvaluationsParameterName]; }
-    }
-
-
-    public IntValue ConstantOptimizationIterations {
-      get { return ConstantOptimizationIterationsParameter.Value; }
-    }
-    public DoubleValue ConstantOptimizationImprovement {
-      get { return ConstantOptimizationImprovementParameter.Value; }
-    }
-    public PercentValue ConstantOptimizationProbability {
-      get { return ConstantOptimizationProbabilityParameter.Value; }
-    }
-    public PercentValue ConstantOptimizationRowsPercentage {
-      get { return ConstantOptimizationRowsPercentageParameter.Value; }
-    }
-    public bool UpdateConstantsInTree {
-      get { return UpdateConstantsInTreeParameter.Value.Value; }
-      set { UpdateConstantsInTreeParameter.Value.Value = value; }
-    }
-
-    public bool UpdateVariableWeights {
-      get { return UpdateVariableWeightsParameter.Value.Value; }
-      set { UpdateVariableWeightsParameter.Value.Value = value; }
-    }
-
-    public bool CountEvaluations {
-      get { return CountEvaluationsParameter.Value.Value; }
-      set { CountEvaluationsParameter.Value.Value = value; }
-    }
-
-    public override bool Maximization {
-      get { return true; }
-    }
-
-    [StorableConstructor]
-    protected SymbolicRegressionConstantOptimizationEvaluator(StorableConstructorFlag _) : base(_) { }
-    protected SymbolicRegressionConstantOptimizationEvaluator(SymbolicRegressionConstantOptimizationEvaluator original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public SymbolicRegressionConstantOptimizationEvaluator()
-      : base() {
-      Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsParameterName, "Determines how many iterations should be calculated while optimizing the constant of a symbolic expression tree (0 indicates other or default stopping criterion).", new IntValue(10)));
-      Parameters.Add(new FixedValueParameter<DoubleValue>(ConstantOptimizationImprovementParameterName, "Determines the relative improvement which must be achieved in the constant optimization to continue with it (0 indicates other or default stopping criterion).", new DoubleValue(0)) { Hidden = true });
-      Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationProbabilityParameterName, "Determines the probability that the constants are optimized", new PercentValue(1)));
-      Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for constant optimization", new PercentValue(1)));
-      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateConstantsInTreeParameterName, "Determines if the constants in the tree should be overwritten by the optimized constants.", new BoolValue(true)) { Hidden = true });
-      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be  optimized.", new BoolValue(true)) { Hidden = true });
-
-      Parameters.Add(new FixedValueParameter<BoolValue>(CountEvaluationsParameterName, "Determines if function and gradient evaluation should be counted.", new BoolValue(false)));
-      Parameters.Add(new ResultParameter<IntValue>(FunctionEvaluationsResultParameterName, "The number of function evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
-      Parameters.Add(new ResultParameter<IntValue>(GradientEvaluationsResultParameterName, "The number of gradient evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicRegressionConstantOptimizationEvaluator(this, cloner);
-    }
-
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(UpdateConstantsInTreeParameterName))
-        Parameters.Add(new FixedValueParameter<BoolValue>(UpdateConstantsInTreeParameterName, "Determines if the constants in the tree should be overwritten by the optimized constants.", new BoolValue(true)));
-      if (!Parameters.ContainsKey(UpdateVariableWeightsParameterName))
-        Parameters.Add(new FixedValueParameter<BoolValue>(UpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be  optimized.", new BoolValue(true)));
-
-      if (!Parameters.ContainsKey(CountEvaluationsParameterName))
-        Parameters.Add(new FixedValueParameter<BoolValue>(CountEvaluationsParameterName, "Determines if function and gradient evaluation should be counted.", new BoolValue(false)));
-
-      if (!Parameters.ContainsKey(FunctionEvaluationsResultParameterName))
-        Parameters.Add(new ResultParameter<IntValue>(FunctionEvaluationsResultParameterName, "The number of function evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
-      if (!Parameters.ContainsKey(GradientEvaluationsResultParameterName))
-        Parameters.Add(new ResultParameter<IntValue>(GradientEvaluationsResultParameterName, "The number of gradient evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
-    }
-
-    private static readonly object locker = new object();
-    public override IOperation InstrumentedApply() {
-      var solution = SymbolicExpressionTreeParameter.ActualValue;
-      double quality;
-      if (RandomParameter.ActualValue.NextDouble() < ConstantOptimizationProbability.Value) {
-        IEnumerable<int> constantOptimizationRows = GenerateRowsToEvaluate(ConstantOptimizationRowsPercentage.Value);
-        var counter = new EvaluationsCounter();
-        quality = OptimizeConstants(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, ProblemDataParameter.ActualValue,
-           constantOptimizationRows, ApplyLinearScalingParameter.ActualValue.Value, ConstantOptimizationIterations.Value, updateVariableWeights: UpdateVariableWeights, lowerEstimationLimit: EstimationLimitsParameter.ActualValue.Lower, upperEstimationLimit: EstimationLimitsParameter.ActualValue.Upper, updateConstantsInTree: UpdateConstantsInTree, counter: counter);
-
-        if (ConstantOptimizationRowsPercentage.Value != RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value) {
-          var evaluationRows = GenerateRowsToEvaluate();
-          quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, evaluationRows, ApplyLinearScalingParameter.ActualValue.Value);
-        }
-
-        if (CountEvaluations) {
-          lock (locker) {
-            FunctionEvaluationsResultParameter.ActualValue.Value += counter.FunctionEvaluations;
-            GradientEvaluationsResultParameter.ActualValue.Value += counter.GradientEvaluations;
-          }
-        }
-
-      } else {
-        var evaluationRows = GenerateRowsToEvaluate();
-        quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, evaluationRows, ApplyLinearScalingParameter.ActualValue.Value);
-      }
-      QualityParameter.ActualValue = new DoubleValue(quality);
-
-      return base.InstrumentedApply();
-    }
-
-    public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows) {
-      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
-      EstimationLimitsParameter.ExecutionContext = context;
-      ApplyLinearScalingParameter.ExecutionContext = context;
-      FunctionEvaluationsResultParameter.ExecutionContext = context;
-      GradientEvaluationsResultParameter.ExecutionContext = context;
-
-      // Pearson R² evaluator is used on purpose instead of the const-opt evaluator, 
-      // because Evaluate() is used to get the quality of evolved models on 
-      // different partitions of the dataset (e.g., best validation model)
-      double r2 = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, ApplyLinearScalingParameter.ActualValue.Value);
-
-      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
-      EstimationLimitsParameter.ExecutionContext = null;
-      ApplyLinearScalingParameter.ExecutionContext = null;
-      FunctionEvaluationsResultParameter.ExecutionContext = null;
-      GradientEvaluationsResultParameter.ExecutionContext = null;
-
-      return r2;
-    }
-
-    public class EvaluationsCounter {
-      public int FunctionEvaluations = 0;
-      public int GradientEvaluations = 0;
-    }
-
-    public static double OptimizeConstants(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
-      ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
-      int maxIterations, bool updateVariableWeights = true,
-      double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue,
-      bool updateConstantsInTree = true, Action<double[], double, object> iterationCallback = null, EvaluationsCounter counter = null) {
-
-      // Numeric constants in the tree become variables for parameter optimization.
-      // Variables in the tree become parameters (fixed values) for parameter optimization.
-      // For each parameter (variable in the original tree) we store the 
-      // variable name, variable value (for factor vars) and lag as a DataForVariable object.
-      // A dictionary is used to find parameters
-      double[] initialConstants;
-      var parameters = new List<TreeToAutoDiffTermConverter.DataForVariable>();
-
-      TreeToAutoDiffTermConverter.ParametricFunction func;
-      TreeToAutoDiffTermConverter.ParametricFunctionGradient func_grad;
-      if (!TreeToAutoDiffTermConverter.TryConvertToAutoDiff(tree, updateVariableWeights, applyLinearScaling, out parameters, out initialConstants, out func, out func_grad))
-        throw new NotSupportedException("Could not optimize constants of symbolic expression tree due to not supported symbols used in the tree.");
-      if (parameters.Count == 0) return 0.0; // constant expressions always have a R² of 0.0 
-      var parameterEntries = parameters.ToArray(); // order of entries must be the same for x
-
-      // extract inital constants
-      double[] c;
-      if (applyLinearScaling) {
-        c = new double[initialConstants.Length + 2];
-        c[0] = 0.0;
-        c[1] = 1.0;
-        Array.Copy(initialConstants, 0, c, 2, initialConstants.Length);
-      } else {
-        c = (double[])initialConstants.Clone();
-      }
-
-      double originalQuality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling);
-
-      if (counter == null) counter = new EvaluationsCounter();
-      var rowEvaluationsCounter = new EvaluationsCounter();
-
-      alglib.lsfitstate state;
-      alglib.lsfitreport rep;
-      int retVal;
-
-      IDataset ds = problemData.Dataset;
-      double[,] x = new double[rows.Count(), parameters.Count];
-      int row = 0;
-      foreach (var r in rows) {
-        int col = 0;
-        foreach (var info in parameterEntries) {
-          if (ds.VariableHasType<double>(info.variableName)) {
-            x[row, col] = ds.GetDoubleValue(info.variableName, r + info.lag);
-          } else if (ds.VariableHasType<string>(info.variableName)) {
-            x[row, col] = ds.GetStringValue(info.variableName, r) == info.variableValue ? 1 : 0;
-          } else throw new InvalidProgramException("found a variable of unknown type");
-          col++;
-        }
-        row++;
-      }
-      double[] y = ds.GetDoubleValues(problemData.TargetVariable, rows).ToArray();
-      int n = x.GetLength(0);
-      int m = x.GetLength(1);
-      int k = c.Length;
-
-      alglib.ndimensional_pfunc function_cx_1_func = CreatePFunc(func);
-      alglib.ndimensional_pgrad function_cx_1_grad = CreatePGrad(func_grad);
-      alglib.ndimensional_rep xrep = (p, f, obj) => iterationCallback(p, f, obj);
-
-      try {
-        alglib.lsfitcreatefg(x, y, c, n, m, k, false, out state);
-        alglib.lsfitsetcond(state, 0.0, maxIterations);
-        alglib.lsfitsetxrep(state, iterationCallback != null);
-        alglib.lsfitfit(state, function_cx_1_func, function_cx_1_grad, xrep, rowEvaluationsCounter);
-        alglib.lsfitresults(state, out retVal, out c, out rep);
-      } catch (ArithmeticException) {
-        return originalQuality;
-      } catch (alglib.alglibexception) {
-        return originalQuality;
-      }
-
-      counter.FunctionEvaluations += rowEvaluationsCounter.FunctionEvaluations / n;
-      counter.GradientEvaluations += rowEvaluationsCounter.GradientEvaluations / n;
-
-      //retVal == -7  => constant optimization failed due to wrong gradient
-      //          -8  => optimizer detected  NAN / INF  in  the target
-      //                 function and/ or gradient
-      if (retVal != -7 && retVal != -8) {
-        if (applyLinearScaling) {
-          var tmp = new double[c.Length - 2];
-          Array.Copy(c, 2, tmp, 0, tmp.Length);
-          UpdateConstants(tree, tmp, updateVariableWeights);
-        } else UpdateConstants(tree, c, updateVariableWeights);
-      }
-      var quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling);
-
-      if (!updateConstantsInTree) UpdateConstants(tree, initialConstants, updateVariableWeights);
-
-      if (originalQuality - quality > 0.001 || double.IsNaN(quality)) {
-        UpdateConstants(tree, initialConstants, updateVariableWeights);
-        return originalQuality;
-      }
-      return quality;
-    }
-
-    private static void UpdateConstants(ISymbolicExpressionTree tree, double[] constants, bool updateVariableWeights) {
-      int i = 0;
-      foreach (var node in tree.Root.IterateNodesPrefix().OfType<SymbolicExpressionTreeTerminalNode>()) {
-        ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
-        VariableTreeNodeBase variableTreeNodeBase = node as VariableTreeNodeBase;
-        FactorVariableTreeNode factorVarTreeNode = node as FactorVariableTreeNode;
-        if (constantTreeNode != null) {
-          if (constantTreeNode.Parent.Symbol is Power 
-              && constantTreeNode.Parent.GetSubtree(1) == constantTreeNode) continue; // exponents in powers are not optimizated (see TreeToAutoDiffTermConverter)
-          constantTreeNode.Value = constants[i++];
-        } else if (updateVariableWeights && variableTreeNodeBase != null)
-          variableTreeNodeBase.Weight = constants[i++];
-        else if (factorVarTreeNode != null) {
-          for (int j = 0; j < factorVarTreeNode.Weights.Length; j++)
-            factorVarTreeNode.Weights[j] = constants[i++];
-        }
-      }
-    }
-
-    private static alglib.ndimensional_pfunc CreatePFunc(TreeToAutoDiffTermConverter.ParametricFunction func) {
-      return (double[] c, double[] x, ref double fx, object o) => {
-        fx = func(c, x);
-        var counter = (EvaluationsCounter)o;
-        counter.FunctionEvaluations++;
-      };
-    }
-
-    private static alglib.ndimensional_pgrad CreatePGrad(TreeToAutoDiffTermConverter.ParametricFunctionGradient func_grad) {
-      return (double[] c, double[] x, ref double fx, double[] grad, object o) => {
-        var tuple = func_grad(c, x);
-        fx = tuple.Item2;
-        Array.Copy(tuple.Item1, grad, grad.Length);
-        var counter = (EvaluationsCounter)o;
-        counter.GradientEvaluations++;
-      };
-    }
-    public static bool CanOptimizeConstants(ISymbolicExpressionTree tree) {
-      return TreeToAutoDiffTermConverter.IsCompatible(tree);
-    }
-  }
-}
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionParameterOptimizationEvaluator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionParameterOptimizationEvaluator.cs	(revision 18132)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionParameterOptimizationEvaluator.cs	(revision 18132)
@@ -0,0 +1,401 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HEAL.Attic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
+  [Item("Parameter Optimization Evaluator", "Calculates Pearson R² of a symbolic regression solution and optimizes the parameters used.")]
+  [StorableType("24B68851-036D-4446-BD6F-3823E9028FF4")]
+  public class SymbolicRegressionParameterOptimizationEvaluator : SymbolicRegressionSingleObjectiveEvaluator {
+    private const string ParameterOptimizationIterationsParameterName = "ParameterOptimizationIterations";
+    private const string ParameterOptimizationImprovementParameterName = "ParameterOptimizationImprovement";
+    private const string ParameterOptimizationProbabilityParameterName = "ParameterOptimizationProbability";
+    private const string ParameterOptimizationRowsPercentageParameterName = "ParameterOptimizationRowsPercentage";
+    private const string UpdateParametersInTreeParameterName = "UpdateParametersInSymbolicExpressionTree";
+    private const string UpdateVariableWeightsParameterName = "Update Variable Weights";
+
+    private const string FunctionEvaluationsResultParameterName = "Parameters Optimization Function Evaluations";
+    private const string GradientEvaluationsResultParameterName = "Parameters Optimization Gradient Evaluations";
+    private const string CountEvaluationsParameterName = "Count Function and Gradient Evaluations";
+
+    public IFixedValueParameter<IntValue> ParameterOptimizationIterationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[ParameterOptimizationIterationsParameterName]; }
+    }
+    public IFixedValueParameter<DoubleValue> ParameterOptimizationImprovementParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[ParameterOptimizationImprovementParameterName]; }
+    }
+    public IFixedValueParameter<PercentValue> ParameterOptimizationProbabilityParameter {
+      get { return (IFixedValueParameter<PercentValue>)Parameters[ParameterOptimizationProbabilityParameterName]; }
+    }
+    public IFixedValueParameter<PercentValue> ParameterOptimizationRowsPercentageParameter {
+      get { return (IFixedValueParameter<PercentValue>)Parameters[ParameterOptimizationRowsPercentageParameterName]; }
+    }
+    public IFixedValueParameter<BoolValue> UpdateParametersInTreeParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateParametersInTreeParameterName]; }
+    }
+    public IFixedValueParameter<BoolValue> UpdateVariableWeightsParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateVariableWeightsParameterName]; }
+    }
+
+    public IResultParameter<IntValue> FunctionEvaluationsResultParameter {
+      get { return (IResultParameter<IntValue>)Parameters[FunctionEvaluationsResultParameterName]; }
+    }
+    public IResultParameter<IntValue> GradientEvaluationsResultParameter {
+      get { return (IResultParameter<IntValue>)Parameters[GradientEvaluationsResultParameterName]; }
+    }
+    public IFixedValueParameter<BoolValue> CountEvaluationsParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[CountEvaluationsParameterName]; }
+    }
+
+
+    public IntValue ParameterOptimizationIterations {
+      get { return ParameterOptimizationIterationsParameter.Value; }
+    }
+    public DoubleValue ParameterOptimizationImprovement {
+      get { return ParameterOptimizationImprovementParameter.Value; }
+    }
+    public PercentValue ParameterOptimizationProbability {
+      get { return ParameterOptimizationProbabilityParameter.Value; }
+    }
+    public PercentValue ParameterOptimizationRowsPercentage {
+      get { return ParameterOptimizationRowsPercentageParameter.Value; }
+    }
+    public bool UpdateParametersInTree {
+      get { return UpdateParametersInTreeParameter.Value.Value; }
+      set { UpdateParametersInTreeParameter.Value.Value = value; }
+    }
+
+    public bool UpdateVariableWeights {
+      get { return UpdateVariableWeightsParameter.Value.Value; }
+      set { UpdateVariableWeightsParameter.Value.Value = value; }
+    }
+
+    public bool CountEvaluations {
+      get { return CountEvaluationsParameter.Value.Value; }
+      set { CountEvaluationsParameter.Value.Value = value; }
+    }
+
+    public override bool Maximization {
+      get { return true; }
+    }
+
+    [StorableConstructor]
+    protected SymbolicRegressionParameterOptimizationEvaluator(StorableConstructorFlag _) : base(_) { }
+    protected SymbolicRegressionParameterOptimizationEvaluator(SymbolicRegressionParameterOptimizationEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public SymbolicRegressionParameterOptimizationEvaluator()
+      : base() {
+      Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "Determines how many iterations should be calculated while optimizing the parameter of a symbolic expression tree (0 indicates other or default stopping criterion).", new IntValue(10)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(ParameterOptimizationImprovementParameterName, "Determines the relative improvement which must be achieved in the parameter optimization to continue with it (0 indicates other or default stopping criterion).", new DoubleValue(0)) { Hidden = true });
+      Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationProbabilityParameterName, "Determines the probability that the parameters are optimized", new PercentValue(1)));
+      Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for parameter optimization", new PercentValue(1)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateParametersInTreeParameterName, "Determines if the parameters in the tree should be overwritten by the optimized parameters.", new BoolValue(true)) { Hidden = true });
+      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be  optimized.", new BoolValue(true)) { Hidden = true });
+
+      Parameters.Add(new FixedValueParameter<BoolValue>(CountEvaluationsParameterName, "Determines if function and gradient evaluation should be counted.", new BoolValue(false)));
+      Parameters.Add(new ResultParameter<IntValue>(FunctionEvaluationsResultParameterName, "The number of function evaluations performed by the parameters optimization evaluator", "Results", new IntValue()));
+      Parameters.Add(new ResultParameter<IntValue>(GradientEvaluationsResultParameterName, "The number of gradient evaluations performed by the parameters optimization evaluator", "Results", new IntValue()));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicRegressionParameterOptimizationEvaluator(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(UpdateParametersInTreeParameterName)) {
+        if (Parameters.ContainsKey("UpdateConstantsInSymbolicExpressionTree")) {
+          Parameters.Add(new FixedValueParameter<BoolValue>(UpdateParametersInTreeParameterName, "Determines if the parameters in the tree should be overwritten by the optimized parameters.", (BoolValue)Parameters["UpdateConstantsInSymbolicExpressionTree"].ActualValue));
+          Parameters.Remove("UpdateConstantsInSymbolicExpressionTree");
+        } else {
+          Parameters.Add(new FixedValueParameter<BoolValue>(UpdateParametersInTreeParameterName, "Determines if the parameters in the tree should be overwritten by the optimized parameters.", new BoolValue(true)));
+        }
+      }
+
+      if (!Parameters.ContainsKey(UpdateVariableWeightsParameterName))
+        Parameters.Add(new FixedValueParameter<BoolValue>(UpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be  optimized.", new BoolValue(true)));
+
+      if (!Parameters.ContainsKey(CountEvaluationsParameterName))
+        Parameters.Add(new FixedValueParameter<BoolValue>(CountEvaluationsParameterName, "Determines if function and gradient evaluation should be counted.", new BoolValue(false)));
+
+      if (!Parameters.ContainsKey(FunctionEvaluationsResultParameterName)) {
+        if (Parameters.ContainsKey("Constants Optimization Function Evaluations")) {
+          Parameters.Remove("Constants Optimization Function Evaluations");
+        }
+        Parameters.Add(new ResultParameter<IntValue>(FunctionEvaluationsResultParameterName, "The number of function evaluations performed by the parameters optimization evaluator", "Results", new IntValue()));
+      }
+
+      if (!Parameters.ContainsKey(GradientEvaluationsResultParameterName)) {
+        if (Parameters.ContainsKey("Constants Optimization Gradient Evaluations")) {
+          Parameters.Remove("Constants Optimization Gradient Evaluations");
+        }
+        Parameters.Add(new ResultParameter<IntValue>(GradientEvaluationsResultParameterName, "The number of gradient evaluations performed by the parameters optimization evaluator", "Results", new IntValue()));
+      }
+
+      if (!Parameters.ContainsKey(ParameterOptimizationIterationsParameterName)) {
+        if (Parameters.ContainsKey("ConstantOptimizationIterations")) {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "Determines how many iterations should be calculated while optimizing the parameter of a symbolic expression tree (0 indicates other or default stopping criterion).", (IntValue)Parameters["ConstantOptimizationIterations"].ActualValue));
+          Parameters.Remove("ConstantOptimizationIterations");
+        } else {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "Determines how many iterations should be calculated while optimizing the parameter of a symbolic expression tree (0 indicates other or default stopping criterion).", new IntValue(10)));
+        }
+      }
+
+      if (!Parameters.ContainsKey(ParameterOptimizationImprovementParameterName)) {
+        if (Parameters.ContainsKey("CosntantOptimizationImprovement")) {
+          Parameters.Add(new FixedValueParameter<DoubleValue>(ParameterOptimizationImprovementParameterName, "Determines the relative improvement which must be achieved in the parameter optimization to continue with it (0 indicates other or default stopping criterion).",
+            (DoubleValue)Parameters["CosntantOptimizationImprovement"].ActualValue) { Hidden = true });
+          Parameters.Remove("CosntantOptimizationImprovement");
+        } else {
+          Parameters.Add(new FixedValueParameter<DoubleValue>(ParameterOptimizationImprovementParameterName, "Determines the relative improvement which must be achieved in the parameter optimization to continue with it (0 indicates other or default stopping criterion).", new DoubleValue(0)) { Hidden = true });
+        }
+      }
+
+      if (!Parameters.ContainsKey(ParameterOptimizationProbabilityParameterName)) {
+        if (Parameters.ContainsKey("ConstantOptimizationProbability")) {
+          Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationProbabilityParameterName, "Determines the probability that the parameters are optimized",
+            (PercentValue)Parameters["ConstantOptimizationProbability"].ActualValue));
+          Parameters.Remove("ConstantOptimizationProbability");
+        } else {
+          Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationProbabilityParameterName, "Determines the probability that the parameters are optimized", new PercentValue(1)));
+        }
+      }
+
+      if (!Parameters.ContainsKey(ParameterOptimizationRowsPercentageParameterName)) {
+        if (Parameters.ContainsKey("ConstantOptimizationRowsPercentage")) {
+          Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for parameter optimization", (PercentValue)Parameters["ConstantOptimizationRowsPercentage"].ActualValue));
+          Parameters.Remove("ConstantOptimizationRowsPercentage");
+        } else {
+          Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for parameter optimization", new PercentValue(1)));
+        }
+        
+      }
+    }
+
+    private static readonly object locker = new object();
+    public override IOperation InstrumentedApply() {
+      var solution = SymbolicExpressionTreeParameter.ActualValue;
+      double quality;
+      if (RandomParameter.ActualValue.NextDouble() < ParameterOptimizationProbability.Value) {
+        IEnumerable<int> parameterOptimizationRows = GenerateRowsToEvaluate(ParameterOptimizationRowsPercentage.Value);
+        var counter = new EvaluationsCounter();
+        quality = OptimizeParameters(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, ProblemDataParameter.ActualValue,
+           parameterOptimizationRows, ApplyLinearScalingParameter.ActualValue.Value, ParameterOptimizationIterations.Value, updateVariableWeights: UpdateVariableWeights, lowerEstimationLimit: EstimationLimitsParameter.ActualValue.Lower, upperEstimationLimit: EstimationLimitsParameter.ActualValue.Upper, updateParametersInTree: UpdateParametersInTree, counter: counter);
+
+        if (ParameterOptimizationRowsPercentage.Value != RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value) {
+          var evaluationRows = GenerateRowsToEvaluate();
+          quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, evaluationRows, ApplyLinearScalingParameter.ActualValue.Value);
+        }
+
+        if (CountEvaluations) {
+          lock (locker) {
+            FunctionEvaluationsResultParameter.ActualValue.Value += counter.FunctionEvaluations;
+            GradientEvaluationsResultParameter.ActualValue.Value += counter.GradientEvaluations;
+          }
+        }
+
+      } else {
+        var evaluationRows = GenerateRowsToEvaluate();
+        quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, evaluationRows, ApplyLinearScalingParameter.ActualValue.Value);
+      }
+      QualityParameter.ActualValue = new DoubleValue(quality);
+
+      return base.InstrumentedApply();
+    }
+
+    public override double Evaluate(IExecutionContext context, ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows) {
+      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = context;
+      EstimationLimitsParameter.ExecutionContext = context;
+      ApplyLinearScalingParameter.ExecutionContext = context;
+      FunctionEvaluationsResultParameter.ExecutionContext = context;
+      GradientEvaluationsResultParameter.ExecutionContext = context;
+
+      // Pearson R² evaluator is used on purpose instead of the const-opt evaluator, 
+      // because Evaluate() is used to get the quality of evolved models on 
+      // different partitions of the dataset (e.g., best validation model)
+      double r2 = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, tree, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, problemData, rows, ApplyLinearScalingParameter.ActualValue.Value);
+
+      SymbolicDataAnalysisTreeInterpreterParameter.ExecutionContext = null;
+      EstimationLimitsParameter.ExecutionContext = null;
+      ApplyLinearScalingParameter.ExecutionContext = null;
+      FunctionEvaluationsResultParameter.ExecutionContext = null;
+      GradientEvaluationsResultParameter.ExecutionContext = null;
+
+      return r2;
+    }
+
+    public class EvaluationsCounter {
+      public int FunctionEvaluations = 0;
+      public int GradientEvaluations = 0;
+    }
+
+    public static double OptimizeParameters(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
+      ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
+      int maxIterations, bool updateVariableWeights = true,
+      double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue,
+      bool updateParametersInTree = true, Action<double[], double, object> iterationCallback = null, EvaluationsCounter counter = null) {
+
+      // Numeric parameters in the tree become variables for parameter optimization.
+      // Variables in the tree become parameters (fixed values) for parameter optimization.
+      // For each parameter (variable in the original tree) we store the 
+      // variable name, variable value (for factor vars) and lag as a DataForVariable object.
+      // A dictionary is used to find parameters
+      double[] initialParameters;
+      var parameters = new List<TreeToAutoDiffTermConverter.DataForVariable>();
+
+      TreeToAutoDiffTermConverter.ParametricFunction func;
+      TreeToAutoDiffTermConverter.ParametricFunctionGradient func_grad;
+      if (!TreeToAutoDiffTermConverter.TryConvertToAutoDiff(tree, updateVariableWeights, applyLinearScaling, out parameters, out initialParameters, out func, out func_grad))
+        throw new NotSupportedException("Could not optimize parameters of symbolic expression tree due to not supported symbols used in the tree.");
+      if (parameters.Count == 0) return 0.0; // constant expressions always have a R² of 0.0 
+      var parameterEntries = parameters.ToArray(); // order of entries must be the same for x
+
+      // extract inital parameters
+      double[] c;
+      if (applyLinearScaling) {
+        c = new double[initialParameters.Length + 2];
+        c[0] = 0.0;
+        c[1] = 1.0;
+        Array.Copy(initialParameters, 0, c, 2, initialParameters.Length);
+      } else {
+        c = (double[])initialParameters.Clone();
+      }
+
+      double originalQuality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling);
+
+      if (counter == null) counter = new EvaluationsCounter();
+      var rowEvaluationsCounter = new EvaluationsCounter();
+
+      alglib.lsfitstate state;
+      alglib.lsfitreport rep;
+      int retVal;
+
+      IDataset ds = problemData.Dataset;
+      double[,] x = new double[rows.Count(), parameters.Count];
+      int row = 0;
+      foreach (var r in rows) {
+        int col = 0;
+        foreach (var info in parameterEntries) {
+          if (ds.VariableHasType<double>(info.variableName)) {
+            x[row, col] = ds.GetDoubleValue(info.variableName, r + info.lag);
+          } else if (ds.VariableHasType<string>(info.variableName)) {
+            x[row, col] = ds.GetStringValue(info.variableName, r) == info.variableValue ? 1 : 0;
+          } else throw new InvalidProgramException("found a variable of unknown type");
+          col++;
+        }
+        row++;
+      }
+      double[] y = ds.GetDoubleValues(problemData.TargetVariable, rows).ToArray();
+      int n = x.GetLength(0);
+      int m = x.GetLength(1);
+      int k = c.Length;
+
+      alglib.ndimensional_pfunc function_cx_1_func = CreatePFunc(func);
+      alglib.ndimensional_pgrad function_cx_1_grad = CreatePGrad(func_grad);
+      alglib.ndimensional_rep xrep = (p, f, obj) => iterationCallback(p, f, obj);
+
+      try {
+        alglib.lsfitcreatefg(x, y, c, n, m, k, false, out state);
+        alglib.lsfitsetcond(state, 0.0, maxIterations);
+        alglib.lsfitsetxrep(state, iterationCallback != null);
+        alglib.lsfitfit(state, function_cx_1_func, function_cx_1_grad, xrep, rowEvaluationsCounter);
+        alglib.lsfitresults(state, out retVal, out c, out rep);
+      } catch (ArithmeticException) {
+        return originalQuality;
+      } catch (alglib.alglibexception) {
+        return originalQuality;
+      }
+
+      counter.FunctionEvaluations += rowEvaluationsCounter.FunctionEvaluations / n;
+      counter.GradientEvaluations += rowEvaluationsCounter.GradientEvaluations / n;
+
+      //retVal == -7  => parameter optimization failed due to wrong gradient
+      //          -8  => optimizer detected  NAN / INF  in  the target
+      //                 function and/ or gradient
+      if (retVal != -7 && retVal != -8) {
+        if (applyLinearScaling) {
+          var tmp = new double[c.Length - 2];
+          Array.Copy(c, 2, tmp, 0, tmp.Length);
+          UpdateParameters(tree, tmp, updateVariableWeights);
+        } else UpdateParameters(tree, c, updateVariableWeights);
+      }
+      var quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling);
+
+      if (!updateParametersInTree) UpdateParameters(tree, initialParameters, updateVariableWeights);
+
+      if (originalQuality - quality > 0.001 || double.IsNaN(quality)) {
+        UpdateParameters(tree, initialParameters, updateVariableWeights);
+        return originalQuality;
+      }
+      return quality;
+    }
+
+    private static void UpdateParameters(ISymbolicExpressionTree tree, double[] parameters, bool updateVariableWeights) {
+      int i = 0;
+      foreach (var node in tree.Root.IterateNodesPrefix().OfType<SymbolicExpressionTreeTerminalNode>()) {
+        NumberTreeNode numberTreeNode = node as NumberTreeNode;
+        VariableTreeNodeBase variableTreeNodeBase = node as VariableTreeNodeBase;
+        FactorVariableTreeNode factorVarTreeNode = node as FactorVariableTreeNode;
+        if (numberTreeNode != null) {
+          if (numberTreeNode.Parent.Symbol is Power 
+              && numberTreeNode.Parent.GetSubtree(1) == numberTreeNode) continue; // exponents in powers are not optimizated (see TreeToAutoDiffTermConverter)
+          numberTreeNode.Value = parameters[i++];
+        } else if (updateVariableWeights && variableTreeNodeBase != null)
+          variableTreeNodeBase.Weight = parameters[i++];
+        else if (factorVarTreeNode != null) {
+          for (int j = 0; j < factorVarTreeNode.Weights.Length; j++)
+            factorVarTreeNode.Weights[j] = parameters[i++];
+        }
+      }
+    }
+
+    private static alglib.ndimensional_pfunc CreatePFunc(TreeToAutoDiffTermConverter.ParametricFunction func) {
+      return (double[] c, double[] x, ref double fx, object o) => {
+        fx = func(c, x);
+        var counter = (EvaluationsCounter)o;
+        counter.FunctionEvaluations++;
+      };
+    }
+
+    private static alglib.ndimensional_pgrad CreatePGrad(TreeToAutoDiffTermConverter.ParametricFunctionGradient func_grad) {
+      return (double[] c, double[] x, ref double fx, double[] grad, object o) => {
+        var tuple = func_grad(c, x);
+        fx = tuple.Item2;
+        Array.Copy(tuple.Item1, grad, grad.Length);
+        var counter = (EvaluationsCounter)o;
+        counter.GradientEvaluations++;
+      };
+    }
+    public static bool CanOptimizeParameters(ISymbolicExpressionTree tree) {
+      return TreeToAutoDiffTermConverter.IsCompatible(tree);
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/ParameterOptimizationAnalyzer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/ParameterOptimizationAnalyzer.cs	(revision 18132)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/ParameterOptimizationAnalyzer.cs	(revision 18132)
@@ -0,0 +1,187 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HEAL.Attic;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
+  /// <summary>
+  /// An operator that optimizes the parameters for the best symbolic expression tress in the current generation.
+  /// </summary>
+  [Item("ParameterOptimizationAnalyzer", "An operator that performs a parameter optimization on the best symbolic expression trees.")]
+  [StorableType("9FB87E7B-A9E2-49DD-A92A-78BD9FC17916")]
+  public sealed class ParameterOptimizationAnalyzer : SymbolicDataAnalysisSingleObjectiveAnalyzer, IStatefulItem {
+    private const string PercentageOfBestSolutionsParameterName = "PercentageOfBestSolutions";
+    private const string ParameterOptimizationEvaluatorParameterName = "ParameterOptimizationOperator";
+
+    private const string DataTableNameParameterOptimizationImprovement = "Parameter Optimization Improvement";
+    private const string DataRowNameMinimumImprovement = "Minimum improvement";
+    private const string DataRowNameMedianImprovement = "Median improvement";
+    private const string DataRowNameAverageImprovement = "Average improvement";
+    private const string DataRowNameMaximumImprovement = "Maximum improvement";
+
+    #region parameter properties
+    public IFixedValueParameter<PercentValue> PercentageOfBestSolutionsParameter {
+      get { return (IFixedValueParameter<PercentValue>)Parameters[PercentageOfBestSolutionsParameterName]; }
+    }
+
+    public IFixedValueParameter<SymbolicRegressionParameterOptimizationEvaluator> ParameterOptimizationEvaluatorParameter {
+      get { return (IFixedValueParameter<SymbolicRegressionParameterOptimizationEvaluator>)Parameters[ParameterOptimizationEvaluatorParameterName]; }
+    }
+    #endregion
+
+    #region properties
+    public SymbolicRegressionParameterOptimizationEvaluator ParameterOptimizationEvaluator {
+      get { return ParameterOptimizationEvaluatorParameter.Value; }
+    }
+    public double PercentageOfBestSolutions {
+      get { return PercentageOfBestSolutionsParameter.Value.Value; }
+    }
+
+    private DataTable ParameterOptimizationImprovementDataTable {
+      get {
+        IResult result;
+        ResultCollection.TryGetValue(DataTableNameParameterOptimizationImprovement, out result);
+        if (result == null) return null;
+        return (DataTable)result.Value;
+      }
+    }
+    private DataRow MinimumImprovement {
+      get { return ParameterOptimizationImprovementDataTable.Rows[DataRowNameMinimumImprovement]; }
+    }
+    private DataRow MedianImprovement {
+      get { return ParameterOptimizationImprovementDataTable.Rows[DataRowNameMedianImprovement]; }
+    }
+    private DataRow AverageImprovement {
+      get { return ParameterOptimizationImprovementDataTable.Rows[DataRowNameAverageImprovement]; }
+    }
+    private DataRow MaximumImprovement {
+      get { return ParameterOptimizationImprovementDataTable.Rows[DataRowNameMaximumImprovement]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private ParameterOptimizationAnalyzer(StorableConstructorFlag _) : base(_) { }
+    private ParameterOptimizationAnalyzer(ParameterOptimizationAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new ParameterOptimizationAnalyzer(this, cloner); }
+    public ParameterOptimizationAnalyzer()
+      : base() {
+      Parameters.Add(new FixedValueParameter<PercentValue>(PercentageOfBestSolutionsParameterName, "The percentage of the top solutions which should be analyzed.", new PercentValue(0.1)));
+      Parameters.Add(new FixedValueParameter<SymbolicRegressionParameterOptimizationEvaluator>(ParameterOptimizationEvaluatorParameterName, "The operator used to perform the parameter optimization"));
+
+      //Changed the ActualName of the EvaluationPartitionParameter so that it matches the parameter name of symbolic regression problems.
+      ParameterOptimizationEvaluator.EvaluationPartitionParameter.ActualName = "FitnessCalculationPartition";
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ParameterOptimizationEvaluatorParameterName)) {
+        if (Parameters.ContainsKey("ConstantOptimizationOperator")) {
+          Parameters.Add(new FixedValueParameter<SymbolicRegressionParameterOptimizationEvaluator>(ParameterOptimizationEvaluatorParameterName, "The operator used to perform the parameter optimization"));
+          Parameters.Remove("ConstantOptimizationOperator");
+        } else {
+          Parameters.Add(new FixedValueParameter<SymbolicRegressionParameterOptimizationEvaluator>(ParameterOptimizationEvaluatorParameterName, "The operator used to perform the parameter optimization"));
+        }
+      }
+    }
+
+
+    private double[] qualitiesBeforeCoOp = null;
+    private int[] scopeIndexes = null;
+    void IStatefulItem.InitializeState() {
+      qualitiesBeforeCoOp = null;
+      scopeIndexes = null;
+    }
+    void IStatefulItem.ClearState() {
+      qualitiesBeforeCoOp = null;
+      scopeIndexes = null;
+    }
+
+    public override IOperation Apply() {
+      //code executed in the first call of analyzer
+      if (qualitiesBeforeCoOp == null) {
+        double[] trainingQuality;
+        // sort is ascending and we take the first n% => order so that best solutions are smallest
+        // sort order is determined by maximization parameter
+        if (Maximization.Value) {
+          // largest values must be sorted first
+          trainingQuality = Quality.Select(x => -x.Value).ToArray();
+        } else {
+          // smallest values must be sorted first
+          trainingQuality = Quality.Select(x => x.Value).ToArray();
+        }
+        // sort trees by training qualities
+        int topN = (int)Math.Max(trainingQuality.Length * PercentageOfBestSolutions, 1);
+        scopeIndexes = Enumerable.Range(0, trainingQuality.Length).ToArray();
+        Array.Sort(trainingQuality, scopeIndexes);
+        scopeIndexes = scopeIndexes.Take(topN).ToArray();
+        qualitiesBeforeCoOp = scopeIndexes.Select(x => Quality[x].Value).ToArray();
+
+        OperationCollection operationCollection = new OperationCollection();
+        operationCollection.Parallel = true;
+        foreach (var scopeIndex in scopeIndexes) {
+          var childOperation = ExecutionContext.CreateChildOperation(ParameterOptimizationEvaluator, ExecutionContext.Scope.SubScopes[scopeIndex]);
+          operationCollection.Add(childOperation);
+        }
+
+        return new OperationCollection { operationCollection, ExecutionContext.CreateOperation(this) };
+      }
+
+      //code executed to analyze results of parameter optimization
+      double[] qualitiesAfterCoOp = scopeIndexes.Select(x => Quality[x].Value).ToArray();
+      var qualityImprovement = qualitiesBeforeCoOp.Zip(qualitiesAfterCoOp, (b, a) => a - b).ToArray();
+
+      if (!ResultCollection.ContainsKey(DataTableNameParameterOptimizationImprovement)) {
+        var dataTable = new DataTable(DataTableNameParameterOptimizationImprovement);
+        ResultCollection.Add(new Result(DataTableNameParameterOptimizationImprovement, dataTable));
+        dataTable.VisualProperties.YAxisTitle = "R²";
+
+        dataTable.Rows.Add(new DataRow(DataRowNameMinimumImprovement));
+        MinimumImprovement.VisualProperties.StartIndexZero = true;
+
+        dataTable.Rows.Add(new DataRow(DataRowNameMedianImprovement));
+        MedianImprovement.VisualProperties.StartIndexZero = true;
+
+        dataTable.Rows.Add(new DataRow(DataRowNameAverageImprovement));
+        AverageImprovement.VisualProperties.StartIndexZero = true;
+
+        dataTable.Rows.Add(new DataRow(DataRowNameMaximumImprovement));
+        MaximumImprovement.VisualProperties.StartIndexZero = true;
+      }
+
+      MinimumImprovement.Values.Add(qualityImprovement.Min());
+      MedianImprovement.Values.Add(qualityImprovement.Median());
+      AverageImprovement.Values.Add(qualityImprovement.Average());
+      MaximumImprovement.Values.Add(qualityImprovement.Max());
+
+      qualitiesBeforeCoOp = null;
+      scopeIndexes = null;
+      return base.Apply();
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPruningOperator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPruningOperator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPruningOperator.cs	(revision 18132)
@@ -91,17 +91,16 @@
       for (int i = 0; i < nodes.Count; ++i) {
         var node = nodes[i];
-        if (node is ConstantTreeNode) continue;
+        if (node is INumericTreeNode) continue; // skip constants and numbers
 
-        double impactValue, replacementValue;
-        double newQualityForImpactsCalculation;
-        impactValuesCalculator.CalculateImpactAndReplacementValues(model, node, problemData, rows, out impactValue, out replacementValue, out newQualityForImpactsCalculation, qualityForImpactsCalculation);
+        impactValuesCalculator.CalculateImpactAndReplacementValues(model, node, problemData, rows, 
+          out double impactValue, out double replacementValue, out double newQualityForImpactsCalculation, qualityForImpactsCalculation);
 
         if (pruneOnlyZeroImpactNodes && !impactValue.IsAlmost(0.0)) continue;
         if (!pruneOnlyZeroImpactNodes && impactValue > nodeImpactThreshold) continue;
 
-        var constantNode = (ConstantTreeNode)node.Grammar.GetSymbol("Constant").CreateTreeNode();
-        constantNode.Value = replacementValue;
+        var numNode = (NumberTreeNode)node.Grammar.GetSymbol("Number").CreateTreeNode();
+        numNode.Value = replacementValue;
 
-        ReplaceWithConstant(node, constantNode);
+        ReplaceWithNumber(node, numNode);
         i += node.GetLength() - 1; // skip subtrees under the node that was folded
 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis.Views/3.4/InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView.Designer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis.Views/3.4/InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView.Designer.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis.Views/3.4/InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView.Designer.cs	(revision 18132)
@@ -53,5 +53,5 @@
       this.Name = "InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView";
       this.Size = new System.Drawing.Size(564, 348);
-      this.btnOptimizeConstants.Enabled = false;
+      this.btnOptimizeParameters.Enabled = false;
       this.ResumeLayout(false);
     }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj	(revision 18132)
@@ -129,4 +129,16 @@
     </Compile>
     <Compile Include="Plugin.cs" />
+    <Compile Include="Symbols\ConstantView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Symbols\ConstantView.Designer.cs">
+      <DependentUpon>ConstantView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Symbols\NumberView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Symbols\NumberView.Designer.cs">
+      <DependentUpon>NumberView.cs</DependentUpon>
+    </Compile>
     <Compile Include="TextualSymbolicDataAnalysisModelView.cs">
       <SubType>UserControl</SubType>
@@ -146,10 +158,4 @@
     <Compile Include="GraphicalSymbolicDataAnalysisModelView.designer.cs">
       <DependentUpon>GraphicalSymbolicDataAnalysisModelView.cs</DependentUpon>
-    </Compile>
-    <Compile Include="Symbols\ConstantView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="Symbols\ConstantView.Designer.cs">
-      <DependentUpon>ConstantView.cs</DependentUpon>
     </Compile>
     <Compile Include="Symbols\LaggedVariableView.cs">
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.Designer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.Designer.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.Designer.cs	(revision 18132)
@@ -54,5 +54,5 @@
       this.flowLayoutPanel = new System.Windows.Forms.FlowLayoutPanel();
       this.btnSimplify = new System.Windows.Forms.Button();
-      this.btnOptimizeConstants = new System.Windows.Forms.Button();
+      this.btnOptimizeParameters = new System.Windows.Forms.Button();
       this.grpViewHost = new System.Windows.Forms.GroupBox();
       this.treeChart = new HeuristicLab.Problems.DataAnalysis.Symbolic.Views.InteractiveSymbolicExpressionTreeChart();
@@ -132,5 +132,5 @@
             | System.Windows.Forms.AnchorStyles.Right)));
       this.flowLayoutPanel.Controls.Add(this.btnSimplify);
-      this.flowLayoutPanel.Controls.Add(this.btnOptimizeConstants);
+      this.flowLayoutPanel.Controls.Add(this.btnOptimizeParameters);
       this.flowLayoutPanel.Location = new System.Drawing.Point(6, 370);
       this.flowLayoutPanel.Name = "flowLayoutPanel";
@@ -153,19 +153,19 @@
       this.btnSimplify.Click += new System.EventHandler(this.btnSimplify_Click);
       // 
-      // btnOptimizeConstants
-      // 
-      this.btnOptimizeConstants.AutoSize = true;
-      this.btnOptimizeConstants.Enabled = false;
-      this.btnOptimizeConstants.Image = HeuristicLab.Common.Resources.VSImageLibrary.Performance;
-      this.btnOptimizeConstants.Location = new System.Drawing.Point(89, 3);
-      this.btnOptimizeConstants.Name = "btnOptimizeConstants";
-      this.btnOptimizeConstants.Size = new System.Drawing.Size(80, 24);
-      this.btnOptimizeConstants.TabIndex = 2;
-      this.btnOptimizeConstants.Text = "Optimize";
-      this.btnOptimizeConstants.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageBeforeText;
-      this.toolTip.SetToolTip(this.btnOptimizeConstants, "Optimizes the numerical constants of the model. \r\nIf the algorithm converges, opt" +
+      // btnOptimizeParameters
+      // 
+      this.btnOptimizeParameters.AutoSize = true;
+      this.btnOptimizeParameters.Enabled = false;
+      this.btnOptimizeParameters.Image = HeuristicLab.Common.Resources.VSImageLibrary.Performance;
+      this.btnOptimizeParameters.Location = new System.Drawing.Point(89, 3);
+      this.btnOptimizeParameters.Name = "btnOptimizeParameters";
+      this.btnOptimizeParameters.Size = new System.Drawing.Size(80, 24);
+      this.btnOptimizeParameters.TabIndex = 2;
+      this.btnOptimizeParameters.Text = "Optimize";
+      this.btnOptimizeParameters.TextImageRelation = System.Windows.Forms.TextImageRelation.ImageBeforeText;
+      this.toolTip.SetToolTip(this.btnOptimizeParameters, "Optimizes the parameters of the model. \r\nIf the algorithm converges, opt" +
         "imization is stopped.");
-      this.btnOptimizeConstants.UseVisualStyleBackColor = true;
-      this.btnOptimizeConstants.Click += new System.EventHandler(this.btnOptimizeConstants_Click);
+      this.btnOptimizeParameters.UseVisualStyleBackColor = true;
+      this.btnOptimizeParameters.Click += new System.EventHandler(this.btnOptimizeParameters_Click);
       // 
       // grpViewHost
@@ -228,5 +228,5 @@
     private System.Windows.Forms.Button btnSimplify;
     private System.Windows.Forms.FlowLayoutPanel flowLayoutPanel;
-    protected System.Windows.Forms.Button btnOptimizeConstants;
+    protected System.Windows.Forms.Button btnOptimizeParameters;
     private System.Windows.Forms.Label treeStatusValue;
     private System.Windows.Forms.ToolTip toolTip;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 18132)
@@ -109,5 +109,5 @@
 
     // the optimizer always assumes 2 children for multiplication and addition nodes
-    // thus, we enforce that the tree stays valid so that the constant optimization won't throw an exception
+    // thus, we enforce that the tree stays valid so that the parameter optimization won't throw an exception
     // by returning 2 as the minimum allowed arity for addition and multiplication symbols
     private readonly Func<ISymbol, int> GetMinArity = symbol => {
@@ -130,9 +130,9 @@
 
       if (valid) {
-        btnOptimizeConstants.Enabled = true;
+        btnOptimizeParameters.Enabled = true;
         btnSimplify.Enabled = true;
         treeStatusValue.Visible = false;
       } else {
-        btnOptimizeConstants.Enabled = false;
+        btnOptimizeParameters.Enabled = false;
         btnSimplify.Enabled = false;
         treeStatusValue.Visible = true;
@@ -193,5 +193,5 @@
       treeChart.Tree = tree.Root.SubtreeCount > 1 ? new SymbolicExpressionTree(tree.Root) : new SymbolicExpressionTree(tree.Root.GetSubtree(0).GetSubtree(0));
 
-      progress.Start("Calculate Impact and Replacement Values ...");
+      progress.Start("Calculate impact and replacement values ...");
       cancellationTokenSource = new CancellationTokenSource();
       progress.CanBeStopped = true;
@@ -203,6 +203,6 @@
 
         var replacementValues = impactAndReplacementValues.ToDictionary(x => x.Key, x => x.Value.Item2);
-        foreach (var pair in replacementValues.Where(pair => !(pair.Key is ConstantTreeNode))) {
-          foldedNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
+        foreach (var pair in replacementValues.Where(pair => !(pair.Key is INumericTreeNode))) {
+          foldedNodes[pair.Key] = MakeNumberTreeNode(pair.Value);
         }
         
@@ -235,6 +235,6 @@
       foreach (var node in tree.Root.GetSubtree(0).GetSubtree(0).IterateNodesPrefix()) {
         if (progress.ProgressState == ProgressState.StopRequested) continue;
-        double impactValue, replacementValue, newQualityForImpactsCalculation;
-        impactCalculator.CalculateImpactAndReplacementValues(Content.Model, node, Content.ProblemData, Content.ProblemData.TrainingIndices, out impactValue, out replacementValue, out newQualityForImpactsCalculation);
+        impactCalculator.CalculateImpactAndReplacementValues(Content.Model, node, Content.ProblemData, Content.ProblemData.TrainingIndices, 
+          out double impactValue, out double replacementValue, out _);
         double newProgressValue = progress.ProgressValue + 1.0 / (tree.Length - 2);
         progress.ProgressValue = Math.Min(newProgressValue, 1);
@@ -246,13 +246,13 @@
     protected abstract void UpdateModel(ISymbolicExpressionTree tree);
 
-    protected virtual ISymbolicExpressionTree OptimizeConstants(ISymbolicExpressionTree tree, IProgress progress) {
+    protected virtual ISymbolicExpressionTree OptimizeParameters(ISymbolicExpressionTree tree, IProgress progress) {
       return tree;
     }
 
-    private static ConstantTreeNode MakeConstantTreeNode(double value) {
-      var constant = new Constant { MinValue = value - 1, MaxValue = value + 1 };
-      var constantTreeNode = (ConstantTreeNode)constant.CreateTreeNode();
-      constantTreeNode.Value = value;
-      return constantTreeNode;
+    private static NumberTreeNode MakeNumberTreeNode(double value) {
+      var num = new Number { MinValue = value - 1, MaxValue = value + 1 };
+      var numTreeNode = (NumberTreeNode)num.CreateTreeNode();
+      numTreeNode.Value = value;
+      return numTreeNode;
     }
 
@@ -297,5 +297,5 @@
         VisualTreeNode<ISymbolicExpressionTreeNode> visualTree = treeChart.GetVisualSymbolicExpressionTreeNode(treeNode);
 
-        if (!(treeNode is ConstantTreeNode) && nodeImpacts.ContainsKey(treeNode)) {
+        if (!(treeNode is INumericTreeNode) && nodeImpacts.ContainsKey(treeNode)) {
           visualTree.ToolTip = visualTree.Content.ToString();
           double impact = nodeImpacts[treeNode];
@@ -314,15 +314,14 @@
           }
           visualTree.ToolTip += Environment.NewLine + "Node impact: " + impact;
-          var constantReplacementNode = foldedNodes[treeNode] as ConstantTreeNode;
-          if (constantReplacementNode != null) {
-            visualTree.ToolTip += Environment.NewLine + "Replacement value: " + constantReplacementNode.Value;
+          if (foldedNodes[treeNode] is INumericTreeNode numReplacementNode) {
+            visualTree.ToolTip += Environment.NewLine + "Replacement value: " + numReplacementNode.Value;
           }
         }
         if (visualTree != null) {
           if (nodeIntervals.ContainsKey(treeNode))
-            visualTree.ToolTip += String.Format($"{Environment.NewLine}Intervals: [{nodeIntervals[treeNode].LowerBound:G5} ... {nodeIntervals[treeNode].UpperBound:G5}]");
+            visualTree.ToolTip += string.Format($"{Environment.NewLine}Intervals: [{nodeIntervals[treeNode].LowerBound:G5} ... {nodeIntervals[treeNode].UpperBound:G5}]");
           if (changedNodes.ContainsKey(treeNode)) {
             visualTree.LineColor = Color.DodgerBlue;
-          } else if (treeNode is ConstantTreeNode && foldedNodes.ContainsKey(treeNode)) {
+          } else if (treeNode is INumericTreeNode && foldedNodes.ContainsKey(treeNode)) {
             visualTree.LineColor = Color.DarkOrange;
           }
@@ -337,6 +336,6 @@
     }
 
-    private async void btnOptimizeConstants_Click(object sender, EventArgs e) {
-      progress.Start("Optimizing Constants ...");
+    private async void btnOptimizeParameters_Click(object sender, EventArgs e) {
+      progress.Start("Optimizing parameters ...");
       cancellationTokenSource = new CancellationTokenSource();
       progress.CanBeStopped = true;
@@ -344,5 +343,5 @@
         var tree = (ISymbolicExpressionTree)Content.Model.SymbolicExpressionTree.Clone();
 
-        var newTree = await Task.Run(() => OptimizeConstants(tree, progress));
+        var newTree = await Task.Run(() => OptimizeParameters(tree, progress));
         try {
           await Task.Delay(300, cancellationTokenSource.Token); // wait for progressbar to finish animation
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicExpressionTreeChart.Designer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicExpressionTreeChart.Designer.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicExpressionTreeChart.Designer.cs	(revision 18132)
@@ -64,5 +64,5 @@
       this.insertNodeToolStripMenuItem.Name = "insertNodeToolStripMenuItem";
       this.insertNodeToolStripMenuItem.Size = new System.Drawing.Size(165, 22);
-      this.insertNodeToolStripMenuItem.Text = "Insert Node";
+      this.insertNodeToolStripMenuItem.Text = "Insert node";
       this.insertNodeToolStripMenuItem.Click += new System.EventHandler(this.insertNodeToolStripMenuItem_Click);
       // 
@@ -71,5 +71,5 @@
       this.changeNodeToolStripMenuItem.Name = "changeNodeToolStripMenuItem";
       this.changeNodeToolStripMenuItem.Size = new System.Drawing.Size(165, 22);
-      this.changeNodeToolStripMenuItem.Text = "Change Node";
+      this.changeNodeToolStripMenuItem.Text = "Change node";
       this.changeNodeToolStripMenuItem.Click += new System.EventHandler(this.changeNodeToolStripMenuItem_Click);
       // 
@@ -78,5 +78,5 @@
       this.cutToolStripMenuItem.Name = "cutToolStripMenuItem";
       this.cutToolStripMenuItem.Size = new System.Drawing.Size(165, 22);
-      this.cutToolStripMenuItem.Text = "Cut Subtree";
+      this.cutToolStripMenuItem.Text = "Cut subtree";
       this.cutToolStripMenuItem.Click += new System.EventHandler(this.cutToolStripMenuItem_Click);
       // 
@@ -109,5 +109,5 @@
       this.pasteToolStripMenuItem.Name = "pasteToolStripMenuItem";
       this.pasteToolStripMenuItem.Size = new System.Drawing.Size(165, 22);
-      this.pasteToolStripMenuItem.Text = "Paste Subtree";
+      this.pasteToolStripMenuItem.Text = "Paste subtree";
       this.pasteToolStripMenuItem.Click += new System.EventHandler(this.pasteToolStripMenuItem_Clicked);
       // 
@@ -121,5 +121,5 @@
       this.copyToolStripMenuItem.Name = "copyToolStripMenuItem";
       this.copyToolStripMenuItem.Size = new System.Drawing.Size(165, 22);
-      this.copyToolStripMenuItem.Text = "Copy Subtree";
+      this.copyToolStripMenuItem.Text = "Copy subtree";
       this.copyToolStripMenuItem.Click += new System.EventHandler(this.copyToolStripMenuItem_Click);
       // 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicExpressionTreeChart.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicExpressionTreeChart.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicExpressionTreeChart.cs	(revision 18132)
@@ -28,6 +28,6 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
-  internal delegate void
-  ModifyTree(ISymbolicExpressionTree tree, ISymbolicExpressionTreeNode node, ISymbolicExpressionTreeNode oldChild, ISymbolicExpressionTreeNode newChild, bool removeSubtree = true);
+  internal delegate void ModifyTree(ISymbolicExpressionTree tree, ISymbolicExpressionTreeNode node, ISymbolicExpressionTreeNode oldChild, ISymbolicExpressionTreeNode newChild, 
+                                    bool removeSubtree = true);
 
   internal sealed partial class InteractiveSymbolicExpressionTreeChart : SymbolicExpressionTreeChart {
@@ -82,5 +82,5 @@
 
     protected override void OnSymbolicExpressionTreeNodeClicked(object sender, MouseEventArgs e) {
-      currSelected = (VisualTreeNode<ISymbolicExpressionTreeNode>)sender; ;
+      currSelected = (VisualTreeNode<ISymbolicExpressionTreeNode>)sender;
       base.OnSymbolicExpressionTreeNodeClicked(sender, e);
     }
@@ -104,7 +104,6 @@
         var symbol = dialog.SelectedSymbol;
         var node = symbol.CreateTreeNode();
-        if (node is ConstantTreeNode) {
-          var constant = node as ConstantTreeNode;
-          constant.Value = double.Parse(dialog.constantValueTextBox.Text);
+        if (node is INumericTreeNode numTreeNode) {
+          numTreeNode.Value = double.Parse(dialog.numberValueTextBox.Text);
         } else if (node is VariableTreeNode) {
           var variable = node as VariableTreeNode;
@@ -133,6 +132,6 @@
       ISymbolicExpressionTreeNode newNode = null;
       var result = DialogResult.Cancel;
-      if (node is ConstantTreeNode) {
-        using (var dialog = new ConstantNodeEditDialog(node)) {
+      if (node is INumericTreeNode) {
+        using (var dialog = new NumberNodeEditDialog(node)) {
           dialog.ShowDialog(this);
           newNode = dialog.NewNode;
@@ -200,5 +199,5 @@
       // check if the copied/cut node (stored in the tempNode) can be inserted as a child of the current selected node
       var node = currSelected.Content;
-      if (node is ConstantTreeNode || node is VariableTreeNode) return;
+      if (node is INumericTreeNode || node is VariableTreeNode) return;
       // check if the currently selected node can accept the copied node as a child 
       // no need to check the grammar, an arity check will do just fine here
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.Designer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.Designer.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.Designer.cs	(revision 18132)
@@ -45,17 +45,7 @@
     /// </summary>
     private void InitializeComponent() {
-      this.weightNuLabel = new System.Windows.Forms.Label();
-      this.minValueTextBox = new System.Windows.Forms.TextBox();
-      this.initializationGroupBox = new System.Windows.Forms.GroupBox();
-      this.weightSigmaLabel = new System.Windows.Forms.Label();
-      this.maxValueTextBox = new System.Windows.Forms.TextBox();
-      this.mutationGroupBox = new System.Windows.Forms.GroupBox();
-      this.multiplicativeChangeLabel = new System.Windows.Forms.Label();
-      this.multiplicativeChangeSigmaTextBox = new System.Windows.Forms.TextBox();
-      this.additiveChangeLabel = new System.Windows.Forms.Label();
-      this.additiveChangeSigmaTextBox = new System.Windows.Forms.TextBox();
+      this.valueLabel = new System.Windows.Forms.Label();
+      this.valueTextBox = new System.Windows.Forms.TextBox();
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
-      this.initializationGroupBox.SuspendLayout();
-      this.mutationGroupBox.SuspendLayout();
       this.SuspendLayout();
       // 
@@ -68,4 +58,12 @@
       this.errorProvider.SetIconAlignment(this.initialFrequencyTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
       this.initialFrequencyTextBox.Size = new System.Drawing.Size(280, 20);
+      // 
+      // minimumArityLabel
+      // 
+      this.toolTip.SetToolTip(this.minimumArityLabel, "The minimum arity of the symbol");
+      // 
+      // maximumArityLabel
+      // 
+      this.toolTip.SetToolTip(this.maximumArityLabel, "The maximum arity of the symbol");
       // 
       // minimumArityTextBox
@@ -89,134 +87,38 @@
       this.infoLabel.Location = new System.Drawing.Point(379, 3);
       // 
-      // weightNuLabel
+      // valueLabel
       // 
-      this.weightNuLabel.AutoSize = true;
-      this.weightNuLabel.Location = new System.Drawing.Point(6, 22);
-      this.weightNuLabel.Name = "weightNuLabel";
-      this.weightNuLabel.Size = new System.Drawing.Size(56, 13);
-      this.weightNuLabel.TabIndex = 0;
-      this.weightNuLabel.Text = "Min value:";
-      this.toolTip.SetToolTip(this.weightNuLabel, "The minimal value to use for random initialization of constants.");
+      this.valueLabel.AutoSize = true;
+      this.valueLabel.Location = new System.Drawing.Point(3, 130);
+      this.valueLabel.Name = "valueLabel";
+      this.valueLabel.Size = new System.Drawing.Size(37, 13);
+      this.valueLabel.TabIndex = 0;
+      this.valueLabel.Text = "Value:";
+      this.toolTip.SetToolTip(this.valueLabel, "The value of the constant.");
       // 
-      // minValueTextBox
+      // valueTextBox
       // 
-      this.minValueTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+      this.valueTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
             | System.Windows.Forms.AnchorStyles.Right)));
-      this.errorProvider.SetIconAlignment(this.minValueTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
-      this.minValueTextBox.Location = new System.Drawing.Point(92, 19);
-      this.minValueTextBox.Name = "minValueTextBox";
-      this.minValueTextBox.Size = new System.Drawing.Size(300, 20);
-      this.minValueTextBox.TabIndex = 1;
-      this.toolTip.SetToolTip(this.minValueTextBox, "The minimal value to use for random initialization of constants.");
-      this.minValueTextBox.TextChanged += new System.EventHandler(this.minValueTextBox_TextChanged);
-      // 
-      // initializationGroupBox
-      // 
-      this.initializationGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.initializationGroupBox.Controls.Add(this.weightSigmaLabel);
-      this.initializationGroupBox.Controls.Add(this.maxValueTextBox);
-      this.initializationGroupBox.Controls.Add(this.weightNuLabel);
-      this.initializationGroupBox.Controls.Add(this.minValueTextBox);
-      this.initializationGroupBox.Location = new System.Drawing.Point(0, 127);
-      this.initializationGroupBox.Name = "initializationGroupBox";
-      this.initializationGroupBox.Size = new System.Drawing.Size(398, 73);
-      this.initializationGroupBox.TabIndex = 5;
-      this.initializationGroupBox.TabStop = false;
-      this.initializationGroupBox.Text = "Initialization";
-      // 
-      // weightSigmaLabel
-      // 
-      this.weightSigmaLabel.AutoSize = true;
-      this.weightSigmaLabel.Location = new System.Drawing.Point(6, 48);
-      this.weightSigmaLabel.Name = "weightSigmaLabel";
-      this.weightSigmaLabel.Size = new System.Drawing.Size(59, 13);
-      this.weightSigmaLabel.TabIndex = 2;
-      this.weightSigmaLabel.Text = "Max value:";
-      this.toolTip.SetToolTip(this.weightSigmaLabel, "The maximal value to use for random initialization of constants.");
-      // 
-      // maxValueTextBox
-      // 
-      this.maxValueTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.errorProvider.SetIconAlignment(this.maxValueTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
-      this.maxValueTextBox.Location = new System.Drawing.Point(92, 45);
-      this.maxValueTextBox.Name = "maxValueTextBox";
-      this.maxValueTextBox.Size = new System.Drawing.Size(300, 20);
-      this.maxValueTextBox.TabIndex = 3;
-      this.toolTip.SetToolTip(this.maxValueTextBox, "The maximal value to use for random initialization of constants.");
-      this.maxValueTextBox.TextChanged += new System.EventHandler(this.maxValueTextBox_TextChanged);
-      // 
-      // mutationGroupBox
-      // 
-      this.mutationGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.mutationGroupBox.Controls.Add(this.multiplicativeChangeLabel);
-      this.mutationGroupBox.Controls.Add(this.multiplicativeChangeSigmaTextBox);
-      this.mutationGroupBox.Controls.Add(this.additiveChangeLabel);
-      this.mutationGroupBox.Controls.Add(this.additiveChangeSigmaTextBox);
-      this.mutationGroupBox.Location = new System.Drawing.Point(0, 206);
-      this.mutationGroupBox.Name = "mutationGroupBox";
-      this.mutationGroupBox.Size = new System.Drawing.Size(398, 73);
-      this.mutationGroupBox.TabIndex = 6;
-      this.mutationGroupBox.TabStop = false;
-      this.mutationGroupBox.Text = "Mutation";
-      // 
-      // multiplicativeChangeLabel
-      // 
-      this.multiplicativeChangeLabel.AutoSize = true;
-      this.multiplicativeChangeLabel.Location = new System.Drawing.Point(6, 48);
-      this.multiplicativeChangeLabel.Name = "multiplicativeChangeLabel";
-      this.multiplicativeChangeLabel.Size = new System.Drawing.Size(146, 13);
-      this.multiplicativeChangeLabel.TabIndex = 2;
-      this.multiplicativeChangeLabel.Text = "Multiplicative change (sigma):";
-      this.toolTip.SetToolTip(this.multiplicativeChangeLabel, "The sigma (std. dev.) parameter for the normal distribution to use to sample the " +
-        "multiplicative change.");
-      // 
-      // multiplicativeChangeSigmaTextBox
-      // 
-      this.multiplicativeChangeSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.errorProvider.SetIconAlignment(this.multiplicativeChangeSigmaTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
-      this.multiplicativeChangeSigmaTextBox.Location = new System.Drawing.Point(168, 45);
-      this.multiplicativeChangeSigmaTextBox.Name = "multiplicativeChangeSigmaTextBox";
-      this.multiplicativeChangeSigmaTextBox.Size = new System.Drawing.Size(224, 20);
-      this.multiplicativeChangeSigmaTextBox.TabIndex = 3;
-      this.toolTip.SetToolTip(this.multiplicativeChangeSigmaTextBox, "The sigma (std. dev.) parameter for the normal distribution to use to sample a mu" +
-        "ltiplicative change.");
-      this.multiplicativeChangeSigmaTextBox.TextChanged += new System.EventHandler(this.multiplicativeChangeSigmaTextBox_TextChanged);
-      // 
-      // additiveChangeLabel
-      // 
-      this.additiveChangeLabel.AutoSize = true;
-      this.additiveChangeLabel.Location = new System.Drawing.Point(6, 22);
-      this.additiveChangeLabel.Name = "additiveChangeLabel";
-      this.additiveChangeLabel.Size = new System.Drawing.Size(123, 13);
-      this.additiveChangeLabel.TabIndex = 0;
-      this.additiveChangeLabel.Text = "Additive change (sigma):";
-      this.toolTip.SetToolTip(this.additiveChangeLabel, "The sigma (std. dev.) parameter for the normal distribution to sample the additiv" +
-        "e change.");
-      // 
-      // additiveChangeSigmaTextBox
-      // 
-      this.additiveChangeSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.errorProvider.SetIconAlignment(this.additiveChangeSigmaTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
-      this.additiveChangeSigmaTextBox.Location = new System.Drawing.Point(168, 19);
-      this.additiveChangeSigmaTextBox.Name = "additiveChangeSigmaTextBox";
-      this.additiveChangeSigmaTextBox.Size = new System.Drawing.Size(224, 20);
-      this.additiveChangeSigmaTextBox.TabIndex = 1;
-      this.toolTip.SetToolTip(this.additiveChangeSigmaTextBox, "The sigma (std. dev.) parameter for the normal distribution to use to sample an a" +
-        "dditive change.");
-      this.additiveChangeSigmaTextBox.TextChanged += new System.EventHandler(this.additiveChangeSigmaTextBox_TextChanged);
+      this.errorProvider.SetIconAlignment(this.valueTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.valueTextBox.Location = new System.Drawing.Point(93, 127);
+      this.valueTextBox.Name = "valueTextBox";
+      this.valueTextBox.Size = new System.Drawing.Size(280, 20);
+      this.valueTextBox.TabIndex = 1;
+      this.toolTip.SetToolTip(this.valueTextBox, "The value of the constant.");
+      this.valueTextBox.TextChanged += new System.EventHandler(this.valueTextBox_TextChanged);
       // 
       // ConstantView
       // 
-      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
       this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
-      this.Controls.Add(this.mutationGroupBox);
-      this.Controls.Add(this.initializationGroupBox);
+      this.Controls.Add(this.valueLabel);
+      this.Controls.Add(this.valueTextBox);
       this.Name = "ConstantView";
-      this.Size = new System.Drawing.Size(398, 284);
+      this.Size = new System.Drawing.Size(398, 168);
+      this.Controls.SetChildIndex(this.valueTextBox, 0);
+      this.Controls.SetChildIndex(this.valueLabel, 0);
+      this.Controls.SetChildIndex(this.enabledCheckBox, 0);
+      this.Controls.SetChildIndex(this.initialFrequencyLabel, 0);
+      this.Controls.SetChildIndex(this.initialFrequencyTextBox, 0);
       this.Controls.SetChildIndex(this.maximumArityLabel, 0);
       this.Controls.SetChildIndex(this.maximumArityTextBox, 0);
@@ -224,15 +126,7 @@
       this.Controls.SetChildIndex(this.minimumArityTextBox, 0);
       this.Controls.SetChildIndex(this.infoLabel, 0);
-      this.Controls.SetChildIndex(this.initializationGroupBox, 0);
-      this.Controls.SetChildIndex(this.initialFrequencyTextBox, 0);
-      this.Controls.SetChildIndex(this.initialFrequencyLabel, 0);
       this.Controls.SetChildIndex(this.nameLabel, 0);
       this.Controls.SetChildIndex(this.nameTextBox, 0);
-      this.Controls.SetChildIndex(this.mutationGroupBox, 0);
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
-      this.initializationGroupBox.ResumeLayout(false);
-      this.initializationGroupBox.PerformLayout();
-      this.mutationGroupBox.ResumeLayout(false);
-      this.mutationGroupBox.PerformLayout();
       this.ResumeLayout(false);
       this.PerformLayout();
@@ -242,15 +136,6 @@
     #endregion
 
-    private System.Windows.Forms.Label weightNuLabel;
-    private System.Windows.Forms.TextBox minValueTextBox;
-    protected System.Windows.Forms.GroupBox initializationGroupBox;
-    private System.Windows.Forms.Label weightSigmaLabel;
-    private System.Windows.Forms.TextBox maxValueTextBox;
-    protected System.Windows.Forms.GroupBox mutationGroupBox;
-    private System.Windows.Forms.Label multiplicativeChangeLabel;
-    private System.Windows.Forms.TextBox multiplicativeChangeSigmaTextBox;
-    private System.Windows.Forms.Label additiveChangeLabel;
-    private System.Windows.Forms.TextBox additiveChangeSigmaTextBox;
-
+    private System.Windows.Forms.Label valueLabel;
+    private System.Windows.Forms.TextBox valueTextBox;
   }
 }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.cs	(revision 18132)
@@ -43,5 +43,5 @@
       Content.Changed += new EventHandler(Content_Changed);
     }
-
+    
     protected override void DeregisterContentEvents() {
       base.DeregisterContentEvents();
@@ -56,12 +56,6 @@
     protected override void SetEnabledStateOfControls() {
       base.SetEnabledStateOfControls();
-      minValueTextBox.Enabled = Content != null;
-      minValueTextBox.ReadOnly = ReadOnly;
-      maxValueTextBox.Enabled = Content != null;
-      maxValueTextBox.ReadOnly = ReadOnly;
-      additiveChangeSigmaTextBox.Enabled = Content != null;
-      additiveChangeSigmaTextBox.ReadOnly = ReadOnly;
-      multiplicativeChangeSigmaTextBox.Enabled = Content != null;
-      multiplicativeChangeSigmaTextBox.ReadOnly = ReadOnly;
+      valueTextBox.Enabled = Content != null;
+      valueTextBox.ReadOnly = ReadOnly;
     }
 
@@ -73,40 +67,11 @@
 
     #region control event handlers
-    private void minValueTextBox_TextChanged(object sender, EventArgs e) {
-      double min;
-      if (double.TryParse(minValueTextBox.Text, out min)) {
-        Content.MinValue = min;
-        errorProvider.SetError(minValueTextBox, string.Empty);
+    private void valueTextBox_TextChanged(object sender, EventArgs e) {
+      double val;
+      if (double.TryParse(valueTextBox.Text, out val)) {
+        Content.Value = val;
+        errorProvider.SetError(valueTextBox, string.Empty);
       } else {
-        errorProvider.SetError(minValueTextBox, "Invalid value");
-      }
-    }
-    private void maxValueTextBox_TextChanged(object sender, EventArgs e) {
-      double max;
-      if (double.TryParse(maxValueTextBox.Text, out max)) {
-        Content.MaxValue = max;
-        errorProvider.SetError(maxValueTextBox, string.Empty);
-      } else {
-        errorProvider.SetError(maxValueTextBox, "Invalid value");
-      }
-    }
-
-    private void additiveChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
-      double sigma;
-      if (double.TryParse(additiveChangeSigmaTextBox.Text, out sigma) && sigma >= 0.0) {
-        Content.ManipulatorSigma = sigma;
-        errorProvider.SetError(additiveChangeSigmaTextBox, string.Empty);
-      } else {
-        errorProvider.SetError(additiveChangeSigmaTextBox, "Invalid value");
-      }
-    }
-
-    private void multiplicativeChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
-      double sigma;
-      if (double.TryParse(multiplicativeChangeSigmaTextBox.Text, out sigma) && sigma >= 0.0) {
-        Content.MultiplicativeManipulatorSigma = sigma;
-        errorProvider.SetError(multiplicativeChangeSigmaTextBox, string.Empty);
-      } else {
-        errorProvider.SetError(multiplicativeChangeSigmaTextBox, "Invalid value");
+        errorProvider.SetError(valueTextBox, "Invalid value");
       }
     }
@@ -116,14 +81,7 @@
     private void UpdateControl() {
       if (Content == null) {
-        minValueTextBox.Text = string.Empty;
-        maxValueTextBox.Text = string.Empty;
-        minValueTextBox.Text = string.Empty;
-        multiplicativeChangeSigmaTextBox.Text = string.Empty;
-        additiveChangeSigmaTextBox.Text = string.Empty;
+        valueTextBox.Text = string.Empty;
       } else {
-        minValueTextBox.Text = Content.MinValue.ToString();
-        maxValueTextBox.Text = Content.MaxValue.ToString();
-        additiveChangeSigmaTextBox.Text = Content.ManipulatorSigma.ToString();
-        multiplicativeChangeSigmaTextBox.Text = Content.MultiplicativeManipulatorSigma.ToString();
+        valueTextBox.Text = Content.Value.ToString("g17");
       }
       SetEnabledStateOfControls();
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/NumberView.Designer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/NumberView.Designer.cs	(revision 18132)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/NumberView.Designer.cs	(revision 18132)
@@ -0,0 +1,256 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
+  partial class NumberView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.weightNuLabel = new System.Windows.Forms.Label();
+      this.minValueTextBox = new System.Windows.Forms.TextBox();
+      this.initializationGroupBox = new System.Windows.Forms.GroupBox();
+      this.weightSigmaLabel = new System.Windows.Forms.Label();
+      this.maxValueTextBox = new System.Windows.Forms.TextBox();
+      this.mutationGroupBox = new System.Windows.Forms.GroupBox();
+      this.multiplicativeChangeLabel = new System.Windows.Forms.Label();
+      this.multiplicativeChangeSigmaTextBox = new System.Windows.Forms.TextBox();
+      this.additiveChangeLabel = new System.Windows.Forms.Label();
+      this.additiveChangeSigmaTextBox = new System.Windows.Forms.TextBox();
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
+      this.initializationGroupBox.SuspendLayout();
+      this.mutationGroupBox.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // initialFrequencyLabel
+      // 
+      this.toolTip.SetToolTip(this.initialFrequencyLabel, "Relative frequency of the symbol in randomly created trees");
+      // 
+      // initialFrequencyTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.initialFrequencyTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.initialFrequencyTextBox.Size = new System.Drawing.Size(280, 20);
+      // 
+      // minimumArityTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.minimumArityTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.minimumArityTextBox.Size = new System.Drawing.Size(280, 20);
+      // 
+      // maximumArityTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.maximumArityTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.maximumArityTextBox.Size = new System.Drawing.Size(280, 20);
+      // 
+      // nameTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.errorProvider.SetIconPadding(this.nameTextBox, 2);
+      this.nameTextBox.Size = new System.Drawing.Size(280, 20);
+      // 
+      // infoLabel
+      // 
+      this.infoLabel.Location = new System.Drawing.Point(379, 3);
+      // 
+      // weightNuLabel
+      // 
+      this.weightNuLabel.AutoSize = true;
+      this.weightNuLabel.Location = new System.Drawing.Point(6, 22);
+      this.weightNuLabel.Name = "weightNuLabel";
+      this.weightNuLabel.Size = new System.Drawing.Size(56, 13);
+      this.weightNuLabel.TabIndex = 0;
+      this.weightNuLabel.Text = "Min value:";
+      this.toolTip.SetToolTip(this.weightNuLabel, "The minimal value to use for random initialization of numbers.");
+      // 
+      // minValueTextBox
+      // 
+      this.minValueTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.errorProvider.SetIconAlignment(this.minValueTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.minValueTextBox.Location = new System.Drawing.Point(92, 19);
+      this.minValueTextBox.Name = "minValueTextBox";
+      this.minValueTextBox.Size = new System.Drawing.Size(300, 20);
+      this.minValueTextBox.TabIndex = 1;
+      this.toolTip.SetToolTip(this.minValueTextBox, "The minimal value to use for random initialization of numbers.");
+      this.minValueTextBox.TextChanged += new System.EventHandler(this.minValueTextBox_TextChanged);
+      // 
+      // initializationGroupBox
+      // 
+      this.initializationGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.initializationGroupBox.Controls.Add(this.weightSigmaLabel);
+      this.initializationGroupBox.Controls.Add(this.maxValueTextBox);
+      this.initializationGroupBox.Controls.Add(this.weightNuLabel);
+      this.initializationGroupBox.Controls.Add(this.minValueTextBox);
+      this.initializationGroupBox.Location = new System.Drawing.Point(0, 127);
+      this.initializationGroupBox.Name = "initializationGroupBox";
+      this.initializationGroupBox.Size = new System.Drawing.Size(398, 73);
+      this.initializationGroupBox.TabIndex = 5;
+      this.initializationGroupBox.TabStop = false;
+      this.initializationGroupBox.Text = "Initialization";
+      // 
+      // weightSigmaLabel
+      // 
+      this.weightSigmaLabel.AutoSize = true;
+      this.weightSigmaLabel.Location = new System.Drawing.Point(6, 48);
+      this.weightSigmaLabel.Name = "weightSigmaLabel";
+      this.weightSigmaLabel.Size = new System.Drawing.Size(59, 13);
+      this.weightSigmaLabel.TabIndex = 2;
+      this.weightSigmaLabel.Text = "Max value:";
+      this.toolTip.SetToolTip(this.weightSigmaLabel, "The maximal value to use for random initialization of numbers.");
+      // 
+      // maxValueTextBox
+      // 
+      this.maxValueTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.errorProvider.SetIconAlignment(this.maxValueTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.maxValueTextBox.Location = new System.Drawing.Point(92, 45);
+      this.maxValueTextBox.Name = "maxValueTextBox";
+      this.maxValueTextBox.Size = new System.Drawing.Size(300, 20);
+      this.maxValueTextBox.TabIndex = 3;
+      this.toolTip.SetToolTip(this.maxValueTextBox, "The maximal value to use for random initialization of numbers.");
+      this.maxValueTextBox.TextChanged += new System.EventHandler(this.maxValueTextBox_TextChanged);
+      // 
+      // mutationGroupBox
+      // 
+      this.mutationGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.mutationGroupBox.Controls.Add(this.multiplicativeChangeLabel);
+      this.mutationGroupBox.Controls.Add(this.multiplicativeChangeSigmaTextBox);
+      this.mutationGroupBox.Controls.Add(this.additiveChangeLabel);
+      this.mutationGroupBox.Controls.Add(this.additiveChangeSigmaTextBox);
+      this.mutationGroupBox.Location = new System.Drawing.Point(0, 206);
+      this.mutationGroupBox.Name = "mutationGroupBox";
+      this.mutationGroupBox.Size = new System.Drawing.Size(398, 73);
+      this.mutationGroupBox.TabIndex = 6;
+      this.mutationGroupBox.TabStop = false;
+      this.mutationGroupBox.Text = "Mutation";
+      // 
+      // multiplicativeChangeLabel
+      // 
+      this.multiplicativeChangeLabel.AutoSize = true;
+      this.multiplicativeChangeLabel.Location = new System.Drawing.Point(6, 48);
+      this.multiplicativeChangeLabel.Name = "multiplicativeChangeLabel";
+      this.multiplicativeChangeLabel.Size = new System.Drawing.Size(146, 13);
+      this.multiplicativeChangeLabel.TabIndex = 2;
+      this.multiplicativeChangeLabel.Text = "Multiplicative change (sigma):";
+      this.toolTip.SetToolTip(this.multiplicativeChangeLabel, "The sigma (std. dev.) parameter for the normal distribution to use to sample the " +
+        "multiplicative change.");
+      // 
+      // multiplicativeChangeSigmaTextBox
+      // 
+      this.multiplicativeChangeSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.errorProvider.SetIconAlignment(this.multiplicativeChangeSigmaTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.multiplicativeChangeSigmaTextBox.Location = new System.Drawing.Point(168, 45);
+      this.multiplicativeChangeSigmaTextBox.Name = "multiplicativeChangeSigmaTextBox";
+      this.multiplicativeChangeSigmaTextBox.Size = new System.Drawing.Size(224, 20);
+      this.multiplicativeChangeSigmaTextBox.TabIndex = 3;
+      this.toolTip.SetToolTip(this.multiplicativeChangeSigmaTextBox, "The sigma (std. dev.) parameter for the normal distribution to use to sample a mu" +
+        "ltiplicative change.");
+      this.multiplicativeChangeSigmaTextBox.TextChanged += new System.EventHandler(this.multiplicativeChangeSigmaTextBox_TextChanged);
+      // 
+      // additiveChangeLabel
+      // 
+      this.additiveChangeLabel.AutoSize = true;
+      this.additiveChangeLabel.Location = new System.Drawing.Point(6, 22);
+      this.additiveChangeLabel.Name = "additiveChangeLabel";
+      this.additiveChangeLabel.Size = new System.Drawing.Size(123, 13);
+      this.additiveChangeLabel.TabIndex = 0;
+      this.additiveChangeLabel.Text = "Additive change (sigma):";
+      this.toolTip.SetToolTip(this.additiveChangeLabel, "The sigma (std. dev.) parameter for the normal distribution to sample the additiv" +
+        "e change.");
+      // 
+      // additiveChangeSigmaTextBox
+      // 
+      this.additiveChangeSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.errorProvider.SetIconAlignment(this.additiveChangeSigmaTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.additiveChangeSigmaTextBox.Location = new System.Drawing.Point(168, 19);
+      this.additiveChangeSigmaTextBox.Name = "additiveChangeSigmaTextBox";
+      this.additiveChangeSigmaTextBox.Size = new System.Drawing.Size(224, 20);
+      this.additiveChangeSigmaTextBox.TabIndex = 1;
+      this.toolTip.SetToolTip(this.additiveChangeSigmaTextBox, "The sigma (std. dev.) parameter for the normal distribution to use to sample an a" +
+        "dditive change.");
+      this.additiveChangeSigmaTextBox.TextChanged += new System.EventHandler(this.additiveChangeSigmaTextBox_TextChanged);
+      // 
+      // ConstantView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
+      this.Controls.Add(this.mutationGroupBox);
+      this.Controls.Add(this.initializationGroupBox);
+      this.Name = "ConstantView";
+      this.Size = new System.Drawing.Size(398, 284);
+      this.Controls.SetChildIndex(this.maximumArityLabel, 0);
+      this.Controls.SetChildIndex(this.maximumArityTextBox, 0);
+      this.Controls.SetChildIndex(this.minimumArityLabel, 0);
+      this.Controls.SetChildIndex(this.minimumArityTextBox, 0);
+      this.Controls.SetChildIndex(this.infoLabel, 0);
+      this.Controls.SetChildIndex(this.initializationGroupBox, 0);
+      this.Controls.SetChildIndex(this.initialFrequencyTextBox, 0);
+      this.Controls.SetChildIndex(this.initialFrequencyLabel, 0);
+      this.Controls.SetChildIndex(this.nameLabel, 0);
+      this.Controls.SetChildIndex(this.nameTextBox, 0);
+      this.Controls.SetChildIndex(this.mutationGroupBox, 0);
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
+      this.initializationGroupBox.ResumeLayout(false);
+      this.initializationGroupBox.PerformLayout();
+      this.mutationGroupBox.ResumeLayout(false);
+      this.mutationGroupBox.PerformLayout();
+      this.ResumeLayout(false);
+      this.PerformLayout();
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.Label weightNuLabel;
+    private System.Windows.Forms.TextBox minValueTextBox;
+    protected System.Windows.Forms.GroupBox initializationGroupBox;
+    private System.Windows.Forms.Label weightSigmaLabel;
+    private System.Windows.Forms.TextBox maxValueTextBox;
+    protected System.Windows.Forms.GroupBox mutationGroupBox;
+    private System.Windows.Forms.Label multiplicativeChangeLabel;
+    private System.Windows.Forms.TextBox multiplicativeChangeSigmaTextBox;
+    private System.Windows.Forms.Label additiveChangeLabel;
+    private System.Windows.Forms.TextBox additiveChangeSigmaTextBox;
+
+  }
+}
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/NumberView.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/NumberView.cs	(revision 18132)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/NumberView.cs	(revision 18132)
@@ -0,0 +1,133 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Windows.Forms;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
+using HeuristicLab.MainForm;
+using HeuristicLab.MainForm.WindowsForms;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
+  [View("Number View")]
+  [Content(typeof(Number), true)]
+  public partial class NumberView : SymbolView {
+    public new Number Content {
+      get { return (Number)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public NumberView() {
+      InitializeComponent();
+    }
+
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      Content.Changed += new EventHandler(Content_Changed);
+    }
+
+    protected override void DeregisterContentEvents() {
+      base.DeregisterContentEvents();
+      Content.Changed -= new EventHandler(Content_Changed);
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      UpdateControl();
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      minValueTextBox.Enabled = Content != null;
+      minValueTextBox.ReadOnly = ReadOnly;
+      maxValueTextBox.Enabled = Content != null;
+      maxValueTextBox.ReadOnly = ReadOnly;
+      additiveChangeSigmaTextBox.Enabled = Content != null;
+      additiveChangeSigmaTextBox.ReadOnly = ReadOnly;
+      multiplicativeChangeSigmaTextBox.Enabled = Content != null;
+      multiplicativeChangeSigmaTextBox.ReadOnly = ReadOnly;
+    }
+
+    #region content event handlers
+    private void Content_Changed(object sender, EventArgs e) {
+      UpdateControl();
+    }
+    #endregion
+
+    #region control event handlers
+    private void minValueTextBox_TextChanged(object sender, EventArgs e) {
+      double min;
+      if (double.TryParse(minValueTextBox.Text, out min)) {
+        Content.MinValue = min;
+        errorProvider.SetError(minValueTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(minValueTextBox, "Invalid value");
+      }
+    }
+    private void maxValueTextBox_TextChanged(object sender, EventArgs e) {
+      double max;
+      if (double.TryParse(maxValueTextBox.Text, out max)) {
+        Content.MaxValue = max;
+        errorProvider.SetError(maxValueTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(maxValueTextBox, "Invalid value");
+      }
+    }
+
+    private void additiveChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
+      double sigma;
+      if (double.TryParse(additiveChangeSigmaTextBox.Text, out sigma) && sigma >= 0.0) {
+        Content.ManipulatorSigma = sigma;
+        errorProvider.SetError(additiveChangeSigmaTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(additiveChangeSigmaTextBox, "Invalid value");
+      }
+    }
+
+    private void multiplicativeChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
+      double sigma;
+      if (double.TryParse(multiplicativeChangeSigmaTextBox.Text, out sigma) && sigma >= 0.0) {
+        Content.MultiplicativeManipulatorSigma = sigma;
+        errorProvider.SetError(multiplicativeChangeSigmaTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(multiplicativeChangeSigmaTextBox, "Invalid value");
+      }
+    }
+    #endregion
+
+    #region helpers
+    private void UpdateControl() {
+      if (Content == null) {
+        minValueTextBox.Text = string.Empty;
+        maxValueTextBox.Text = string.Empty;
+        minValueTextBox.Text = string.Empty;
+        multiplicativeChangeSigmaTextBox.Text = string.Empty;
+        additiveChangeSigmaTextBox.Text = string.Empty;
+      } else {
+        minValueTextBox.Text = Content.MinValue.ToString();
+        maxValueTextBox.Text = Content.MaxValue.ToString();
+        additiveChangeSigmaTextBox.Text = Content.ManipulatorSigma.ToString();
+        multiplicativeChangeSigmaTextBox.Text = Content.MultiplicativeManipulatorSigma.ToString();
+      }
+      SetEnabledStateOfControls();
+    }
+    #endregion
+  }
+}
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.Designer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.Designer.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.Designer.cs	(revision 18132)
@@ -21,5 +21,5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
-  partial class ConstantNodeEditDialog {
+  partial class NumberNodeEditDialog {
     /// <summary>
     /// Required designer variable.
@@ -121,5 +121,5 @@
       this.cancelButton.Click += new System.EventHandler(this.cancelButton_Click);
       // 
-      // ConstantNodeEditDialog
+      // NumberNodeEditDialog
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
@@ -138,10 +138,10 @@
       this.MaximizeBox = false;
       this.MinimizeBox = false;
-      this.Name = "ConstantNodeEditDialog";
+      this.Name = "NumberNodeEditDialog";
       this.ShowIcon = false;
       this.ShowInTaskbar = false;
       this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
-      this.Text = "Edit constant value";
-      this.KeyDown += new System.Windows.Forms.KeyEventHandler(this.ConstantNodeEditDialog_KeyDown);
+      this.Text = "Edit number value";
+      this.KeyDown += new System.Windows.Forms.KeyEventHandler(this.NumberNodeEditDialog_KeyDown);
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
       this.ResumeLayout(false);
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.cs	(revision 18132)
@@ -28,20 +28,20 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
-  public partial class ConstantNodeEditDialog : Form {
-    private ConstantTreeNode constantTreeNode;
-    public ConstantTreeNode NewNode {
-      get { return constantTreeNode; }
+  public partial class NumberNodeEditDialog : Form {
+    private INumericTreeNode numberTreeNode;
+    public INumericTreeNode NewNode {
+      get { return numberTreeNode; }
       set {
         if (InvokeRequired)
-          Invoke(new Action<SymbolicExpressionTreeNode>(x => constantTreeNode = (ConstantTreeNode)x), value);
+          Invoke(new Action<SymbolicExpressionTreeNode>(x => numberTreeNode = (INumericTreeNode)x), value);
         else
-          constantTreeNode = value;
+          numberTreeNode = value;
       }
     }
 
-    public ConstantNodeEditDialog(ISymbolicExpressionTreeNode node) {
+    public NumberNodeEditDialog(ISymbolicExpressionTreeNode node) {
       InitializeComponent();
       oldValueTextBox.TabStop = false; // cannot receive focus using tab key
-      NewNode = (ConstantTreeNode)node;
+      NewNode = (INumericTreeNode)node;
       InitializeFields();
     }
@@ -49,8 +49,8 @@
     private void InitializeFields() {
       if (NewNode == null)
-        throw new ArgumentException("Node is not a constant.");
+        throw new ArgumentException("Node is not a number.");
       else {
-        this.Text = "Edit constant";
-        newValueTextBox.Text = oldValueTextBox.Text = Math.Round(constantTreeNode.Value, 4).ToString();
+        this.Text = "Edit number";
+        newValueTextBox.Text = oldValueTextBox.Text = Math.Round(numberTreeNode.Value, 4).ToString();
       }
     }
@@ -71,6 +71,5 @@
 
     private static bool ValidateNewValue(string value, out string errorMessage) {
-      double val;
-      bool valid = double.TryParse(value, out val);
+      bool valid = double.TryParse(value, out _);
       errorMessage = string.Empty;
       if (!valid) {
@@ -87,8 +86,8 @@
     // proxy handler passing key strokes to the parent control
     private void childControl_KeyDown(object sender, KeyEventArgs e) {
-      ConstantNodeEditDialog_KeyDown(sender, e);
+      NumberNodeEditDialog_KeyDown(sender, e);
     }
 
-    private void ConstantNodeEditDialog_KeyDown(object sender, KeyEventArgs e) {
+    private void NumberNodeEditDialog_KeyDown(object sender, KeyEventArgs e) {
       if ((e.KeyCode == Keys.Enter) || (e.KeyCode == Keys.Return)) {
         if (!ValidateChildren()) return;
@@ -100,10 +99,10 @@
     public event EventHandler DialogValidated;
     private void OnDialogValidated(object sender, EventArgs e) {
-      if (constantTreeNode == null) return;
+      if (numberTreeNode == null) return;
       var value = double.Parse(newValueTextBox.Text);
       // we impose an extra validation condition: that the new value is different from the original value
-      if (constantTreeNode.Value.Equals(value)) return;
+      if (numberTreeNode.Value.Equals(value)) return;
 
-      constantTreeNode.Value = value;
+      numberTreeNode.Value = value;
       DialogResult = DialogResult.OK;
       var dialogValidated = DialogValidated;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeNodeInsertDialog.Designer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeNodeInsertDialog.Designer.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeNodeInsertDialog.Designer.cs	(revision 18132)
@@ -52,6 +52,6 @@
       this.variableNamesCombo = new System.Windows.Forms.ComboBox();
       this.variableWeightTextBox = new System.Windows.Forms.TextBox();
-      this.constantValueTextBox = new System.Windows.Forms.TextBox();
-      this.constantValueLabel = new System.Windows.Forms.Label();
+      this.numberValueTextBox = new System.Windows.Forms.TextBox();
+      this.numberValueLabel = new System.Windows.Forms.Label();
       this.errorProvider = new System.Windows.Forms.ErrorProvider(this.components);
       this.okButton = new System.Windows.Forms.Button();
@@ -121,23 +121,23 @@
       this.variableWeightTextBox.Validating += new System.ComponentModel.CancelEventHandler(this.variableWeightTextBox_Validating);
       // 
-      // constantValueTextBox
-      // 
-      this.constantValueTextBox.Location = new System.Drawing.Point(101, 37);
-      this.constantValueTextBox.Name = "constantValueTextBox";
-      this.constantValueTextBox.Size = new System.Drawing.Size(127, 20);
-      this.constantValueTextBox.TabIndex = 7;
-      this.constantValueTextBox.Text = "0.0";
-      this.constantValueTextBox.Visible = false;
-      this.constantValueTextBox.Validating += new System.ComponentModel.CancelEventHandler(this.constantValueTextBox_Validating);
-      // 
-      // constantValueLabel
-      // 
-      this.constantValueLabel.AutoSize = true;
-      this.constantValueLabel.Location = new System.Drawing.Point(19, 40);
-      this.constantValueLabel.Name = "constantValueLabel";
-      this.constantValueLabel.Size = new System.Drawing.Size(34, 13);
-      this.constantValueLabel.TabIndex = 8;
-      this.constantValueLabel.Text = "Value";
-      this.constantValueLabel.Visible = false;
+      // numberValueTextBox
+      // 
+      this.numberValueTextBox.Location = new System.Drawing.Point(101, 37);
+      this.numberValueTextBox.Name = "numberValueTextBox";
+      this.numberValueTextBox.Size = new System.Drawing.Size(127, 20);
+      this.numberValueTextBox.TabIndex = 7;
+      this.numberValueTextBox.Text = "0.0";
+      this.numberValueTextBox.Visible = false;
+      this.numberValueTextBox.Validating += new System.ComponentModel.CancelEventHandler(this.numberValueTextBox_Validating);
+      // 
+      // numberValueLabel
+      // 
+      this.numberValueLabel.AutoSize = true;
+      this.numberValueLabel.Location = new System.Drawing.Point(19, 40);
+      this.numberValueLabel.Name = "numberValueLabel";
+      this.numberValueLabel.Size = new System.Drawing.Size(34, 13);
+      this.numberValueLabel.TabIndex = 8;
+      this.numberValueLabel.Text = "Value";
+      this.numberValueLabel.Visible = false;
       // 
       // errorProvider
@@ -187,6 +187,6 @@
       this.Controls.Add(this.cancelButton);
       this.Controls.Add(this.okButton);
-      this.Controls.Add(this.constantValueLabel);
-      this.Controls.Add(this.constantValueTextBox);
+      this.Controls.Add(this.numberValueLabel);
+      this.Controls.Add(this.numberValueTextBox);
       this.Controls.Add(this.variableWeightTextBox);
       this.Controls.Add(this.variableNamesCombo);
@@ -211,7 +211,7 @@
     private System.Windows.Forms.Label variableWeightLabel;
     private System.Windows.Forms.Label variableNameLabel;
-    private System.Windows.Forms.Label constantValueLabel;
+    private System.Windows.Forms.Label numberValueLabel;
     private System.Windows.Forms.ErrorProvider errorProvider;
-    internal System.Windows.Forms.TextBox constantValueTextBox;
+    internal System.Windows.Forms.TextBox numberValueTextBox;
     internal System.Windows.Forms.TextBox variableWeightTextBox;
     internal System.Windows.Forms.ComboBox variableNamesCombo;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeNodeInsertDialog.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeNodeInsertDialog.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeNodeInsertDialog.cs	(revision 18132)
@@ -57,12 +57,12 @@
       var combo = (ComboBox)sender;
       var symbol = combo.Items[combo.SelectedIndex];
-      if (symbol is Constant) {
-        // add controls to the dialog for changing the constant value
+      if (symbol is Number) {
+        // add controls to the dialog for changing the number value
         variableNameLabel.Visible = false;
         variableNamesCombo.Visible = false;
         variableWeightLabel.Visible = false;
         variableWeightTextBox.Visible = false;
-        constantValueLabel.Visible = true;
-        constantValueTextBox.Visible = true;
+        numberValueLabel.Visible = true;
+        numberValueTextBox.Visible = true;
       } else if (symbol is VariableBase) {
         var variableSymbol = (VariableBase)symbol;
@@ -80,6 +80,6 @@
         variableWeightLabel.Visible = true;
         variableWeightTextBox.Visible = true;
-        constantValueLabel.Visible = false;
-        constantValueTextBox.Visible = false;
+        numberValueLabel.Visible = false;
+        numberValueTextBox.Visible = false;
         // add controls to the dialog for changing the variable name or weight
       } else {
@@ -88,6 +88,6 @@
         variableWeightLabel.Visible = false;
         variableWeightTextBox.Visible = false;
-        constantValueLabel.Visible = false;
-        constantValueTextBox.Visible = false;
+        numberValueLabel.Visible = false;
+        numberValueTextBox.Visible = false;
       }
     }
@@ -102,10 +102,10 @@
     }
 
-    private void constantValueTextBox_Validating(object sender, CancelEventArgs e) {
+    private void numberValueTextBox_Validating(object sender, CancelEventArgs e) {
       string errorMessage;
-      if (ValidateDoubleValue(constantValueTextBox.Text, out errorMessage)) return;
+      if (ValidateDoubleValue(numberValueTextBox.Text, out errorMessage)) return;
       e.Cancel = true;
-      errorProvider.SetError(constantValueTextBox, errorMessage);
-      constantValueTextBox.SelectAll();
+      errorProvider.SetError(numberValueTextBox, errorMessage);
+      numberValueTextBox.SelectAll();
     }
 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeVariableNodeEditDialog.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeVariableNodeEditDialog.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeVariableNodeEditDialog.cs	(revision 18132)
@@ -60,5 +60,5 @@
     private void InitializeFields() {
       if (NewNode == null)
-        throw new ArgumentException("Node is not a constant.");
+        throw new ArgumentException("Node is not a variable node.");
       else {
         this.Text = "Edit variable";
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs	(revision 18132)
@@ -88,5 +88,4 @@
       StringBuilder builder = new StringBuilder();
       var varTreeNode = tree as VariableTreeNode;
-      var constTreeNode = tree as ConstantTreeNode;
       var factorVarTreeNode = tree as FactorVariableTreeNode;
       var binFactorVarTreeNode = tree as BinaryFactorVariableTreeNode;
@@ -97,6 +96,6 @@
       } else if (binFactorVarTreeNode != null) {
         builder.Append("(factor " + binFactorVarTreeNode.VariableName + "=" + binFactorVarTreeNode.VariableValue);
-      } else if (constTreeNode != null) {
-        builder.Append("(const");
+      } else if (tree is INumericTreeNode) {
+        builder.Append("(num"); // numbers and constants are treated as equivalent here, the value does not matter
       } else {
         builder.Append("(" + tree.ToString());
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs	(revision 18132)
@@ -41,5 +41,5 @@
     }
 
-    private static readonly Constant constantSy = new Constant();
+    private static readonly Number numberSy = new Number();
     private static readonly Addition addSy = new Addition();
     private static readonly Subtraction subSy = new Subtraction();
@@ -52,13 +52,13 @@
 
     public static ISymbolicExpressionTreeNode Derive(ISymbolicExpressionTreeNode branch, string variableName) {
-      if (branch.Symbol is Constant) {
-        return CreateConstant(0.0);
+      if (branch.Symbol is INumericSymbol) {
+        return CreateNumber(0.0);
       }
       if (branch.Symbol is Variable) {
         var varNode = branch as VariableTreeNode;
         if (varNode.VariableName == variableName) {
-          return CreateConstant(varNode.Weight);
+          return CreateNumber(varNode.Weight);
         } else {
-          return CreateConstant(0.0);
+          return CreateNumber(0.0);
         }
       }
@@ -102,5 +102,5 @@
         if (branch.SubtreeCount == 1) {
           var g = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-          var gPrime = Product(CreateConstant(-1.0), Derive(g, variableName));
+          var gPrime = Product(CreateNumber(-1.0), Derive(g, variableName));
           var sqrNode = new Square().CreateTreeNode();
           sqrNode.AddSubtree(g);
@@ -125,5 +125,5 @@
       if (branch.Symbol is Logarithm) {
         var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Div(CreateConstant(1.0), f), Derive(f, variableName));
+        return Product(Div(CreateNumber(1.0), f), Derive(f, variableName));
       }
       if (branch.Symbol is Exponential) {
@@ -133,30 +133,30 @@
       if (branch.Symbol is Square) {
         var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Product(CreateConstant(2.0), f), Derive(f, variableName));
+        return Product(Product(CreateNumber(2.0), f), Derive(f, variableName));
       }
       if (branch.Symbol is SquareRoot) {
         var f = (ISymbolicExpressionTreeNode)branch.Clone();
         var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Div(CreateConstant(1.0), Product(CreateConstant(2.0), f)), Derive(u, variableName));
+        return Product(Div(CreateNumber(1.0), Product(CreateNumber(2.0), f)), Derive(u, variableName));
       }
       if (branch.Symbol is CubeRoot) {
         var f = (ISymbolicExpressionTreeNode)branch.Clone();
         var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Div(CreateConstant(1.0), Product(CreateConstant(3.0), Square(f))), Derive(u, variableName));  // 1/3 1/cbrt(f(x))^2 d/dx f(x)
+        return Product(Div(CreateNumber(1.0), Product(CreateNumber(3.0), Square(f))), Derive(u, variableName));  // 1/3 1/cbrt(f(x))^2 d/dx f(x)
       }
       if (branch.Symbol is Cube) {
         var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Product(CreateConstant(3.0), Square(f)), Derive(f, variableName));
+        return Product(Product(CreateNumber(3.0), Square(f)), Derive(f, variableName));
       }
       if (branch.Symbol is Power) {
         // HL evaluators handle power strangely (exponent is rounded to an integer)
         // here we only support the case when the exponent is a constant integer 
-        var exponent = branch.GetSubtree(1) as ConstantTreeNode;
+        var exponent = branch.GetSubtree(1) as INumericTreeNode;
         if (exponent != null && Math.Truncate(exponent.Value) == exponent.Value) {
           var newPower = (ISymbolicExpressionTreeNode)branch.Clone();
           var f = (ISymbolicExpressionTreeNode)newPower.GetSubtree(0).Clone();
-          var newExponent = (ConstantTreeNode)newPower.GetSubtree(1);
-          newExponent.Value -= 1;
-          return Product(Product(CreateConstant(exponent.Value), newPower), Derive(f, variableName));
+          var newExponent = (INumericTreeNode)numberSy.CreateTreeNode();
+          newExponent.Value = ((INumericTreeNode)newPower.GetSubtree(1)).Value - 1;
+          return Product(Product(CreateNumber(exponent.Value), newPower), Derive(f, variableName));
         } else throw new NotSupportedException("Cannot derive non-integer powers");
       }
@@ -171,5 +171,5 @@
         var b = (ISymbolicExpressionTreeNode)branch.GetSubtree(1).Clone();
 
-        var definition = Div(a, SquareRoot(Sum(Square(b), CreateConstant(1.0))));
+        var definition = Div(a, SquareRoot(Sum(Square(b), CreateNumber(1.0))));
         return Derive(definition, variableName);
       }
@@ -184,5 +184,5 @@
         var sin = (new Sine()).CreateTreeNode();
         sin.AddSubtree(u);
-        return Product(CreateConstant(-1.0), Product(sin, Derive(u, variableName)));
+        return Product(CreateNumber(-1.0), Product(sin, Derive(u, variableName)));
       }
       if (branch.Symbol is Tangent) {
@@ -196,5 +196,5 @@
         var fxp = Derive(branch.GetSubtree(0), variableName);
         var tanh = (ISymbolicExpressionTreeNode)branch.Clone();
-        return Product(fxp, Subtract(CreateConstant(1.0), Square(tanh)));
+        return Product(fxp, Subtract(CreateNumber(1.0), Square(tanh)));
       }
       throw new NotSupportedException(string.Format("Symbol {0} is not supported.", branch.Symbol));
@@ -253,8 +253,8 @@
     }
 
-    private static ISymbolicExpressionTreeNode CreateConstant(double v) {
-      var constNode = (ConstantTreeNode)constantSy.CreateTreeNode();
-      constNode.Value = v;
-      return constNode;
+    private static ISymbolicExpressionTreeNode CreateNumber(double v) {
+      var numberNode = (NumberTreeNode)numberSy.CreateTreeNode();
+      numberNode.Value = v;
+      return numberNode;
     }
 
@@ -264,4 +264,5 @@
         where
           !(n.Symbol is Variable) &&
+          !(n.Symbol is Number) &&
           !(n.Symbol is Constant) &&
           !(n.Symbol is Addition) &&
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/LinearModelToTreeConverter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/LinearModelToTreeConverter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/LinearModelToTreeConverter.cs	(revision 18132)
@@ -58,5 +58,5 @@
 
       if (@const!=0.0) {
-        ConstantTreeNode cNode = (ConstantTreeNode)new Constant().CreateTreeNode();
+        NumberTreeNode cNode = (NumberTreeNode)new Number().CreateTreeNode();
         cNode.Value = @const;
         add.AddSubtree(cNode);
@@ -99,5 +99,5 @@
 
       if (!@const.IsAlmost(0.0)) {
-        ConstantTreeNode cNode = (ConstantTreeNode)new Constant().CreateTreeNode();
+        NumberTreeNode cNode = (NumberTreeNode)new Number().CreateTreeNode();
         cNode.Value = @const;
         addition.AddSubtree(cNode);
@@ -130,5 +130,5 @@
 
       if (!@const.IsAlmost(0.0)) {
-        ConstantTreeNode cNode = (ConstantTreeNode)new Constant().CreateTreeNode();
+        NumberTreeNode cNode = (NumberTreeNode)new Number().CreateTreeNode();
         cNode.Value = @const;
         addition.AddSubtree(cNode);
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs	(revision 18132)
@@ -36,5 +36,5 @@
     private static readonly Multiplication mulSymbol = new Multiplication();
     private static readonly Division divSymbol = new Division();
-    private static readonly Constant constSymbol = new Constant();
+    private static readonly Number numberSymbol = new Number();
     private static readonly Absolute absSymbol = new Absolute();
     private static readonly Logarithm logSymbol = new Logarithm();
@@ -81,5 +81,5 @@
     private static ISymbolicExpressionTreeNode MacroExpand(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode node,
       IList<ISymbolicExpressionTreeNode> argumentTrees) {
-      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.Subtrees);
+      var subtrees = new List<ISymbolicExpressionTreeNode>(node.Subtrees);
       while (node.SubtreeCount > 0) node.RemoveSubtree(0);
       if (node.Symbol is InvokeFunction) {
@@ -240,9 +240,14 @@
     }
 
+    private static bool IsNumber(ISymbolicExpressionTreeNode node) {
+      return node.Symbol is Number;
+    }
     private static bool IsConstant(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Constant;
     }
-
-    // dynamic
+    private static bool IsConstantOrNumber(ISymbolicExpressionTreeNode node) {
+      return node is INumericTreeNode;
+    }
+
     private static bool IsTimeLag(ISymbolicExpressionTreeNode node) {
       return node.Symbol is TimeLag;
@@ -261,5 +266,5 @@
     /// <returns></returns>
     public static ISymbolicExpressionTreeNode GetSimplifiedTree(ISymbolicExpressionTreeNode original) {
-      if (IsConstant(original) || IsVariableBase(original)) {
+      if (IsConstantOrNumber(original) || IsVariableBase(original)) {
         return (ISymbolicExpressionTreeNode)original.Clone();
       } else if (IsAbsolute(original)) {
@@ -324,8 +329,8 @@
     private static ISymbolicExpressionTreeNode SimplifyAny(ISymbolicExpressionTreeNode original) {
       // can't simplify this function but simplify all subtrees 
-      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(original.Subtrees);
+      var subtrees = new List<ISymbolicExpressionTreeNode>(original.Subtrees);
       while (original.Subtrees.Count() > 0) original.RemoveSubtree(0);
       var clone = (SymbolicExpressionTreeNode)original.Clone();
-      List<ISymbolicExpressionTreeNode> simplifiedSubtrees = new List<ISymbolicExpressionTreeNode>();
+      var simplifiedSubtrees = new List<ISymbolicExpressionTreeNode>();
       foreach (var subtree in subtrees) {
         simplifiedSubtrees.Add(GetSimplifiedTree(subtree));
@@ -335,12 +340,12 @@
         clone.AddSubtree(simplifiedSubtree);
       }
-      if (simplifiedSubtrees.TrueForAll(t => IsConstant(t))) {
-        SimplifyConstantExpression(clone);
+      if (simplifiedSubtrees.TrueForAll(IsNumber)) {
+        FoldNumbers(clone);
       }
       return clone;
     }
 
-    private static ISymbolicExpressionTreeNode SimplifyConstantExpression(ISymbolicExpressionTreeNode original) {
-      // not yet implemented
+    private static ISymbolicExpressionTreeNode FoldNumbers(ISymbolicExpressionTreeNode original) {
+      // TODO not implemented
       return original;
     }
@@ -354,6 +359,6 @@
         var sum = original.Subtrees
           .Select(GetSimplifiedTree)
-          .Aggregate(MakeSum);
-        return MakeFraction(sum, MakeConstant(original.Subtrees.Count()));
+          .Aggregate(Sum);
+        return Fraction(sum, Number(original.Subtrees.Count()));
       }
     }
@@ -369,6 +374,6 @@
         var remaining = original.Subtrees.Skip(2);
         return
-          MakeProduct(GetSimplifiedTree(first),
-            Invert(remaining.Aggregate(GetSimplifiedTree(second), (a, b) => MakeProduct(a, GetSimplifiedTree(b)))));
+          Product(GetSimplifiedTree(first),
+            Invert(remaining.Aggregate(GetSimplifiedTree(second), (a, b) => Product(a, GetSimplifiedTree(b)))));
       }
     }
@@ -380,5 +385,5 @@
         return original.Subtrees
           .Select(GetSimplifiedTree)
-          .Aggregate(MakeProduct);
+          .Aggregate(Product);
       }
     }
@@ -392,5 +397,5 @@
         var first = original.Subtrees.First();
         var remaining = original.Subtrees.Skip(1);
-        return remaining.Aggregate(GetSimplifiedTree(first), (a, b) => MakeSum(a, Negate(GetSimplifiedTree(b))));
+        return remaining.Aggregate(GetSimplifiedTree(first), (a, b) => Sum(a, Negate(GetSimplifiedTree(b))));
       }
     }
@@ -404,14 +409,14 @@
         return original.Subtrees
           .Select(GetSimplifiedTree)
-          .Aggregate(MakeSum);
+          .Aggregate(Sum);
       }
     }
 
     private static ISymbolicExpressionTreeNode SimplifyAbsolute(ISymbolicExpressionTreeNode original) {
-      return MakeAbs(GetSimplifiedTree(original.GetSubtree(0)));
+      return Abs(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifyNot(ISymbolicExpressionTreeNode original) {
-      return MakeNot(GetSimplifiedTree(original.GetSubtree(0)));
+      return Not(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
@@ -419,5 +424,5 @@
       return original.Subtrees
         .Select(GetSimplifiedTree)
-        .Aggregate(MakeOr);
+        .Aggregate(Or);
     }
 
@@ -425,65 +430,65 @@
       return original.Subtrees
         .Select(GetSimplifiedTree)
-        .Aggregate(MakeAnd);
+        .Aggregate(And);
     }
 
     private static ISymbolicExpressionTreeNode SimplifyLessThan(ISymbolicExpressionTreeNode original) {
-      return MakeLessThan(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
+      return LessThan(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifyGreaterThan(ISymbolicExpressionTreeNode original) {
-      return MakeGreaterThan(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
+      return GreaterThan(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifyIfThenElse(ISymbolicExpressionTreeNode original) {
-      return MakeIfThenElse(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)),
+      return IfThenElse(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)),
         GetSimplifiedTree(original.GetSubtree(2)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifyTangent(ISymbolicExpressionTreeNode original) {
-      return MakeTangent(GetSimplifiedTree(original.GetSubtree(0)));
+      return Tangent(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifyCosine(ISymbolicExpressionTreeNode original) {
-      return MakeCosine(GetSimplifiedTree(original.GetSubtree(0)));
+      return Cosine(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifySine(ISymbolicExpressionTreeNode original) {
-      return MakeSine(GetSimplifiedTree(original.GetSubtree(0)));
+      return Sine(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifyExp(ISymbolicExpressionTreeNode original) {
-      return MakeExp(GetSimplifiedTree(original.GetSubtree(0)));
+      return Exp(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifySquare(ISymbolicExpressionTreeNode original) {
-      return MakeSquare(GetSimplifiedTree(original.GetSubtree(0)));
+      return Square(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifySquareRoot(ISymbolicExpressionTreeNode original) {
-      return MakeSquareRoot(GetSimplifiedTree(original.GetSubtree(0)));
+      return SquareRoot(GetSimplifiedTree(original.GetSubtree(0)));
     }
     private static ISymbolicExpressionTreeNode SimplifyCube(ISymbolicExpressionTreeNode original) {
-      return MakeCube(GetSimplifiedTree(original.GetSubtree(0)));
+      return Cube(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifyCubeRoot(ISymbolicExpressionTreeNode original) {
-      return MakeCubeRoot(GetSimplifiedTree(original.GetSubtree(0)));
+      return CubeRoot(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifyLog(ISymbolicExpressionTreeNode original) {
-      return MakeLog(GetSimplifiedTree(original.GetSubtree(0)));
+      return Log(GetSimplifiedTree(original.GetSubtree(0)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifyRoot(ISymbolicExpressionTreeNode original) {
-      return MakeRoot(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
+      return Root(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifyPower(ISymbolicExpressionTreeNode original) {
-      return MakePower(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
+      return Power(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
 
     private static ISymbolicExpressionTreeNode SimplifyAnalyticalQuotient(ISymbolicExpressionTreeNode original) {
-      return MakeAnalyticalQuotient(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
+      return AQ(GetSimplifiedTree(original.GetSubtree(0)), GetSimplifiedTree(original.GetSubtree(1)));
     }
 
@@ -494,5 +499,5 @@
         return AddLagToDynamicNodes(simplifiedSubtree, laggedTreeNode.Lag);
       } else {
-        return MakeTimeLag(simplifiedSubtree, laggedTreeNode.Lag);
+        return Lag(simplifiedSubtree, laggedTreeNode.Lag);
       }
     }
@@ -501,8 +506,8 @@
       var laggedTreeNode = original as ILaggedTreeNode;
       var simplifiedSubtree = GetSimplifiedTree(original.GetSubtree(0));
-      if (IsConstant(simplifiedSubtree)) {
-        return GetSimplifiedTree(MakeProduct(simplifiedSubtree, MakeConstant(-laggedTreeNode.Lag)));
-      } else {
-        return MakeIntegral(simplifiedSubtree, laggedTreeNode.Lag);
+      if (IsConstantOrNumber(simplifiedSubtree)) {
+        return GetSimplifiedTree(Product(simplifiedSubtree, Number(-laggedTreeNode.Lag)));
+      } else {
+        return Integral(simplifiedSubtree, laggedTreeNode.Lag);
       }
     }
@@ -512,7 +517,7 @@
     #region low level tree restructuring
 
-    private static ISymbolicExpressionTreeNode MakeTimeLag(ISymbolicExpressionTreeNode subtree, int lag) {
+    private static ISymbolicExpressionTreeNode Lag(ISymbolicExpressionTreeNode subtree, int lag) {
       if (lag == 0) return subtree;
-      if (IsConstant(subtree)) return subtree;
+      if (IsConstantOrNumber(subtree)) return subtree;
       var lagNode = (LaggedTreeNode)timeLagSymbol.CreateTreeNode();
       lagNode.Lag = lag;
@@ -521,8 +526,8 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeIntegral(ISymbolicExpressionTreeNode subtree, int lag) {
+    private static ISymbolicExpressionTreeNode Integral(ISymbolicExpressionTreeNode subtree, int lag) {
       if (lag == 0) return subtree;
       else if (lag == -1 || lag == 1) {
-        return MakeSum(subtree, AddLagToDynamicNodes((ISymbolicExpressionTreeNode)subtree.Clone(), lag));
+        return Sum(subtree, AddLagToDynamicNodes((ISymbolicExpressionTreeNode)subtree.Clone(), lag));
       } else {
         var node = (LaggedTreeNode)integralSymbol.CreateTreeNode();
@@ -533,9 +538,9 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeNot(ISymbolicExpressionTreeNode t) {
-      if (IsConstant(t)) {
-        var constNode = t as ConstantTreeNode;
-        if (constNode.Value > 0) return MakeConstant(-1.0);
-        else return MakeConstant(1.0);
+    private static ISymbolicExpressionTreeNode Not(ISymbolicExpressionTreeNode t) {
+      if (IsNumber(t)) {
+        var numNode = t as NumberTreeNode;
+        if (numNode.Value > 0) return Number(-1.0);
+        else return Number(1.0);
       } else if (IsNot(t)) {
         return t.GetSubtree(0);
@@ -543,5 +548,5 @@
         var gtNode = gtSymbol.CreateTreeNode();
         gtNode.AddSubtree(t);
-        gtNode.AddSubtree(MakeConstant(0.0));
+        gtNode.AddSubtree(Number(0.0));
         var notNode = notSymbol.CreateTreeNode();
         notNode.AddSubtree(gtNode);
@@ -554,22 +559,22 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeOr(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
-        var constA = a as ConstantTreeNode;
-        var constB = b as ConstantTreeNode;
-        if (constA.Value > 0.0 || constB.Value > 0.0) {
-          return MakeConstant(1.0);
+    private static ISymbolicExpressionTreeNode Or(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+      if (IsNumber(a) && IsNumber(b)) {
+        var aNode = a as NumberTreeNode;
+        var bNode = b as NumberTreeNode;
+        if (aNode.Value > 0.0 || bNode.Value > 0.0) {
+          return Number(1.0);
         } else {
-          return MakeConstant(-1.0);
-        }
-      } else if (IsConstant(a)) {
-        return MakeOr(b, a);
-      } else if (IsConstant(b)) {
-        var constT = b as ConstantTreeNode;
-        if (constT.Value > 0.0) {
+          return Number(-1.0);
+        }
+      } else if (IsNumber(a)) {
+        return Or(b, a);
+      } else if (IsNumber(b)) {
+        var bNode = b as NumberTreeNode;
+        if (bNode.Value > 0.0) {
           // boolean expression is necessarily true
-          return MakeConstant(1.0);
+          return Number(1.0);
         } else {
-          // the constant value has no effect on the result of the boolean condition so we can drop the constant term
+          // the value has no effect on the result of the boolean condition so we can drop the number
           var orNode = orSymbol.CreateTreeNode();
           orNode.AddSubtree(a);
@@ -584,19 +589,19 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeAnd(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
-        var constA = a as ConstantTreeNode;
-        var constB = b as ConstantTreeNode;
-        if (constA.Value > 0.0 && constB.Value > 0.0) {
-          return MakeConstant(1.0);
+    private static ISymbolicExpressionTreeNode And(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+      if (IsNumber(a) && IsNumber(b)) {
+        var aNode = a as NumberTreeNode;
+        var bNode = b as NumberTreeNode;
+        if (aNode.Value > 0.0 && bNode.Value > 0.0) {
+          return Number(1.0);
         } else {
-          return MakeConstant(-1.0);
-        }
-      } else if (IsConstant(a)) {
-        return MakeAnd(b, a);
-      } else if (IsConstant(b)) {
-        var constB = b as ConstantTreeNode;
-        if (constB.Value > 0.0) {
-          // the constant value has no effect on the result of the boolean condition so we can drop the constant term
+          return Number(-1.0);
+        }
+      } else if (IsNumber(a)) {
+        return And(b, a);
+      } else if (IsNumber(b)) {
+        var bNode = b as NumberTreeNode;
+        if (bNode.Value > 0.0) {
+          // the value has no effect on the result of the boolean condition so we can drop the number
           var andNode = andSymbol.CreateTreeNode();
           andNode.AddSubtree(a);
@@ -604,5 +609,5 @@
         } else {
           // boolean expression is necessarily false
-          return MakeConstant(-1.0);
+          return Number(-1.0);
         }
       } else {
@@ -614,11 +619,11 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeLessThan(ISymbolicExpressionTreeNode leftSide,
+    private static ISymbolicExpressionTreeNode LessThan(ISymbolicExpressionTreeNode leftSide,
       ISymbolicExpressionTreeNode rightSide) {
-      if (IsConstant(leftSide) && IsConstant(rightSide)) {
-        var lsConst = leftSide as ConstantTreeNode;
-        var rsConst = rightSide as ConstantTreeNode;
-        if (lsConst.Value < rsConst.Value) return MakeConstant(1.0);
-        else return MakeConstant(-1.0);
+      if (IsNumber(leftSide) && IsNumber(rightSide)) {
+        var lsNode = leftSide as NumberTreeNode;
+        var rsNode = rightSide as NumberTreeNode;
+        if (lsNode.Value < rsNode.Value) return Number(1.0);
+        else return Number(-1.0);
       } else {
         var ltNode = ltSymbol.CreateTreeNode();
@@ -629,11 +634,11 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeGreaterThan(ISymbolicExpressionTreeNode leftSide,
+    private static ISymbolicExpressionTreeNode GreaterThan(ISymbolicExpressionTreeNode leftSide,
       ISymbolicExpressionTreeNode rightSide) {
-      if (IsConstant(leftSide) && IsConstant(rightSide)) {
-        var lsConst = leftSide as ConstantTreeNode;
-        var rsConst = rightSide as ConstantTreeNode;
-        if (lsConst.Value > rsConst.Value) return MakeConstant(1.0);
-        else return MakeConstant(-1.0);
+      if (IsNumber(leftSide) && IsNumber(rightSide)) {
+        var lsNode = leftSide as NumberTreeNode;
+        var rsNode = rightSide as NumberTreeNode;
+        if (lsNode.Value > rsNode.Value) return Number(1.0);
+        else return Number(-1.0);
       } else {
         var gtNode = gtSymbol.CreateTreeNode();
@@ -644,9 +649,9 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeIfThenElse(ISymbolicExpressionTreeNode condition,
+    private static ISymbolicExpressionTreeNode IfThenElse(ISymbolicExpressionTreeNode condition,
       ISymbolicExpressionTreeNode trueBranch, ISymbolicExpressionTreeNode falseBranch) {
-      if (IsConstant(condition)) {
-        var constT = condition as ConstantTreeNode;
-        if (constT.Value > 0.0) return trueBranch;
+      if (IsConstantOrNumber(condition)) {
+        var condNode = condition as INumericTreeNode;
+        if (condNode.Value > 0.0) return trueBranch;
         else return falseBranch;
       } else {
@@ -657,5 +662,5 @@
           var gtNode = gtSymbol.CreateTreeNode();
           gtNode.AddSubtree(condition);
-          gtNode.AddSubtree(MakeConstant(0.0));
+          gtNode.AddSubtree(Number(0.0));
           ifNode.AddSubtree(gtNode);
         }
@@ -666,14 +671,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeSine(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
-        return MakeConstant(Math.Sin(constT.Value));
+    private static ISymbolicExpressionTreeNode Sine(ISymbolicExpressionTreeNode node) {
+      if (IsNumber(node)) {
+        var numNode = node as NumberTreeNode;
+        return Number(Math.Sin(numNode.Value));
       } else if (IsFactor(node)) {
         var factor = node as FactorVariableTreeNode;
-        return MakeFactor(factor.Symbol, factor.VariableName, factor.Weights.Select(Math.Sin));
+        return Factor(factor.Symbol, factor.VariableName, factor.Weights.Select(Math.Sin));
       } else if (IsBinFactor(node)) {
         var binFactor = node as BinaryFactorVariableTreeNode;
-        return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Sin(binFactor.Weight));
+        return BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Sin(binFactor.Weight));
       } else {
         var sineNode = sineSymbol.CreateTreeNode();
@@ -683,14 +688,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeTangent(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
-        return MakeConstant(Math.Tan(constT.Value));
+    private static ISymbolicExpressionTreeNode Tangent(ISymbolicExpressionTreeNode node) {
+      if (IsNumber(node)) {
+        var numNode = node as NumberTreeNode;
+        return Number(Math.Tan(numNode.Value));
       } else if (IsFactor(node)) {
         var factor = node as FactorVariableTreeNode;
-        return MakeFactor(factor.Symbol, factor.VariableName, factor.Weights.Select(Math.Tan));
+        return Factor(factor.Symbol, factor.VariableName, factor.Weights.Select(Math.Tan));
       } else if (IsBinFactor(node)) {
         var binFactor = node as BinaryFactorVariableTreeNode;
-        return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Tan(binFactor.Weight));
+        return BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Tan(binFactor.Weight));
       } else {
         var tanNode = tanSymbol.CreateTreeNode();
@@ -700,16 +705,16 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeCosine(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
-        return MakeConstant(Math.Cos(constT.Value));
+    private static ISymbolicExpressionTreeNode Cosine(ISymbolicExpressionTreeNode node) {
+      if (IsNumber(node)) {
+        var numNode = node as NumberTreeNode;
+        return Number(Math.Cos(numNode.Value));
       } else if (IsFactor(node)) {
         var factor = node as FactorVariableTreeNode;
-        return MakeFactor(factor.Symbol, factor.VariableName, factor.Weights.Select(Math.Cos));
+        return Factor(factor.Symbol, factor.VariableName, factor.Weights.Select(Math.Cos));
       } else if (IsBinFactor(node)) {
         var binFactor = node as BinaryFactorVariableTreeNode;
         // cos(0) = 1 see similar case for Exp(binfactor)
-        return MakeSum(MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Cos(binFactor.Weight) - 1),
-          MakeConstant(1.0));
+        return Sum(BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Cos(binFactor.Weight) - 1),
+          Number(1.0));
       } else {
         var cosNode = cosineSymbol.CreateTreeNode();
@@ -719,22 +724,22 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeExp(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
-        return MakeConstant(Math.Exp(constT.Value));
+    private static ISymbolicExpressionTreeNode Exp(ISymbolicExpressionTreeNode node) {
+      if (IsNumber(node)) {
+        var numNode = node as NumberTreeNode;
+        return Number(Math.Exp(numNode.Value));
       } else if (IsFactor(node)) {
         var factNode = node as FactorVariableTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Exp(w)));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Exp(w)));
       } else if (IsBinFactor(node)) {
         // exp( binfactor w val=a) = if(val=a) exp(w) else exp(0) = binfactor( (exp(w) - 1) val a) + 1
         var binFactor = node as BinaryFactorVariableTreeNode;
         return
-          MakeSum(MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Exp(binFactor.Weight) - 1), MakeConstant(1.0));
+          Sum(BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Exp(binFactor.Weight) - 1), Number(1.0));
       } else if (IsLog(node)) {
         return node.GetSubtree(0);
       } else if (IsAddition(node)) {
-        return node.Subtrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, t));
+        return node.Subtrees.Select(s => Exp(s)).Aggregate((s, t) => Product(s, t));
       } else if (IsSubtraction(node)) {
-        return node.Subtrees.Select(s => MakeExp(s)).Aggregate((s, t) => MakeProduct(s, Negate(t)));
+        return node.Subtrees.Select(s => Exp(s)).Aggregate((s, t) => Product(s, Negate(t)));
       } else {
         var expNode = expSymbol.CreateTreeNode();
@@ -743,15 +748,15 @@
       }
     }
-    private static ISymbolicExpressionTreeNode MakeLog(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
-        return MakeConstant(Math.Log(constT.Value));
+    private static ISymbolicExpressionTreeNode Log(ISymbolicExpressionTreeNode node) {
+      if (IsNumber(node)) {
+        var numNode = node as NumberTreeNode;
+        return Number(Math.Log(numNode.Value));
       } else if (IsFactor(node)) {
         var factNode = node as FactorVariableTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Log(w)));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Log(w)));
       } else if (IsExp(node)) {
         return node.GetSubtree(0);
       } else if (IsSquareRoot(node)) {
-        return MakeFraction(MakeLog(node.GetSubtree(0)), MakeConstant(2.0));
+        return Fraction(Log(node.GetSubtree(0)), Number(2.0));
       } else {
         var logNode = logSymbol.CreateTreeNode();
@@ -761,14 +766,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeSquare(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
-        return MakeConstant(constT.Value * constT.Value);
+    private static ISymbolicExpressionTreeNode Square(ISymbolicExpressionTreeNode node) {
+      if (IsNumber(node)) {
+        var numNode = node as NumberTreeNode;
+        return Number(numNode.Value * numNode.Value);
       } else if (IsFactor(node)) {
         var factNode = node as FactorVariableTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => w * w));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => w * w));
       } else if (IsBinFactor(node)) {
         var binFactor = node as BinaryFactorVariableTreeNode;
-        return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, binFactor.Weight * binFactor.Weight);
+        return BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, binFactor.Weight * binFactor.Weight);
       } else if (IsSquareRoot(node)) {
         return node.GetSubtree(0);
@@ -777,15 +782,15 @@
         var mulNode = mulSymbol.CreateTreeNode();
         foreach (var subtree in node.Subtrees) {
-          mulNode.AddSubtree(MakeSquare(subtree));
+          mulNode.AddSubtree(Square(subtree));
         }
         return mulNode;
       } else if (IsAbsolute(node)) {
-        return MakeSquare(node.GetSubtree(0)); // sqr(abs(x)) = sqr(x)
+        return Square(node.GetSubtree(0)); // sqr(abs(x)) = sqr(x)
       } else if (IsExp(node)) {
-        return MakeExp(MakeProduct(node.GetSubtree(0), MakeConstant(2.0))); // sqr(exp(x)) = exp(2x)
+        return Exp(Product(node.GetSubtree(0), Number(2.0))); // sqr(exp(x)) = exp(2x)
       } else if (IsSquare(node)) {
-        return MakePower(node.GetSubtree(0), MakeConstant(4));
+        return Power(node.GetSubtree(0), Number(4));
       } else if (IsCube(node)) {
-        return MakePower(node.GetSubtree(0), MakeConstant(6));
+        return Power(node.GetSubtree(0), Number(6));
       } else {
         var sqrNode = sqrSymbol.CreateTreeNode();
@@ -795,22 +800,22 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeCube(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
-        return MakeConstant(constT.Value * constT.Value * constT.Value);
+    private static ISymbolicExpressionTreeNode Cube(ISymbolicExpressionTreeNode node) {
+      if (IsNumber(node)) {
+        var numNode = node as NumberTreeNode;
+        return Number(numNode.Value * numNode.Value * numNode.Value);
       } else if (IsFactor(node)) {
         var factNode = node as FactorVariableTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => w * w * w));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => w * w * w));
       } else if (IsBinFactor(node)) {
         var binFactor = node as BinaryFactorVariableTreeNode;
-        return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, binFactor.Weight * binFactor.Weight * binFactor.Weight);
+        return BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, binFactor.Weight * binFactor.Weight * binFactor.Weight);
       } else if (IsCubeRoot(node)) {
         return node.GetSubtree(0); // NOTE: not really accurate because cuberoot(x) with negative x is evaluated to NaN and after this simplification we evaluate as x
       } else if (IsExp(node)) {
-        return MakeExp(MakeProduct(node.GetSubtree(0), MakeConstant(3)));
+        return Exp(Product(node.GetSubtree(0), Number(3)));
       } else if (IsSquare(node)) {
-        return MakePower(node.GetSubtree(0), MakeConstant(6));
+        return Power(node.GetSubtree(0), Number(6));
       } else if (IsCube(node)) {
-        return MakePower(node.GetSubtree(0), MakeConstant(9));
+        return Power(node.GetSubtree(0), Number(9));
       } else {
         var cubeNode = cubeSymbol.CreateTreeNode();
@@ -820,14 +825,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeAbs(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
-        return MakeConstant(Math.Abs(constT.Value));
+    private static ISymbolicExpressionTreeNode Abs(ISymbolicExpressionTreeNode node) {
+      if (IsNumber(node)) {
+        var numNode = node as NumberTreeNode;
+        return Number(Math.Abs(numNode.Value));
       } else if (IsFactor(node)) {
         var factNode = node as FactorVariableTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Abs(w)));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Abs(w)));
       } else if (IsBinFactor(node)) {
         var binFactor = node as BinaryFactorVariableTreeNode;
-        return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Abs(binFactor.Weight));
+        return BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Abs(binFactor.Weight));
       } else if (IsSquare(node) || IsExp(node) || IsSquareRoot(node) || IsCubeRoot(node)) {
         return node; // abs(sqr(x)) = sqr(x), abs(exp(x)) = exp(x) ...
@@ -835,5 +840,5 @@
         var mul = mulSymbol.CreateTreeNode();
         foreach (var st in node.Subtrees) {
-          mul.AddSubtree(MakeAbs(st));
+          mul.AddSubtree(Abs(st));
         }
         return mul;
@@ -841,5 +846,5 @@
         var div = divSymbol.CreateTreeNode();
         foreach (var st in node.Subtrees) {
-          div.AddSubtree(MakeAbs(st));
+          div.AddSubtree(Abs(st));
         }
         return div;
@@ -852,14 +857,14 @@
 
     // constant folding only
-    private static ISymbolicExpressionTreeNode MakeAnalyticalQuotient(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(b)) {
-        var c = b as ConstantTreeNode;
-        return MakeFraction(a, MakeConstant(Math.Sqrt(1.0 + c.Value * c.Value)));
+    private static ISymbolicExpressionTreeNode AQ(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+      if (IsNumber(b)) {
+        var nNode = b as NumberTreeNode;
+        return Fraction(a, Number(Math.Sqrt(1.0 + nNode.Value * nNode.Value)));
       } else if (IsFactor(b)) {
         var factNode = b as FactorVariableTreeNode;
-        return MakeFraction(a, MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Sqrt(1.0 + w * w))));
+        return Fraction(a, Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Sqrt(1.0 + w * w))));
       } else if (IsBinFactor(b)) {
         var binFactor = b as BinaryFactorVariableTreeNode;
-        return MakeFraction(a, MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Sqrt(1.0 + binFactor.Weight * binFactor.Weight)));
+        return Fraction(a, BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Sqrt(1.0 + binFactor.Weight * binFactor.Weight)));
       } else {
         var aqNode = aqSymbol.CreateTreeNode();
@@ -870,14 +875,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeSquareRoot(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
-        return MakeConstant(Math.Sqrt(constT.Value));
+    private static ISymbolicExpressionTreeNode SquareRoot(ISymbolicExpressionTreeNode node) {
+      if (IsNumber(node)) {
+        var numNode = node as NumberTreeNode;
+        return Number(Math.Sqrt(numNode.Value));
       } else if (IsFactor(node)) {
         var factNode = node as FactorVariableTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Sqrt(w)));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Sqrt(w)));
       } else if (IsBinFactor(node)) {
         var binFactor = node as BinaryFactorVariableTreeNode;
-        return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Sqrt(binFactor.Weight));
+        return BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Sqrt(binFactor.Weight));
       } else if (IsSquare(node)) {
         return node.GetSubtree(0); // NOTE: not really accurate because sqrt(x) with negative x is evaluated to NaN and after this simplification we evaluate as x
@@ -889,14 +894,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeCubeRoot(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
-        return MakeConstant(Math.Pow(constT.Value, 1.0 / 3.0));
+    private static ISymbolicExpressionTreeNode CubeRoot(ISymbolicExpressionTreeNode node) {
+      if (IsNumber(node)) {
+        var numNode = node as NumberTreeNode;
+        return Number(Math.Pow(numNode.Value, 1.0 / 3.0));
       } else if (IsFactor(node)) {
         var factNode = node as FactorVariableTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(w, 1.0 / 3.0)));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(w, 1.0 / 3.0)));
       } else if (IsBinFactor(node)) {
         var binFactor = node as BinaryFactorVariableTreeNode;
-        return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Sqrt(Math.Pow(binFactor.Weight, 1.0 / 3.0)));
+        return BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Sqrt(Math.Pow(binFactor.Weight, 1.0 / 3.0)));
       } else if (IsCube(node)) {
         return node.GetSubtree(0);
@@ -908,53 +913,52 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeRoot(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
-        var constA = a as ConstantTreeNode;
-        var constB = b as ConstantTreeNode;
-        return MakeConstant(Math.Pow(constA.Value, 1.0 / Math.Round(constB.Value)));
-      } else if (IsFactor(a) && IsConstant(b)) {
+    private static ISymbolicExpressionTreeNode Root(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+      if (IsNumber(a) && IsNumber(b)) {
+        var aNode = a as NumberTreeNode;
+        var bNode = b as NumberTreeNode;
+        return Number(Math.Pow(aNode.Value, 1.0 / Math.Round(bNode.Value)));
+      } else if (IsFactor(a) && IsNumber(b)) {
         var factNode = a as FactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName,
-          factNode.Weights.Select(w => Math.Pow(w, 1.0 / Math.Round(constNode.Value))));
-      } else if (IsBinFactor(a) && IsConstant(b)) {
+        var bNode = b as NumberTreeNode;
+        return Factor(factNode.Symbol, factNode.VariableName,
+          factNode.Weights.Select(w => Math.Pow(w, 1.0 / Math.Round(bNode.Value))));
+      } else if (IsBinFactor(a) && IsNumber(b)) {
         var binFactor = a as BinaryFactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
-        return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Pow(binFactor.Weight, 1.0 / Math.Round(constNode.Value)));
-      } else if (IsConstant(a) && IsFactor(b)) {
-        var constNode = a as ConstantTreeNode;
+        var bNode = b as NumberTreeNode;
+        return BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Pow(binFactor.Weight, 1.0 / Math.Round(bNode.Value)));
+      } else if (IsNumber(a) && IsFactor(b)) {
+        var aNode = a as NumberTreeNode;
         var factNode = b as FactorVariableTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(constNode.Value, 1.0 / Math.Round(w))));
-      } else if (IsConstant(a) && IsBinFactor(b)) {
-        var constNode = a as ConstantTreeNode;
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(aNode.Value, 1.0 / Math.Round(w))));
+      } else if (IsNumber(a) && IsBinFactor(b)) {
+        var aNode = a as NumberTreeNode;
         var factNode = b as BinaryFactorVariableTreeNode;
-        return MakeBinFactor(factNode.Symbol, factNode.VariableName, factNode.VariableValue, Math.Pow(constNode.Value, 1.0 / Math.Round(factNode.Weight)));
+        return BinFactor(factNode.Symbol, factNode.VariableName, factNode.VariableValue, Math.Pow(aNode.Value, 1.0 / Math.Round(factNode.Weight)));
       } else if (IsFactor(a) && IsFactor(b) && AreSameTypeAndVariable(a, b)) {
         var node0 = a as FactorVariableTreeNode;
         var node1 = b as FactorVariableTreeNode;
-        return MakeFactor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => Math.Pow(u, 1.0 / Math.Round(v))));
-      } else if (IsConstant(b)) {
-        var constB = b as ConstantTreeNode;
-        var constBValue = Math.Round(constB.Value);
-        if (constBValue == 1.0) {
+        return Factor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => Math.Pow(u, 1.0 / Math.Round(v))));
+      } else if (IsNumber(b)) {
+        var bNode = b as NumberTreeNode;
+        var bVal = Math.Round(bNode.Value);
+        if (bVal == 1.0) {
           // root(a, 1) => a
           return a;
-        } else if (constBValue == 0.0) {
+        } else if (bVal == 0.0) {
           // root(a, 0) is not defined 
-          //return MakeConstant(1.0);
-          return MakeConstant(double.NaN);
-        } else if (constBValue == -1.0) {
+          return Number(double.NaN);
+        } else if (bVal == -1.0) {
           // root(a, -1) => a^(-1/1) => 1/a
-          return MakeFraction(MakeConstant(1.0), a);
-        } else if (constBValue < 0) {
+          return Fraction(Number(1.0), a);
+        } else if (bVal < 0) {
           // root(a, -b) => a^(-1/b) => (1/a)^(1/b) => root(1, b) / root(a, b) => 1 / root(a, b)
           var rootNode = rootSymbol.CreateTreeNode();
           rootNode.AddSubtree(a);
-          rootNode.AddSubtree(MakeConstant(-1.0 * constBValue));
-          return MakeFraction(MakeConstant(1.0), rootNode);
+          rootNode.AddSubtree(Number(-1.0 * bVal));
+          return Fraction(Number(1.0), rootNode);
         } else {
           var rootNode = rootSymbol.CreateTreeNode();
           rootNode.AddSubtree(a);
-          rootNode.AddSubtree(MakeConstant(constBValue));
+          rootNode.AddSubtree(Number(bVal));
           return rootNode;
         }
@@ -968,35 +972,35 @@
 
 
-    private static ISymbolicExpressionTreeNode MakePower(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
-        var constA = a as ConstantTreeNode;
-        var constB = b as ConstantTreeNode;
-        return MakeConstant(Math.Pow(constA.Value, Math.Round(constB.Value)));
-      } else if (IsFactor(a) && IsConstant(b)) {
+    private static ISymbolicExpressionTreeNode Power(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+      if (IsNumber(a) && IsNumber(b)) {
+        var aNode = a as NumberTreeNode;
+        var bNode = b as NumberTreeNode;
+        return Number(Math.Pow(aNode.Value, Math.Round(bNode.Value)));
+      } else if (IsFactor(a) && IsNumber(b)) {
         var factNode = a as FactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(w, Math.Round(constNode.Value))));
-      } else if (IsBinFactor(a) && IsConstant(b)) {
+        var bNode = b as NumberTreeNode;
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(w, Math.Round(bNode.Value))));
+      } else if (IsBinFactor(a) && IsNumber(b)) {
         var binFactor = a as BinaryFactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
-        return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Pow(binFactor.Weight, Math.Round(constNode.Value)));
-      } else if (IsConstant(a) && IsFactor(b)) {
-        var constNode = a as ConstantTreeNode;
+        var bNode = b as NumberTreeNode;
+        return BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Pow(binFactor.Weight, Math.Round(bNode.Value)));
+      } else if (IsNumber(a) && IsFactor(b)) {
+        var aNode = a as NumberTreeNode;
         var factNode = b as FactorVariableTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(constNode.Value, Math.Round(w))));
-      } else if (IsConstant(a) && IsBinFactor(b)) {
-        var constNode = a as ConstantTreeNode;
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(aNode.Value, Math.Round(w))));
+      } else if (IsNumber(a) && IsBinFactor(b)) {
+        var aNode = a as NumberTreeNode;
         var factNode = b as BinaryFactorVariableTreeNode;
-        return MakeBinFactor(factNode.Symbol, factNode.VariableName, factNode.VariableValue, Math.Pow(constNode.Value, Math.Round(factNode.Weight)));
+        return BinFactor(factNode.Symbol, factNode.VariableName, factNode.VariableValue, Math.Pow(aNode.Value, Math.Round(factNode.Weight)));
       } else if (IsFactor(a) && IsFactor(b) && AreSameTypeAndVariable(a, b)) {
         var node0 = a as FactorVariableTreeNode;
         var node1 = b as FactorVariableTreeNode;
-        return MakeFactor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => Math.Pow(u, Math.Round(v))));
-      } else if (IsConstant(b)) {
-        var constB = b as ConstantTreeNode;
-        double exponent = Math.Round(constB.Value);
+        return Factor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => Math.Pow(u, Math.Round(v))));
+      } else if (IsNumber(b)) {
+        var bNode = b as NumberTreeNode;
+        double exponent = Math.Round(bNode.Value);
         if (exponent == 0.0) {
           // a^0 => 1
-          return MakeConstant(1.0);
+          return Number(1.0);
         } else if (exponent == 1.0) {
           // a^1 => a
@@ -1004,15 +1008,15 @@
         } else if (exponent == -1.0) {
           // a^-1 => 1/a
-          return MakeFraction(MakeConstant(1.0), a);
+          return Fraction(Number(1.0), a);
         } else if (exponent < 0) {
           // a^-b => (1/a)^b => 1/(a^b)
           var powNode = powSymbol.CreateTreeNode();
           powNode.AddSubtree(a);
-          powNode.AddSubtree(MakeConstant(-1.0 * exponent));
-          return MakeFraction(MakeConstant(1.0), powNode);
+          powNode.AddSubtree(Number(-1.0 * exponent));
+          return Fraction(Number(1.0), powNode);
         } else {
           var powNode = powSymbol.CreateTreeNode();
           powNode.AddSubtree(a);
-          powNode.AddSubtree(MakeConstant(exponent));
+          powNode.AddSubtree(Number(exponent));
           return powNode;
         }
@@ -1026,29 +1030,29 @@
 
 
-    // MakeFraction, MakeProduct and MakeSum take two already simplified trees and create a new simplified tree
-    private static ISymbolicExpressionTreeNode MakeFraction(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
+    // Fraction, Product and Sum take two already simplified trees and create a new simplified tree
+    private static ISymbolicExpressionTreeNode Fraction(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+      if (IsNumber(a) && IsNumber(b)) {
         // fold constants
-        return MakeConstant(((ConstantTreeNode)a).Value / ((ConstantTreeNode)b).Value);
-      } else if ((IsConstant(a) && ((ConstantTreeNode)a).Value != 1.0)) {
+        return Number(((NumberTreeNode)a).Value / ((NumberTreeNode)b).Value);
+      } else if (IsNumber(a) && ((NumberTreeNode)a).Value != 1.0) {
         // a / x => (a * 1/a) / (x * 1/a) => 1 / (x * 1/a)
-        return MakeFraction(MakeConstant(1.0), MakeProduct(b, Invert(a)));
-      } else if (IsVariableBase(a) && IsConstant(b)) {
+        return Fraction(Number(1.0), Product(b, Invert(a)));
+      } else if (IsVariableBase(a) && IsNumber(b)) {
         // merge constant values into variable weights
-        var constB = ((ConstantTreeNode)b).Value;
-        ((VariableTreeNodeBase)a).Weight /= constB;
+        var bVal = ((NumberTreeNode)b).Value;
+        ((VariableTreeNodeBase)a).Weight /= bVal;
         return a;
-      } else if (IsFactor(a) && IsConstant(b)) {
+      } else if (IsFactor(a) && IsNumber(b)) {
         var factNode = a as FactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => w / constNode.Value));
-      } else if (IsBinFactor(a) && IsConstant(b)) {
+        var bNode = b as NumberTreeNode;
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => w / bNode.Value));
+      } else if (IsBinFactor(a) && IsNumber(b)) {
         var factNode = a as BinaryFactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
-        return MakeBinFactor(factNode.Symbol, factNode.VariableName, factNode.VariableValue, factNode.Weight / constNode.Value);
+        var bNode = b as NumberTreeNode;
+        return BinFactor(factNode.Symbol, factNode.VariableName, factNode.VariableValue, factNode.Weight / bNode.Value);
       } else if (IsFactor(a) && IsFactor(b) && AreSameTypeAndVariable(a, b)) {
         var node0 = a as FactorVariableTreeNode;
         var node1 = b as FactorVariableTreeNode;
-        return MakeFactor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => u / v));
+        return Factor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => u / v));
       } else if (IsFactor(a) && IsBinFactor(b) && ((IVariableTreeNode)a).VariableName == ((IVariableTreeNode)b).VariableName) {
         var node0 = a as FactorVariableTreeNode;
@@ -1062,33 +1066,33 @@
           if (wi == i) newWeighs[i] /= node1.Weight;
           else newWeighs[i] /= 0.0;
-        return MakeFactor(node0.Symbol, node0.VariableName, newWeighs);
+        return Factor(node0.Symbol, node0.VariableName, newWeighs);
       } else if (IsFactor(a)) {
-        return MakeFraction(MakeConstant(1.0), MakeProduct(b, Invert(a)));
+        return Fraction(Number(1.0), Product(b, Invert(a)));
       } else if (IsVariableBase(a) && IsVariableBase(b) && AreSameTypeAndVariable(a, b) && !IsBinFactor(b)) {
         // cancel variables (not allowed for bin factors because of division by zero)
         var aVar = a as VariableTreeNode;
         var bVar = b as VariableTreeNode;
-        return MakeConstant(aVar.Weight / bVar.Weight);
-      } else if (IsAddition(a) && IsConstant(b)) {
+        return Number(aVar.Weight / bVar.Weight);
+      } else if (IsAddition(a) && IsNumber(b)) {
         return a.Subtrees
           .Select(x => GetSimplifiedTree(x))
-          .Select(x => MakeFraction(x, GetSimplifiedTree(b)))
-          .Aggregate((c, d) => MakeSum(c, d));
-      } else if (IsMultiplication(a) && IsConstant(b)) {
-        return MakeProduct(a, Invert(b));
-      } else if (IsDivision(a) && IsConstant(b)) {
+          .Select(x => Fraction(x, GetSimplifiedTree(b)))
+          .Aggregate((c, d) => Sum(c, d));
+      } else if (IsMultiplication(a) && IsNumber(b)) {
+        return Product(a, Invert(b));
+      } else if (IsDivision(a) && IsNumber(b)) {
         // (a1 / a2) / c => (a1 / (a2 * c))
-        return MakeFraction(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
+        return Fraction(a.GetSubtree(0), Product(a.GetSubtree(1), b));
       } else if (IsDivision(a) && IsDivision(b)) {
         // (a1 / a2) / (b1 / b2) => 
-        return MakeFraction(MakeProduct(a.GetSubtree(0), b.GetSubtree(1)), MakeProduct(a.GetSubtree(1), b.GetSubtree(0)));
+        return Fraction(Product(a.GetSubtree(0), b.GetSubtree(1)), Product(a.GetSubtree(1), b.GetSubtree(0)));
       } else if (IsDivision(a)) {
         // (a1 / a2) / b => (a1 / (a2 * b))
-        return MakeFraction(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
+        return Fraction(a.GetSubtree(0), Product(a.GetSubtree(1), b));
       } else if (IsDivision(b)) {
         // a / (b1 / b2) => (a * b2) / b1
-        return MakeFraction(MakeProduct(a, b.GetSubtree(1)), b.GetSubtree(0));
+        return Fraction(Product(a, b.GetSubtree(1)), b.GetSubtree(0));
       } else if (IsAnalyticalQuotient(a)) {
-        return MakeAnalyticalQuotient(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
+        return AQ(a.GetSubtree(0), Product(a.GetSubtree(1), b));
       } else {
         var div = divSymbol.CreateTreeNode();
@@ -1099,26 +1103,26 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeSum(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
+    private static ISymbolicExpressionTreeNode Sum(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+      if (IsNumber(a) && IsNumber(b)) {
         // fold constants
-        ((ConstantTreeNode)a).Value += ((ConstantTreeNode)b).Value;
+        ((NumberTreeNode)a).Value += ((NumberTreeNode)b).Value;
         return a;
-      } else if (IsConstant(a)) {
+      } else if (IsNumber(a)) {
         // c + x => x + c
         // b is not constant => make sure constant is on the right
-        return MakeSum(b, a);
-      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value == 0.0) {
+        return Sum(b, a);
+      } else if (IsNumber(b) && ((NumberTreeNode)b).Value == 0.0) {
         // x + 0 => x
         return a;
-      } else if (IsFactor(a) && IsConstant(b)) {
+      } else if (IsFactor(a) && IsNumber(b)) {
         var factNode = a as FactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select((w) => w + constNode.Value));
+        var bNode = b as NumberTreeNode;
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select((w) => w + bNode.Value));
       } else if (IsFactor(a) && IsFactor(b) && AreSameTypeAndVariable(a, b)) {
         var node0 = a as FactorVariableTreeNode;
         var node1 = b as FactorVariableTreeNode;
-        return MakeFactor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => u + v));
+        return Factor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => u + v));
       } else if (IsBinFactor(a) && IsFactor(b)) {
-        return MakeSum(b, a);
+        return Sum(b, a);
       } else if (IsFactor(a) && IsBinFactor(b) &&
         ((IVariableTreeNode)a).VariableName == ((IVariableTreeNode)b).VariableName) {
@@ -1131,5 +1135,5 @@
         node0.Weights.CopyTo(newWeighs, 0);
         newWeighs[wi] += node1.Weight;
-        return MakeFactor(node0.Symbol, node0.VariableName, newWeighs);
+        return Factor(node0.Symbol, node0.VariableName, newWeighs);
       } else if (IsAddition(a) && IsAddition(b)) {
         // merge additions
@@ -1138,7 +1142,7 @@
         for (int i = 0; i < a.Subtrees.Count() - 1; i++) add.AddSubtree(a.GetSubtree(i));
         for (int i = 0; i < b.Subtrees.Count() - 1; i++) add.AddSubtree(b.GetSubtree(i));
-        if (IsConstant(a.Subtrees.Last()) && IsConstant(b.Subtrees.Last())) {
-          add.AddSubtree(MakeSum(a.Subtrees.Last(), b.Subtrees.Last()));
-        } else if (IsConstant(a.Subtrees.Last())) {
+        if (IsNumber(a.Subtrees.Last()) && IsNumber(b.Subtrees.Last())) {
+          add.AddSubtree(Sum(a.Subtrees.Last(), b.Subtrees.Last()));
+        } else if (IsNumber(a.Subtrees.Last())) {
           add.AddSubtree(b.Subtrees.Last());
           add.AddSubtree(a.Subtrees.Last());
@@ -1154,12 +1158,12 @@
         }
       } else if (IsAddition(b)) {
-        return MakeSum(b, a);
-      } else if (IsAddition(a) && IsConstant(b)) {
+        return Sum(b, a);
+      } else if (IsAddition(a) && IsNumber(b)) {
         // a is an addition and b is a constant => append b to a and make sure the constants are merged
         var add = addSymbol.CreateTreeNode();
         // add all sub trees except for the last
         for (int i = 0; i < a.Subtrees.Count() - 1; i++) add.AddSubtree(a.GetSubtree(i));
-        if (IsConstant(a.Subtrees.Last()))
-          add.AddSubtree(MakeSum(a.Subtrees.Last(), b));
+        if (IsNumber(a.Subtrees.Last()))
+          add.AddSubtree(Sum(a.Subtrees.Last(), b));
         else {
           add.AddSubtree(a.Subtrees.Last());
@@ -1201,7 +1205,7 @@
                             group node by GroupId(node) into g
                             select g;
-      var constant = (from node in subtrees.OfType<ConstantTreeNode>()
-                      select node.Value).DefaultIfEmpty(0.0).Sum();
-      var unchangedSubtrees = subtrees.Where(t => t.SubtreeCount > 0 || !(t is IVariableTreeNode) && !(t is ConstantTreeNode));
+      var sumNumbers = (from node in subtrees.OfType<NumberTreeNode>()
+                        select node.Value).DefaultIfEmpty(0.0).Sum();
+      var unchangedSubtrees = subtrees.Where(t => t.SubtreeCount > 0 || !(t is IVariableTreeNode) && !(t is NumberTreeNode));
 
       foreach (var variableNodeGroup in groupedVarNodes) {
@@ -1224,6 +1228,6 @@
       foreach (var unchangedSubtree in unchangedSubtrees)
         sum.AddSubtree(unchangedSubtree);
-      if (constant != 0.0) {
-        sum.AddSubtree(MakeConstant(constant));
+      if (sumNumbers != 0.0) {
+        sum.AddSubtree(Number(sumNumbers));
       }
     }
@@ -1231,15 +1235,11 @@
     // nodes referencing variables can be grouped if they have
     private static string GroupId(IVariableTreeNode node) {
-      var binaryFactorNode = node as BinaryFactorVariableTreeNode;
-      var factorNode = node as FactorVariableTreeNode;
-      var variableNode = node as VariableTreeNode;
-      var laggedVarNode = node as LaggedVariableTreeNode;
-      if (variableNode != null) {
+      if (node is VariableTreeNode variableNode) {
         return "var " + variableNode.VariableName;
-      } else if (binaryFactorNode != null) {
+      } else if (node is BinaryFactorVariableTreeNode binaryFactorNode) {
         return "binfactor " + binaryFactorNode.VariableName + " " + binaryFactorNode.VariableValue;
-      } else if (factorNode != null) {
+      } else if (node is FactorVariableTreeNode factorNode) {
         return "factor " + factorNode.VariableName;
-      } else if (laggedVarNode != null) {
+      } else if (node is LaggedVariableTreeNode laggedVarNode) {
         return "lagged " + laggedVarNode.VariableName + " " + laggedVarNode.Lag;
       } else {
@@ -1249,29 +1249,29 @@
 
 
-    private static ISymbolicExpressionTreeNode MakeProduct(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
+    private static ISymbolicExpressionTreeNode Product(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+      if (IsNumber(a) && IsNumber(b)) {
         // fold constants
-        return MakeConstant(((ConstantTreeNode)a).Value * ((ConstantTreeNode)b).Value);
-      } else if (IsConstant(a)) {
+        return Number(((NumberTreeNode)a).Value * ((NumberTreeNode)b).Value);
+      } else if (IsNumber(a)) {
         // a * $ => $ * a
-        return MakeProduct(b, a);
+        return Product(b, a);
       } else if (IsFactor(a) && IsFactor(b) && AreSameTypeAndVariable(a, b)) {
         var node0 = a as FactorVariableTreeNode;
         var node1 = b as FactorVariableTreeNode;
-        return MakeFactor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => u * v));
+        return Factor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => u * v));
       } else if (IsBinFactor(a) && IsBinFactor(b) && AreSameTypeAndVariable(a, b)) {
         var node0 = a as BinaryFactorVariableTreeNode;
         var node1 = b as BinaryFactorVariableTreeNode;
-        return MakeBinFactor(node0.Symbol, node0.VariableName, node0.VariableValue, node0.Weight * node1.Weight);
-      } else if (IsFactor(a) && IsConstant(b)) {
+        return BinFactor(node0.Symbol, node0.VariableName, node0.VariableValue, node0.Weight * node1.Weight);
+      } else if (IsFactor(a) && IsNumber(b)) {
         var node0 = a as FactorVariableTreeNode;
-        var node1 = b as ConstantTreeNode;
-        return MakeFactor(node0.Symbol, node0.VariableName, node0.Weights.Select(w => w * node1.Value));
-      } else if (IsBinFactor(a) && IsConstant(b)) {
+        var node1 = b as NumberTreeNode;
+        return Factor(node0.Symbol, node0.VariableName, node0.Weights.Select(w => w * node1.Value));
+      } else if (IsBinFactor(a) && IsNumber(b)) {
         var node0 = a as BinaryFactorVariableTreeNode;
-        var node1 = b as ConstantTreeNode;
-        return MakeBinFactor(node0.Symbol, node0.VariableName, node0.VariableValue, node0.Weight * node1.Value);
+        var node1 = b as NumberTreeNode;
+        return BinFactor(node0.Symbol, node0.VariableName, node0.VariableValue, node0.Weight * node1.Value);
       } else if (IsBinFactor(a) && IsFactor(b)) {
-        return MakeProduct(b, a);
+        return Product(b, a);
       } else if (IsFactor(a) && IsBinFactor(b) &&
         ((IVariableTreeNode)a).VariableName == ((IVariableTreeNode)b).VariableName) {
@@ -1281,28 +1281,28 @@
         var wi = Array.IndexOf(varValues, node1.VariableValue);
         if (wi < 0) throw new ArgumentException();
-        return MakeBinFactor(node1.Symbol, node1.VariableName, node1.VariableValue, node1.Weight * node0.Weights[wi]);
-      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value == 1.0) {
+        return BinFactor(node1.Symbol, node1.VariableName, node1.VariableValue, node1.Weight * node0.Weights[wi]);
+      } else if (IsNumber(b) && ((NumberTreeNode)b).Value == 1.0) {
         // $ * 1.0 => $
         return a;
-      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value == 0.0) {
-        return MakeConstant(0);
-      } else if (IsConstant(b) && IsVariableBase(a)) {
+      } else if (IsNumber(b) && ((NumberTreeNode)b).Value == 0.0) {
+        return Number(0);
+      } else if (IsNumber(b) && IsVariableBase(a)) {
         // multiply constants into variables weights
-        ((VariableTreeNodeBase)a).Weight *= ((ConstantTreeNode)b).Value;
+        ((VariableTreeNodeBase)a).Weight *= ((NumberTreeNode)b).Value;
         return a;
-      } else if (IsConstant(b) && IsAddition(a) ||
+      } else if (IsNumber(b) && IsAddition(a) ||
           IsFactor(b) && IsAddition(a) ||
           IsBinFactor(b) && IsAddition(a)) {
-        // multiply constants into additions
-        return a.Subtrees.Select(x => MakeProduct(GetSimplifiedTree(x), GetSimplifiedTree(b))).Aggregate((c, d) => MakeSum(c, d));
+        // multiply numbers into additions
+        return a.Subtrees.Select(x => Product(GetSimplifiedTree(x), GetSimplifiedTree(b))).Aggregate((c, d) => Sum(c, d));
       } else if (IsDivision(a) && IsDivision(b)) {
         // (a1 / a2) * (b1 / b2) => (a1 * b1) / (a2 * b2)
-        return MakeFraction(MakeProduct(a.GetSubtree(0), b.GetSubtree(0)), MakeProduct(a.GetSubtree(1), b.GetSubtree(1)));
+        return Fraction(Product(a.GetSubtree(0), b.GetSubtree(0)), Product(a.GetSubtree(1), b.GetSubtree(1)));
       } else if (IsDivision(a)) {
         // (a1 / a2) * b => (a1 * b) / a2
-        return MakeFraction(MakeProduct(a.GetSubtree(0), b), a.GetSubtree(1));
+        return Fraction(Product(a.GetSubtree(0), b), a.GetSubtree(1));
       } else if (IsDivision(b)) {
         // a * (b1 / b2) => (b1 * a) / b2
-        return MakeFraction(MakeProduct(b.GetSubtree(0), a), b.GetSubtree(1));
+        return Fraction(Product(b.GetSubtree(0), a), b.GetSubtree(1));
       } else if (IsMultiplication(a) && IsMultiplication(b)) {
         // merge multiplications (make sure constants are merged)
@@ -1313,5 +1313,5 @@
         return mul;
       } else if (IsMultiplication(b)) {
-        return MakeProduct(b, a);
+        return Product(b, a);
       } else if (IsMultiplication(a)) {
         // a is already an multiplication => append b
@@ -1320,18 +1320,18 @@
         return a;
       } else if (IsAbsolute(a) && IsAbsolute(b)) {
-        return MakeAbs(MakeProduct(a.GetSubtree(0), b.GetSubtree(0)));
-      } else if (IsAbsolute(a) && IsConstant(b)) {
-        var constNode = b as ConstantTreeNode;
-        var posF = Math.Abs(constNode.Value);
-        if (constNode.Value > 0) {
-          return MakeAbs(MakeProduct(a.GetSubtree(0), MakeConstant(posF)));
+        return Abs(Product(a.GetSubtree(0), b.GetSubtree(0)));
+      } else if (IsAbsolute(a) && IsNumber(b)) {
+        var bNode = b as NumberTreeNode;
+        var posF = Math.Abs(bNode.Value);
+        if (bNode.Value > 0) {
+          return Abs(Product(a.GetSubtree(0), Number(posF)));
         } else {
           var mul = mulSymbol.CreateTreeNode();
-          mul.AddSubtree(MakeAbs(MakeProduct(a.GetSubtree(0), MakeConstant(posF))));
-          mul.AddSubtree(MakeConstant(-1.0));
+          mul.AddSubtree(Abs(Product(a.GetSubtree(0), Number(posF))));
+          mul.AddSubtree(Number(-1.0));
           return mul;
         }
       } else if (IsAnalyticalQuotient(a)) {
-        return MakeAnalyticalQuotient(MakeProduct(a.GetSubtree(0), b), a.GetSubtree(1));
+        return AQ(Product(a.GetSubtree(0), b), a.GetSubtree(1));
       } else {
         var mul = mulSymbol.CreateTreeNode();
@@ -1355,15 +1355,12 @@
 
     private static ISymbolicExpressionTreeNode AddLagToDynamicNodes(ISymbolicExpressionTreeNode node, int lag) {
-      var laggedTreeNode = node as ILaggedTreeNode;
-      var variableNode = node as VariableTreeNode;
-      var variableConditionNode = node as VariableConditionTreeNode;
-      if (laggedTreeNode != null)
+      if (node is ILaggedTreeNode laggedTreeNode)
         laggedTreeNode.Lag += lag;
-      else if (variableNode != null) {
+      else if (node is VariableTreeNode variableNode) {
         var laggedVariableNode = (LaggedVariableTreeNode)laggedVariableSymbol.CreateTreeNode();
         laggedVariableNode.Lag = lag;
         laggedVariableNode.VariableName = variableNode.VariableName;
         return laggedVariableNode;
-      } else if (variableConditionNode != null) {
+      } else if (node is VariableConditionTreeNode) {
         throw new NotSupportedException("Removal of time lags around variable condition symbols is not allowed.");
       }
@@ -1389,13 +1386,13 @@
                             orderby g.Count()
                             select g;
-      var constantProduct = (from node in subtrees.OfType<VariableTreeNodeBase>()
-                             select node.Weight)
-        .Concat(from node in subtrees.OfType<ConstantTreeNode>()
-                select node.Value)
-        .DefaultIfEmpty(1.0)
-        .Aggregate((c1, c2) => c1 * c2);
+      var numberProduct = (from node in subtrees.OfType<VariableTreeNodeBase>()
+                           select node.Weight)
+                          .Concat(from node in subtrees.OfType<NumberTreeNode>()
+                                  select node.Value)
+                          .DefaultIfEmpty(1.0)
+                          .Aggregate((c1, c2) => c1 * c2);
 
       var unchangedSubtrees = from tree in subtrees
-                              where tree.SubtreeCount > 0 || !(tree is IVariableTreeNode) && !(tree is ConstantTreeNode)
+                              where tree.SubtreeCount > 0 || !(tree is IVariableTreeNode) && !(tree is NumberTreeNode)
                               select tree;
 
@@ -1422,7 +1419,7 @@
           }
           for (int j = 0; j < representative.Weights.Length; j++) {
-            representative.Weights[j] *= constantProduct;
+            representative.Weights[j] *= numberProduct;
           }
-          constantProduct = 1.0;
+          numberProduct = 1.0;
           // if the product already contains a factor it is not necessary to multiply a constant below
           prod.AddSubtree(representative);
@@ -1433,6 +1430,6 @@
         prod.AddSubtree(unchangedSubtree);
 
-      if (constantProduct != 1.0) {
-        prod.AddSubtree(MakeConstant(constantProduct));
+      if (numberProduct != 1.0) {
+        prod.AddSubtree(Number(numberProduct));
       }
     }
@@ -1446,6 +1443,6 @@
     /// <returns>-x</returns>
     private static ISymbolicExpressionTreeNode Negate(ISymbolicExpressionTreeNode x) {
-      if (IsConstant(x)) {
-        ((ConstantTreeNode)x).Value *= -1;
+      if (IsNumber(x)) {
+        ((NumberTreeNode)x).Value *= -1;
       } else if (IsVariableBase(x)) {
         var variableTree = (VariableTreeNodeBase)x;
@@ -1471,5 +1468,5 @@
       } else {
         // any other function
-        return MakeProduct(x, MakeConstant(-1));
+        return Product(x, Number(-1));
       }
       return x;
@@ -1483,24 +1480,24 @@
     /// <returns></returns>
     private static ISymbolicExpressionTreeNode Invert(ISymbolicExpressionTreeNode x) {
-      if (IsConstant(x)) {
-        return MakeConstant(1.0 / ((ConstantTreeNode)x).Value);
+      if (IsNumber(x)) {
+        return Number(1.0 / ((NumberTreeNode)x).Value);
       } else if (IsFactor(x)) {
         var factorNode = (FactorVariableTreeNode)x;
-        return MakeFactor(factorNode.Symbol, factorNode.VariableName, factorNode.Weights.Select(w => 1.0 / w));
+        return Factor(factorNode.Symbol, factorNode.VariableName, factorNode.Weights.Select(w => 1.0 / w));
       } else if (IsDivision(x)) {
-        return MakeFraction(x.GetSubtree(1), x.GetSubtree(0));
+        return Fraction(x.GetSubtree(1), x.GetSubtree(0));
       } else {
         // any other function
-        return MakeFraction(MakeConstant(1), x);
-      }
-    }
-
-    private static ISymbolicExpressionTreeNode MakeConstant(double value) {
-      ConstantTreeNode constantTreeNode = (ConstantTreeNode)(constSymbol.CreateTreeNode());
-      constantTreeNode.Value = value;
-      return constantTreeNode;
-    }
-
-    private static ISymbolicExpressionTreeNode MakeFactor(FactorVariable sy, string variableName, IEnumerable<double> weights) {
+        return Fraction(Number(1), x);
+      }
+    }
+
+    private static ISymbolicExpressionTreeNode Number(double value) {
+      var numberTreeNode = (NumberTreeNode)numberSymbol.CreateTreeNode();
+      numberTreeNode.Value = value;
+      return numberTreeNode;
+    }
+
+    private static ISymbolicExpressionTreeNode Factor(FactorVariable sy, string variableName, IEnumerable<double> weights) {
       var tree = (FactorVariableTreeNode)sy.CreateTreeNode();
       tree.VariableName = variableName;
@@ -1508,5 +1505,5 @@
       return tree;
     }
-    private static ISymbolicExpressionTreeNode MakeBinFactor(BinaryFactorVariable sy, string variableName, string variableValue, double weight) {
+    private static ISymbolicExpressionTreeNode BinFactor(BinaryFactorVariable sy, string variableName, string variableValue, double weight) {
       var tree = (BinaryFactorVariableTreeNode)sy.CreateTreeNode();
       tree.VariableName = variableName;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs	(revision 18132)
@@ -102,5 +102,5 @@
 
     public static bool TryConvertToAutoDiff(ISymbolicExpressionTree tree, bool makeVariableWeightsVariable, bool addLinearScalingTerms,
-      out List<DataForVariable> parameters, out double[] initialConstants,
+      out List<DataForVariable> parameters, out double[] initialParamValues,
       out ParametricFunction func,
       out ParametricFunctionGradient func_grad) {
@@ -115,5 +115,5 @@
           parameterEntries.Select(kvp => kvp.Value).ToArray());
         parameters = new List<DataForVariable>(parameterEntries.Select(kvp => kvp.Key));
-        initialConstants = transformator.initialConstants.ToArray();
+        initialParamValues = transformator.initialParamValues.ToArray();
         func = (vars, @params) => compiledTerm.Evaluate(vars, @params);
         func_grad = (vars, @params) => compiledTerm.Differentiate(vars, @params);
@@ -123,5 +123,5 @@
         func_grad = null;
         parameters = null;
-        initialConstants = null;
+        initialParamValues = null;
       }
       return false;
@@ -129,6 +129,5 @@
 
     // state for recursive transformation of trees 
-    private readonly
-    List<double> initialConstants;
+    private readonly List<double> initialParamValues;
     private readonly Dictionary<DataForVariable, AutoDiff.Variable> parameters;
     private readonly List<AutoDiff.Variable> variables;
@@ -139,5 +138,5 @@
       this.makeVariableWeightsVariable = makeVariableWeightsVariable;
       this.addLinearScalingTerms = addLinearScalingTerms;
-      this.initialConstants = new List<double>();
+      this.initialParamValues = new List<double>();
       this.parameters = new Dictionary<DataForVariable, AutoDiff.Variable>();
       this.variables = new List<AutoDiff.Variable>();
@@ -145,9 +144,13 @@
 
     private AutoDiff.Term ConvertToAutoDiff(ISymbolicExpressionTreeNode node) {
-      if (node.Symbol is Constant) {
-        initialConstants.Add(((ConstantTreeNode)node).Value);
+      if (node.Symbol is Number) {
+        initialParamValues.Add(((NumberTreeNode)node).Value);
         var var = new AutoDiff.Variable();
         variables.Add(var);
         return var;
+      }
+      if (node.Symbol is Constant) {
+        // constants are fixed in autodiff
+        return (node as ConstantTreeNode).Value;
       }
       if (node.Symbol is Variable || node.Symbol is BinaryFactorVariable) {
@@ -159,5 +162,5 @@
 
         if (makeVariableWeightsVariable) {
-          initialConstants.Add(varNode.Weight);
+          initialParamValues.Add(varNode.Weight);
           var w = new AutoDiff.Variable();
           variables.Add(w);
@@ -173,5 +176,5 @@
           var par = FindOrCreateParameter(parameters, factorVarNode.VariableName, variableValue);
 
-          initialConstants.Add(factorVarNode.GetValue(variableValue));
+          initialParamValues.Add(factorVarNode.GetValue(variableValue));
           var wVar = new AutoDiff.Variable();
           variables.Add(wVar);
@@ -186,5 +189,5 @@
 
         if (makeVariableWeightsVariable) {
-          initialConstants.Add(varNode.Weight);
+          initialParamValues.Add(varNode.Weight);
           var w = new AutoDiff.Variable();
           variables.Add(w);
@@ -260,7 +263,7 @@
       }
       if (node.Symbol is Power) {
-        var powerNode = node.GetSubtree(1) as ConstantTreeNode;
+        var powerNode = node.GetSubtree(1) as INumericTreeNode;
         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.");
+          throw new NotSupportedException("Only numeric powers are allowed in parameter optimization. Try to use exp() and log() instead of the power symbol.");
         var intPower = Math.Truncate(powerNode.Value);
         if (intPower != powerNode.Value)
@@ -313,6 +316,5 @@
       var data = new DataForVariable(varName, varValue, lag);
 
-      AutoDiff.Variable par = null;
-      if (!parameters.TryGetValue(data, out par)) {
+      if (!parameters.TryGetValue(data, out AutoDiff.Variable par)) {
         // not found -> create new parameter and entries in names and values lists
         par = new AutoDiff.Variable();
@@ -330,4 +332,5 @@
           !(n.Symbol is FactorVariable) &&
           !(n.Symbol is LaggedVariable) &&
+          !(n.Symbol is Number) &&
           !(n.Symbol is Constant) &&
           !(n.Symbol is Addition) &&
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs	(revision 18132)
@@ -33,5 +33,5 @@
   public static class BaseInfixExpressionFormatter {
     public static void FormatRecursively(ISymbolicExpressionTreeNode node, StringBuilder strBuilder,
-                                          NumberFormatInfo numberFormat, string formatString, List<KeyValuePair<string, double>> constants = null) {
+                                          NumberFormatInfo numberFormat, string formatString, List<KeyValuePair<string, double>> parameters = null) {
       if (node.SubtreeCount > 1) {
         var token = GetToken(node.Symbol);
@@ -40,9 +40,9 @@
             token == "*" || token == "/" || token == "AND") {
           strBuilder.Append("(");
-          FormatRecursively(node.Subtrees.First(), strBuilder, numberFormat, formatString, constants);
+          FormatRecursively(node.Subtrees.First(), strBuilder, numberFormat, formatString, parameters);
 
           foreach (var subtree in node.Subtrees.Skip(1)) {
             strBuilder.Append(" ").Append(token).Append(" ");
-            FormatRecursively(subtree, strBuilder, numberFormat, formatString, constants);
+            FormatRecursively(subtree, strBuilder, numberFormat, formatString, parameters);
           }
 
@@ -51,12 +51,12 @@
           // handle integer powers directly
           strBuilder.Append("(");
-          FormatRecursively(node.Subtrees.First(), strBuilder, numberFormat, formatString, constants);
+          FormatRecursively(node.Subtrees.First(), strBuilder, numberFormat, formatString, parameters);
 
           var power = node.GetSubtree(1);
-          if(power is ConstantTreeNode constNode && Math.Truncate(constNode.Value) == constNode.Value) {
-            strBuilder.Append(" ").Append(token).Append(" ").Append(constNode.Value.ToString(formatString, numberFormat));
+          if(power is INumericTreeNode numNode && Math.Truncate(numNode.Value) == numNode.Value) {
+            strBuilder.Append(" ").Append(token).Append(" ").Append(numNode.Value.ToString(formatString, numberFormat));
           } else {
             strBuilder.Append(" ").Append(token).Append(" ");
-            FormatRecursively(power, strBuilder, numberFormat, formatString, constants);
+            FormatRecursively(power, strBuilder, numberFormat, formatString, parameters);
           }
 
@@ -65,8 +65,8 @@
           // function with multiple arguments
           strBuilder.Append(token).Append("(");
-          FormatRecursively(node.Subtrees.First(), strBuilder, numberFormat, formatString, constants);
+          FormatRecursively(node.Subtrees.First(), strBuilder, numberFormat, formatString, parameters);
           foreach (var subtree in node.Subtrees.Skip(1)) {
             strBuilder.Append(", ");
-            FormatRecursively(subtree, strBuilder, numberFormat, formatString, constants);
+            FormatRecursively(subtree, strBuilder, numberFormat, formatString, parameters);
           }
 
@@ -77,15 +77,15 @@
         if (token == "-" || token == "NOT") {
           strBuilder.Append("(").Append(token).Append("(");
-          FormatRecursively(node.GetSubtree(0), strBuilder, numberFormat, formatString, constants);
+          FormatRecursively(node.GetSubtree(0), strBuilder, numberFormat, formatString, parameters);
           strBuilder.Append("))");
         } else if (token == "/") {
           strBuilder.Append("1/");
-          FormatRecursively(node.GetSubtree(0), strBuilder, numberFormat, formatString, constants);
+          FormatRecursively(node.GetSubtree(0), strBuilder, numberFormat, formatString, parameters);
         } else if (token == "+" || token == "*") {
-          FormatRecursively(node.GetSubtree(0), strBuilder, numberFormat, formatString, constants);
+          FormatRecursively(node.GetSubtree(0), strBuilder, numberFormat, formatString, parameters);
         } else {
           // function with only one argument
           strBuilder.Append(token).Append("(");
-          FormatRecursively(node.GetSubtree(0), strBuilder, numberFormat, formatString, constants);
+          FormatRecursively(node.GetSubtree(0), strBuilder, numberFormat, formatString, parameters);
           strBuilder.Append(")");
         }
@@ -96,5 +96,5 @@
           if (!varNode.Weight.IsAlmost(1.0)) {
             strBuilder.Append("(");
-            AppendConstant(strBuilder, constants, varNode.Weight, formatString, numberFormat);
+            AppendNumber(strBuilder, parameters, varNode.Weight, formatString, numberFormat);
             strBuilder.Append("*");
           }
@@ -110,5 +110,5 @@
           if (!varNode.Weight.IsAlmost(1.0)) {
             strBuilder.Append("(");
-            AppendConstant(strBuilder, constants, varNode.Weight, formatString, numberFormat);
+            AppendNumber(strBuilder, parameters, varNode.Weight, formatString, numberFormat);
             strBuilder.Append("*");
           }
@@ -124,5 +124,5 @@
           for (int i = 0; i < factorNode.Weights.Length; i++) {
             if (i > 0) strBuilder.Append(", ");
-            AppendConstant(strBuilder, constants, factorNode.Weights[i], formatString, numberFormat);
+            AppendNumber(strBuilder, parameters, factorNode.Weights[i], formatString, numberFormat);
           }
           strBuilder.Append("]");
@@ -131,5 +131,5 @@
           if (!factorNode.Weight.IsAlmost(1.0)) {
             strBuilder.Append("(");
-            AppendConstant(strBuilder, constants, factorNode.Weight, formatString, numberFormat);
+            AppendNumber(strBuilder, parameters, factorNode.Weight, formatString, numberFormat);
 
             strBuilder.Append("*");
@@ -141,11 +141,11 @@
 
           if (!factorNode.Weight.IsAlmost(1.0)) strBuilder.Append(")");
-        } else if (node.Symbol is Constant) {
-          var constNode = node as ConstantTreeNode;
-          if (constants == null && constNode.Value < 0) {
-            strBuilder.Append("(").Append(constNode.Value.ToString(formatString, numberFormat))
-                      .Append(")"); // (-1
+        } else if (node is INumericTreeNode numNode) {
+          if (parameters == null && numNode.Value < 0) {
+            // negative value
+            strBuilder.Append("(").Append(numNode.Value.ToString(formatString, numberFormat))
+                      .Append(")"); 
           } else {
-            AppendConstant(strBuilder, constants, constNode.Value, formatString, numberFormat);
+            AppendNumber(strBuilder, parameters, numNode.Value, formatString, numberFormat);
           }
         }
@@ -153,9 +153,9 @@
     }
 
-    private static void AppendConstant(StringBuilder strBuilder, List<KeyValuePair<string, double>> constants, double value, string formatString, NumberFormatInfo numberFormat) {
-      if (constants != null) {
-        string constantKey = $"c_{constants.Count}";
-        strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", constantKey);
-        constants.Add(new KeyValuePair<string, double>(constantKey, value));
+    private static void AppendNumber(StringBuilder strBuilder, List<KeyValuePair<string, double>> parameters, double value, string formatString, NumberFormatInfo numberFormat) {
+      if (parameters != null) {
+        string paramKey = $"c_{parameters.Count}";
+        strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", paramKey);
+        parameters.Add(new KeyValuePair<string, double>(paramKey, value));
       } else {
         strBuilder.Append(value.ToString(formatString, numberFormat));
@@ -204,6 +204,6 @@
     /// </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="formatString">The format string for numeric parameters (e.g. \"G4\" to limit to 4 digits, default is \"G\")</param>
+    /// <param name="numberFormat">Number format that should be used for parameters (e.g. NumberFormatInfo.InvariantInfo (default)).</param>
+    /// <param name="formatString">The format string for parameters (e.g. \"G4\" to limit to 4 digits, default is \"G\")</param>
     /// <returns>Infix expression</returns>
     public string Format(ISymbolicExpressionTree symbolicExpressionTree, NumberFormatInfo numberFormat,
@@ -241,15 +241,15 @@
     public string Format(ISymbolicExpressionTree symbolicExpressionTree) {
       StringBuilder strBuilder = new StringBuilder();
-      var constants = new List<KeyValuePair<string, double>>();
+      var parameters = new List<KeyValuePair<string, double>>();
       BaseInfixExpressionFormatter.FormatRecursively(symbolicExpressionTree.Root.GetSubtree(0).GetSubtree(0),
-        strBuilder, NumberFormatInfo.InvariantInfo, "G", constants);
+        strBuilder, NumberFormatInfo.InvariantInfo, "G", parameters);
       strBuilder.Append($"{Environment.NewLine}{Environment.NewLine}");
 
-      int maxDigits = GetDigits(constants.Count);
-      int padding = constants.Max(x => x.Value.ToString("F12", CultureInfo.InvariantCulture).Length);
-      foreach (var constant in constants) {
-        int digits = GetDigits(Int32.Parse(constant.Key.Substring(2)));
-        strBuilder.Append($"{constant.Key}{new String(' ', maxDigits - digits)} = " +
-                          string.Format($"{{0,{padding}:F12}}", constant.Value, CultureInfo.InvariantCulture) +
+      int maxDigits = GetDigits(parameters.Count);
+      int padding = parameters.Max(x => x.Value.ToString("F12", CultureInfo.InvariantCulture).Length);
+      foreach (var param in parameters) {
+        int digits = GetDigits(int.Parse(param.Key.Substring(2)));
+        strBuilder.Append($"{param.Key}{new string(' ', maxDigits - digits)} = " +
+                          string.Format($"{{0,{padding}:F12}}", param.Value, CultureInfo.InvariantCulture) +
                           Environment.NewLine);
       }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs	(revision 18132)
@@ -162,7 +162,6 @@
           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;
@@ -311,7 +310,7 @@
 
     private void GenerateFactorSource(StringBuilder strBuilder) {
-      strBuilder.AppendLine("private static double EvaluateFactor(string factorValue, string[] factorValues, double[] constants) {");
+      strBuilder.AppendLine("private static double EvaluateFactor(string factorValue, string[] factorValues, double[] parameters) {");
       strBuilder.AppendLine("   for(int i=0;i<factorValues.Length;i++) " +
-                            "      if(factorValues[i] == factorValue) return constants[i];" +
+                            "      if(factorValues[i] == factorValue) return parameters[i];" +
                             "   throw new ArgumentException();");
       strBuilder.AppendLine("}");
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs	(revision 18132)
@@ -47,10 +47,10 @@
     private string GetExcelColumnName(int columnNumber) {
       int dividend = columnNumber;
-      string columnName = String.Empty;
+      string columnName = string.Empty;
 
       while (dividend > 0) {
         int modulo = (dividend - 1) % 26;
         columnName = System.Convert.ToChar(65 + modulo) + columnName;
-        dividend = (int)((dividend - modulo) / 26);
+        dividend = (dividend - modulo) / 26;
       }
 
@@ -134,7 +134,7 @@
         }
         stringBuilder.Append("))");
-      } else if (symbol is Constant) {
-        ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
-        stringBuilder.Append(constantTreeNode.Value.ToString(CultureInfo.InvariantCulture));
+      } else if (symbol is INumericSymbol numSy) {
+        var numTreeNode = node as INumericTreeNode;
+        stringBuilder.Append(numTreeNode.Value.ToString(CultureInfo.InvariantCulture));
       } else if (symbol is Cosine) {
         stringBuilder.Append("COS(");
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs	(revision 18132)
@@ -33,6 +33,6 @@
   [StorableType("D7186DFF-1596-4A58-B27D-974DF0D93E4F")]
   public sealed class SymbolicDataAnalysisExpressionLatexFormatter : NamedItem, ISymbolicExpressionTreeStringFormatter {
-    private readonly List<KeyValuePair<string, double>> constants;
-    private int constIndex;
+    private readonly List<KeyValuePair<string, double>> parameters;
+    private int paramIdx;
     private int targetCount;
     private int currentLag;
@@ -44,6 +44,6 @@
     private SymbolicDataAnalysisExpressionLatexFormatter(SymbolicDataAnalysisExpressionLatexFormatter original, Cloner cloner)
       : base(original, cloner) {
-      constants = new List<KeyValuePair<string, double>>(original.constants);
-      constIndex = original.constIndex;
+      parameters = new List<KeyValuePair<string, double>>(original.parameters);
+      paramIdx = original.paramIdx;
       currentLag = original.currentLag;
       targetCount = original.targetCount;
@@ -53,5 +53,5 @@
       Name = ItemName;
       Description = ItemDescription;
-      constants = new List<KeyValuePair<string, double>>();
+      parameters = new List<KeyValuePair<string, double>>();
     }
 
@@ -66,6 +66,6 @@
       try {
         StringBuilder strBuilder = new StringBuilder();
-        constants.Clear();
-        constIndex = 0;
+        parameters.Clear();
+        paramIdx = 0;
         this.targetVariable = targetVariable;
         containsTimeSeriesSymbol = symbolicExpressionTree.IterateNodesBreadth().Any(n => IsTimeSeriesSymbol(n.Symbol));
@@ -189,31 +189,30 @@
       } else if (node.Symbol is IfThenElse) {
         strBuilder.Append(@" \operatorname{if}  \left( ");
-      } else if (node.Symbol is Constant) {
-        var constName = "c_{" + constIndex + "}";
-        constIndex++;
-        var constNode = node as ConstantTreeNode;
-        if (constNode.Value.IsAlmost(1.0)) {
+      } else if (node.Symbol is INumericSymbol numSy) {
+        var numName = "c_{" + paramIdx + "}";
+        paramIdx++;
+        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);
+          parameters.Add(new KeyValuePair<string, double>(numName, numericNode.Value));
+        }
       } else if (node.Symbol is FactorVariable) {
         var factorNode = node as FactorVariableTreeNode;
-        var constName = "c_{" + constIndex + "}";
-        strBuilder.Append(constName + " ");
+        var paramName = "c_{" + paramIdx + "}";
+        strBuilder.Append(paramName + " ");
         foreach (var e in factorNode.Symbol.GetVariableValues(factorNode.VariableName)
           .Zip(factorNode.Weights, Tuple.Create)) {
-          constants.Add(new KeyValuePair<string, double>("c_{" + constIndex + ", " + EscapeLatexString(factorNode.VariableName) + "=" + EscapeLatexString(e.Item1) + "}", e.Item2));
-        }
-        constIndex++;
+          parameters.Add(new KeyValuePair<string, double>("c_{" + paramIdx + ", " + EscapeLatexString(factorNode.VariableName) + "=" + EscapeLatexString(e.Item1) + "}", e.Item2));
+        }
+        paramIdx++;
       } else if (node.Symbol is BinaryFactorVariable) {
         var binFactorNode = node as BinaryFactorVariableTreeNode;
         if (!binFactorNode.Weight.IsAlmost((1.0))) {
-          var constName = "c_{" + constIndex + "}";
-          strBuilder.Append(constName + "  \\cdot");
-          constants.Add(new KeyValuePair<string, double>(constName, binFactorNode.Weight));
-          constIndex++;
+          var paramName = "c_{" + paramIdx + "}";
+          strBuilder.Append(paramName + "  \\cdot");
+          parameters.Add(new KeyValuePair<string, double>(paramName, binFactorNode.Weight));
+          paramIdx++;
         }
         strBuilder.Append("(" + EscapeLatexString(binFactorNode.VariableName));
@@ -223,8 +222,8 @@
         var laggedVarNode = node as LaggedVariableTreeNode;
         if (!laggedVarNode.Weight.IsAlmost(1.0)) {
-          var constName = "c_{" + constIndex + "}";
-          strBuilder.Append(constName + "  \\cdot");
-          constants.Add(new KeyValuePair<string, double>(constName, laggedVarNode.Weight));
-          constIndex++;
+          var paramName = "c_{" + paramIdx + "}";
+          strBuilder.Append(paramName + "  \\cdot");
+          parameters.Add(new KeyValuePair<string, double>(paramName, laggedVarNode.Weight));
+          paramIdx++;
         }
         strBuilder.Append(EscapeLatexString(laggedVarNode.VariableName));
@@ -234,8 +233,8 @@
         var varNode = node as VariableTreeNode;
         if (!varNode.Weight.IsAlmost((1.0))) {
-          var constName = "c_{" + constIndex + "}";
-          strBuilder.Append(constName + "  \\cdot");
-          constants.Add(new KeyValuePair<string, double>(constName, varNode.Weight));
-          constIndex++;
+          var paramName = "c_{" + paramIdx + "}";
+          strBuilder.Append(paramName + "  \\cdot");
+          parameters.Add(new KeyValuePair<string, double>(paramName, varNode.Weight));
+          paramIdx++;
         }
         strBuilder.Append(EscapeLatexString(varNode.VariableName));
@@ -271,12 +270,12 @@
       } else if (node.Symbol is VariableCondition) {
         var conditionTreeNode = node as VariableConditionTreeNode;
-        var constName = "c_{" + constants.Count + "}";
-        string p = @"1 /  1 + \exp  - " + constName + " ";
-        constants.Add(new KeyValuePair<string, double>(constName, conditionTreeNode.Slope));
-        constIndex++;
-        var const2Name = "c_{" + constants.Count + @"}";
+        var paramName = "c_{" + parameters.Count + "}";
+        string p = @"1 /  1 + \exp  - " + paramName + " ";
+        parameters.Add(new KeyValuePair<string, double>(paramName, conditionTreeNode.Slope));
+        paramIdx++;
+        var const2Name = "c_{" + parameters.Count + @"}";
         p += @" \cdot " + EscapeLatexString(conditionTreeNode.VariableName) + LagToString(currentLag) + " - " + const2Name + "   ";
-        constants.Add(new KeyValuePair<string, double>(const2Name, conditionTreeNode.Threshold));
-        constIndex++;
+        parameters.Add(new KeyValuePair<string, double>(const2Name, conditionTreeNode.Threshold));
+        paramIdx++;
         strBuilder.Append(@" \left( " + p + @"\cdot ");
       } else {
@@ -379,12 +378,12 @@
       } else if (node.Symbol is VariableCondition) {
         var conditionTreeNode = node as VariableConditionTreeNode;
-        var const1Name = "c_{" + constants.Count + "}";
+        var const1Name = "c_{" + parameters.Count + "}";
         string p = @"1 / \left( 1 + \exp \left( - " + const1Name + " ";
-        constants.Add(new KeyValuePair<string, double>(const1Name, conditionTreeNode.Slope));
-        constIndex++;
-        var const2Name = "c_{" + constants.Count + "}";
+        parameters.Add(new KeyValuePair<string, double>(const1Name, conditionTreeNode.Slope));
+        paramIdx++;
+        var const2Name = "c_{" + parameters.Count + "}";
         p += @" \cdot " + EscapeLatexString(conditionTreeNode.VariableName) + LagToString(currentLag) + " - " + const2Name + " \right) \right) \right)   ";
-        constants.Add(new KeyValuePair<string, double>(const2Name, conditionTreeNode.Threshold));
-        constIndex++;
+        parameters.Add(new KeyValuePair<string, double>(const2Name, conditionTreeNode.Threshold));
+        paramIdx++;
         strBuilder.Append(@" +  \left( 1 - " + p + @" \right) \cdot ");
       } else {
@@ -471,4 +470,5 @@
       } 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) {
@@ -481,12 +481,12 @@
           .AppendLine("\\begin{align*}")
           .AppendLine("\\nonumber");
-        // output all constant values
-        if (constants.Count > 0) {
-          foreach (var constant in constants) {
+        // output all parameter values
+        if (parameters.Count > 0) {
+          foreach (var param in parameters) {
             // replace "." with ".&" to align decimal points
-            var constStr = string.Format(System.Globalization.NumberFormatInfo.InvariantInfo, "{0:G5}", constant.Value);
-            if (!constStr.Contains(".")) constStr = constStr + ".0";
-            constStr = constStr.Replace(".", "&.");  // fix problem in rendering of aligned expressions
-            strBuilder.Append(constant.Key + "& = & " + constStr);
+            var paramStr = string.Format(System.Globalization.NumberFormatInfo.InvariantInfo, "{0:G5}", param.Value);
+            if (!paramStr.Contains(".")) paramStr = paramStr + ".0";
+            paramStr = paramStr.Replace(".", "&.");  // fix problem in rendering of aligned expressions
+            strBuilder.Append(param.Key + "& = & " + paramStr);
             strBuilder.Append(@"\\");
           }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs	(revision 18132)
@@ -151,7 +151,7 @@
         }
         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(");
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs	(revision 18132)
@@ -130,7 +130,7 @@
           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;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionPythonFormatter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionPythonFormatter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionPythonFormatter.cs	(revision 18132)
@@ -202,6 +202,6 @@
       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,7 +227,11 @@
     }
 
-    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;
+      if (node is INumericTreeNode numNode) {
+        strBuilder.Append(numNode.Value.ToString("g17", CultureInfo.InvariantCulture));
+      } else {
+        throw new NotSupportedException("Formatting of symbol: " + symbol + " not supported for Python symbolic expression tree formatter.");
+      }
     }
 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs	(revision 18132)
@@ -83,7 +83,7 @@
         }
         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(FormatRecursively(node.GetSubtree(0)));
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/TSQLExpressionFormatter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/TSQLExpressionFormatter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/TSQLExpressionFormatter.cs	(revision 18132)
@@ -93,8 +93,8 @@
       //Generate function header
       strBuilder.Append("CREATE FUNCTION dbo.REGRESSIONMODEL(");
-      strBuilder.Append(string.Join(", ", sortedVarcharIdentifiers.Select(n => string.Format("{0} NVARCHAR(max)",n))));
+      strBuilder.Append(string.Join(", ", sortedVarcharIdentifiers.Select(n => string.Format("{0} NVARCHAR(max)", n))));
       if (varcharVarNames.Any() && floatVarNames.Any())
         strBuilder.Append(",");
-      strBuilder.Append(string.Join(", ", sortedFloatIdentifiers.Select(n => string.Format("{0} FLOAT",n))));
+      strBuilder.Append(string.Join(", ", sortedFloatIdentifiers.Select(n => string.Format("{0} FLOAT", n))));
       strBuilder.AppendLine(")");
 
@@ -164,7 +164,6 @@
           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;
@@ -181,7 +180,7 @@
     private void FormatIfThenElse(int level, ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
       strBuilder.Append("CASE ISNULL((SELECT 1 WHERE");
-      FormatRecursively(level,node.GetSubtree(0), strBuilder);
+      FormatRecursively(level, node.GetSubtree(0), strBuilder);
       strBuilder.AppendLine("),0)");
-      strBuilder.AppendIndented(level,"WHEN 1 THEN ");
+      strBuilder.AppendIndented(level, "WHEN 1 THEN ");
       FormatRecursively(level, node.GetSubtree(1), strBuilder);
       strBuilder.AppendLine();
@@ -203,5 +202,5 @@
 
     private string VariableName2Identifier(string variableName) {
-      return "@"+variableName.Replace(' ', '_');
+      return "@" + variableName.Replace(' ', '_');
     }
 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/ArithmeticExpressionGrammar.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/ArithmeticExpressionGrammar.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/ArithmeticExpressionGrammar.cs	(revision 18132)
@@ -49,12 +49,14 @@
       var mul = new Multiplication();
       var div = new Division();
+      var number = new Number();
+      number.MinValue = -20;
+      number.MaxValue = 20;
       var constant = new Constant();
-      constant.MinValue = -20;
-      constant.MaxValue = 20;
+      constant.Enabled = false;
       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, 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 };
 
@@ -65,4 +67,5 @@
         SetSubtreeCount(funSymb, 1, 3);
       }
+      SetSubtreeCount(number, 0, 0);
       SetSubtreeCount(constant, 0, 0);
       SetSubtreeCount(variableSymbol, 0, 0);
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs	(revision 18132)
@@ -118,7 +118,7 @@
       variableCondition.InitialFrequency = 0.0;
 
-      var constant = new Constant();
-      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,7 +130,10 @@
       autoregressiveVariable.Enabled = false;
 
+      var constant = new Constant();
+      constant.Enabled = false;
+
       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, 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
@@ -139,5 +142,5 @@
       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, laggedVariable, autoregressiveVariable };
+      var terminalSymbols = new List<Symbol>() { variableSymbol, binFactorVariable, factorVariable, number, constant, laggedVariable, autoregressiveVariable };
 
       foreach (var symb in allSymbols)
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/LinearScalingGrammar.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/LinearScalingGrammar.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/LinearScalingGrammar.cs	(revision 18132)
@@ -66,7 +66,9 @@
       var abs = new Absolute();
       var aq = new AnalyticQuotient();
+      var number = new Number();
+      number.MinValue = -20;
+      number.MaxValue = 20;
       var constant = new Constant();
-      constant.MinValue = -20;
-      constant.MaxValue = 20;
+      constant.Enabled = false;
       var variableSymbol = new Variable();
 
@@ -78,5 +80,5 @@
       //all other symbols
       var allSymbols = new List<Symbol> {
-        add, sub, mul, div, constant, 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
       };
@@ -86,5 +88,5 @@
       var realValueSymbols = new List<Symbol> {
          add, sub, mul, div, sin, cos, tan, tanh, exp, log, aq, abs, square, cube, sqrt, cbrt,
-         variableSymbol, constant,
+         variableSymbol, number, constant
         };
 
@@ -113,9 +115,9 @@
       //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
@@ -129,4 +131,5 @@
       Symbols.First(s => s is CubeRoot).Enabled = false;
       Symbols.First(s => s is Absolute).Enabled = false;
+      Symbols.First(s => s is Constant).Enabled = false;
     }
   }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs	(revision 18132)
@@ -105,7 +105,9 @@
       var derivative = new Derivative();
 
+      var number = new Number();
+      number.MinValue = -20;
+      number.MaxValue = 20;
       var constant = new Constant();
-      constant.MinValue = -20;
-      constant.MaxValue = 20;
+      constant.Enabled = false;
       var variableSymbol = new Variable();
       var binFactorVariable = new BinaryFactorVariable();
@@ -121,5 +123,5 @@
       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, 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 });
 
@@ -193,4 +195,5 @@
       AddAllowedChildSymbol(powerSymbols, laggedVariable, 0);
       AddAllowedChildSymbol(powerSymbols, autoregressiveVariable, 0);
+      AddAllowedChildSymbol(powerSymbols, number, 1);
       AddAllowedChildSymbol(powerSymbols, constant, 1);
 
@@ -249,4 +252,5 @@
       Symbols.First(s => s.Name == ConditionalSymbolsName).Enabled = false;
       Symbols.First(s => s.Name == TimeSeriesSymbolsName).Enabled = false;
+      Symbols.First(s => s is Constant).Enabled = false;
     }
 
@@ -262,4 +266,5 @@
       Symbols.First(s => s.Name == PowerFunctionsName).Enabled = false;
       Symbols.First(s => s.Name == TimeSeriesSymbolsName).Enabled = false;
+      Symbols.First(s => s is Constant).Enabled = false;
     }
 
@@ -278,4 +283,5 @@
       Symbols.First(s => s is Integral).Enabled = false;
       Symbols.First(s => s is TimeLag).Enabled = false;
+      Symbols.First(s => s is Constant).Enabled = false;
     }
   }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/SymbolicExpressionTreeHash.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/SymbolicExpressionTreeHash.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/SymbolicExpressionTreeHash.cs	(revision 18132)
@@ -28,13 +28,5 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   public static class SymbolicExpressionTreeHash {
-    private static readonly Addition add = new Addition();
-    private static readonly Subtraction sub = new Subtraction();
-    private static readonly Multiplication mul = new Multiplication();
-    private static readonly Division div = new Division();
-    private static readonly Logarithm log = new Logarithm();
-    private static readonly Exponential exp = new Exponential();
-    private static readonly Sine sin = new Sine();
-    private static readonly Cosine cos = new Cosine();
-    private static readonly Constant constant = new Constant();
+    private static readonly Number number = new Number();
 
     private static ISymbolicExpressionTreeNode ActualRoot(this ISymbolicExpressionTree tree) => tree.Root.GetSubtree(0).GetSubtree(0);
@@ -66,6 +58,6 @@
       var symbol = node.Symbol;
       var name = symbol.Name;
-      if (node is ConstantTreeNode constantNode) {
-        name = strict ? constantNode.Value.ToString() : symbol.Name;
+      if (node is INumericTreeNode numNode) {
+        name = strict ? numNode.Value.ToString() : "Number";
       } else if (node is VariableTreeNode variableNode) {
         name = strict ? variableNode.Weight.ToString() + variableNode.VariableName : variableNode.VariableName;
@@ -222,7 +214,7 @@
             variableTreeNode.VariableName = variable.VariableName;
             variableTreeNode.Weight = variable.Weight;
-          } else if (node.Data is ConstantTreeNode @const) {
-            var constantTreeNode = (ConstantTreeNode)treeNodes[i];
-            constantTreeNode.Value = @const.Value;
+          } else if (node.Data is INumericTreeNode existingNumNode) {
+            var newNumNode = (INumericTreeNode)treeNodes[i];
+            newNumNode.Value = existingNumNode.Value;
           }
           continue;
@@ -272,5 +264,5 @@
     }
 
-    // simplify multiplications by reducing constants and div terms
+    // simplify multiplications by reducing numbers and div terms
     public static void SimplifyMultiplication(ref HashNode<ISymbolicExpressionTreeNode>[] nodes, int i) {
       var node = nodes[i];
@@ -285,12 +277,12 @@
 
         var symbol = child.Data.Symbol;
-        if (child.Data is ConstantTreeNode firstConst) {
-          // fold sibling constant nodes into the first constant
+        if (child.Data is INumericTreeNode firstNum) {
+          // fold sibling number nodes into the first number
           for (int k = j + 1; k < children.Length; ++k) {
             var sibling = nodes[children[k]];
-            if (sibling.Data is ConstantTreeNode otherConst) {
+            if (sibling.Data is INumericTreeNode otherNum) {
               sibling.Enabled = false;
               node.Arity--;
-              firstConst.Value *= otherConst.Value;
+              firstNum.Value *= otherNum.Value;
             } else {
               break;
@@ -298,11 +290,11 @@
           }
         } else if (child.Data is VariableTreeNode variable) {
-          // fold sibling constant nodes into the variable weight
+          // fold sibling number nodes into the variable weight
           for (int k = j + 1; k < children.Length; ++k) {
             var sibling = nodes[children[k]];
-            if (sibling.Data is ConstantTreeNode constantNode) {
+            if (sibling.Data is INumericTreeNode numNode) {
               sibling.Enabled = false;
               node.Arity--;
-              variable.Weight *= constantNode.Value;
+              variable.Weight *= numNode.Value;
             } else {
               break;
@@ -328,8 +320,8 @@
         }
 
-        if (node.Arity == 0) { // if everything is simplified this node becomes constant
-          var constantTreeNode = constant.CreateTreeNode<ConstantTreeNode>();
-          constantTreeNode.Value = 1;
-          nodes[i] = constantTreeNode.ToHashNode();
+        if (node.Arity == 0) { // if everything is simplified this node becomes a number
+          var numNode = number.CreateTreeNode<NumberTreeNode>();
+          numNode.Value = 1;
+          nodes[i] = numNode.ToHashNode();
         } else if (node.Arity == 1) { // when i have only 1 arg left i can skip this node
           node.Enabled = false;
@@ -344,16 +336,16 @@
       var tmp = nodes;
 
-      if (children.All(x => tmp[x].Data.Symbol is Constant)) {
-        var v = ((ConstantTreeNode)nodes[children.First()].Data).Value;
+      if (children.All(x => tmp[x].Data.Symbol is INumericSymbol)) {
+        var v = ((INumericTreeNode)nodes[children.First()].Data).Value;
         if (node.Arity == 1) {
           v = 1 / v;
         } else if (node.Arity > 1) {
           foreach (var j in children.Skip(1)) {
-            v /= ((ConstantTreeNode)nodes[j].Data).Value;
-          }
-        }
-        var constantTreeNode = constant.CreateTreeNode<ConstantTreeNode>();
-        constantTreeNode.Value = v;
-        nodes[i] = constantTreeNode.ToHashNode();
+            v /= ((INumericTreeNode)nodes[j].Data).Value;
+          }
+        }
+        var numNode = number.CreateTreeNode<NumberTreeNode>();
+        numNode.Value = v;
+        nodes[i] = numNode.ToHashNode();
         return;
       }
@@ -368,7 +360,7 @@
         }
         if (node.Arity == 0) {
-          var constantTreeNode = constant.CreateTreeNode<ConstantTreeNode>();
-          constantTreeNode.Value = 1; // x / x = 1
-          nodes[i] = constantTreeNode.ToHashNode();
+          var numNode = number.CreateTreeNode<NumberTreeNode>();
+          numNode.Value = 1; // x / x = 1
+          nodes[i] = numNode.ToHashNode();
         }
       }
@@ -376,5 +368,5 @@
 
     public static void SimplifyUnaryNode(ref HashNode<ISymbolicExpressionTreeNode>[] nodes, int i) {
-      // check if the child of the unary node is a constant, then the whole node can be simplified
+      // check if the child of the unary node is a number, then the whole node can be simplified
       var parent = nodes[i];
       var child = nodes[i - 1];
@@ -383,5 +375,5 @@
       var childSymbol = child.Data.Symbol;
 
-      if (childSymbol is Constant) {
+      if (childSymbol is INumericSymbol) {
         nodes[i].Enabled = false;
       } else if ((parentSymbol is Exponential && childSymbol is Logarithm) || (parentSymbol is Logarithm && childSymbol is Exponential)) {
@@ -393,9 +385,9 @@
       var children = nodes.IterateChildren(i);
       var tmp = nodes;
-      if (children.All(x => tmp[x].Data.Symbol is Constant)) {
+      if (children.All(x => tmp[x].Data.Symbol is INumericSymbol)) {
         foreach (var j in children) {
           nodes[j].Enabled = false;
         }
-        nodes[i] = constant.CreateTreeNode().ToHashNode();
+        nodes[i] = number.CreateTreeNode().ToHashNode();
       }
     }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 18132)
@@ -47,4 +47,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>default</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
@@ -57,4 +58,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>default</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
@@ -67,4 +69,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>default</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
@@ -77,4 +80,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>default</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
@@ -87,4 +91,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>default</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
@@ -97,4 +102,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>default</LangVersion>
   </PropertyGroup>
   <ItemGroup>
@@ -168,4 +174,6 @@
     <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" />
@@ -232,6 +240,6 @@
     <Compile Include="Symbols\AutoregressiveVariable.cs" />
     <Compile Include="Symbols\Average.cs" />
-    <Compile Include="Symbols\Constant.cs" />
-    <Compile Include="Symbols\ConstantTreeNode.cs" />
+    <Compile Include="Symbols\Number.cs" />
+    <Compile Include="Symbols\NumberTreeNode.cs" />
     <Compile Include="Symbols\AiryA.cs" />
     <Compile Include="Symbols\AiryB.cs" />
@@ -245,4 +253,6 @@
     <Compile Include="Symbols\CubeRoot.cs" />
     <Compile Include="Symbols\HyperbolicTangent.cs" />
+    <Compile Include="Symbols\Constant.cs" />
+    <Compile Include="Symbols\ConstantTreeNode.cs" />
     <Compile Include="Symbols\VariableBase.cs" />
     <Compile Include="Symbols\VariableTreeNodeBase.cs" />
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs	(revision 18131)
+++ /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 18131)
+++ /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 18131)
+++ /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;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/INumericSymbol.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/INumericSymbol.cs	(revision 18132)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/INumericSymbol.cs	(revision 18132)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HEAL.Attic;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [StorableType("3CD759AF-A45E-4B70-BDCF-66AF1A03BAD8")]
+  public interface INumericSymbol : ISymbol { }
+
+}
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/INumericTreeNode.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/INumericTreeNode.cs	(revision 18132)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/INumericTreeNode.cs	(revision 18132)
@@ -0,0 +1,30 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HEAL.Attic;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [StorableType("194AFEE6-96E2-4F53-A5AD-D3CCFE928AE5")]
+  public interface INumericTreeNode : ISymbolicExpressionTreeNode {
+    double Value { get; set; }
+  }
+}
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchInstruction.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchInstruction.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchInstruction.cs	(revision 18132)
@@ -5,5 +5,5 @@
     public int childIndex;
 
-    public double value; // for constants
+    public double value; // for numbers and constants
     public double weight; // for variables
     public double[] buf;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithBoundsEstimator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithBoundsEstimator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithBoundsEstimator.cs	(revision 18132)
@@ -126,7 +126,8 @@
             break;
           }
-        case OpCodes.Constant: {
-            var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
-            result = new Interval(constTreeNode.Value, constTreeNode.Value);
+        case OpCodes.Constant: // fall through
+        case OpCodes.Number: {
+            var numericTreeNode = (INumericTreeNode)currentInstr.dynamicNode;
+            result = new Interval(numericTreeNode.Value, numericTreeNode.Value);
             break;
           }
@@ -324,4 +325,5 @@
         where
           !(n.Symbol is Variable) &&
+          !(n.Symbol is Number) &&
           !(n.Symbol is Constant) &&
           !(n.Symbol is StartSymbol) &&
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithCompiledExpressionBoundsEstimator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithCompiledExpressionBoundsEstimator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithCompiledExpressionBoundsEstimator.cs	(revision 18132)
@@ -116,4 +116,5 @@
         where
           !(n.Symbol is Variable) &&
+          !(n.Symbol is Number) &&
           !(n.Symbol is Constant) &&
           !(n.Symbol is StartSymbol) &&
@@ -153,7 +154,8 @@
             );
           }
-        case OpCodes.Constant: {
-            var v = (node as ConstantTreeNode).Value;
-            // we have to make an interval out of the constant because this may be the root of the tree (and we are expected to return an Interval)
+        case OpCodes.Constant: // fall through
+        case OpCodes.Number: {
+            var v = (node as INumericTreeNode).Value;
+            // we have to make an interval out of the number because this may be the root of the tree (and we are expected to return an Interval)
             return Expression.Constant(new Interval(v, v), typeof(Interval));
           }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs	(revision 18132)
@@ -186,8 +186,9 @@
             break;
           }
+        case OpCodes.Number: // fall through
         case OpCodes.Constant: {
-            var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
-            result = new Interval(constTreeNode.Value, constTreeNode.Value);
-            break;
+          var numericTreeNode = (INumericTreeNode)currentInstr.dynamicNode;
+          result = new Interval(numericTreeNode.Value, numericTreeNode.Value);
+          break;
           }
         case OpCodes.Add: {
@@ -324,4 +325,5 @@
         if (
           !(n.Symbol is Variable) &&
+          !(n.Symbol is Number) &&
           !(n.Symbol is Constant) &&
           !(n.Symbol is StartSymbol) &&
@@ -346,6 +348,6 @@
         else if (n.Symbol is Power) {
           // only integer exponents are supported
-          var exp = n.GetSubtree(1) as ConstantTreeNode;
-          if (exp == null || exp.Value != Math.Truncate(exp.Value)) return false;
+          var exponent = n.GetSubtree(1) as INumericTreeNode;
+          if (exponent == null || exponent.Value != Math.Truncate(exponent.Value)) return false;
         }
       }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs	(revision 18132)
@@ -46,5 +46,5 @@
     Variable = 18,
     LagVariable = 19,
-    Constant = 20,
+    Number = 20,
     Arg = 21,
     Power = 22,
@@ -79,4 +79,5 @@
     CubeRoot = 51,
     Tanh = 52,
+    Constant = 53
   };
   public static class OpCodes {
@@ -101,5 +102,6 @@
     public const byte Variable = (byte)OpCode.Variable;
     public const byte LagVariable = (byte)OpCode.LagVariable;
-    public const byte Constant = (byte)OpCode.Constant;
+    public const byte Number = (byte)OpCode.Number;
+    public const byte Constant = (byte) OpCode.Constant;
     public const byte Arg = (byte)OpCode.Arg;
     public const byte Power = (byte)OpCode.Power;
@@ -159,4 +161,5 @@
       { typeof(LaggedVariable), OpCodes.LagVariable },
       { typeof(AutoregressiveTargetVariable),OpCodes.LagVariable},
+      { typeof(Number), OpCodes.Number },
       { typeof(Constant), OpCodes.Constant },
       { typeof(Argument), OpCodes.Arg },
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs	(revision 18132)
@@ -157,7 +157,8 @@
       #region switch opcode
       switch (opcode) {
-        case OpCodes.Constant: {
-            var constantTreeNode = (ConstantTreeNode)node;
-            return Expression.Constant(constantTreeNode.Value);
+        case OpCodes.Constant: // fall through
+        case OpCodes.Number: {
+          var numberTreeNode = (INumericTreeNode)node;
+          return Expression.Constant(numberTreeNode.Value);
           }
         case OpCodes.Variable: {
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs	(revision 18132)
@@ -84,5 +84,7 @@
               break;
             }
-          case OpCodes.Constant: break; // nothing to do here, don't remove because we want to prevent falling into the default case here.
+          case OpCodes.Constant: // fall through
+          case OpCodes.Number: 
+            break; // nothing to do here, don't remove because we want to prevent falling into the default case here.
           case OpCodes.Add: {
               Load(instr.buf, code[c].buf);
@@ -279,6 +281,6 @@
             cachedData[variable.VariableName] = code[i].data;
           }
-        } else if (node is ConstantTreeNode constant) {
-          code[i].value = constant.Value;
+        } else if (node is INumericTreeNode numeric) {
+          code[i].value = numeric.Value;
           for (int j = 0; j < BATCHSIZE; ++j)
             code[i].buf[j] = code[i].value;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs	(revision 18132)
@@ -711,9 +711,10 @@
             return;
           }
+        case OpCodes.Number: // fall through
         case OpCodes.Constant: {
-            ConstantTreeNode constNode = (ConstantTreeNode)currentInstr.dynamicNode;
-            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, constNode.Value);
-            return;
-          }
+          var constNode = (INumericTreeNode) currentInstr.dynamicNode;
+          il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, constNode.Value);
+          return;
+        }
 
         //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) ) 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 18132)
@@ -496,8 +496,9 @@
             return ((IList<double>)currentInstr.data)[actualRow] * laggedVariableTreeNode.Weight;
           }
-        case OpCodes.Constant: {
-            var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
-            return constTreeNode.Value;
-          }
+        case OpCodes.Constant:  // fall through
+        case OpCodes.Number: {
+          var numericTreeNode = (INumericTreeNode) currentInstr.dynamicNode;
+          return numericTreeNode.Value;
+        }
 
         //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) ) 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs	(revision 18132)
@@ -416,8 +416,9 @@
         #region opcode switch
         switch (instr.opCode) {
+          case OpCodes.Number: // fall through
           case OpCodes.Constant: {
-              var constTreeNode = (ConstantTreeNode)instr.dynamicNode;
-              instr.value = constTreeNode.Value;
-              instr.skip = true; // the value is already set so this instruction should be skipped in the evaluation phase
+            var numericTreeNode = (INumericTreeNode)instr.dynamicNode;
+            instr.value = numericTreeNode.Value;
+            instr.skip = true; // the value is already set so this instruction should be skipped in the evaluation phase
             }
             break;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs	(revision 18132)
@@ -82,6 +82,6 @@
           code[i].weight = variable.Weight;
           code[i].data = cachedData[variable.VariableName].AddrOfPinnedObject();
-        } else if (node is ConstantTreeNode constant) {
-          code[i].value = constant.Value;
+        } else if (node is INumericTreeNode numeric) {
+          code[i].value = numeric.Value;
         }
 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionPruningOperator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionPruningOperator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionPruningOperator.cs	(revision 18132)
@@ -33,5 +33,5 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableType("DBE27385-2E8C-4314-88B4-F96A5240FC9D")]
-  [Item("SymbolicExpressionTreePruningOperator", "An operator that replaces introns with constant values in a symbolic expression tree.")]
+  [Item("SymbolicExpressionTreePruningOperator", "An operator that replaces sub-trees with small impacts with numbers in a symbolic expression tree.")]
   public abstract class SymbolicDataAnalysisExpressionPruningOperator : SingleSuccessorOperator, ISymbolicExpressionTreeOperator {
     #region parameter names
@@ -172,18 +172,17 @@
       for (int i = 0; i < nodes.Count; ++i) {
         var node = nodes[i];
-        if (node is ConstantTreeNode) continue;
-
-        double impactValue, replacementValue;
-        double newQualityForImpacts;
-        ImpactValuesCalculator.CalculateImpactAndReplacementValues(model, node, problemData, rows, out impactValue, out replacementValue, out newQualityForImpacts, qualityForImpactsCalculation);
+        if (node is INumericTreeNode) continue;
+
+        ImpactValuesCalculator.CalculateImpactAndReplacementValues(model, node, problemData, rows, 
+          out double impactValue, out double replacementValue, out double newQualityForImpacts, qualityForImpactsCalculation);
 
         if (PruneOnlyZeroImpactNodes && !impactValue.IsAlmost(0.0)) continue;
         if (!PruneOnlyZeroImpactNodes && impactValue > NodeImpactThreshold) continue;
 
-        var constantNode = (ConstantTreeNode)node.Grammar.GetSymbol("Constant").CreateTreeNode();
-        constantNode.Value = replacementValue;
+        var numberNode = (NumberTreeNode)node.Grammar.GetSymbol("Number").CreateTreeNode();
+        numberNode.Value = replacementValue;
 
         var length = node.GetLength();
-        ReplaceWithConstant(node, constantNode);
+        ReplaceWithNumber(node, numberNode);
         i += length - 1; // skip subtrees under the node that was folded
 
@@ -205,5 +204,5 @@
     }
 
-    protected static void ReplaceWithConstant(ISymbolicExpressionTreeNode original, ISymbolicExpressionTreeNode replacement) {
+    protected static void ReplaceWithNumber(ISymbolicExpressionTreeNode original, ISymbolicExpressionTreeNode replacement) {
       var parent = original.Parent;
       var i = parent.IndexOfSubtree(original);
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModel.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModel.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModel.cs	(revision 18132)
@@ -115,14 +115,14 @@
       if (linearScalingCalculator.ErrorState != OnlineCalculatorError.None) return;
 
-      ConstantTreeNode alphaTreeNode = null;
-      ConstantTreeNode betaTreeNode = null;
+      NumberTreeNode alphaTreeNode = null;
+      NumberTreeNode betaTreeNode = null;
       // check if model has a structure that can be re-used for scaling
       var startNode = SymbolicExpressionTree.Root.GetSubtree(0);
       var addNode = startNode.GetSubtree(0);
       if (addNode.Symbol is Addition && addNode.SubtreeCount == 2) {
-        alphaTreeNode = (ConstantTreeNode)addNode.Subtrees.LastOrDefault(n => n is ConstantTreeNode);
+        alphaTreeNode = (NumberTreeNode)addNode.Subtrees.LastOrDefault(n => n is NumberTreeNode);
         var mulNode = addNode.Subtrees.FirstOrDefault(n => n.Symbol is Multiplication);
         if (mulNode != null) {
-          betaTreeNode = (ConstantTreeNode)mulNode.Subtrees.LastOrDefault(n => n is ConstantTreeNode);
+          betaTreeNode = (NumberTreeNode)mulNode.Subtrees.LastOrDefault(n => n is NumberTreeNode);
         }
       }
@@ -146,7 +146,7 @@
         var addition = new Addition();
         var node = addition.CreateTreeNode();
-        var alphaConst = MakeConstant(alpha);
+        var alphaNode = MakeNumber(alpha);
         node.AddSubtree(treeNode);
-        node.AddSubtree(alphaConst);
+        node.AddSubtree(alphaNode);
         return node;
       }
@@ -157,15 +157,15 @@
         return treeNode;
       } else {
-        var multipliciation = new Multiplication();
-        var node = multipliciation.CreateTreeNode();
-        var betaConst = MakeConstant(beta);
+        var multiplication = new Multiplication();
+        var node = multiplication.CreateTreeNode();
+        var betaNode = MakeNumber(beta);
         node.AddSubtree(treeNode);
-        node.AddSubtree(betaConst);
+        node.AddSubtree(betaNode);
         return node;
       }
     }
 
-    private static ISymbolicExpressionTreeNode MakeConstant(double c) {
-      var node = (ConstantTreeNode)(new Constant()).CreateTreeNode();
+    private static ISymbolicExpressionTreeNode MakeNumber(double c) {
+      var node = (NumberTreeNode)(new Number()).CreateTreeNode();
       node.Value = c;
       return node;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModelComplexityCalculator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModelComplexityCalculator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModelComplexityCalculator.cs	(revision 18132)
@@ -36,4 +36,5 @@
 
       switch (OpCodes.MapSymbolToOpCode(node)) {
+        case OpCodes.Number: // fall through
         case OpCodes.Constant: {
             return 1;
@@ -80,5 +81,5 @@
         case OpCodes.Root: {
             double complexity = CalculateComplexity(node.GetSubtree(0));
-            var exponent = node.GetSubtree(1) as ConstantTreeNode;
+            var exponent = node.GetSubtree(1) as INumericTreeNode;
             if (exponent != null) {
               double expVal = exponent.Value;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSolutionImpactValuesCalculator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSolutionImpactValuesCalculator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSolutionImpactValuesCalculator.cs	(revision 18132)
@@ -59,6 +59,6 @@
         tempModelParentNode.RemoveSubtree(i);
 
-        var constantNode = new ConstantTreeNode(new Constant()) { Value = repValue };
-        tempModelParentNode.InsertSubtree(i, constantNode);
+        var numberNode = new NumberTreeNode(new Number()) { Value = repValue };
+        tempModelParentNode.InsertSubtree(i, numberNode);
 
         newQualityForImpactsCalculation = CalculateQualityForImpacts(tempModel, problemData, rows);
@@ -79,10 +79,9 @@
     protected IEnumerable<double> CalculateReplacementValues(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
       IDataset dataset, IEnumerable<int> rows) {
-      //optimization: constant nodes return always the same value
-      ConstantTreeNode constantNode = node as ConstantTreeNode;
+      var numberNode = node as INumericTreeNode;
       BinaryFactorVariableTreeNode binaryFactorNode = node as BinaryFactorVariableTreeNode;
       FactorVariableTreeNode factorNode = node as FactorVariableTreeNode;
-      if (constantNode != null) {
-        yield return constantNode.Value;
+      if (numberNode != null) {
+        yield return numberNode.Value;
       } else if (binaryFactorNode != null) {
         // valid replacements are either all off or all on
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Constant.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Constant.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Constant.cs	(revision 18132)
@@ -1,3 +1,3 @@
-#region License Information
+﻿#region License Information
 /* HeuristicLab
  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -20,109 +20,36 @@
 #endregion
 
-using System;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HEAL.Attic;
+
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [StorableType("5CD355EA-36E4-4E43-B8C4-9E9CF4CBC860")]
-  [Item("Constant", "Represents a constant value.")]
-  public sealed class Constant : Symbol {
-    #region Properties
-    [Storable]
-    private double minValue;
-    public double MinValue {
-      get { return minValue; }
-      set {
-        if (value != minValue) {
-          minValue = value;
-          OnChanged(EventArgs.Empty);
-        }
-      }
-    }
-    [Storable]
-    private double maxValue;
-    public double MaxValue {
-      get { return maxValue; }
-      set {
-        if (value != maxValue) {
-          maxValue = value;
-          OnChanged(EventArgs.Empty);
-        }
-      }
-    }
-    [Storable]
-    private double manipulatorMu;
-    public double ManipulatorMu {
-      get { return manipulatorMu; }
-      set {
-        if (value != manipulatorMu) {
-          manipulatorMu = value;
-          OnChanged(EventArgs.Empty);
-        }
-      }
-    }
-    [Storable]
-    private double manipulatorSigma;
-    public double ManipulatorSigma {
-      get { return manipulatorSigma; }
-      set {
-        if (value < 0) throw new ArgumentException();
-        if (value != manipulatorSigma) {
-          manipulatorSigma = value;
-          OnChanged(EventArgs.Empty);
-        }
-      }
-    }
-    [Storable(DefaultValue = 0.0)]
-    private double multiplicativeManipulatorSigma;
-    public double MultiplicativeManipulatorSigma {
-      get { return multiplicativeManipulatorSigma; }
-      set {
-        if (value < 0) throw new ArgumentException();
-        if (value != multiplicativeManipulatorSigma) {
-          multiplicativeManipulatorSigma = value;
-          OnChanged(EventArgs.Empty);
-        }
-      }
-    }
-
+  [StorableType("44E03792-5E65-4C70-99B2-7849B8927E28")]
+  [Item("Constant", "Represents a real-valued constant.")]
+  public sealed class Constant : Symbol, INumericSymbol {
     private const int minimumArity = 0;
     private const int maximumArity = 0;
 
-    public override int MinimumArity {
-      get { return minimumArity; }
-    }
-    public override int MaximumArity {
-      get { return maximumArity; }
-    }
-    #endregion
+    public override int MinimumArity => minimumArity;
+    public override int MaximumArity => maximumArity;
+
+    public double Value { get; set; }
 
     [StorableConstructor]
     private Constant(StorableConstructorFlag _) : base(_) { }
-    private Constant(Constant original, Cloner cloner)
-      : base(original, cloner) {
-      minValue = original.minValue;
-      maxValue = original.maxValue;
-      manipulatorMu = original.manipulatorMu;
-      manipulatorSigma = original.manipulatorSigma;
-      multiplicativeManipulatorSigma = original.multiplicativeManipulatorSigma;
+
+    private Constant(Constant original, Cloner cloner) : base(original, cloner) {
+      this.Value = original.Value;
     }
-    public Constant()
-      : base("Constant", "Represents a constant value.") {
-      manipulatorMu = 0.0;
-      manipulatorSigma = 1.0;
-      multiplicativeManipulatorSigma = 0.03;
-      minValue = -20.0;
-      maxValue = 20.0;
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Constant(this, cloner);
     }
+
+    public Constant() : base("Constant", "Represents a real-valued constant.") { }
 
     public override ISymbolicExpressionTreeNode CreateTreeNode() {
       return new ConstantTreeNode(this);
     }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Constant(this, cloner);
-    }
   }
 }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/ConstantTreeNode.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/ConstantTreeNode.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/ConstantTreeNode.cs	(revision 18132)
@@ -1,3 +1,3 @@
-#region License Information
+﻿#region License Information
 /* HeuristicLab
  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -20,21 +20,17 @@
 #endregion
 
+using HEAL.Attic;
 using HeuristicLab.Common;
-using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HEAL.Attic;
-using HeuristicLab.Random;
+
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [StorableType("247DBD04-18F2-4184-B6F5-6E283BF06FD0")]
-  public sealed class ConstantTreeNode : SymbolicExpressionTreeTerminalNode {
-    public new Constant Symbol {
-      get { return (Constant)base.Symbol; }
-    }
+  [StorableType("F91000E6-B041-4648-A9E8-595228F957FA")]
+  public sealed class ConstantTreeNode : SymbolicExpressionTreeTerminalNode, INumericTreeNode {
 
-    private double constantValue;
-    [Storable]
-    public double Value {
-      get { return constantValue; }
-      set { constantValue = value; }
+    public new Constant Symbol => (Constant) base.Symbol;
+
+    public double Value { 
+      get => Symbol.Value;
+      set => throw new System.NotSupportedException("Cannot change the value of a constant.");
     }
 
@@ -44,32 +40,8 @@
     private ConstantTreeNode(ConstantTreeNode original, Cloner cloner)
       : base(original, cloner) {
-      constantValue = original.constantValue;
     }
 
     private ConstantTreeNode() : base() { }
     public ConstantTreeNode(Constant constantSymbol) : base(constantSymbol) { }
-
-    public override bool HasLocalParameters {
-      get {
-        return true;
-      }
-    }
-    public override void ResetLocalParameters(IRandom random) {
-      base.ResetLocalParameters(random);
-      var range = Symbol.MaxValue - Symbol.MinValue;
-      Value = random.NextDouble() * range + Symbol.MinValue;
-    }
-
-    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
-      base.ShakeLocalParameters(random, shakingFactor);
-      // 50% additive & 50% multiplicative
-      if (random.NextDouble() < 0.5) {
-        double x = NormalDistributedRandom.NextDouble(random, Symbol.ManipulatorMu, Symbol.ManipulatorSigma);
-        Value = Value + x * shakingFactor;
-      } else {
-        double x = NormalDistributedRandom.NextDouble(random, 1.0, Symbol.MultiplicativeManipulatorSigma);
-        Value = Value * x;
-      }
-    }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -78,5 +50,5 @@
 
     public override string ToString() {
-      return constantValue.ToString("E4");
+      return $"{Value:E4}";
     }
   }
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Number.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Number.cs	(revision 18132)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Number.cs	(revision 18132)
@@ -0,0 +1,128 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HEAL.Attic;
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [StorableType("5CD355EA-36E4-4E43-B8C4-9E9CF4CBC860")]
+  [Item("Number", "Represents a number.")]
+  public sealed class Number : Symbol, INumericSymbol {
+    #region Properties
+    [Storable]
+    private double minValue;
+    public double MinValue {
+      get { return minValue; }
+      set {
+        if (value != minValue) {
+          minValue = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double maxValue;
+    public double MaxValue {
+      get { return maxValue; }
+      set {
+        if (value != maxValue) {
+          maxValue = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double manipulatorMu;
+    public double ManipulatorMu {
+      get { return manipulatorMu; }
+      set {
+        if (value != manipulatorMu) {
+          manipulatorMu = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double manipulatorSigma;
+    public double ManipulatorSigma {
+      get { return manipulatorSigma; }
+      set {
+        if (value < 0) throw new ArgumentException();
+        if (value != manipulatorSigma) {
+          manipulatorSigma = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable(DefaultValue = 0.0)]
+    private double multiplicativeManipulatorSigma;
+    public double MultiplicativeManipulatorSigma {
+      get { return multiplicativeManipulatorSigma; }
+      set {
+        if (value < 0) throw new ArgumentException();
+        if (value != multiplicativeManipulatorSigma) {
+          multiplicativeManipulatorSigma = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+
+    private const int minimumArity = 0;
+    private const int maximumArity = 0;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private Number(StorableConstructorFlag _) : base(_) { }
+    private Number(Number original, Cloner cloner)
+      : base(original, cloner) {
+      minValue = original.minValue;
+      maxValue = original.maxValue;
+      manipulatorMu = original.manipulatorMu;
+      manipulatorSigma = original.manipulatorSigma;
+      multiplicativeManipulatorSigma = original.multiplicativeManipulatorSigma;
+    }
+    public Number()
+      : base("Number", "Represents a numerical value.") {
+      manipulatorMu = 0.0;
+      manipulatorSigma = 1.0;
+      multiplicativeManipulatorSigma = 0.03;
+      minValue = -20.0;
+      maxValue = 20.0;
+    }
+
+    public override ISymbolicExpressionTreeNode CreateTreeNode() {
+      return new NumberTreeNode(this);
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Number(this, cloner);
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/NumberTreeNode.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/NumberTreeNode.cs	(revision 18132)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/NumberTreeNode.cs	(revision 18132)
@@ -0,0 +1,74 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HEAL.Attic;
+using HeuristicLab.Random;
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [StorableType("247DBD04-18F2-4184-B6F5-6E283BF06FD0")]
+  public sealed class NumberTreeNode : SymbolicExpressionTreeTerminalNode, INumericTreeNode {
+    public new Number Symbol => (Number)base.Symbol;
+
+    [Storable]
+    public double Value { get; set; }
+
+    [StorableConstructor]
+    private NumberTreeNode(StorableConstructorFlag _) : base(_) { }
+
+    private NumberTreeNode(NumberTreeNode original, Cloner cloner)
+      : base(original, cloner) {
+      Value = original.Value;
+    }
+
+    private NumberTreeNode() : base() { }
+    public NumberTreeNode(Number numberSymbol) : base(numberSymbol) { }
+
+    public override bool HasLocalParameters => true;
+
+    public override void ResetLocalParameters(IRandom random) {
+      base.ResetLocalParameters(random);
+      var range = Symbol.MaxValue - Symbol.MinValue;
+      Value = random.NextDouble() * range + Symbol.MinValue;
+    }
+
+    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
+      base.ShakeLocalParameters(random, shakingFactor);
+      // 50% additive & 50% multiplicative
+      if (random.NextDouble() < 0.5) {
+        var x = NormalDistributedRandom.NextDouble(random, Symbol.ManipulatorMu, Symbol.ManipulatorSigma);
+        Value = Value + x * shakingFactor;
+      } else {
+        var x = NormalDistributedRandom.NextDouble(random, 1.0, Symbol.MultiplicativeManipulatorSigma);
+        Value = Value * x;
+      }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NumberTreeNode(this, cloner);
+    }
+
+    public override string ToString() {
+      return $"{Value:E4}";
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Transformations/SymbolicExpressionTreeBacktransformator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Transformations/SymbolicExpressionTreeBacktransformator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Transformations/SymbolicExpressionTreeBacktransformator.cs	(revision 18132)
@@ -90,5 +90,5 @@
     private ISymbolicExpressionTreeNode CreateNodeFromWeight(ISymbolicExpressionTreeNode transformationTree, VariableTreeNode variableNode) {
       var multiplicationNode = new SymbolicExpressionTreeNode(new Multiplication());
-      multiplicationNode.AddSubtree(new ConstantTreeNode(new Constant()) { Value = variableNode.Weight });
+      multiplicationNode.AddSubtree(new NumberTreeNode(new Number()) { Value = variableNode.Weight });
       multiplicationNode.AddSubtree(transformationTree);
       return multiplicationNode;
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Transformations/TransformationToSymbolicTreeMapper.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Transformations/TransformationToSymbolicTreeMapper.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Transformations/TransformationToSymbolicTreeMapper.cs	(revision 18132)
@@ -84,5 +84,5 @@
       // k * x
       var multiplicationNode = new Multiplication().CreateTreeNode();
-      var kNode = CreateConstantTreeNode("k", kValue);
+      var kNode = CreateNumber("k", kValue);
       var xNode = CreateVariableTreeNode(column, "x");
       multiplicationNode.AddSubtree(kNode);
@@ -91,5 +91,5 @@
       // ( k * x ) + d
       var additionNode = new Addition().CreateTreeNode();
-      var dNode = CreateConstantTreeNode("d", dValue);
+      var dNode = CreateNumber("d", dValue);
       additionNode.AddSubtree(multiplicationNode);
       additionNode.AddSubtree(dNode);
@@ -105,5 +105,5 @@
       // x - d
       var substractionNode = new Subtraction().CreateTreeNode();
-      var dNode = CreateConstantTreeNode("d", dValue);
+      var dNode = CreateNumber("d", dValue);
       var xNode = CreateVariableTreeNode(column, "x");
       substractionNode.AddSubtree(xNode);
@@ -112,5 +112,5 @@
       // ( x - d ) / k
       var divisionNode = new Division().CreateTreeNode();
-      var kNode = CreateConstantTreeNode("k", kValue);
+      var kNode = CreateNumber("k", kValue);
       divisionNode.AddSubtree(substractionNode);
       divisionNode.AddSubtree(kNode);
@@ -157,5 +157,5 @@
       var powerNode = new Power().CreateTreeNode();
       var xNode = CreateVariableTreeNode(column, "x");
-      var expNode = CreateConstantTreeNode("exp", expValue);
+      var expNode = CreateNumber("exp", expValue);
       powerNode.AddSubtree(xNode);
       powerNode.AddSubtree(expNode);
@@ -171,5 +171,5 @@
       var rootNode = new Root().CreateTreeNode();
       var xNode = CreateVariableTreeNode(column, "x");
-      var bNode = CreateConstantTreeNode("b", expValue);
+      var bNode = CreateNumber("b", expValue);
       rootNode.AddSubtree(xNode);
       rootNode.AddSubtree(bNode);
@@ -220,5 +220,5 @@
       // log(x, b)
       var logNode = new Logarithm().CreateTreeNode();
-      var bNode = CreateConstantTreeNode("b", b);
+      var bNode = CreateNumber("b", b);
       var xNode = CreateVariableTreeNode(column, "x");
       logNode.AddSubtree(xNode);
@@ -231,5 +231,5 @@
       // b ^ x
       var powerNode = new Power().CreateTreeNode();
-      var bNode = CreateConstantTreeNode("b", b);
+      var bNode = CreateNumber("b", b);
       var xNode = CreateVariableTreeNode(column, "x");
       powerNode.AddSubtree(bNode);
@@ -242,5 +242,5 @@
       // 1 / x
       var divNode = new Division().CreateTreeNode();
-      var oneNode = CreateConstantTreeNode("1", 1.0);
+      var oneNode = CreateNumber("1", 1.0);
       var xNode = CreateVariableTreeNode(column, "x");
       divNode.AddSubtree(oneNode);
@@ -254,5 +254,5 @@
       var substractionNode = new Subtraction().CreateTreeNode();
       var xNode = CreateVariableTreeNode(variable, "x");
-      var m_orgNode = CreateConstantTreeNode("m_org", m_org);
+      var m_orgNode = CreateNumber("m_org", m_org);
       substractionNode.AddSubtree(xNode);
       substractionNode.AddSubtree(m_orgNode);
@@ -260,5 +260,5 @@
       // (x - m_org) / s_org
       var divisionNode = new Division().CreateTreeNode();
-      var s_orgNode = CreateConstantTreeNode("s_org", s_org);
+      var s_orgNode = CreateNumber("s_org", s_org);
       divisionNode.AddSubtree(substractionNode);
       divisionNode.AddSubtree(s_orgNode);
@@ -266,5 +266,5 @@
       // ((x - m_org) / s_org ) * s_tar
       var multiplicationNode = new Multiplication().CreateTreeNode();
-      var s_tarNode = CreateConstantTreeNode("s_tar", s_tar);
+      var s_tarNode = CreateNumber("s_tar", s_tar);
       multiplicationNode.AddSubtree(divisionNode);
       multiplicationNode.AddSubtree(s_tarNode);
@@ -272,5 +272,5 @@
       // ((x - m_org) / s_org ) * s_tar + m_tar
       var additionNode = new Addition().CreateTreeNode();
-      var m_tarNode = CreateConstantTreeNode("m_tar", m_tar);
+      var m_tarNode = CreateNumber("m_tar", m_tar);
       additionNode.AddSubtree(multiplicationNode);
       additionNode.AddSubtree(m_tarNode);
@@ -279,6 +279,6 @@
     }
 
-    private ConstantTreeNode CreateConstantTreeNode(string description, double value) {
-      return new ConstantTreeNode(new Constant()) { Value = value };
+    private NumberTreeNode CreateNumber(string description, double value) {
+      return new NumberTreeNode(new Number()) { Value = value };
     }
 
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeBottomUpSimilarityCalculator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeBottomUpSimilarityCalculator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeBottomUpSimilarityCalculator.cs	(revision 18132)
@@ -41,5 +41,5 @@
     protected override bool IsCommutative { get { return true; } }
 
-    public bool MatchConstantValues { get; set; }
+    public bool MatchParameterValues { get; set; }
     public bool MatchVariableWeights { get; set; }
 
@@ -66,14 +66,13 @@
 
     public static double CalculateSimilarity(ISymbolicExpressionTreeNode n1, ISymbolicExpressionTreeNode n2, bool strict = false) {
-      var calculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator { MatchConstantValues = strict, MatchVariableWeights = strict };
       return CalculateSimilarity(n1, n2, strict);
     }
 
-    public static Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> ComputeBottomUpMapping(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2, bool strict = false) {
+    public static NodeMap ComputeBottomUpMapping(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2, bool strict = false) {
       return ComputeBottomUpMapping(ActualRoot(t1), ActualRoot(t2), strict);
     }
 
-    public static Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> ComputeBottomUpMapping(ISymbolicExpressionTreeNode n1, ISymbolicExpressionTreeNode n2, bool strict = false) {
-      var calculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator { MatchConstantValues = strict, MatchVariableWeights = strict };
+    public static NodeMap ComputeBottomUpMapping(ISymbolicExpressionTreeNode n1, ISymbolicExpressionTreeNode n2, bool strict = false) {
+      var calculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator { MatchParameterValues = strict, MatchVariableWeights = strict };
       return calculator.ComputeBottomUpMapping(n1, n2);
     }
@@ -81,5 +80,5 @@
 
     public double CalculateSimilarity(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2) {
-      return CalculateSimilarity(t1, t2, out Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> map);
+      return CalculateSimilarity(t1, t2, out _);
     }
 
@@ -110,9 +109,9 @@
     }
 
-    public Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> ComputeBottomUpMapping(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2) {
+    public NodeMap ComputeBottomUpMapping(ISymbolicExpressionTree t1, ISymbolicExpressionTree t2) {
       return ComputeBottomUpMapping(ActualRoot(t1), ActualRoot(t2));
     }
 
-    public Dictionary<ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode> ComputeBottomUpMapping(ISymbolicExpressionTreeNode n1, ISymbolicExpressionTreeNode n2) {
+    public NodeMap ComputeBottomUpMapping(ISymbolicExpressionTreeNode n1, ISymbolicExpressionTreeNode n2) {
       var compactedGraph = Compact(n1, n2);
 
@@ -211,6 +210,6 @@
         return node.Symbol.Name;
 
-      if (node is ConstantTreeNode constant)
-        return MatchConstantValues ? constant.Value.ToString(CultureInfo.InvariantCulture) : constant.Symbol.Name;
+      if (node is INumericTreeNode numNode)
+        return MatchParameterValues ? numNode.Value.ToString(CultureInfo.InvariantCulture) : "Numeric";
 
       if (node is VariableTreeNode variable)
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculator.cs	(revision 18132)
@@ -38,7 +38,7 @@
     }
 
-    public bool MatchConstantValues {
-      get { return comparer.MatchConstantValues; }
-      set { comparer.MatchConstantValues = value; }
+    public bool MatchParameterValues {
+      get { return comparer.MatchParameterValues; }
+      set { comparer.MatchParameterValues = value; }
     }
 
@@ -59,5 +59,5 @@
     public SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculator() {
       comparer = new SymbolicExpressionTreeNodeEqualityComparer {
-        MatchConstantValues = true,
+        MatchParameterValues = true,
         MatchVariableNames = true,
         MatchVariableWeights = true
@@ -65,7 +65,7 @@
     }
 
-    public SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculator(bool matchVariableWeights, bool matchConstantValues) {
+    public SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculator(bool matchVariableWeights, bool matchParameterValues) {
       comparer = new SymbolicExpressionTreeNodeEqualityComparer {
-        MatchConstantValues = matchConstantValues,
+        MatchParameterValues = matchParameterValues,
         MatchVariableNames = true,
         MatchVariableWeights = matchVariableWeights
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeComparer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeComparer.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeComparer.cs	(revision 18132)
@@ -28,5 +28,5 @@
   // this comparer considers that a < b if the type of a is "greater" than the type of b, for example:
   // - A function node is "greater" than a terminal node
-  // - A variable terminal is "greater" than a constant terminal
+  // - A variable terminal is "greater" than a numeric terminal
   // - used for bringing subtrees to a "canonical" form when the operation allows reordering of arguments
   public class SymbolicExpressionTreeNodeComparer : ISymbolicExpressionTreeNodeComparer {
@@ -52,6 +52,6 @@
 
       // at this point we know a and b are not variables
-      var ca = a as ConstantTreeNode;
-      var cb = b as ConstantTreeNode;
+      var ca = a as INumericTreeNode;
+      var cb = b as INumericTreeNode;
 
       if (ca != null && cb != null)
Index: /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeEqualityComparer.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeEqualityComparer.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeEqualityComparer.cs	(revision 18132)
@@ -33,5 +33,5 @@
     protected SymbolicExpressionTreeNodeEqualityComparer(SymbolicExpressionTreeNodeEqualityComparer original, Cloner cloner)
       : base(original, cloner) {
-      matchConstantValues = original.matchConstantValues;
+      matchParameterValues = original.matchParameterValues;
       matchVariableNames = original.matchVariableNames;
       matchVariableWeights = original.matchVariableWeights;
@@ -41,8 +41,8 @@
     // more flexible matching criteria 
     [Storable]
-    private bool matchConstantValues;
-    public bool MatchConstantValues {
-      get { return matchConstantValues; }
-      set { matchConstantValues = value; }
+    private bool matchParameterValues;
+    public bool MatchParameterValues {
+      get { return matchParameterValues; }
+      set { matchParameterValues = value; }
     }
 
@@ -66,5 +66,5 @@
 
     public SymbolicExpressionTreeNodeEqualityComparer() {
-      matchConstantValues = true;
+      matchParameterValues = true;
       matchVariableNames = true;
       matchVariableWeights = true;
@@ -86,9 +86,9 @@
         return (!MatchVariableNames || va.VariableName.Equals(vb.VariableName)) && (!MatchVariableWeights || va.Weight.Equals(vb.Weight));
       }
-      var ca = a as ConstantTreeNode;
-      if (ca != null) {
-        var cb = b as ConstantTreeNode;
+
+      if (a is INumericTreeNode ca) {
+        var cb = b as INumericTreeNode;
         if (cb == null) return false;
-        return (!MatchConstantValues || ca.Value.Equals(cb.Value));
+        return (!MatchParameterValues || ca.Value.Equals(cb.Value));
       }
       return false;
Index: /trunk/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineLinearScalingParameterCalculator.cs
===================================================================
--- /trunk/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineLinearScalingParameterCalculator.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineLinearScalingParameterCalculator.cs	(revision 18132)
@@ -28,5 +28,5 @@
 
     /// <summary>
-    /// Additive constant
+    /// Additive offset
     /// </summary>
     public double Alpha {
@@ -103,5 +103,5 @@
     /// <param name="original">Values that should be scaled</param>
     /// <param name="target">Target values to which the original values should be scaled</param>
-    /// <param name="alpha">Additive constant for the linear scaling</param>
+    /// <param name="alpha">Additive offset for the linear scaling</param>
     /// <param name="beta">Multiplicative factor for the linear scaling</param>
     /// <param name="errorState">Flag that indicates if errors occurred in the calculation of the linea scaling parameters.</param>
Index: /trunk/HeuristicLab.Problems.ExternalEvaluation.GP/3.5/ExternalEvaluationExpressionGrammar.cs
===================================================================
--- /trunk/HeuristicLab.Problems.ExternalEvaluation.GP/3.5/ExternalEvaluationExpressionGrammar.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.ExternalEvaluation.GP/3.5/ExternalEvaluationExpressionGrammar.cs	(revision 18132)
@@ -21,4 +21,5 @@
 
 using System.Collections.Generic;
+using System.Linq;
 using HEAL.Attic;
 using HeuristicLab.Common;
@@ -62,10 +63,11 @@
       var or = new Or();
       var not = new Not();
+      var number = new Number();
+      number.MinValue = -20;
+      number.MaxValue = 20;
       var constant = new Constant();
-      constant.MinValue = -20;
-      constant.MaxValue = 20;
       variableSymbol = new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable();
 
-      var allSymbols = new List<Symbol>() { add, sub, mul, div, mean, sin, cos, tan, log, exp, @if, gt, lt, and, or, not, constant, variableSymbol };
+      var allSymbols = new List<Symbol>() { add, sub, mul, div, mean, sin, cos, tan, log, exp, @if, gt, lt, and, or, not, number, constant, variableSymbol };
       var unaryFunctionSymbols = new List<Symbol>() { sin, cos, tan, log, exp, not };
       var binaryFunctionSymbols = new List<Symbol>() { gt, lt };
@@ -86,5 +88,6 @@
 
       SetSubtreeCount(@if, 3, 3);
-      SetSubtreeCount(constant, 0, 0);
+      SetSubtreeCount(number, 0, 0);
+      SetSubtreeCount(constant,0, 0);
       SetSubtreeCount(variableSymbol, 0, 0);
 
@@ -101,4 +104,6 @@
           }
       }
+
+      Symbols.First(s => s is Constant).Enabled = false;
     }
   }
Index: /trunk/HeuristicLab.Problems.ExternalEvaluation.GP/3.5/ExternalEvaluationSymbolicExpressionTreeStringFormatter.cs
===================================================================
--- /trunk/HeuristicLab.Problems.ExternalEvaluation.GP/3.5/ExternalEvaluationSymbolicExpressionTreeStringFormatter.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.ExternalEvaluation.GP/3.5/ExternalEvaluationSymbolicExpressionTreeStringFormatter.cs	(revision 18132)
@@ -106,7 +106,7 @@
           var varNode = node as VariableTreeNode;
           strBuilder.AppendFormat("(* {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 numericNode = node as INumericTreeNode;
+          strBuilder.Append(numericNode.Value.ToString("g17", CultureInfo.InvariantCulture));
         } else {
           throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " not supported for external evaluation.");
Index: /trunk/HeuristicLab.Problems.GrammaticalEvolution/3.4/Mappers/PIGEMapper.cs
===================================================================
--- /trunk/HeuristicLab.Problems.GrammaticalEvolution/3.4/Mappers/PIGEMapper.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.GrammaticalEvolution/3.4/Mappers/PIGEMapper.cs	(revision 18132)
@@ -42,6 +42,6 @@
   ///   integer vector and rule may be one value from a "content" integer vector.
   ///   
-  ///   Order:   NT   = nont % Num. NT      ... determines, which non-terminal to expand next
-  ///   Content: Rule = rule % Num. Rules   ... rule determination as with standard GE mappers
+  ///   Order:   NT   = nont % Number. NT      ... determines, which non-terminal to expand next
+  ///   Content: Rule = rule % Number. Rules   ... rule determination as with standard GE mappers
   /// 
   /// Four mutation and crossover strategies possible:
@@ -155,10 +155,10 @@
           current.AddSubtree(GetRandomTerminalNode(current, grammar, random));
         } else {
-          // Order:   NT   = nont % Num. NT
+          // Order:   NT   = nont % Number. NT
           int nt = NontVector[genotypeIndex] % nonTerminals.Count;
           ISymbolicExpressionTreeNode current = nonTerminals[nt];
           nonTerminals.RemoveAt(nt);
 
-          // Content: Rule = rule % Num. Rules
+          // Content: Rule = rule % Number. Rules
           ISymbolicExpressionTreeNode newNode = GetNewChildNode(current, genotype, grammar, genotypeIndex, random);
           int arity = SampleArity(random, newNode, grammar);
Index: /trunk/HeuristicLab.Problems.GrammaticalEvolution/3.4/SymbolicRegression/GESymbolicExpressionGrammar.cs
===================================================================
--- /trunk/HeuristicLab.Problems.GrammaticalEvolution/3.4/SymbolicRegression/GESymbolicExpressionGrammar.cs	(revision 18131)
+++ /trunk/HeuristicLab.Problems.GrammaticalEvolution/3.4/SymbolicRegression/GESymbolicExpressionGrammar.cs	(revision 18132)
@@ -81,9 +81,4 @@
           var constVal = rand.NextDouble() * 20.0 - 10.0;
           constant.Name = string.Format("{0:0.000}", constVal);
-          constant.MinValue = constVal;
-          constant.MaxValue = constVal;
-          constant.ManipulatorSigma = 0.0;
-          constant.ManipulatorMu = 0.0;
-          constant.MultiplicativeManipulatorSigma = 0.0;
         } while (constants.Any(c => c.Name == constant.Name)); // unlikely, but it could happen that the same constant value is sampled twice. so we resample if necessary.
         constants.Add(constant);
Index: /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPSymbolicClassificationSampleTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPSymbolicClassificationSampleTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPSymbolicClassificationSampleTest.cs	(revision 18132)
@@ -109,10 +109,10 @@
       varSymbol.WeightManipulatorSigma = 0.05;
       varSymbol.MultiplicativeWeightManipulatorSigma = 0.03;
-      var constSymbol = grammar.Symbols.OfType<Constant>().Single();
-      constSymbol.MaxValue = 20;
-      constSymbol.MinValue = -20;
-      constSymbol.ManipulatorMu = 0.0;
-      constSymbol.ManipulatorSigma = 1;
-      constSymbol.MultiplicativeManipulatorSigma = 0.03;
+      var numSymbol = grammar.Symbols.OfType<Number>().Single();
+      numSymbol.MaxValue = 20;
+      numSymbol.MinValue = -20;
+      numSymbol.ManipulatorMu = 0.0;
+      numSymbol.ManipulatorSigma = 1;
+      numSymbol.MultiplicativeManipulatorSigma = 0.03;
       symbClassProblem.SymbolicExpressionTreeGrammar = grammar;
 
Index: /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPSymbolicRegressionSampleTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPSymbolicRegressionSampleTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPSymbolicRegressionSampleTest.cs	(revision 18132)
@@ -110,10 +110,10 @@
       varSymbol.WeightManipulatorSigma = 0.05;
       varSymbol.MultiplicativeWeightManipulatorSigma = 0.03;
-      var constSymbol = grammar.Symbols.OfType<Constant>().Single();
-      constSymbol.MaxValue = 20;
-      constSymbol.MinValue = -20;
-      constSymbol.ManipulatorMu = 0.0;
-      constSymbol.ManipulatorSigma = 1;
-      constSymbol.MultiplicativeManipulatorSigma = 0.03;
+      var numSymbol = grammar.Symbols.OfType<Number>().Single();
+      numSymbol.MaxValue = 20;
+      numSymbol.MinValue = -20;
+      numSymbol.ManipulatorMu = 0.0;
+      numSymbol.ManipulatorSigma = 1;
+      numSymbol.MultiplicativeManipulatorSigma = 0.03;
       symbRegProblem.SymbolicExpressionTreeGrammar = grammar;
 
Index: /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPSymbolicRegressionSampleWithOSTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPSymbolicRegressionSampleWithOSTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GPSymbolicRegressionSampleWithOSTest.cs	(revision 18132)
@@ -66,5 +66,5 @@
         // Unfortunately, running the same test on a different machine results in different values
         // For x86 environments the results below match but on x64 there is a difference
-        // We tracked down the ConstantOptimizationEvaluator as a possible cause but have not
+        // We tracked down the ParameterOptimizationEvaluator as a possible cause but have not
         // been able to identify the real cause. Presumably, execution on a Xeon and a Core i7 processor 
         // leads to different results. 
@@ -184,6 +184,6 @@
       problem.MaximumFunctionArguments.Value = 0;
 
-      var evaluator = new SymbolicRegressionConstantOptimizationEvaluator();
-      evaluator.ConstantOptimizationIterations.Value = 5;
+      var evaluator = new SymbolicRegressionParameterOptimizationEvaluator();
+      evaluator.ParameterOptimizationIterations.Value = 5;
       problem.EvaluatorParameter.Value = evaluator;
       problem.RelativeNumberOfEvaluatedSamplesParameter.Hidden = true;
Index: /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GeSymbolicRegressionSampleTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GeSymbolicRegressionSampleTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/GeSymbolicRegressionSampleTest.cs	(revision 18132)
@@ -113,4 +113,8 @@
         problem.SymbolicExpressionTreeGrammar.RemoveSymbol(c);
       }
+      var numbers = problem.SymbolicExpressionTreeGrammar.AllowedSymbols.OfType<Number>().ToList();
+      foreach (var n in numbers) {
+        problem.SymbolicExpressionTreeGrammar.RemoveSymbol(n);
+      }
 
       SamplesUtils.ConfigureOsGeneticAlgorithmParameters<GenderSpecificSelector, Encodings.IntegerVectorEncoding.SinglePointCrossover, Encodings.IntegerVectorEncoding.UniformOnePositionManipulator>(
Index: /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/ShapeConstrainedRegressionSampleTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/ShapeConstrainedRegressionSampleTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab-3.3/Samples/ShapeConstrainedRegressionSampleTest.cs	(revision 18132)
@@ -35,5 +35,5 @@
   [TestClass]
   public class ShapeConstrainedRegressionSampleTest {
-    private const string SampleFileName = "GA_Shape_Constrained_Regression";
+    private const string SampleFileName = "GP_Shape_Constrained_Regression";
     private static readonly ProtoBufSerializer serializer = new ProtoBufSerializer();
 
@@ -47,7 +47,7 @@
 
       if (Environment.Is64BitProcess) {
-        Assert.AreEqual(0.355347729912352, SamplesUtils.GetDoubleResult(ga, "BestQuality"), 1E-8);
-        Assert.AreEqual(27.6606834433137, SamplesUtils.GetDoubleResult(ga, "CurrentAverageQuality"), 1E-8);
-        Assert.AreEqual(3359.91748220025, SamplesUtils.GetDoubleResult(ga, "CurrentWorstQuality"), 1E-8);
+        Assert.AreEqual(0.035536903914644882, SamplesUtils.GetDoubleResult(ga, "BestQuality"), 1E-8);
+        Assert.AreEqual(26.707437555596698, SamplesUtils.GetDoubleResult(ga, "CurrentAverageQuality"), 1E-8);
+        Assert.AreEqual(3294.1754151628993, SamplesUtils.GetDoubleResult(ga, "CurrentWorstQuality"), 1E-8);
         Assert.AreEqual(150200, SamplesUtils.GetIntResult(ga, "EvaluatedSolutions"));
       } else {
@@ -57,4 +57,13 @@
         Assert.AreEqual(150200, SamplesUtils.GetIntResult(ga, "EvaluatedSolutions"));
       }
+    }
+
+    [TestMethod]
+    [TestCategory("Samples.Create")]
+    [TestProperty("Time", "medium")]
+    public void CreateShapeConstrainedRegressionSampleTest() {
+      var ga = CreateShapeConstrainedRegressionSample();
+      string path = Path.Combine(SamplesUtils.SamplesDirectory, SampleFileName + SamplesUtils.SampleFileExtension);
+      serializer.Serialize(ga, path);
     }
 
@@ -82,5 +91,5 @@
 
       #region Algorithm Configuration
-      alg.Name = "Genetic Programming - Shape constrained Regression";
+      alg.Name = "Genetic Programming - Shape-constrained Regression";
       alg.Description = "A standard genetic programming algorithm to solve a shape constrained regression problem (Radiated gravitational wave power - Feynman instance)";
       alg.Problem = problem;
@@ -93,4 +102,5 @@
 
       alg.Engine = new ParallelEngine.ParallelEngine();
+
       return alg;
     }
Index: /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/DeriveTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/DeriveTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/DeriveTest.cs	(revision 18132)
@@ -35,14 +35,14 @@
       var formatter = new InfixExpressionFormatter();
       var parser = new InfixExpressionParser();
-      Assert.AreEqual("0", Derive("3", "x"));
+      Assert.AreEqual("0", Derive("<num=3>", "x"));
       Assert.AreEqual("1", Derive("x", "x"));
-      Assert.AreEqual("10", Derive("10*x", "x"));
-      Assert.AreEqual("10", Derive("x*10", "x"));
+      Assert.AreEqual("10", Derive("<num=10>*x", "x"));
+      Assert.AreEqual("10", Derive("x*<num=10>", "x"));
       Assert.AreEqual("(2*'x')", Derive("x*x", "x"));
       Assert.AreEqual("((('x' * 'x') * 2) + ('x' * 'x'))", Derive("x*x*x", "x")); // simplifier does not merge (x*x)*2 + x*x  to 3*x*x
-      Assert.AreEqual("0", Derive("10*x", "y"));
-      Assert.AreEqual("20", Derive("10*x+20*y", "y"));
-      Assert.AreEqual("6", Derive("2*3*x", "x"));
-      Assert.AreEqual("(10*'y')", Derive("10*x*y+20*y", "x"));
+      Assert.AreEqual("0", Derive("<num=10>*x", "y"));
+      Assert.AreEqual("20", Derive("<num=10>*x+<num=20>*y", "y"));
+      Assert.AreEqual("6", Derive("<num=2>*<num=3>*x", "x"));
+      Assert.AreEqual("(10*'y')", Derive("<num=10>*x*y+<num=20>*y", "x"));
       Assert.AreEqual("(1 / (SQR('x') * (-1)))", Derive("1/x", "x"));
       Assert.AreEqual("('y' / (SQR('x') * (-1)))", Derive("y/x", "x"));
@@ -51,14 +51,14 @@
       Assert.AreEqual("((((-2*'x') + (-1)) * ('a' + 'b')) / SQR(('x' + SQR('x'))))", Derive("(a+b)/(x+SQR(x))", "x"));
       Assert.AreEqual("EXP('x')", Derive("exp(x)", "x"));
-      Assert.AreEqual("(EXP((3*'x')) * 3)", Derive("exp(3*x)", "x"));
+      Assert.AreEqual("(EXP((3*'x')) * 3)", Derive("exp(<num=3>*x)", "x"));
       Assert.AreEqual("(1 / 'x')", Derive("log(x)", "x"));
-      Assert.AreEqual("(1 / 'x')", Derive("log(3*x)", "x"));   // 3 * 1/(3*x)
-      Assert.AreEqual("(1 / ('x' + (0.333333333333333*'y')))", Derive("log(3*x+y)", "x"));  // simplifier does not try to keep fractions
-      Assert.AreEqual("(1 / (SQRT(((3*'x') + 'y')) * 0.666666666666667))", Derive("sqrt(3*x+y)", "x"));   // 3 / (2 * sqrt(3*x+y)) = 1 / ((2/3) * sqrt(3*x+y)) 
-      Assert.AreEqual("(COS((3*'x')) * 3)", Derive("sin(3*x)", "x"));
-      Assert.AreEqual("(SIN((3*'x')) * (-3))", Derive("cos(3*x)", "x"));
-      Assert.AreEqual("(1 / (SQR(COS((3*'x'))) * 0.333333333333333))", Derive("tan(3*x)", "x")); // diff(tan(f(x)), x) = 1.0 / cos²(f(x)), simplifier puts constant factor into the denominator
+      Assert.AreEqual("(1 / 'x')", Derive("log(<num=3>*x)", "x"));   // 3 * 1/(3*x)
+      Assert.AreEqual("(1 / ('x' + (0.333333333333333*'y')))", Derive("log(<num=3>*x+y)", "x"));  // simplifier does not try to keep fractions
+      Assert.AreEqual("(1 / (SQRT(((3*'x') + 'y')) * 0.666666666666667))", Derive("sqrt(<num=3>*x+y)", "x"));   // 3 / (2 * sqrt(3*x+y)) = 1 / ((2/3) * sqrt(3*x+y)) 
+      Assert.AreEqual("(COS((3*'x')) * 3)", Derive("sin(<num=3>*x)", "x"));
+      Assert.AreEqual("(SIN((3*'x')) * (-3))", Derive("cos(<num=3>*x)", "x"));
+      Assert.AreEqual("(1 / (SQR(COS((3*'x'))) * 0.333333333333333))", Derive("tan(<num=3>*x)", "x")); // diff(tan(f(x)), x) = 1.0 / cos²(f(x)), simplifier puts constant factor into the denominator
 
-      Assert.AreEqual("((9*'x') / ABS((3*'x')))", Derive("abs(3*x)", "x"));
+      Assert.AreEqual("((9*'x') / ABS((3*'x')))", Derive("abs(<num=3>*x)", "x"));
       Assert.AreEqual("(SQR('x') * 3)", Derive("cube(x)", "x"));
       Assert.AreEqual("(1 / (SQR(CUBEROOT('x')) * 3))", Derive("cuberoot(x)", "x"));
Index: /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionCrossoverTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionCrossoverTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionCrossoverTest.cs	(revision 18132)
@@ -110,5 +110,5 @@
       grammar.MinimumFunctionDefinitions = 0;
 
-      var trees = Util.CreateRandomTrees(twister, dataset, grammar, PopulationSize, 1, MaxTreeLength, 0, 0);
+      var trees = Util.CreateRandomTrees(twister, dataset, grammar, PopulationSize, MaxTreeLength);
       foreach (ISymbolicExpressionTree tree in trees) {
         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
Index: /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs	(revision 18132)
@@ -141,5 +141,5 @@
       grammar.ConfigureAsDefaultRegressionGrammar();
 
-      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
+      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 100);
       foreach (ISymbolicExpressionTree tree in randomTrees) {
         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
@@ -155,5 +155,5 @@
 
       var grammar = new FullFunctionalExpressionGrammar();
-      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
+      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 100);
       foreach (ISymbolicExpressionTree tree in randomTrees) {
         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
@@ -169,5 +169,5 @@
 
       var grammar = new ArithmeticExpressionGrammar();
-      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
+      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 100);
       foreach (SymbolicExpressionTree tree in randomTrees) {
         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
@@ -249,5 +249,5 @@
 
       var rows = Enumerable.Range(0, numRows).ToList();
-      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 10, 0, 0);
+      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 10);
       foreach (ISymbolicExpressionTree tree in randomTrees) {
         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
@@ -299,5 +299,5 @@
       grammar.Symbols.First(x => x is Power).Enabled = false;
 
-      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 10, 0, 0);
+      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 10);
       foreach (ISymbolicExpressionTree tree in randomTrees) {
         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
Index: /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeSimplifierTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeSimplifierTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicDataAnalysisExpressionTreeSimplifierTest.cs	(revision 18132)
@@ -230,6 +230,6 @@
 
       #region abs
-      AssertEqualAfterSimplification("(abs 2.0)", "2.0");
-      AssertEqualAfterSimplification("(abs -2.0)", "2.0"); // constant folding
+      AssertEqualAfterSimplification("(abs <num=2.0>)", "2.0");
+      AssertEqualAfterSimplification("(abs <num=-2.0>)", "2.0"); // constant folding
       AssertEqualAfterSimplification("(abs (exp (variable 2.0 x)))", "(exp (variable 2.0 x)))"); // exp is always positive
       AssertEqualAfterSimplification("(abs (exp (variable 2.0 x)))", "(exp (variable 2.0 x)))"); // exp is always positive
@@ -238,6 +238,6 @@
       AssertEqualAfterSimplification("(abs (cuberoot (variable 2.0 a)))", "(cuberoot (variable 2.0 a))"); // cuberoot is always positive (for our cases)
 
-      AssertEqualAfterSimplification("(* (abs (variable 2.0 x)) 2.0)", "(abs (variable 4.0 x))");  // can multiply positive constants into abs
-      AssertEqualAfterSimplification("(* (abs (variable 2.0 x)) -2.0)", "(* (abs (variable 4.0 x)) -1.0)"); // for negative constants keep the sign
+      AssertEqualAfterSimplification("(* (abs (variable 2.0 x)) <num=2.0>)", "(abs (variable 4.0 x))");  // can multiply positive constants into abs
+      AssertEqualAfterSimplification("(* (abs (variable 2.0 x)) <num=-2.0>)", "(* (abs (variable 4.0 x)) -1.0)"); // for negative constants keep the sign
 
       AssertEqualAfterSimplification("(abs (* (variable 1.0 a) (variable 2.0 b)))", "(* (abs (variable 1.0 a)) (abs (variable 1.0 b)) 2.0))");
@@ -265,19 +265,19 @@
 
       #region AQ
-      AssertEqualAfterSimplification("(* (aq (variable 1.0 x) (variable 1.0 y)) 2.0)", "(aq (variable 2.0 x) (variable 1.0 y))");
-      AssertEqualAfterSimplification("(/ (aq (variable 1.0 x) (variable 1.0 y)) 2.0)", "(aq (variable 0.5 x) (variable 1.0 y))");
+      AssertEqualAfterSimplification("(* (aq (variable 1.0 x) (variable 1.0 y)) <num=2.0>)", "(aq (variable 2.0 x) (variable 1.0 y))");
+      AssertEqualAfterSimplification("(/ (aq (variable 1.0 x) (variable 1.0 y)) <num=2.0>)", "(aq (variable 0.5 x) (variable 1.0 y))");
 
       #endregion
 
       #region do not drop subtrees with small weights
-      AssertEqualAfterSimplification("(* 1e-14 (variable 1.0 a))", "(variable 1e-14 a)");
-      AssertEqualAfterSimplification("(+ (variable 1.0 a) 1e-14)", 
-                                     "(+ (variable 1.0 a) 1e-14)");
+      AssertEqualAfterSimplification("(* <num=1e-14> (variable 1.0 a))", "(variable 1e-14 a)");
+      AssertEqualAfterSimplification("(+ (variable 1.0 a) <num=1e-14>)",
+                                     "(+ (variable 1.0 a) <num=1e-14>)");
       // a scenario where a term with small weight can have large effect
-      AssertEqualAfterSimplification("(+ (* (pow (variable 1.0 a) 10) 1e-14) 1.0)",
-                                     "(+ (* (pow (variable 1.0 a) 10) 1e-14) 1.0)");
+      AssertEqualAfterSimplification("(+ (* (pow (variable 1.0 a) <num=10>) <num=1e-14>) 1.0)",
+                                     "(+ (* (pow (variable 1.0 a) <num=10>) <num=1e-14>) 1.0)");
       // a test case (from ticket #2985)
-      AssertEqualAfterSimplification("(+ (* (exp (variable 3.5861E+001 a)) 5.5606E-016) 5.9323E-002)",
-                                     "(+ (* (exp (variable 3.5861E+001 a)) 5.5606E-016) 5.9323E-002)");
+      AssertEqualAfterSimplification("(+ (* (exp (variable 3.5861E+001 a)) <num=5.5606E-016>) <num=5.9323E-002>)",
+                                     "(+ (* (exp (variable 3.5861E+001 a)) <num=5.5606E-016>) <num=5.9323E-002>)");
       #endregion
     }
Index: /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicExpressionTreeBottomUpSimilarityCalculatorTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicExpressionTreeBottomUpSimilarityCalculatorTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicExpressionTreeBottomUpSimilarityCalculatorTest.cs	(revision 18132)
@@ -77,10 +77,10 @@
       var twister = new MersenneTwister(31415);
       var ds = Util.CreateRandomDataset(twister, Rows, Columns);
-      var trees = Util.CreateRandomTrees(twister, ds, grammar, N, 1, 100, 0, 0);
+      var trees = Util.CreateRandomTrees(twister, ds, grammar, N, 100);
 
       double s = 0;
       var sw = new Stopwatch();
 
-      var similarityCalculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator { MatchVariableWeights = false, MatchConstantValues = false };
+      var similarityCalculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator { MatchVariableWeights = false, MatchParameterValues = false };
 
       sw.Start();
@@ -115,7 +115,7 @@
       var twister = new MersenneTwister(31415);
       var ds = Util.CreateRandomDataset(twister, Rows, Columns);
-      var trees = Util.CreateRandomTrees(twister, ds, grammar, N, 1, 100, 0, 0);
+      var trees = Util.CreateRandomTrees(twister, ds, grammar, N, 100);
 
-      var similarityCalculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator { MatchConstantValues = strict, MatchVariableWeights = strict };
+      var similarityCalculator = new SymbolicExpressionTreeBottomUpSimilarityCalculator { MatchParameterValues = strict, MatchVariableWeights = strict };
       var bottomUpSimilarity = 0d;
       for (int i = 0; i < trees.Length - 1; ++i) {
Index: /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculatorTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculatorTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculatorTest.cs	(revision 18132)
@@ -53,5 +53,5 @@
       var twister = new MersenneTwister(31415);
       var ds = Util.CreateRandomDataset(twister, Rows, Columns);
-      var trees = Util.CreateRandomTrees(twister, ds, grammar, N, 1, 100, 0, 0);
+      var trees = Util.CreateRandomTrees(twister, ds, grammar, N, 100);
 
       double s = 0;
Index: /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/Util.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/Util.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4/Util.cs	(revision 18132)
@@ -35,7 +35,7 @@
           varNode.Weight = twister.NextDouble() * 20.0 - 10.0;
           varNode.VariableName = varNames[twister.Next(varNames.Count)];
-        } else if (node is ConstantTreeNode) {
-          var constantNode = node as ConstantTreeNode;
-          constantNode.Value = twister.NextDouble() * 20.0 - 10.0;
+        } else if (node is NumberTreeNode) {
+          var numNode = node as NumberTreeNode;
+          numNode.Value = twister.NextDouble() * 20.0 - 10.0;
         }
       }
@@ -44,10 +44,9 @@
 
     public static ISymbolicExpressionTree[] CreateRandomTrees(MersenneTwister twister, Dataset dataset, ISymbolicExpressionGrammar grammar, int popSize) {
-      return CreateRandomTrees(twister, dataset, grammar, popSize, 1, 200, 3, 3);
+      return CreateRandomTrees(twister, dataset, grammar, popSize, 200);
     }
 
     public static ISymbolicExpressionTree[] CreateRandomTrees(MersenneTwister twister, Dataset dataset, ISymbolicExpressionGrammar grammar,
-      int popSize, int minSize, int maxSize,
-      int maxFunctionDefinitions, int maxFunctionArguments) {
+      int popSize, int maxSize) {
       foreach (Variable variableSymbol in grammar.Symbols.OfType<Variable>()) {
         variableSymbol.VariableNames = dataset.VariableNames.Skip(1);
Index: /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis-3.4/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis-3.4/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis-3.4/SymbolicDataAnalysisExpressionTreeInterpreterTest.cs	(revision 18132)
@@ -66,5 +66,5 @@
       grammar.MinimumFunctionArguments = 0;
       grammar.MinimumFunctionDefinitions = 0;
-      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
+      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 100);
       foreach (ISymbolicExpressionTree tree in randomTrees) {
         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
@@ -83,5 +83,5 @@
       grammar.MinimumFunctionArguments = 0;
       grammar.MinimumFunctionDefinitions = 0;
-      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
+      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 100);
       foreach (ISymbolicExpressionTree tree in randomTrees) {
         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
@@ -100,5 +100,5 @@
       grammar.MinimumFunctionArguments = 0;
       grammar.MinimumFunctionDefinitions = 0;
-      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 1, 100, 0, 0);
+      var randomTrees = Util.CreateRandomTrees(twister, dataset, grammar, N, 100);
       foreach (SymbolicExpressionTree tree in randomTrees) {
         Util.InitTree(tree, twister, new List<string>(dataset.VariableNames));
Index: /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis-3.4/Util.cs
===================================================================
--- /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis-3.4/Util.cs	(revision 18131)
+++ /trunk/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis-3.4/Util.cs	(revision 18132)
@@ -35,7 +35,7 @@
           varNode.Weight = twister.NextDouble() * 20.0 - 10.0;
           varNode.VariableName = varNames[twister.Next(varNames.Count)];
-        } else if (node is ConstantTreeNode) {
-          var constantNode = node as ConstantTreeNode;
-          constantNode.Value = twister.NextDouble() * 20.0 - 10.0;
+        } else if (node is NumberTreeNode) {
+          var numNode = node as NumberTreeNode;
+          numNode.Value = twister.NextDouble() * 20.0 - 10.0;
         }
       }
@@ -44,10 +44,9 @@
 
     public static ISymbolicExpressionTree[] CreateRandomTrees(MersenneTwister twister, Dataset dataset, ISymbolicExpressionGrammar grammar, int popSize) {
-      return CreateRandomTrees(twister, dataset, grammar, popSize, 1, 200, 3, 3);
+      return CreateRandomTrees(twister, dataset, grammar, popSize, 200);
     }
 
     public static ISymbolicExpressionTree[] CreateRandomTrees(MersenneTwister twister, Dataset dataset, ISymbolicExpressionGrammar grammar,
-      int popSize, int minSize, int maxSize,
-      int maxFunctionDefinitions, int maxFunctionArguments) {
+      int popSize, int maxSize) {
       foreach (Variable variableSymbol in grammar.Symbols.OfType<Variable>()) {
         variableSymbol.VariableNames = dataset.VariableNames.Skip(1);
