Index: /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs	(revision 18114)
@@ -239,8 +239,8 @@
     }
 
-    private ISymbolicExpressionTreeNode CreateSymbolicRegressionTreeRecursive(TreeNode[] treeNodes, int nodeIdx, VariableCondition varCondSy, Number constSy) {
+    private ISymbolicExpressionTreeNode CreateSymbolicRegressionTreeRecursive(TreeNode[] treeNodes, int nodeIdx, VariableCondition varCondSy, Number numSy) {
       var curNode = treeNodes[nodeIdx];
       if (curNode.VarName == TreeNode.NO_VARIABLE) {
-        var node = (NumberTreeNode)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: /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs	(revision 18114)
@@ -123,6 +123,6 @@
       : 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("<num> * 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.", 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 +210,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) {
@@ -265,5 +265,5 @@
       if (!SymbolicRegressionParameterOptimizationEvaluator.CanOptimizeParameters(tree)) throw new ArgumentException("The optimizer does not support the specified model structure.");
 
-      // initialize constants randomly
+      // initialize parameters randomly
       if (rand != null) {
         foreach (var node in tree.IterateNodesPrefix().OfType<NumberTreeNode>()) {
Index: /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelAlglib_3_7.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelAlglib_3_7.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelAlglib_3_7.cs	(revision 18114)
@@ -232,5 +232,5 @@
     }
 
-    private ISymbolicExpressionTreeNode CreateRegressionTreeRec(double[] trees, int offset, int k, Number 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,6 +261,6 @@
       // }
 
-      if ((double)(trees[k]) == (double)(-1)) {
-        var numNode = (NumberTreeNode)constSy.CreateTreeNode();
+      if (trees[k] == -1) {
+        var numNode = (NumberTreeNode)numSy.CreateTreeNode();
         numNode.Value = trees[k + 1];
         return numNode;
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelFull.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelFull.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelFull.cs	(revision 18114)
@@ -211,5 +211,5 @@
     }
 
-    private ISymbolicExpressionTreeNode CreateRegressionTreeRec(double[] trees, int offset, int k, Number 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,6 +240,6 @@
       // }
 
-      if ((double)(trees[k]) == (double)(-1)) {
-        var numNode = (NumberTreeNode)constSy.CreateTreeNode();
+      if (trees[k] == -1) {
+        var numNode = (NumberTreeNode)numSy.CreateTreeNode();
         numNode.Value = trees[k + 1];
         return numNode;
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs	(revision 18114)
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNodeSimilarityComparer.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNodeSimilarityComparer.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNodeSimilarityComparer.cs	(revision 18114)
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/FullTreeShaker.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/FullTreeShaker.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/FullTreeShaker.cs	(revision 18114)
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs	(revision 18114)
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationPruningOperator.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationPruningOperator.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicClassificationPruningOperator.cs	(revision 18114)
@@ -103,6 +103,6 @@
         if (node is NumberTreeNode) 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;
@@ -112,5 +112,5 @@
         numberNode.Value = replacementValue;
 
-        ReplaceWithConstant(node, numberNode);
+        ReplaceWithNumber(node, numberNode);
         i += node.GetLength() - 1; // skip subtrees under the node that was folded
 
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.Designer.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.Designer.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.Designer.cs	(revision 18114)
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs	(revision 18114)
@@ -42,5 +42,5 @@
 
       var tree = Content?.Model?.SymbolicExpressionTree;
-      btnOptimizeConstants.Enabled = tree != null && SymbolicRegressionParameterOptimizationEvaluator.CanOptimizeParameters(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;
@@ -65,7 +65,7 @@
         prevResult = result;
         result = SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(model.Interpreter, tree, regressionProblemData, regressionProblemData.TrainingIndices,
-          applyLinearScaling: true, maxIterations: constOptIterations, updateVariableWeights: true, lowerEstimationLimit: model.LowerEstimationLimit, upperEstimationLimit: model.UpperEstimationLimit,
+          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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPruningOperator.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPruningOperator.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionPruningOperator.cs	(revision 18114)
@@ -93,15 +93,14 @@
         if (node is NumberTreeNode) continue;
 
-        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 = (NumberTreeNode)node.Grammar.GetSymbol("Number").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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis.Views/3.4/InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView.Designer.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis.Views/3.4/InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView.Designer.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis.Views/3.4/InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView.Designer.cs	(revision 18114)
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.Designer.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.Designer.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.Designer.cs	(revision 18114)
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs	(revision 18114)
@@ -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;
@@ -204,5 +204,5 @@
         var replacementValues = impactAndReplacementValues.ToDictionary(x => x.Key, x => x.Value.Item2);
         foreach (var pair in replacementValues.Where(pair => !(pair.Key is NumberTreeNode))) {
-          foldedNodes[pair.Key] = MakeConstantTreeNode(pair.Value);
+          foldedNodes[pair.Key] = MakeNumberTreeNode(pair.Value);
         }
         
@@ -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 NumberTreeNode MakeConstantTreeNode(double value) {
-      var constant = new Number { MinValue = value - 1, MaxValue = value + 1 };
-      var constantTreeNode = (NumberTreeNode)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;
     }
 
@@ -314,7 +314,6 @@
           }
           visualTree.ToolTip += Environment.NewLine + "Node impact: " + impact;
-          var constantReplacementNode = foldedNodes[treeNode] as NumberTreeNode;
-          if (constantReplacementNode != null) {
-            visualTree.ToolTip += Environment.NewLine + "Replacement value: " + constantReplacementNode.Value;
+          if (foldedNodes[treeNode] is NumberTreeNode numReplacementNode) {
+            visualTree.ToolTip += Environment.NewLine + "Replacement value: " + numReplacementNode.Value;
           }
         }
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.Designer.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.Designer.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.Designer.cs	(revision 18114)
@@ -97,5 +97,5 @@
       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.toolTip.SetToolTip(this.weightNuLabel, "The minimal value to use for random initialization of numbers.");
       // 
       // minValueTextBox
@@ -108,5 +108,5 @@
       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.toolTip.SetToolTip(this.minValueTextBox, "The minimal value to use for random initialization of numbers.");
       this.minValueTextBox.TextChanged += new System.EventHandler(this.minValueTextBox_TextChanged);
       // 
@@ -134,5 +134,5 @@
       this.weightSigmaLabel.TabIndex = 2;
       this.weightSigmaLabel.Text = "Max value:";
-      this.toolTip.SetToolTip(this.weightSigmaLabel, "The maximal value to use for random initialization of constants.");
+      this.toolTip.SetToolTip(this.weightSigmaLabel, "The maximal value to use for random initialization of numbers.");
       // 
       // maxValueTextBox
@@ -145,5 +145,5 @@
       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.toolTip.SetToolTip(this.maxValueTextBox, "The maximal value to use for random initialization of numbers.");
       this.maxValueTextBox.TextChanged += new System.EventHandler(this.maxValueTextBox_TextChanged);
       // 
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.Designer.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.Designer.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.Designer.cs	(revision 18114)
@@ -142,5 +142,5 @@
       this.ShowInTaskbar = false;
       this.StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
-      this.Text = "Edit constant value";
+      this.Text = "Edit number value";
       this.KeyDown += new System.Windows.Forms.KeyEventHandler(this.NumberNodeEditDialog_KeyDown);
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeConstantNodeEditDialog.cs	(revision 18114)
@@ -51,5 +51,5 @@
         throw new ArgumentException("Node is not a number.");
       else {
-        this.Text = "Edit constant";
+        this.Text = "Edit number";
         newValueTextBox.Text = oldValueTextBox.Text = Math.Round(numberTreeNode.Value, 4).ToString();
       }
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeNodeInsertDialog.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeNodeInsertDialog.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeNodeInsertDialog.cs	(revision 18114)
@@ -58,5 +58,5 @@
       var symbol = combo.Items[combo.SelectedIndex];
       if (symbol is Number) {
-        // add controls to the dialog for changing the constant value
+        // add controls to the dialog for changing the number value
         variableNameLabel.Visible = false;
         variableNamesCombo.Visible = false;
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeVariableNodeEditDialog.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeVariableNodeEditDialog.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TreeEditDialogs/SymbolicExpressionTreeVariableNodeEditDialog.cs	(revision 18114)
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs	(revision 18114)
@@ -88,6 +88,4 @@
       StringBuilder builder = new StringBuilder();
       var varTreeNode = tree as VariableTreeNode;
-      var numTreeNode = tree as NumberTreeNode;
-      var constTreeNode = tree as ConstantTreeNode;
       var factorVarTreeNode = tree as FactorVariableTreeNode;
       var binFactorVarTreeNode = tree as BinaryFactorVariableTreeNode;
@@ -98,6 +96,6 @@
       } else if (binFactorVarTreeNode != null) {
         builder.Append("(factor " + binFactorVarTreeNode.VariableName + "=" + binFactorVarTreeNode.VariableValue);
-      } else if (numTreeNode != null || 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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs	(revision 18114)
@@ -42,5 +42,4 @@
 
     private static readonly Number numberSy = new Number();
-    private static readonly Constant constSy = new Constant();
     private static readonly Addition addSy = new Addition();
     private static readonly Subtraction subSy = new Subtraction();
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs	(revision 18114)
@@ -25,5 +25,4 @@
 using System.Collections.Generic;
 using System.Linq;
-using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
@@ -37,5 +36,4 @@
     private static readonly Division divSymbol = new Division();
     private static readonly Number numberSymbol = new Number();
-    private static readonly Constant constSymbol = new Constant();
     private static readonly Absolute absSymbol = new Absolute();
     private static readonly Logarithm logSymbol = new Logarithm();
@@ -241,4 +239,8 @@
     }
 
+    private static bool IsConstantOrNumber(ISymbolicExpressionTreeNode node) {
+      return node is INumericTreeNode;
+    }
+
     private static bool IsNumber(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Number;
@@ -265,5 +267,5 @@
     /// <returns></returns>
     public static ISymbolicExpressionTreeNode GetSimplifiedTree(ISymbolicExpressionTreeNode original) {
-      if (IsNumber(original) || IsConstant(original) || IsVariableBase(original)) {
+      if (IsConstantOrNumber(original) || IsVariableBase(original)) {
         return (ISymbolicExpressionTreeNode)original.Clone();
       } else if (IsAbsolute(original)) {
@@ -339,12 +341,12 @@
         clone.AddSubtree(simplifiedSubtree);
       }
-      if (simplifiedSubtrees.TrueForAll(IsNumber)) {
-        SimplifyConstantExpression(clone);
+      if (simplifiedSubtrees.TrueForAll(IsConstantOrNumber)) {
+        FoldNumbers(clone);
       }
       return clone;
     }
 
-    private static ISymbolicExpressionTreeNode SimplifyConstantExpression(ISymbolicExpressionTreeNode original) {
-      // not yet implemented
+    private static ISymbolicExpressionTreeNode FoldNumbers(ISymbolicExpressionTreeNode original) {
+      // TODO not yet implemented
       return original;
     }
@@ -358,6 +360,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()));
       }
     }
@@ -373,6 +375,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)))));
       }
     }
@@ -384,5 +386,5 @@
         return original.Subtrees
           .Select(GetSimplifiedTree)
-          .Aggregate(MakeProduct);
+          .Aggregate(Product);
       }
     }
@@ -396,5 +398,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))));
       }
     }
@@ -408,14 +410,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)));
     }
 
@@ -423,5 +425,5 @@
       return original.Subtrees
         .Select(GetSimplifiedTree)
-        .Aggregate(MakeOr);
+        .Aggregate(Or);
     }
 
@@ -429,65 +431,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)));
     }
 
@@ -498,5 +500,5 @@
         return AddLagToDynamicNodes(simplifiedSubtree, laggedTreeNode.Lag);
       } else {
-        return MakeTimeLag(simplifiedSubtree, laggedTreeNode.Lag);
+        return TimeLag(simplifiedSubtree, laggedTreeNode.Lag);
       }
     }
@@ -505,8 +507,8 @@
       var laggedTreeNode = original as ILaggedTreeNode;
       var simplifiedSubtree = GetSimplifiedTree(original.GetSubtree(0));
-      if (IsNumber(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);
       }
     }
@@ -516,5 +518,5 @@
     #region low level tree restructuring
 
-    private static ISymbolicExpressionTreeNode MakeTimeLag(ISymbolicExpressionTreeNode subtree, int lag) {
+    private static ISymbolicExpressionTreeNode TimeLag(ISymbolicExpressionTreeNode subtree, int lag) {
       if (lag == 0) return subtree;
       if (IsNumber(subtree)) return subtree;
@@ -525,8 +527,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();
@@ -537,9 +539,9 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeNot(ISymbolicExpressionTreeNode t) {
+    private static ISymbolicExpressionTreeNode Not(ISymbolicExpressionTreeNode t) {
       if (IsNumber(t)) {
         var constNode = t as NumberTreeNode;
-        if (constNode.Value > 0) return MakeConstant(-1.0);
-        else return MakeConstant(1.0);
+        if (constNode.Value > 0) return Number(-1.0);
+        else return Number(1.0);
       } else if (IsNot(t)) {
         return t.GetSubtree(0);
@@ -547,5 +549,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);
@@ -558,20 +560,20 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeOr(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode Or(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsNumber(a) && IsNumber(b)) {
         var constA = a as NumberTreeNode;
         var constB = b as NumberTreeNode;
         if (constA.Value > 0.0 || constB.Value > 0.0) {
-          return MakeConstant(1.0);
+          return Number(1.0);
         } else {
-          return MakeConstant(-1.0);
+          return Number(-1.0);
         }
       } else if (IsNumber(a)) {
-        return MakeOr(b, a);
+        return Or(b, a);
       } else if (IsNumber(b)) {
         var constT = b as NumberTreeNode;
         if (constT.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
@@ -588,15 +590,15 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeAnd(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode And(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsNumber(a) && IsNumber(b)) {
         var constA = a as NumberTreeNode;
         var constB = b as NumberTreeNode;
         if (constA.Value > 0.0 && constB.Value > 0.0) {
-          return MakeConstant(1.0);
+          return Number(1.0);
         } else {
-          return MakeConstant(-1.0);
+          return Number(-1.0);
         }
       } else if (IsNumber(a)) {
-        return MakeAnd(b, a);
+        return And(b, a);
       } else if (IsNumber(b)) {
         var constB = b as NumberTreeNode;
@@ -608,5 +610,5 @@
         } else {
           // boolean expression is necessarily false
-          return MakeConstant(-1.0);
+          return Number(-1.0);
         }
       } else {
@@ -618,11 +620,11 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeLessThan(ISymbolicExpressionTreeNode leftSide,
+    private static ISymbolicExpressionTreeNode LessThan(ISymbolicExpressionTreeNode leftSide,
       ISymbolicExpressionTreeNode rightSide) {
       if (IsNumber(leftSide) && IsNumber(rightSide)) {
         var lsConst = leftSide as NumberTreeNode;
         var rsConst = rightSide as NumberTreeNode;
-        if (lsConst.Value < rsConst.Value) return MakeConstant(1.0);
-        else return MakeConstant(-1.0);
+        if (lsConst.Value < rsConst.Value) return Number(1.0);
+        else return Number(-1.0);
       } else {
         var ltNode = ltSymbol.CreateTreeNode();
@@ -633,11 +635,11 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeGreaterThan(ISymbolicExpressionTreeNode leftSide,
+    private static ISymbolicExpressionTreeNode GreaterThan(ISymbolicExpressionTreeNode leftSide,
       ISymbolicExpressionTreeNode rightSide) {
       if (IsNumber(leftSide) && IsNumber(rightSide)) {
         var lsConst = leftSide as NumberTreeNode;
         var rsConst = rightSide as NumberTreeNode;
-        if (lsConst.Value > rsConst.Value) return MakeConstant(1.0);
-        else return MakeConstant(-1.0);
+        if (lsConst.Value > rsConst.Value) return Number(1.0);
+        else return Number(-1.0);
       } else {
         var gtNode = gtSymbol.CreateTreeNode();
@@ -648,5 +650,5 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeIfThenElse(ISymbolicExpressionTreeNode condition,
+    private static ISymbolicExpressionTreeNode IfThenElse(ISymbolicExpressionTreeNode condition,
       ISymbolicExpressionTreeNode trueBranch, ISymbolicExpressionTreeNode falseBranch) {
       if (IsNumber(condition)) {
@@ -661,5 +663,5 @@
           var gtNode = gtSymbol.CreateTreeNode();
           gtNode.AddSubtree(condition);
-          gtNode.AddSubtree(MakeConstant(0.0));
+          gtNode.AddSubtree(Number(0.0));
           ifNode.AddSubtree(gtNode);
         }
@@ -670,14 +672,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeSine(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode Sine(ISymbolicExpressionTreeNode node) {
       if (IsNumber(node)) {
         var constT = node as NumberTreeNode;
-        return MakeConstant(Math.Sin(constT.Value));
+        return Number(Math.Sin(constT.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();
@@ -687,14 +689,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeTangent(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode Tangent(ISymbolicExpressionTreeNode node) {
       if (IsNumber(node)) {
         var constT = node as NumberTreeNode;
-        return MakeConstant(Math.Tan(constT.Value));
+        return Number(Math.Tan(constT.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();
@@ -704,16 +706,16 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeCosine(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode Cosine(ISymbolicExpressionTreeNode node) {
       if (IsNumber(node)) {
         var constT = node as NumberTreeNode;
-        return MakeConstant(Math.Cos(constT.Value));
+        return Number(Math.Cos(constT.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();
@@ -723,22 +725,22 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeExp(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode Exp(ISymbolicExpressionTreeNode node) {
       if (IsNumber(node)) {
         var constT = node as NumberTreeNode;
-        return MakeConstant(Math.Exp(constT.Value));
+        return Number(Math.Exp(constT.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();
@@ -747,15 +749,15 @@
       }
     }
-    private static ISymbolicExpressionTreeNode MakeLog(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode Log(ISymbolicExpressionTreeNode node) {
       if (IsNumber(node)) {
         var constT = node as NumberTreeNode;
-        return MakeConstant(Math.Log(constT.Value));
+        return Number(Math.Log(constT.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();
@@ -765,14 +767,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeSquare(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode Square(ISymbolicExpressionTreeNode node) {
       if (IsNumber(node)) {
         var constT = node as NumberTreeNode;
-        return MakeConstant(constT.Value * constT.Value);
+        return Number(constT.Value * constT.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);
@@ -781,15 +783,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();
@@ -799,22 +801,22 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeCube(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode Cube(ISymbolicExpressionTreeNode node) {
       if (IsNumber(node)) {
         var constT = node as NumberTreeNode;
-        return MakeConstant(constT.Value * constT.Value * constT.Value);
+        return Number(constT.Value * constT.Value * constT.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();
@@ -824,14 +826,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeAbs(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode Abs(ISymbolicExpressionTreeNode node) {
       if (IsNumber(node)) {
         var constT = node as NumberTreeNode;
-        return MakeConstant(Math.Abs(constT.Value));
+        return Number(Math.Abs(constT.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) ...
@@ -839,5 +841,5 @@
         var mul = mulSymbol.CreateTreeNode();
         foreach (var st in node.Subtrees) {
-          mul.AddSubtree(MakeAbs(st));
+          mul.AddSubtree(Abs(st));
         }
         return mul;
@@ -845,5 +847,5 @@
         var div = divSymbol.CreateTreeNode();
         foreach (var st in node.Subtrees) {
-          div.AddSubtree(MakeAbs(st));
+          div.AddSubtree(Abs(st));
         }
         return div;
@@ -856,14 +858,14 @@
 
     // constant folding only
-    private static ISymbolicExpressionTreeNode MakeAnalyticalQuotient(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode AQ(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsNumber(b)) {
         var c = b as NumberTreeNode;
-        return MakeFraction(a, MakeConstant(Math.Sqrt(1.0 + c.Value * c.Value)));
+        return Fraction(a, Number(Math.Sqrt(1.0 + c.Value * c.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();
@@ -874,14 +876,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeSquareRoot(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode SquareRoot(ISymbolicExpressionTreeNode node) {
       if (IsNumber(node)) {
         var constT = node as NumberTreeNode;
-        return MakeConstant(Math.Sqrt(constT.Value));
+        return Number(Math.Sqrt(constT.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
@@ -893,14 +895,14 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeCubeRoot(ISymbolicExpressionTreeNode node) {
+    private static ISymbolicExpressionTreeNode CubeRoot(ISymbolicExpressionTreeNode node) {
       if (IsNumber(node)) {
         var constT = node as NumberTreeNode;
-        return MakeConstant(Math.Pow(constT.Value, 1.0 / 3.0));
+        return Number(Math.Pow(constT.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);
@@ -912,30 +914,30 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeRoot(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode Root(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsNumber(a) && IsNumber(b)) {
         var constA = a as NumberTreeNode;
         var constB = b as NumberTreeNode;
-        return MakeConstant(Math.Pow(constA.Value, 1.0 / Math.Round(constB.Value)));
+        return Number(Math.Pow(constA.Value, 1.0 / Math.Round(constB.Value)));
       } else if (IsFactor(a) && IsNumber(b)) {
         var factNode = a as FactorVariableTreeNode;
         var constNode = b as NumberTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName,
+        return Factor(factNode.Symbol, factNode.VariableName,
           factNode.Weights.Select(w => Math.Pow(w, 1.0 / Math.Round(constNode.Value))));
       } else if (IsBinFactor(a) && IsNumber(b)) {
         var binFactor = a as BinaryFactorVariableTreeNode;
         var constNode = b as NumberTreeNode;
-        return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Pow(binFactor.Weight, 1.0 / Math.Round(constNode.Value)));
+        return BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Pow(binFactor.Weight, 1.0 / Math.Round(constNode.Value)));
       } else if (IsNumber(a) && IsFactor(b)) {
         var constNode = 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))));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(constNode.Value, 1.0 / Math.Round(w))));
       } else if (IsNumber(a) && IsBinFactor(b)) {
         var constNode = 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(constNode.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))));
+        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 constB = b as NumberTreeNode;
@@ -947,18 +949,18 @@
           // root(a, 0) is not defined 
           //return MakeConstant(1.0);
-          return MakeConstant(double.NaN);
+          return Number(double.NaN);
         } else if (constBValue == -1.0) {
           // root(a, -1) => a^(-1/1) => 1/a
-          return MakeFraction(MakeConstant(1.0), a);
+          return Fraction(Number(1.0), a);
         } else if (constBValue < 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 * constBValue));
+          return Fraction(Number(1.0), rootNode);
         } else {
           var rootNode = rootSymbol.CreateTreeNode();
           rootNode.AddSubtree(a);
-          rootNode.AddSubtree(MakeConstant(constBValue));
+          rootNode.AddSubtree(Number(constBValue));
           return rootNode;
         }
@@ -972,29 +974,29 @@
 
 
-    private static ISymbolicExpressionTreeNode MakePower(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode Power(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsNumber(a) && IsNumber(b)) {
         var constA = a as NumberTreeNode;
         var constB = b as NumberTreeNode;
-        return MakeConstant(Math.Pow(constA.Value, Math.Round(constB.Value)));
+        return Number(Math.Pow(constA.Value, Math.Round(constB.Value)));
       } else if (IsFactor(a) && IsNumber(b)) {
         var factNode = a as FactorVariableTreeNode;
         var constNode = b as NumberTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(w, Math.Round(constNode.Value))));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(w, Math.Round(constNode.Value))));
       } else if (IsBinFactor(a) && IsNumber(b)) {
         var binFactor = a as BinaryFactorVariableTreeNode;
         var constNode = b as NumberTreeNode;
-        return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Pow(binFactor.Weight, Math.Round(constNode.Value)));
+        return BinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Pow(binFactor.Weight, Math.Round(constNode.Value)));
       } else if (IsNumber(a) && IsFactor(b)) {
         var constNode = 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))));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(constNode.Value, Math.Round(w))));
       } else if (IsNumber(a) && IsBinFactor(b)) {
         var constNode = 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(constNode.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))));
+        return Factor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => Math.Pow(u, Math.Round(v))));
       } else if (IsNumber(b)) {
         var constB = b as NumberTreeNode;
@@ -1002,5 +1004,5 @@
         if (exponent == 0.0) {
           // a^0 => 1
-          return MakeConstant(1.0);
+          return Number(1.0);
         } else if (exponent == 1.0) {
           // a^1 => a
@@ -1008,15 +1010,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;
         }
@@ -1031,11 +1033,11 @@
 
     // MakeFraction, MakeProduct and MakeSum take two already simplified trees and create a new simplified tree
-    private static ISymbolicExpressionTreeNode MakeFraction(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode Fraction(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsNumber(a) && IsNumber(b)) {
         // fold constants
-        return MakeConstant(((NumberTreeNode)a).Value / ((NumberTreeNode)b).Value);
+        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)));
+        return Fraction(Number(1.0), Product(b, Invert(a)));
       } else if (IsVariableBase(a) && IsNumber(b)) {
         // merge constant values into variable weights
@@ -1046,13 +1048,13 @@
         var factNode = a as FactorVariableTreeNode;
         var constNode = b as NumberTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => w / constNode.Value));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => w / constNode.Value));
       } else if (IsBinFactor(a) && IsNumber(b)) {
         var factNode = a as BinaryFactorVariableTreeNode;
         var constNode = b as NumberTreeNode;
-        return MakeBinFactor(factNode.Symbol, factNode.VariableName, factNode.VariableValue, factNode.Weight / constNode.Value);
+        return BinFactor(factNode.Symbol, factNode.VariableName, factNode.VariableValue, factNode.Weight / constNode.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;
@@ -1066,33 +1068,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);
+        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));
+          .Select(x => Fraction(x, GetSimplifiedTree(b)))
+          .Aggregate((c, d) => Sum(c, d));
       } else if (IsMultiplication(a) && IsNumber(b)) {
-        return MakeProduct(a, Invert(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();
@@ -1103,5 +1105,5 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeSum(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode Sum(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsNumber(a) && IsNumber(b)) {
         // fold constants
@@ -1111,5 +1113,5 @@
         // c + x => x + c
         // b is not constant => make sure constant is on the right
-        return MakeSum(b, a);
+        return Sum(b, a);
       } else if (IsNumber(b) && ((NumberTreeNode)b).Value == 0.0) {
         // x + 0 => x
@@ -1118,11 +1120,11 @@
         var factNode = a as FactorVariableTreeNode;
         var constNode = b as NumberTreeNode;
-        return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select((w) => w + constNode.Value));
+        return Factor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select((w) => w + constNode.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) {
@@ -1135,5 +1137,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
@@ -1143,5 +1145,5 @@
         for (int i = 0; i < b.Subtrees.Count() - 1; i++) add.AddSubtree(b.GetSubtree(i));
         if (IsNumber(a.Subtrees.Last()) && IsNumber(b.Subtrees.Last())) {
-          add.AddSubtree(MakeSum(a.Subtrees.Last(), b.Subtrees.Last()));
+          add.AddSubtree(Sum(a.Subtrees.Last(), b.Subtrees.Last()));
         } else if (IsNumber(a.Subtrees.Last())) {
           add.AddSubtree(b.Subtrees.Last());
@@ -1158,5 +1160,5 @@
         }
       } else if (IsAddition(b)) {
-        return MakeSum(b, a);
+        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
@@ -1165,5 +1167,5 @@
         for (int i = 0; i < a.Subtrees.Count() - 1; i++) add.AddSubtree(a.GetSubtree(i));
         if (IsNumber(a.Subtrees.Last()))
-          add.AddSubtree(MakeSum(a.Subtrees.Last(), b));
+          add.AddSubtree(Sum(a.Subtrees.Last(), b));
         else {
           add.AddSubtree(a.Subtrees.Last());
@@ -1229,5 +1231,5 @@
         sum.AddSubtree(unchangedSubtree);
       if (constant != 0.0) {
-        sum.AddSubtree(MakeConstant(constant));
+        sum.AddSubtree(Number(constant));
       }
     }
@@ -1253,29 +1255,29 @@
 
 
-    private static ISymbolicExpressionTreeNode MakeProduct(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
+    private static ISymbolicExpressionTreeNode Product(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
       if (IsNumber(a) && IsNumber(b)) {
         // fold constants
-        return MakeConstant(((NumberTreeNode)a).Value * ((NumberTreeNode)b).Value);
+        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);
+        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 NumberTreeNode;
-        return MakeFactor(node0.Symbol, node0.VariableName, node0.Weights.Select(w => w * node1.Value));
+        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 NumberTreeNode;
-        return MakeBinFactor(node0.Symbol, node0.VariableName, node0.VariableValue, node0.Weight * node1.Value);
+        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) {
@@ -1285,10 +1287,10 @@
         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]);
+        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 (IsNumber(b) && ((NumberTreeNode)b).Value == 0.0) {
-        return MakeConstant(0);
+        return Number(0);
       } else if (IsNumber(b) && IsVariableBase(a)) {
         // multiply constants into variables weights
@@ -1299,14 +1301,14 @@
           IsBinFactor(b) && IsAddition(a)) {
         // multiply constants into additions
-        return a.Subtrees.Select(x => MakeProduct(GetSimplifiedTree(x), GetSimplifiedTree(b))).Aggregate((c, d) => MakeSum(c, d));
+        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)
@@ -1317,5 +1319,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
@@ -1324,18 +1326,18 @@
         return a;
       } else if (IsAbsolute(a) && IsAbsolute(b)) {
-        return MakeAbs(MakeProduct(a.GetSubtree(0), b.GetSubtree(0)));
+        return Abs(Product(a.GetSubtree(0), b.GetSubtree(0)));
       } else if (IsAbsolute(a) && IsNumber(b)) {
         var constNode = b as NumberTreeNode;
         var posF = Math.Abs(constNode.Value);
         if (constNode.Value > 0) {
-          return MakeAbs(MakeProduct(a.GetSubtree(0), MakeConstant(posF)));
+          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();
@@ -1438,5 +1440,5 @@
 
       if (constantProduct != 1.0) {
-        prod.AddSubtree(MakeConstant(constantProduct));
+        prod.AddSubtree(Number(constantProduct));
       }
     }
@@ -1475,5 +1477,5 @@
       } else {
         // any other function
-        return MakeProduct(x, MakeConstant(-1));
+        return Product(x, Number(-1));
       }
       return x;
@@ -1488,17 +1490,17 @@
     private static ISymbolicExpressionTreeNode Invert(ISymbolicExpressionTreeNode x) {
       if (IsNumber(x)) {
-        return MakeConstant(1.0 / ((NumberTreeNode)x).Value);
+        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) {
+        return Fraction(Number(1), x);
+      }
+    }
+
+    private static ISymbolicExpressionTreeNode Number(double value) {
       NumberTreeNode numberTreeNode = (NumberTreeNode)(numberSymbol.CreateTreeNode());
       numberTreeNode.Value = value;
@@ -1506,5 +1508,5 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeFactor(FactorVariable sy, string variableName, IEnumerable<double> weights) {
+    private static ISymbolicExpressionTreeNode Factor(FactorVariable sy, string variableName, IEnumerable<double> weights) {
       var tree = (FactorVariableTreeNode)sy.CreateTreeNode();
       tree.VariableName = variableName;
@@ -1512,5 +1514,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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeToAutoDiffTermConverter.cs	(revision 18114)
@@ -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;
@@ -130,5 +130,5 @@
     // state for recursive transformation of trees 
     private readonly
-    List<double> initialConstants;
+    List<double> initialParamValues;
     private readonly Dictionary<DataForVariable, AutoDiff.Variable> parameters;
     private readonly List<AutoDiff.Variable> variables;
@@ -139,5 +139,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>();
@@ -146,5 +146,5 @@
     private AutoDiff.Term ConvertToAutoDiff(ISymbolicExpressionTreeNode node) {
       if (node.Symbol is Number) {
-        initialConstants.Add(((NumberTreeNode)node).Value);
+        initialParamValues.Add(((NumberTreeNode)node).Value);
         var var = new AutoDiff.Variable();
         variables.Add(var);
@@ -153,5 +153,5 @@
 
       if (node.Symbol is Constant) {
-        initialConstants.Add(((ConstantTreeNode)node).Value);
+        initialParamValues.Add(((ConstantTreeNode)node).Value);
         var var = new AutoDiff.Variable();
         variables.Add(var);
@@ -166,5 +166,5 @@
 
         if (makeVariableWeightsVariable) {
-          initialConstants.Add(varNode.Weight);
+          initialParamValues.Add(varNode.Weight);
           var w = new AutoDiff.Variable();
           variables.Add(w);
@@ -180,5 +180,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);
@@ -193,5 +193,5 @@
 
         if (makeVariableWeightsVariable) {
-          initialConstants.Add(varNode.Weight);
+          initialParamValues.Add(varNode.Weight);
           var w = new AutoDiff.Variable();
           variables.Add(w);
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/InfixExpressionFormatter.cs	(revision 18114)
@@ -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,5 +51,5 @@
           // 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);
@@ -58,5 +58,5 @@
           } 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("*");
@@ -142,10 +142,10 @@
           if (!factorNode.Weight.IsAlmost(1.0)) strBuilder.Append(")");
         } else if (node.Symbol is Number) {
-          var constNode = node as NumberTreeNode;
-          if (constants == null && constNode.Value < 0) {
-            strBuilder.Append("(").Append(constNode.Value.ToString(formatString, numberFormat))
+          var numNode = node as NumberTreeNode;
+          if (parameters == null && numNode.Value < 0) {
+            strBuilder.Append("(").Append(numNode.Value.ToString(formatString, numberFormat))
                       .Append(")"); // (-1
           } 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">Constant format that should be used for numeric parameters (e.g. NumberFormatInfo.InvariantInfo (default)).</param>
-    /// <param name="formatString">The format string for numeric parameters (e.g. \"G4\" to limit to 4 digits, default is \"G\")</param>
+    /// <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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs	(revision 18114)
@@ -310,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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs	(revision 18114)
@@ -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));
@@ -190,6 +190,6 @@
         strBuilder.Append(@" \operatorname{if}  \left( ");
       } else if (node.Symbol is INumericSymbol numNode) {
-        var numName = "c_{" + constIndex + "}";
-        constIndex++;
+        var numName = "c_{" + paramIdx + "}";
+        paramIdx++;
         var numericNode = node as INumericTreeNode;
         if (numericNode.Value.IsAlmost(1.0)) {
@@ -197,22 +197,22 @@
         } else {
           strBuilder.Append(numName);
-          constants.Add(new KeyValuePair<string, double>(numName, numericNode.Value));
+          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));
@@ -222,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));
@@ -233,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));
@@ -270,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 {
@@ -378,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 {
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/ArithmeticExpressionGrammar.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/ArithmeticExpressionGrammar.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/ArithmeticExpressionGrammar.cs	(revision 18114)
@@ -52,10 +52,9 @@
       number.MinValue = -20;
       number.MaxValue = 20;
-      var constant = new Constant();
-      var variableSymbol = new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable();
+      var variableSymbol = new Variable();
       var binFactorVariableSymbol = new BinaryFactorVariable();
       var factorVariableSymbol = new FactorVariable();
 
-      var allSymbols = new List<Symbol>() { add, sub, mul, div, number, constant, variableSymbol, binFactorVariableSymbol, factorVariableSymbol };
+      var allSymbols = new List<Symbol>() { add, sub, mul, div, number, variableSymbol, binFactorVariableSymbol, factorVariableSymbol };
       var functionSymbols = new List<Symbol>() { add, sub, mul, div };
 
@@ -67,5 +66,4 @@
       }
       SetSubtreeCount(number, 0, 0);
-      SetSubtreeCount(constant, 0, 0);
       SetSubtreeCount(variableSymbol, 0, 0);
       SetSubtreeCount(binFactorVariableSymbol, 0, 0);
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs	(revision 18114)
@@ -121,5 +121,5 @@
       number.MinValue = -20;
       number.MaxValue = 20;
-      var variableSymbol = new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable();
+      var variableSymbol = new Variable();
       var binFactorVariable = new BinaryFactorVariable();
       var factorVariable = new FactorVariable();
@@ -130,9 +130,7 @@
       autoregressiveVariable.Enabled = false;
 
-      var constant = new Constant();
-
       var allSymbols = new List<Symbol>() { add, sub, mul, div, aq, mean, abs, sin, cos, tan, log, square, cube, pow, sqrt, cubeRoot, root, exp, tanh,
         airyA, airyB, bessel, cosineIntegral, dawson, erf, expIntegralEi, fresnelCosineIntegral, fresnelSineIntegral, gamma, hypCosineIntegral, hypSineIntegral, norm, psi, sineIntegral,
-        @if, gt, lt, and, or, not,xor, timeLag, integral, derivative, number, constant, variableSymbol, binFactorVariable, factorVariable, laggedVariable,autoregressiveVariable, variableCondition };
+        @if, gt, lt, and, or, not,xor, timeLag, integral, derivative, number, 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
@@ -141,5 +139,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, number, constant, laggedVariable, autoregressiveVariable };
+      var terminalSymbols = new List<Symbol>() { variableSymbol, binFactorVariable, factorVariable, number, laggedVariable, autoregressiveVariable };
 
       foreach (var symb in allSymbols)
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/LinearScalingGrammar.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/LinearScalingGrammar.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/LinearScalingGrammar.cs	(revision 18114)
@@ -69,5 +69,4 @@
       number.MinValue = -20;
       number.MaxValue = 20;
-      var constant = new Constant();
       var variableSymbol = new Variable();
 
@@ -79,5 +78,5 @@
       //all other symbols
       var allSymbols = new List<Symbol> {
-        add, sub, mul, div, number, constant, variableSymbol, sin, cos, tan, log, square, sqrt, cube, cbrt, exp,
+        add, sub, mul, div, number, variableSymbol, sin, cos, tan, log, square, sqrt, cube, cbrt, exp,
         tanh, aq, abs
       };
@@ -87,5 +86,5 @@
       var realValueSymbols = new List<Symbol> {
          add, sub, mul, div, sin, cos, tan, tanh, exp, log, aq, abs, square, cube, sqrt, cbrt,
-         variableSymbol, number, constant
+         variableSymbol, number
         };
 
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs	(revision 18114)
@@ -108,5 +108,4 @@
       number.MinValue = -20;
       number.MaxValue = 20;
-      var constant = new Constant();
       var variableSymbol = new Variable();
       var binFactorVariable = new BinaryFactorVariable();
@@ -122,5 +121,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> { number, constant, variableSymbol, binFactorVariable, factorVariable });
+      var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { number, variableSymbol, binFactorVariable, factorVariable });
       var realValuedSymbols = new GroupSymbol(RealValuedSymbolsName, new List<ISymbol>() { arithmeticSymbols, trigonometricSymbols, exponentialAndLogarithmicSymbols, specialFunctions, terminalSymbols });
 
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/SymbolicExpressionTreeHash.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/SymbolicExpressionTreeHash.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/SymbolicExpressionTreeHash.cs	(revision 18114)
@@ -66,6 +66,6 @@
       var symbol = node.Symbol;
       var name = symbol.Name;
-      if (node is NumberTreeNode constantNode) {
-        name = strict ? constantNode.Value.ToString() : symbol.Name;
+      if (node is NumberTreeNode numNode) {
+        name = strict ? numNode.Value.ToString() : symbol.Name;
       } else if (node is VariableTreeNode variableNode) {
         name = strict ? variableNode.Weight.ToString() + variableNode.VariableName : variableNode.VariableName;
@@ -222,7 +222,7 @@
             variableTreeNode.VariableName = variable.VariableName;
             variableTreeNode.Weight = variable.Weight;
-          } else if (node.Data is NumberTreeNode @const) {
-            var constantTreeNode = (NumberTreeNode)treeNodes[i];
-            constantTreeNode.Value = @const.Value;
+          } else if (node.Data is NumberTreeNode existingNumNode) {
+            var newNumNode = (NumberTreeNode)treeNodes[i];
+            newNumNode.Value = existingNumNode.Value;
           }
           continue;
@@ -272,5 +272,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 +285,12 @@
 
         var symbol = child.Data.Symbol;
-        if (child.Data is NumberTreeNode firstConst) {
-          // fold sibling constant nodes into the first constant
+        if (child.Data is NumberTreeNode 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 NumberTreeNode otherConst) {
+            if (sibling.Data is NumberTreeNode otherNum) {
               sibling.Enabled = false;
               node.Arity--;
-              firstConst.Value *= otherConst.Value;
+              firstNum.Value *= otherNum.Value;
             } else {
               break;
@@ -298,11 +298,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 NumberTreeNode constantNode) {
+            if (sibling.Data is NumberTreeNode numNode) {
               sibling.Enabled = false;
               node.Arity--;
-              variable.Weight *= constantNode.Value;
+              variable.Weight *= numNode.Value;
             } else {
               break;
@@ -328,8 +328,8 @@
         }
 
-        if (node.Arity == 0) { // if everything is simplified this node becomes constant
-          var constantTreeNode = number.CreateTreeNode<NumberTreeNode>();
-          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;
@@ -353,7 +353,7 @@
           }
         }
-        var constantTreeNode = number.CreateTreeNode<NumberTreeNode>();
-        constantTreeNode.Value = v;
-        nodes[i] = constantTreeNode.ToHashNode();
+        var numNode = number.CreateTreeNode<NumberTreeNode>();
+        numNode.Value = v;
+        nodes[i] = numNode.ToHashNode();
         return;
       }
@@ -368,7 +368,7 @@
         }
         if (node.Arity == 0) {
-          var constantTreeNode = number.CreateTreeNode<NumberTreeNode>();
-          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 +376,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];
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/SymbolicExpressionImporter.cs	(revision 18114)
@@ -86,5 +86,4 @@
 
     Number number = new Number();
-    Constant constant = new Constant();
     Variable variable = new Variable();
     LaggedVariable laggedVariable = new LaggedVariable();
@@ -92,5 +91,4 @@
     TimeLag timeLag = new TimeLag();
     Integral integral = new Integral();
-    FactorVariable factorVar = new FactorVariable();
     BinaryFactorVariable binFactorVar = new BinaryFactorVariable();
 
@@ -165,5 +163,5 @@
         t.Value = tokens.Dequeue().DoubleValue;
         return t;
-      } else throw new FormatException("Expected function or constant symbol");
+      } else throw new FormatException("Expected function or number symbol");
     }
 
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchInstruction.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchInstruction.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchInstruction.cs	(revision 18114)
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithBoundsEstimator.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithBoundsEstimator.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithBoundsEstimator.cs	(revision 18114)
@@ -126,12 +126,8 @@
             break;
           }
-        case OpCodes.Constant: {
-            var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
-            result = new Interval(constTreeNode.Value, constTreeNode.Value);
-            break;
-          }
+        case OpCodes.Constant: // fall through
         case OpCodes.Number: {
-            var numberTreeNode = (NumberTreeNode)currentInstr.dynamicNode;
-            result = new Interval(numberTreeNode.Value, numberTreeNode.Value);
+            var numericTreeNode = (INumericTreeNode)currentInstr.dynamicNode;
+            result = new Interval(numericTreeNode.Value, numericTreeNode.Value);
             break;
           }
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithCompiledExpressionBoundsEstimator.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithCompiledExpressionBoundsEstimator.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithCompiledExpressionBoundsEstimator.cs	(revision 18114)
@@ -154,12 +154,8 @@
             );
           }
-        case OpCodes.Constant: {
-            var v = (node as NumberTreeNode).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)
-            return Expression.Constant(new Interval(v, v), typeof(Interval));
-          }
+        case OpCodes.Constant: // fall through
         case OpCodes.Number: {
-            var v = (node as NumberTreeNode).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)
+            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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs	(revision 18114)
@@ -186,12 +186,8 @@
             break;
           }
-        case OpCodes.Number: {
-            var numberTreeNode = (NumberTreeNode)currentInstr.dynamicNode;
-            result = new Interval(numberTreeNode.Value, numberTreeNode.Value);
-            break;
-          }
+        case OpCodes.Number: // fall through
         case OpCodes.Constant: {
-          var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
-          result = new Interval(constTreeNode.Value, constTreeNode.Value);
+          var numericTreeNode = (INumericTreeNode)currentInstr.dynamicNode;
+          result = new Interval(numericTreeNode.Value, numericTreeNode.Value);
           break;
           }
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs	(revision 18114)
@@ -157,10 +157,7 @@
       #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 = (NumberTreeNode)node;
+          var numberTreeNode = (INumericTreeNode)node;
           return Expression.Constant(numberTreeNode.Value);
           }
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs	(revision 18114)
@@ -711,11 +711,7 @@
             return;
           }
-        case OpCodes.Number: {
-            NumberTreeNode numberNode = (NumberTreeNode)currentInstr.dynamicNode;
-            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, numberNode.Value);
-            return;
-          }
+        case OpCodes.Number: // fall through
         case OpCodes.Constant: {
-          ConstantTreeNode constNode = (ConstantTreeNode) currentInstr.dynamicNode;
+          var constNode = (INumericTreeNode) currentInstr.dynamicNode;
           il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, constNode.Value);
           return;
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 18114)
@@ -496,11 +496,8 @@
             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 numberTreeNode = (NumberTreeNode) currentInstr.dynamicNode;
-          return numberTreeNode.Value;
+          var numericTreeNode = (INumericTreeNode) currentInstr.dynamicNode;
+          return numericTreeNode.Value;
         }
 
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs	(revision 18114)
@@ -416,13 +416,8 @@
         #region opcode switch
         switch (instr.opCode) {
-          case OpCodes.Number: {
-              var numberTreeNode = (NumberTreeNode)instr.dynamicNode;
-              instr.value = numberTreeNode.Value;
-              instr.skip = true; // the value is already set so this instruction should be skipped in the evaluation phase
-            }
-            break;
+          case OpCodes.Number: // fall through
           case OpCodes.Constant: {
-            var constTreeNode = (ConstantTreeNode)instr.dynamicNode;
-            instr.value = constTreeNode.Value;
+            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
             }
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionPruningOperator.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionPruningOperator.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionPruningOperator.cs	(revision 18114)
@@ -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
@@ -174,7 +174,6 @@
         if (node is INumericTreeNode) continue;
 
-        double impactValue, replacementValue;
-        double newQualityForImpacts;
-        ImpactValuesCalculator.CalculateImpactAndReplacementValues(model, node, problemData, rows, out impactValue, out replacementValue, out newQualityForImpacts, qualityForImpactsCalculation);
+        ImpactValuesCalculator.CalculateImpactAndReplacementValues(model, node, problemData, rows, 
+          out double impactValue, out double replacementValue, out double newQualityForImpacts, qualityForImpactsCalculation);
 
         if (PruneOnlyZeroImpactNodes && !impactValue.IsAlmost(0.0)) continue;
@@ -185,5 +184,5 @@
 
         var length = node.GetLength();
-        ReplaceWithConstant(node, numberNode);
+        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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModelComplexityCalculator.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModelComplexityCalculator.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModelComplexityCalculator.cs	(revision 18114)
@@ -36,4 +36,5 @@
 
       switch (OpCodes.MapSymbolToOpCode(node)) {
+        case OpCodes.Number: // fall through
         case OpCodes.Constant: {
             return 1;
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSolutionImpactValuesCalculator.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSolutionImpactValuesCalculator.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisSolutionImpactValuesCalculator.cs	(revision 18114)
@@ -79,6 +79,5 @@
     protected IEnumerable<double> CalculateReplacementValues(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree, ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
       IDataset dataset, IEnumerable<int> rows) {
-      //optimization: constant nodes return always the same value
-      NumberTreeNode numberNode = node as NumberTreeNode;
+      var numberNode = node as INumericTreeNode;
       BinaryFactorVariableTreeNode binaryFactorNode = node as BinaryFactorVariableTreeNode;
       FactorVariableTreeNode factorNode = node as FactorVariableTreeNode;
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Constant.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Constant.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Constant.cs	(revision 18114)
@@ -27,6 +27,6 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableType("44E03792-5E65-4C70-99B2-7849B8927E28")]
-  [Item("Constant", "Represents a constant number.")]
-  public sealed class Constant : Symbol, INumericSymbol{
+  [Item("Constant", "Represents a real-valued constant.")]
+  public sealed class Constant : Symbol, INumericSymbol {
     private const int minimumArity = 0;
     private const int maximumArity = 0;
@@ -43,5 +43,5 @@
     }
 
-    public Constant() : base("Constant", "Represents a constant number.") {}
+    public Constant() : base("Constant", "Represents a real-valued constant.") {}
 
     public override ISymbolicExpressionTreeNode CreateTreeNode() {
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/ConstantTreeNode.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/ConstantTreeNode.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/ConstantTreeNode.cs	(revision 18114)
@@ -26,5 +26,5 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableType("F91000E6-B041-4648-A9E8-595228F957FA")]
-  public sealed class ConstantTreeNode : SymbolicExpressionTreeTerminalNode, INumericTreeNode{
+  public sealed class ConstantTreeNode : SymbolicExpressionTreeTerminalNode, INumericTreeNode {
 
     public new Constant Symbol => (Constant) base.Symbol;
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Transformations/TransformationToSymbolicTreeMapper.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Transformations/TransformationToSymbolicTreeMapper.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Transformations/TransformationToSymbolicTreeMapper.cs	(revision 18114)
@@ -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,5 +279,5 @@
     }
 
-    private NumberTreeNode CreateConstantTreeNode(string description, double value) {
+    private NumberTreeNode CreateNumber(string description, double value) {
       return new NumberTreeNode(new Number()) { Value = value };
     }
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeBottomUpSimilarityCalculator.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeBottomUpSimilarityCalculator.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeBottomUpSimilarityCalculator.cs	(revision 18114)
@@ -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 INumericTreeNode 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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculator.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculator.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeMaxCommonSubtreeSimilarityCalculator.cs	(revision 18114)
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeComparer.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeComparer.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeComparer.cs	(revision 18114)
@@ -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 {
Index: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeEqualityComparer.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeEqualityComparer.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/TreeMatching/SymbolicExpressionTreeNodeEqualityComparer.cs	(revision 18114)
@@ -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;
@@ -90,5 +90,5 @@
         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: /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineLinearScalingParameterCalculator.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineLinearScalingParameterCalculator.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineLinearScalingParameterCalculator.cs	(revision 18114)
@@ -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: /branches/3140_NumberSymbol/HeuristicLab.Problems.ExternalEvaluation.GP/3.5/ExternalEvaluationExpressionGrammar.cs
===================================================================
--- /branches/3140_NumberSymbol/HeuristicLab.Problems.ExternalEvaluation.GP/3.5/ExternalEvaluationExpressionGrammar.cs	(revision 18113)
+++ /branches/3140_NumberSymbol/HeuristicLab.Problems.ExternalEvaluation.GP/3.5/ExternalEvaluationExpressionGrammar.cs	(revision 18114)
@@ -65,8 +65,7 @@
       number.MinValue = -20;
       number.MaxValue = 20;
-      var constant = new Constant();
       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, number, constant, variableSymbol };
+      var allSymbols = new List<Symbol>() { add, sub, mul, div, mean, sin, cos, tan, log, exp, @if, gt, lt, and, or, not, number, variableSymbol };
       var unaryFunctionSymbols = new List<Symbol>() { sin, cos, tan, log, exp, not };
       var binaryFunctionSymbols = new List<Symbol>() { gt, lt };
@@ -88,5 +87,4 @@
       SetSubtreeCount(@if, 3, 3);
       SetSubtreeCount(number, 0, 0);
-      SetSubtreeCount(constant,0, 0);
       SetSubtreeCount(variableSymbol, 0, 0);
 
