Changeset 18113 for branches

Timestamp:

12/11/21 12:26:27 (3 years ago)

Author:

chaider

Message:

#3140

• Refactored ConstantOptimization ==> ParameterOptimization

Location:

branches/3140_NumberSymbol

Files:

• HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessCovarianceOptimizationProblem.cs (modified) (6 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/NMSEMultiObjectiveConstraintsEvaluator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredAverageSimilarityEvaluator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredNestedTreeSizeEvaluator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredNumberOfVariablesEvaluator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredTreeComplexityEvaluator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveEvaluator.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NMSESingleObjectiveConstraintsEvaluator.cs (modified) (4 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionParameterOptimizationEvaluator.cs (moved) (moved from branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionConstantOptimizationEvaluator.cs) (11 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/ParameterOptimizationAnalyzer.cs (moved) (moved from branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/ConstantOptimizationAnalyzer.cs) (6 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs (modified) (10 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/TreeSimplifier.cs (modified) (44 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/SymbolicExpressionTreeHash.cs (modified) (10 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModel.cs (modified) (4 diffs)

branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessCovarianceOptimizationProblem.cs

@@ -97 +97 @@
 
     private const string ProblemDataParameterName = "ProblemData";
-    private const string ConstantOptIterationsParameterName = "Constant optimization steps";
+    private const string ParameterOptIterationsParameterName = "Parameter optimization steps";
     private const string RestartsParameterName = "Restarts";
 
@@ -108 +108 @@
       get { return (IValueParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName]; }
     }
-    public IFixedValueParameter<IntValue> ConstantOptIterationsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[ConstantOptIterationsParameterName]; }
+    public IFixedValueParameter<IntValue> ParameterOptIterationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[ParameterOptIterationsParameterName]; }
     }
     public IFixedValueParameter<IntValue> RestartsParameter {
@@ -124 +124 @@
     IDataAnalysisProblemData IDataAnalysisProblem.ProblemData { get { return ProblemData; } }
 
-    public int ConstantOptIterations {
-      get { return ConstantOptIterationsParameter.Value.Value; }
-      set { ConstantOptIterationsParameter.Value.Value = value; }
+    public int ParameterOptIterations {
+      get { return ParameterOptIterationsParameter.Value.Value; }
+      set { ParameterOptIterationsParameter.Value.Value = value; }
     }
 
@@ -153 +153 @@
       : base() {
       Parameters.Add(new ValueParameter<IRegressionProblemData>(ProblemDataParameterName, "The data for the regression problem", new RegressionProblemData()));
-      Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptIterationsParameterName, "Number of optimization steps for hyperparameter values", new IntValue(50)));
-      Parameters.Add(new FixedValueParameter<IntValue>(RestartsParameterName, "The number of random restarts for constant optimization.", new IntValue(10)));
+      Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptIterationsParameterName, "Number of optimization steps for hyperparameter values", new IntValue(50)));
+      Parameters.Add(new FixedValueParameter<IntValue>(RestartsParameterName, "The number of random restarts for parameter optimization.", new IntValue(10)));
       Parameters["Restarts"].Hidden = true;
       var g = new SimpleSymbolicExpressionGrammar();
@@ -236 +236 @@
         double epsx = 0;
         double stpmax = 1;
-        int maxits = ConstantOptIterations;
+        int maxits = ParameterOptIterations;
         alglib.mincgstate state;
         alglib.mincgreport rep;
@@ -384 +384 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ParameterOptIterationsParameterName)) {
+        if (Parameters.ContainsKey("Constant optimization steps")) {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptIterationsParameterName, "Number of optimization steps for hyperparameter values", (IntValue)Parameters["Constant optimization steps"].ActualValue));
+          Parameters.Remove("Constant optimization steps");
+        } else {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptIterationsParameterName, "Number of optimization steps for hyperparameter values", new IntValue(50)));
+        }
+      }
     }
 

branches/3140_NumberSymbol/HeuristicLab.Algorithms.DataAnalysis/3.4/NonlinearRegression/NonlinearRegression.cs

@@ -263 +263 @@
       }
 
-      if (!SymbolicRegressionConstantOptimizationEvaluator.CanOptimizeConstants(tree)) throw new ArgumentException("The optimizer does not support the specified model structure.");
+      if (!SymbolicRegressionParameterOptimizationEvaluator.CanOptimizeParameters(tree)) throw new ArgumentException("The optimizer does not support the specified model structure.");
 
       // initialize constants randomly
@@ -275 +275 @@
       var interpreter = new SymbolicDataAnalysisExpressionTreeLinearInterpreter();
 
-      SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, tree, problemData, problemData.TrainingIndices,
+      SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, tree, problemData, problemData.TrainingIndices,
         applyLinearScaling: applyLinearScaling, maxIterations: maxIterations,
-        updateVariableWeights: false, updateConstantsInTree: true);
+        updateVariableWeights: false, updateParametersInTree: true);
 
       var model = new SymbolicRegressionModel(problemData.TargetVariable, tree, (ISymbolicDataAnalysisExpressionTreeInterpreter)interpreter.Clone());

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs

@@ -42 +42 @@
 
       var tree = Content?.Model?.SymbolicExpressionTree;
-      btnOptimizeConstants.Enabled = tree != null && SymbolicRegressionConstantOptimizationEvaluator.CanOptimizeConstants(tree);
+      btnOptimizeConstants.Enabled = tree != null && SymbolicRegressionParameterOptimizationEvaluator.CanOptimizeParameters(tree);
     }
 
@@ -64 +64 @@
       do {
         prevResult = result;
-        result = SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(model.Interpreter, tree, regressionProblemData, regressionProblemData.TrainingIndices,
+        result = SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(model.Interpreter, tree, regressionProblemData, regressionProblemData.TrainingIndices,
           applyLinearScaling: true, maxIterations: constOptIterations, updateVariableWeights: true, lowerEstimationLimit: model.LowerEstimationLimit, upperEstimationLimit: model.UpperEstimationLimit,
           iterationCallback: (args, func, obj) => {

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

@@ -129 +129 @@
     <Compile Include="Plugin.cs" />
     <Compile Include="ShapeConstraintsAnalyzer.cs" />
-    <Compile Include="SingleObjective\ConstantOptimizationAnalyzer.cs" />
+    <Compile Include="SingleObjective\ParameterOptimizationAnalyzer.cs" />
     <Compile Include="SingleObjective\Evaluators\NMSESingleObjectiveConstraintsEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />
@@ -142 +142 @@
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveMaxAbsoluteErrorEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionSingleObjectiveMeanAbsoluteErrorEvaluator.cs" />
-    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionConstantOptimizationEvaluator.cs" />
+    <Compile Include="SingleObjective\Evaluators\SymbolicRegressionParameterOptimizationEvaluator.cs" />
     <Compile Include="SingleObjective\SymbolicRegressionSingleObjectiveOverfittingAnalyzer.cs" />
     <Compile Include="SymbolicRegressionModel.cs" />

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/NMSEMultiObjectiveConstraintsEvaluator.cs

@@ -90 +90 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, tree, problemData, rows,
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, tree, problemData, rows,
           false,
-          ConstantOptimizationIterations,
-          ConstantOptimizationUpdateVariableWeights,
+          ParameterOptimizationIterations,
+          ParameterOptimizationUpdateVariableWeights,
           estimationLimits.Lower,
           estimationLimits.Upper);

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredAverageSimilarityEvaluator.cs

@@ -76 +76 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
 

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredNestedTreeSizeEvaluator.cs

@@ -54 +54 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights,lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights,lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
 

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredNumberOfVariablesEvaluator.cs

@@ -54 +54 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
       double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value, DecimalPlaces);

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/PearsonRSquaredTreeComplexityEvaluator.cs

@@ -53 +53 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
       double[] qualities = Calculate(interpreter, solution, estimationLimits.Lower, estimationLimits.Upper, problemData, rows, applyLinearScaling, DecimalPlaces);

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveEvaluator.cs

@@ -31 +31 @@
   public abstract class SymbolicRegressionMultiObjectiveEvaluator : SymbolicDataAnalysisMultiObjectiveEvaluator<IRegressionProblemData>, ISymbolicRegressionMultiObjectiveEvaluator {
     private const string DecimalPlacesParameterName = "Decimal Places";
-    private const string UseConstantOptimizationParameterName = "Use constant optimization";
-    private const string ConstantOptimizationIterationsParameterName = "Constant optimization iterations";
+    private const string UseParameterOptimizationParameterName = "Use parameter optimization";
+    private const string ParameterOptimizationIterationsParameterName = "Parameter optimization iterations";
 
-    private const string ConstantOptimizationUpdateVariableWeightsParameterName =
-      "Constant optimization update variable weights";
+    private const string ParameterOptimizationUpdateVariableWeightsParameterName =
+      "Parameter optimization update variable weights";
 
     public IFixedValueParameter<IntValue> DecimalPlacesParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[DecimalPlacesParameterName]; }
     }
-    public IFixedValueParameter<BoolValue> UseConstantOptimizationParameter {
-      get { return (IFixedValueParameter<BoolValue>)Parameters[UseConstantOptimizationParameterName]; }
+    public IFixedValueParameter<BoolValue> UseParameterOptimizationParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[UseParameterOptimizationParameterName]; }
     }
 
-    public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[ConstantOptimizationIterationsParameterName]; }
+    public IFixedValueParameter<IntValue> ParameterOptimizationIterationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[ParameterOptimizationIterationsParameterName]; }
     }
 
-    public IFixedValueParameter<BoolValue> ConstantOptimizationUpdateVariableWeightsParameter {
-      get { return (IFixedValueParameter<BoolValue>)Parameters[ConstantOptimizationUpdateVariableWeightsParameterName]; }
+    public IFixedValueParameter<BoolValue> ParameterOptimizationUpdateVariableWeightsParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[ParameterOptimizationUpdateVariableWeightsParameterName]; }
     }
 
@@ -56 +56 @@
       set { DecimalPlacesParameter.Value.Value = value; }
     }
-    public bool UseConstantOptimization {
-      get { return UseConstantOptimizationParameter.Value.Value; }
-      set { UseConstantOptimizationParameter.Value.Value = value; }
+    public bool UseParameterOptimization {
+      get { return UseParameterOptimizationParameter.Value.Value; }
+      set { UseParameterOptimizationParameter.Value.Value = value; }
     }
-    public int ConstantOptimizationIterations {
-      get { return ConstantOptimizationIterationsParameter.Value.Value; }
-      set { ConstantOptimizationIterationsParameter.Value.Value = value; }
+    public int ParameterOptimizationIterations {
+      get { return ParameterOptimizationIterationsParameter.Value.Value; }
+      set { ParameterOptimizationIterationsParameter.Value.Value = value; }
     }
-    public bool ConstantOptimizationUpdateVariableWeights {
-      get { return ConstantOptimizationUpdateVariableWeightsParameter.Value.Value; }
-      set { ConstantOptimizationUpdateVariableWeightsParameter.Value.Value = value; }
+    public bool ParameterOptimizationUpdateVariableWeights {
+      get { return ParameterOptimizationUpdateVariableWeightsParameter.Value.Value; }
+      set { ParameterOptimizationUpdateVariableWeightsParameter.Value.Value = value; }
     }
 
@@ -78 +78 @@
       : base() {
       Parameters.Add(new FixedValueParameter<IntValue>(DecimalPlacesParameterName, "The number of decimal places used for rounding the quality values.", new IntValue(5)) { Hidden = true });
-      Parameters.Add(new FixedValueParameter<BoolValue>(UseConstantOptimizationParameterName, "", new BoolValue(false)));
-      Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsParameterName, "The number of iterations constant optimization should be applied.", new IntValue(5)));
-      Parameters.Add(new FixedValueParameter<BoolValue>(ConstantOptimizationUpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be optimized during constant optimization.", new BoolValue(true)) { Hidden = true });
+      Parameters.Add(new FixedValueParameter<BoolValue>(UseParameterOptimizationParameterName, "", new BoolValue(false)));
+      Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "The number of iterations parameter optimization should be applied.", new IntValue(5)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(ParameterOptimizationUpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be optimized during parameter optimization.", new BoolValue(true)) { Hidden = true });
     }
 
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(UseConstantOptimizationParameterName)) {
-        Parameters.Add(new FixedValueParameter<BoolValue>(UseConstantOptimizationParameterName, "", new BoolValue(false)));
+      if (!Parameters.ContainsKey(UseParameterOptimizationParameterName)) {
+        if (Parameters.ContainsKey("Use constant optimization")) {
+          Parameters.Add(new FixedValueParameter<BoolValue>(UseParameterOptimizationParameterName, "", (BoolValue)Parameters["Use constant optimization"].ActualValue));
+          Parameters.Remove("Use constant optimization");
+        } else {
+          Parameters.Add(new FixedValueParameter<BoolValue>(UseParameterOptimizationParameterName, "", new BoolValue(false)));
+        }
       }
+
       if (!Parameters.ContainsKey(DecimalPlacesParameterName)) {
         Parameters.Add(new FixedValueParameter<IntValue>(DecimalPlacesParameterName, "The number of decimal places used for rounding the quality values.", new IntValue(-1)) { Hidden = true });
       }
-      if (!Parameters.ContainsKey(ConstantOptimizationIterationsParameterName)) {
-        Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsParameterName, "The number of iterations constant optimization should be applied.", new IntValue(5)));
+      if (!Parameters.ContainsKey(ParameterOptimizationIterationsParameterName)) {
+        if (Parameters.ContainsKey("Constant optimization iterations")) {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "The number of iterations parameter optimization should be applied.", (IntValue)Parameters["Constant optimization iterations"].ActualValue));
+          Parameters.Remove("Constant optimization iterations");
+        } else {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "The number of iterations parameter optimization should be applied.", new IntValue(5)));
+        }
       }
-      if (!Parameters.ContainsKey(ConstantOptimizationUpdateVariableWeightsParameterName)) {
-        Parameters.Add(new FixedValueParameter<BoolValue>(ConstantOptimizationUpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be optimized during constant optimization.", new BoolValue(true)));
+      if (!Parameters.ContainsKey(ParameterOptimizationUpdateVariableWeightsParameterName)) {
+        if (Parameters.ContainsKey("Constant optimization update variable weights")) {
+          Parameters.Add(new FixedValueParameter<BoolValue>(ParameterOptimizationUpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be optimized during parameter optimization.",
+            (BoolValue)Parameters["Constant optimization update variable weights"].ActualValue));
+          Parameters.Remove("Constant optimization update variable weights");
+        } else {
+          Parameters.Add(new FixedValueParameter<BoolValue>(ParameterOptimizationUpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be optimized during parameter optimization.", new BoolValue(true)));
+        }
       }
     }

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs

@@ -53 +53 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
 

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs

@@ -53 +53 @@
       var applyLinearScaling = ApplyLinearScalingParameter.ActualValue.Value;
 
-      if (UseConstantOptimization) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, solution, problemData, rows, applyLinearScaling, ConstantOptimizationIterations, updateVariableWeights: ConstantOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
+      if (UseParameterOptimization) {
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, solution, problemData, rows, applyLinearScaling, ParameterOptimizationIterations, updateVariableWeights: ParameterOptimizationUpdateVariableWeights, lowerEstimationLimit: estimationLimits.Lower, upperEstimationLimit: estimationLimits.Upper);
       }
       double[] qualities = Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, rows, ApplyLinearScalingParameter.ActualValue.Value, DecimalPlaces);

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NMSESingleObjectiveConstraintsEvaluator.cs

@@ -46 +46 @@
       (IFixedValueParameter<BoolValue>)Parameters[OptimizeParametersParameterName];
 
-    public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter =>
+    public IFixedValueParameter<IntValue> ParameterOptimizationIterationsParameter =>
       (IFixedValueParameter<IntValue>)Parameters[ParameterOptimizationIterationsParameterName];
 
@@ -62 +62 @@
     }
 
-    public int ConstantOptimizationIterations {
-      get => ConstantOptimizationIterationsParameter.Value.Value;
-      set => ConstantOptimizationIterationsParameter.Value.Value = value;
+    public int ParameterOptimizationIterations {
+      get => ParameterOptimizationIterationsParameter.Value.Value;
+      set => ParameterOptimizationIterationsParameter.Value.Value = value;
     }
 
@@ -109 +109 @@
 
     [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() { }
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ParameterOptimizationIterationsParameterName)) {
+        if (Parameters.ContainsKey("ParameterOptimizationIterations")) {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "Define how many parameter optimization steps should be performed (default: 10).", (IntValue)Parameters["ParameterOptimizationIterations"].ActualValue));
+          Parameters.Remove("ParameterOptimizationIterations");
+        } else {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "Define how many parameter optimization steps should be performed (default: 10).", new IntValue(10)));
+        }
+      }
+
+    }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -126 +136 @@
 
       if (OptimizeParameters) {
-        SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(interpreter, tree, problemData, rows,
-          false, ConstantOptimizationIterations, true,
+        SymbolicRegressionParameterOptimizationEvaluator.OptimizeParameters(interpreter, tree, problemData, rows,
+          false, ParameterOptimizationIterations, true,
           estimationLimits.Lower, estimationLimits.Upper);
       } else {

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/SymbolicRegressionParameterOptimizationEvaluator.cs

@@ -32 +32 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
-  [Item("Constant Optimization Evaluator", "Calculates Pearson R² of a symbolic regression solution and optimizes the constant used.")]
+  [Item("Parameter Optimization Evaluator", "Calculates Pearson R² of a symbolic regression solution and optimizes the parameters used.")]
   [StorableType("24B68851-036D-4446-BD6F-3823E9028FF4")]
-  public class SymbolicRegressionConstantOptimizationEvaluator : SymbolicRegressionSingleObjectiveEvaluator {
-    private const string ConstantOptimizationIterationsParameterName = "ConstantOptimizationIterations";
-    private const string ConstantOptimizationImprovementParameterName = "ConstantOptimizationImprovement";
-    private const string ConstantOptimizationProbabilityParameterName = "ConstantOptimizationProbability";
-    private const string ConstantOptimizationRowsPercentageParameterName = "ConstantOptimizationRowsPercentage";
-    private const string UpdateConstantsInTreeParameterName = "UpdateConstantsInSymbolicExpressionTree";
+  public class SymbolicRegressionParameterOptimizationEvaluator : SymbolicRegressionSingleObjectiveEvaluator {
+    private const string ParameterOptimizationIterationsParameterName = "ParameterOptimizationIterations";
+    private const string ParameterOptimizationImprovementParameterName = "ParameterOptimizationImprovement";
+    private const string ParameterOptimizationProbabilityParameterName = "ParameterOptimizationProbability";
+    private const string ParameterOptimizationRowsPercentageParameterName = "ParameterOptimizationRowsPercentage";
+    private const string UpdateParametersInTreeParameterName = "UpdateParametersInSymbolicExpressionTree";
     private const string UpdateVariableWeightsParameterName = "Update Variable Weights";
 
-    private const string FunctionEvaluationsResultParameterName = "Constants Optimization Function Evaluations";
-    private const string GradientEvaluationsResultParameterName = "Constants Optimization Gradient Evaluations";
+    private const string FunctionEvaluationsResultParameterName = "Parameters Optimization Function Evaluations";
+    private const string GradientEvaluationsResultParameterName = "Parameters Optimization Gradient Evaluations";
     private const string CountEvaluationsParameterName = "Count Function and Gradient Evaluations";
 
-    public IFixedValueParameter<IntValue> ConstantOptimizationIterationsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[ConstantOptimizationIterationsParameterName]; }
-    }
-    public IFixedValueParameter<DoubleValue> ConstantOptimizationImprovementParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters[ConstantOptimizationImprovementParameterName]; }
-    }
-    public IFixedValueParameter<PercentValue> ConstantOptimizationProbabilityParameter {
-      get { return (IFixedValueParameter<PercentValue>)Parameters[ConstantOptimizationProbabilityParameterName]; }
-    }
-    public IFixedValueParameter<PercentValue> ConstantOptimizationRowsPercentageParameter {
-      get { return (IFixedValueParameter<PercentValue>)Parameters[ConstantOptimizationRowsPercentageParameterName]; }
-    }
-    public IFixedValueParameter<BoolValue> UpdateConstantsInTreeParameter {
-      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateConstantsInTreeParameterName]; }
+    public IFixedValueParameter<IntValue> ParameterOptimizationIterationsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[ParameterOptimizationIterationsParameterName]; }
+    }
+    public IFixedValueParameter<DoubleValue> ParameterOptimizationImprovementParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters[ParameterOptimizationImprovementParameterName]; }
+    }
+    public IFixedValueParameter<PercentValue> ParameterOptimizationProbabilityParameter {
+      get { return (IFixedValueParameter<PercentValue>)Parameters[ParameterOptimizationProbabilityParameterName]; }
+    }
+    public IFixedValueParameter<PercentValue> ParameterOptimizationRowsPercentageParameter {
+      get { return (IFixedValueParameter<PercentValue>)Parameters[ParameterOptimizationRowsPercentageParameterName]; }
+    }
+    public IFixedValueParameter<BoolValue> UpdateParametersInTreeParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[UpdateParametersInTreeParameterName]; }
     }
     public IFixedValueParameter<BoolValue> UpdateVariableWeightsParameter {
@@ -76 +76 @@
 
 
-    public IntValue ConstantOptimizationIterations {
-      get { return ConstantOptimizationIterationsParameter.Value; }
-    }
-    public DoubleValue ConstantOptimizationImprovement {
-      get { return ConstantOptimizationImprovementParameter.Value; }
-    }
-    public PercentValue ConstantOptimizationProbability {
-      get { return ConstantOptimizationProbabilityParameter.Value; }
-    }
-    public PercentValue ConstantOptimizationRowsPercentage {
-      get { return ConstantOptimizationRowsPercentageParameter.Value; }
-    }
-    public bool UpdateConstantsInTree {
-      get { return UpdateConstantsInTreeParameter.Value.Value; }
-      set { UpdateConstantsInTreeParameter.Value.Value = value; }
+    public IntValue ParameterOptimizationIterations {
+      get { return ParameterOptimizationIterationsParameter.Value; }
+    }
+    public DoubleValue ParameterOptimizationImprovement {
+      get { return ParameterOptimizationImprovementParameter.Value; }
+    }
+    public PercentValue ParameterOptimizationProbability {
+      get { return ParameterOptimizationProbabilityParameter.Value; }
+    }
+    public PercentValue ParameterOptimizationRowsPercentage {
+      get { return ParameterOptimizationRowsPercentageParameter.Value; }
+    }
+    public bool UpdateParametersInTree {
+      get { return UpdateParametersInTreeParameter.Value.Value; }
+      set { UpdateParametersInTreeParameter.Value.Value = value; }
     }
 
@@ -108 +108 @@
 
     [StorableConstructor]
-    protected SymbolicRegressionConstantOptimizationEvaluator(StorableConstructorFlag _) : base(_) { }
-    protected SymbolicRegressionConstantOptimizationEvaluator(SymbolicRegressionConstantOptimizationEvaluator original, Cloner cloner)
+    protected SymbolicRegressionParameterOptimizationEvaluator(StorableConstructorFlag _) : base(_) { }
+    protected SymbolicRegressionParameterOptimizationEvaluator(SymbolicRegressionParameterOptimizationEvaluator original, Cloner cloner)
       : base(original, cloner) {
     }
-    public SymbolicRegressionConstantOptimizationEvaluator()
+    public SymbolicRegressionParameterOptimizationEvaluator()
       : base() {
-      Parameters.Add(new FixedValueParameter<IntValue>(ConstantOptimizationIterationsParameterName, "Determines how many iterations should be calculated while optimizing the constant of a symbolic expression tree (0 indicates other or default stopping criterion).", new IntValue(10)));
-      Parameters.Add(new FixedValueParameter<DoubleValue>(ConstantOptimizationImprovementParameterName, "Determines the relative improvement which must be achieved in the constant optimization to continue with it (0 indicates other or default stopping criterion).", new DoubleValue(0)) { Hidden = true });
-      Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationProbabilityParameterName, "Determines the probability that the constants are optimized", new PercentValue(1)));
-      Parameters.Add(new FixedValueParameter<PercentValue>(ConstantOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for constant optimization", new PercentValue(1)));
-      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateConstantsInTreeParameterName, "Determines if the constants in the tree should be overwritten by the optimized constants.", new BoolValue(true)) { Hidden = true });
+      Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "Determines how many iterations should be calculated while optimizing the parameter of a symbolic expression tree (0 indicates other or default stopping criterion).", new IntValue(10)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>(ParameterOptimizationImprovementParameterName, "Determines the relative improvement which must be achieved in the parameter optimization to continue with it (0 indicates other or default stopping criterion).", new DoubleValue(0)) { Hidden = true });
+      Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationProbabilityParameterName, "Determines the probability that the parameters are optimized", new PercentValue(1)));
+      Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for parameter optimization", new PercentValue(1)));
+      Parameters.Add(new FixedValueParameter<BoolValue>(UpdateParametersInTreeParameterName, "Determines if the parameters in the tree should be overwritten by the optimized parameters.", new BoolValue(true)) { Hidden = true });
       Parameters.Add(new FixedValueParameter<BoolValue>(UpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be  optimized.", new BoolValue(true)) { Hidden = true });
 
       Parameters.Add(new FixedValueParameter<BoolValue>(CountEvaluationsParameterName, "Determines if function and gradient evaluation should be counted.", new BoolValue(false)));
-      Parameters.Add(new ResultParameter<IntValue>(FunctionEvaluationsResultParameterName, "The number of function evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
-      Parameters.Add(new ResultParameter<IntValue>(GradientEvaluationsResultParameterName, "The number of gradient evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
+      Parameters.Add(new ResultParameter<IntValue>(FunctionEvaluationsResultParameterName, "The number of function evaluations performed by the parameters optimization evaluator", "Results", new IntValue()));
+      Parameters.Add(new ResultParameter<IntValue>(GradientEvaluationsResultParameterName, "The number of gradient evaluations performed by the parameters optimization evaluator", "Results", new IntValue()));
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicRegressionConstantOptimizationEvaluator(this, cloner);
+      return new SymbolicRegressionParameterOptimizationEvaluator(this, cloner);
     }
 
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(UpdateConstantsInTreeParameterName))
-        Parameters.Add(new FixedValueParameter<BoolValue>(UpdateConstantsInTreeParameterName, "Determines if the constants in the tree should be overwritten by the optimized constants.", new BoolValue(true)));
+      if (!Parameters.ContainsKey(UpdateParametersInTreeParameterName)) {
+        if (Parameters.ContainsKey("UpdateConstantsInSymbolicExpressionTree")) {
+          Parameters.Add(new FixedValueParameter<BoolValue>(UpdateParametersInTreeParameterName, "Determines if the parameters in the tree should be overwritten by the optimized parameters.", (BoolValue)Parameters["UpdateConstantsInSymbolicExpressionTree"].ActualValue));
+          Parameters.Remove("UpdateConstantsInSymbolicExpressionTree");
+        } else {
+          Parameters.Add(new FixedValueParameter<BoolValue>(UpdateParametersInTreeParameterName, "Determines if the parameters in the tree should be overwritten by the optimized parameters.", new BoolValue(true)));
+        }
+      }
+
       if (!Parameters.ContainsKey(UpdateVariableWeightsParameterName))
         Parameters.Add(new FixedValueParameter<BoolValue>(UpdateVariableWeightsParameterName, "Determines if the variable weights in the tree should be  optimized.", new BoolValue(true)));
@@ -140 +147 @@
         Parameters.Add(new FixedValueParameter<BoolValue>(CountEvaluationsParameterName, "Determines if function and gradient evaluation should be counted.", new BoolValue(false)));
 
-      if (!Parameters.ContainsKey(FunctionEvaluationsResultParameterName))
-        Parameters.Add(new ResultParameter<IntValue>(FunctionEvaluationsResultParameterName, "The number of function evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
-      if (!Parameters.ContainsKey(GradientEvaluationsResultParameterName))
-        Parameters.Add(new ResultParameter<IntValue>(GradientEvaluationsResultParameterName, "The number of gradient evaluations performed by the constants optimization evaluator", "Results", new IntValue()));
+      if (!Parameters.ContainsKey(FunctionEvaluationsResultParameterName)) {
+        if (Parameters.ContainsKey("Constants Optimization Function Evaluations")) {
+          Parameters.Remove("Constants Optimization Function Evaluations");
+        }
+        Parameters.Add(new ResultParameter<IntValue>(FunctionEvaluationsResultParameterName, "The number of function evaluations performed by the parameters optimization evaluator", "Results", new IntValue()));
+      }
+
+      if (!Parameters.ContainsKey(GradientEvaluationsResultParameterName)) {
+        if (Parameters.ContainsKey("Constants Optimization Gradient Evaluations")) {
+          Parameters.Remove("Constants Optimization Gradient Evaluations");
+        }
+        Parameters.Add(new ResultParameter<IntValue>(GradientEvaluationsResultParameterName, "The number of gradient evaluations performed by the parameters optimization evaluator", "Results", new IntValue()));
+      }
+
+      if (!Parameters.ContainsKey(ParameterOptimizationIterationsParameterName)) {
+        if (Parameters.ContainsKey("ConstantOptimizationIterations")) {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "Determines how many iterations should be calculated while optimizing the parameter of a symbolic expression tree (0 indicates other or default stopping criterion).", (IntValue)Parameters["ConstantOptimizationIterations"].ActualValue));
+          Parameters.Remove("ConstantOptimizationIterations");
+        } else {
+          Parameters.Add(new FixedValueParameter<IntValue>(ParameterOptimizationIterationsParameterName, "Determines how many iterations should be calculated while optimizing the parameter of a symbolic expression tree (0 indicates other or default stopping criterion).", new IntValue(10)));
+        }
+      }
+
+      if (!Parameters.ContainsKey(ParameterOptimizationImprovementParameterName)) {
+        if (Parameters.ContainsKey("CosntantOptimizationImprovement")) {
+          Parameters.Add(new FixedValueParameter<DoubleValue>(ParameterOptimizationImprovementParameterName, "Determines the relative improvement which must be achieved in the parameter optimization to continue with it (0 indicates other or default stopping criterion).",
+            (DoubleValue)Parameters["CosntantOptimizationImprovement"].ActualValue) { Hidden = true });
+          Parameters.Remove("CosntantOptimizationImprovement");
+        } else {
+          Parameters.Add(new FixedValueParameter<DoubleValue>(ParameterOptimizationImprovementParameterName, "Determines the relative improvement which must be achieved in the parameter optimization to continue with it (0 indicates other or default stopping criterion).", new DoubleValue(0)) { Hidden = true });
+        }
+      }
+
+      if (!Parameters.ContainsKey(ParameterOptimizationProbabilityParameterName)) {
+        if (Parameters.ContainsKey("ConstantOptimizationProbability")) {
+          Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationProbabilityParameterName, "Determines the probability that the parameters are optimized",
+            (PercentValue)Parameters["ConstantOptimizationProbability"].ActualValue));
+          Parameters.Remove("ConstantOptimizationProbability");
+        } else {
+          Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationProbabilityParameterName, "Determines the probability that the parameters are optimized", new PercentValue(1)));
+        }
+      }
+
+      if (!Parameters.ContainsKey(ParameterOptimizationRowsPercentageParameterName)) {
+        if (Parameters.ContainsKey("ConstantOptimizationRowsPercentage")) {
+          Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for parameter optimization", (PercentValue)Parameters["ConstantOptimizationRowsPercentage"].ActualValue));
+          Parameters.Remove("ConstantOptimizationRowsPercentage");
+        } else {
+          Parameters.Add(new FixedValueParameter<PercentValue>(ParameterOptimizationRowsPercentageParameterName, "Determines the percentage of the rows which should be used for parameter optimization", new PercentValue(1)));
+        }
+        
+      }
     }
 
@@ -150 +205 @@
       var solution = SymbolicExpressionTreeParameter.ActualValue;
       double quality;
-      if (RandomParameter.ActualValue.NextDouble() < ConstantOptimizationProbability.Value) {
-        IEnumerable<int> constantOptimizationRows = GenerateRowsToEvaluate(ConstantOptimizationRowsPercentage.Value);
+      if (RandomParameter.ActualValue.NextDouble() < ParameterOptimizationProbability.Value) {
+        IEnumerable<int> parameterOptimizationRows = GenerateRowsToEvaluate(ParameterOptimizationRowsPercentage.Value);
         var counter = new EvaluationsCounter();
-        quality = OptimizeConstants(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, ProblemDataParameter.ActualValue,
-           constantOptimizationRows, ApplyLinearScalingParameter.ActualValue.Value, ConstantOptimizationIterations.Value, updateVariableWeights: UpdateVariableWeights, lowerEstimationLimit: EstimationLimitsParameter.ActualValue.Lower, upperEstimationLimit: EstimationLimitsParameter.ActualValue.Upper, updateConstantsInTree: UpdateConstantsInTree, counter: counter);
-
-        if (ConstantOptimizationRowsPercentage.Value != RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value) {
+        quality = OptimizeParameters(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, ProblemDataParameter.ActualValue,
+           parameterOptimizationRows, ApplyLinearScalingParameter.ActualValue.Value, ParameterOptimizationIterations.Value, updateVariableWeights: UpdateVariableWeights, lowerEstimationLimit: EstimationLimitsParameter.ActualValue.Lower, upperEstimationLimit: EstimationLimitsParameter.ActualValue.Upper, updateParametersInTree: UpdateParametersInTree, counter: counter);
+
+        if (ParameterOptimizationRowsPercentage.Value != RelativeNumberOfEvaluatedSamplesParameter.ActualValue.Value) {
           var evaluationRows = GenerateRowsToEvaluate();
           quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(SymbolicDataAnalysisTreeInterpreterParameter.ActualValue, solution, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper, ProblemDataParameter.ActualValue, evaluationRows, ApplyLinearScalingParameter.ActualValue.Value);
@@ -203 +258 @@
     }
 
-    public static double OptimizeConstants(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
+    public static double OptimizeParameters(ISymbolicDataAnalysisExpressionTreeInterpreter interpreter,
       ISymbolicExpressionTree tree, IRegressionProblemData problemData, IEnumerable<int> rows, bool applyLinearScaling,
       int maxIterations, bool updateVariableWeights = true,
       double lowerEstimationLimit = double.MinValue, double upperEstimationLimit = double.MaxValue,
-      bool updateConstantsInTree = true, Action<double[], double, object> iterationCallback = null, EvaluationsCounter counter = null) {
-
-      // Numeric constants in the tree become variables for parameter optimization.
+      bool updateParametersInTree = true, Action<double[], double, object> iterationCallback = null, EvaluationsCounter counter = null) {
+
+      // Numeric parameters in the tree become variables for parameter optimization.
       // Variables in the tree become parameters (fixed values) for parameter optimization.
       // For each parameter (variable in the original tree) we store the 
       // variable name, variable value (for factor vars) and lag as a DataForVariable object.
       // A dictionary is used to find parameters
-      double[] initialConstants;
+      double[] initialParameters;
       var parameters = new List<TreeToAutoDiffTermConverter.DataForVariable>();
 
       TreeToAutoDiffTermConverter.ParametricFunction func;
       TreeToAutoDiffTermConverter.ParametricFunctionGradient func_grad;
-      if (!TreeToAutoDiffTermConverter.TryConvertToAutoDiff(tree, updateVariableWeights, applyLinearScaling, out parameters, out initialConstants, out func, out func_grad))
-        throw new NotSupportedException("Could not optimize constants of symbolic expression tree due to not supported symbols used in the tree.");
+      if (!TreeToAutoDiffTermConverter.TryConvertToAutoDiff(tree, updateVariableWeights, applyLinearScaling, out parameters, out initialParameters, out func, out func_grad))
+        throw new NotSupportedException("Could not optimize parameters of symbolic expression tree due to not supported symbols used in the tree.");
       if (parameters.Count == 0) return 0.0; // constant expressions always have a R² of 0.0 
       var parameterEntries = parameters.ToArray(); // order of entries must be the same for x
 
-      // extract inital constants
+      // extract inital parameters
       double[] c;
       if (applyLinearScaling) {
-        c = new double[initialConstants.Length + 2];
+        c = new double[initialParameters.Length + 2];
         c[0] = 0.0;
         c[1] = 1.0;
-        Array.Copy(initialConstants, 0, c, 2, initialConstants.Length);
+        Array.Copy(initialParameters, 0, c, 2, initialParameters.Length);
       } else {
-        c = (double[])initialConstants.Clone();
+        c = (double[])initialParameters.Clone();
       }
 
@@ -283 +338 @@
       counter.GradientEvaluations += rowEvaluationsCounter.GradientEvaluations / n;
 
-      //retVal == -7  => constant optimization failed due to wrong gradient
+      //retVal == -7  => parameter optimization failed due to wrong gradient
       //          -8  => optimizer detected  NAN / INF  in  the target
       //                 function and/ or gradient
@@ -290 +345 @@
           var tmp = new double[c.Length - 2];
           Array.Copy(c, 2, tmp, 0, tmp.Length);
-          UpdateConstants(tree, tmp, updateVariableWeights);
-        } else UpdateConstants(tree, c, updateVariableWeights);
+          UpdateParameters(tree, tmp, updateVariableWeights);
+        } else UpdateParameters(tree, c, updateVariableWeights);
       }
       var quality = SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.Calculate(interpreter, tree, lowerEstimationLimit, upperEstimationLimit, problemData, rows, applyLinearScaling);
 
-      if (!updateConstantsInTree) UpdateConstants(tree, initialConstants, updateVariableWeights);
+      if (!updateParametersInTree) UpdateParameters(tree, initialParameters, updateVariableWeights);
 
       if (originalQuality - quality > 0.001 || double.IsNaN(quality)) {
-        UpdateConstants(tree, initialConstants, updateVariableWeights);
+        UpdateParameters(tree, initialParameters, updateVariableWeights);
         return originalQuality;
       }
@@ -304 +359 @@
     }
 
-    private static void UpdateConstants(ISymbolicExpressionTree tree, double[] constants, bool updateVariableWeights) {
+    private static void UpdateParameters(ISymbolicExpressionTree tree, double[] parameters, bool updateVariableWeights) {
       int i = 0;
       foreach (var node in tree.Root.IterateNodesPrefix().OfType<SymbolicExpressionTreeTerminalNode>()) {
@@ -313 +368 @@
           if (numberTreeNode.Parent.Symbol is Power 
               && numberTreeNode.Parent.GetSubtree(1) == numberTreeNode) continue; // exponents in powers are not optimizated (see TreeToAutoDiffTermConverter)
-          numberTreeNode.Value = constants[i++];
+          numberTreeNode.Value = parameters[i++];
         } else if (updateVariableWeights && variableTreeNodeBase != null)
-          variableTreeNodeBase.Weight = constants[i++];
+          variableTreeNodeBase.Weight = parameters[i++];
         else if (factorVarTreeNode != null) {
           for (int j = 0; j < factorVarTreeNode.Weights.Length; j++)
-            factorVarTreeNode.Weights[j] = constants[i++];
+            factorVarTreeNode.Weights[j] = parameters[i++];
         }
       }
@@ -340 +395 @@
       };
     }
-    public static bool CanOptimizeConstants(ISymbolicExpressionTree tree) {
+    public static bool CanOptimizeParameters(ISymbolicExpressionTree tree) {
       return TreeToAutoDiffTermConverter.IsCompatible(tree);
     }

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/ParameterOptimizationAnalyzer.cs

@@ -32 +32 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Regression {
   /// <summary>
-  /// An operator that optimizes the constants for the best symbolic expression tress in the current generation.
+  /// An operator that optimizes the parameters for the best symbolic expression tress in the current generation.
   /// </summary>
-  [Item("ConstantOptimizationAnalyzer", "An operator that performs a constant optimization on the best symbolic expression trees.")]
+  [Item("ParameterOptimizationAnalyzer", "An operator that performs a parameter optimization on the best symbolic expression trees.")]
   [StorableType("9FB87E7B-A9E2-49DD-A92A-78BD9FC17916")]
-  public sealed class ConstantOptimizationAnalyzer : SymbolicDataAnalysisSingleObjectiveAnalyzer, IStatefulItem {
+  public sealed class ParameterOptimizationAnalyzer : SymbolicDataAnalysisSingleObjectiveAnalyzer, IStatefulItem {
     private const string PercentageOfBestSolutionsParameterName = "PercentageOfBestSolutions";
-    private const string ConstantOptimizationEvaluatorParameterName = "ConstantOptimizationOperator";
+    private const string ParameterOptimizationEvaluatorParameterName = "ParameterOptimizationOperator";
 
-    private const string DataTableNameConstantOptimizationImprovement = "Constant Optimization Improvement";
+    private const string DataTableNameParameterOptimizationImprovement = "Parameter Optimization Improvement";
     private const string DataRowNameMinimumImprovement = "Minimum improvement";
     private const string DataRowNameMedianImprovement = "Median improvement";
@@ -51 +51 @@
     }
 
-    public IFixedValueParameter<SymbolicRegressionConstantOptimizationEvaluator> ConstantOptimizationEvaluatorParameter {
-      get { return (IFixedValueParameter<SymbolicRegressionConstantOptimizationEvaluator>)Parameters[ConstantOptimizationEvaluatorParameterName]; }
+    public IFixedValueParameter<SymbolicRegressionParameterOptimizationEvaluator> ParameterOptimizationEvaluatorParameter {
+      get { return (IFixedValueParameter<SymbolicRegressionParameterOptimizationEvaluator>)Parameters[ParameterOptimizationEvaluatorParameterName]; }
     }
     #endregion
 
     #region properties
-    public SymbolicRegressionConstantOptimizationEvaluator ConstantOptimizationEvaluator {
-      get { return ConstantOptimizationEvaluatorParameter.Value; }
+    public SymbolicRegressionParameterOptimizationEvaluator ParameterOptimizationEvaluator {
+      get { return ParameterOptimizationEvaluatorParameter.Value; }
     }
     public double PercentageOfBestSolutions {
@@ -64 +64 @@
     }
 
-    private DataTable ConstantOptimizationImprovementDataTable {
+    private DataTable ParameterOptimizationImprovementDataTable {
       get {
         IResult result;
-        ResultCollection.TryGetValue(DataTableNameConstantOptimizationImprovement, out result);
+        ResultCollection.TryGetValue(DataTableNameParameterOptimizationImprovement, out result);
         if (result == null) return null;
         return (DataTable)result.Value;
@@ -73 +73 @@
     }
     private DataRow MinimumImprovement {
-      get { return ConstantOptimizationImprovementDataTable.Rows[DataRowNameMinimumImprovement]; }
+      get { return ParameterOptimizationImprovementDataTable.Rows[DataRowNameMinimumImprovement]; }
     }
     private DataRow MedianImprovement {
-      get { return ConstantOptimizationImprovementDataTable.Rows[DataRowNameMedianImprovement]; }
+      get { return ParameterOptimizationImprovementDataTable.Rows[DataRowNameMedianImprovement]; }
     }
     private DataRow AverageImprovement {
-      get { return ConstantOptimizationImprovementDataTable.Rows[DataRowNameAverageImprovement]; }
+      get { return ParameterOptimizationImprovementDataTable.Rows[DataRowNameAverageImprovement]; }
     }
     private DataRow MaximumImprovement {
-      get { return ConstantOptimizationImprovementDataTable.Rows[DataRowNameMaximumImprovement]; }
+      get { return ParameterOptimizationImprovementDataTable.Rows[DataRowNameMaximumImprovement]; }
     }
     #endregion
 
     [StorableConstructor]
-    private ConstantOptimizationAnalyzer(StorableConstructorFlag _) : base(_) { }
-    private ConstantOptimizationAnalyzer(ConstantOptimizationAnalyzer original, Cloner cloner) : base(original, cloner) { }
-    public override IDeepCloneable Clone(Cloner cloner) { return new ConstantOptimizationAnalyzer(this, cloner); }
-    public ConstantOptimizationAnalyzer()
+    private ParameterOptimizationAnalyzer(StorableConstructorFlag _) : base(_) { }
+    private ParameterOptimizationAnalyzer(ParameterOptimizationAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) { return new ParameterOptimizationAnalyzer(this, cloner); }
+    public ParameterOptimizationAnalyzer()
       : base() {
       Parameters.Add(new FixedValueParameter<PercentValue>(PercentageOfBestSolutionsParameterName, "The percentage of the top solutions which should be analyzed.", new PercentValue(0.1)));
-      Parameters.Add(new FixedValueParameter<SymbolicRegressionConstantOptimizationEvaluator>(ConstantOptimizationEvaluatorParameterName, "The operator used to perform the constant optimization"));
+      Parameters.Add(new FixedValueParameter<SymbolicRegressionParameterOptimizationEvaluator>(ParameterOptimizationEvaluatorParameterName, "The operator used to perform the parameter optimization"));
 
       //Changed the ActualName of the EvaluationPartitionParameter so that it matches the parameter name of symbolic regression problems.
-      ConstantOptimizationEvaluator.EvaluationPartitionParameter.ActualName = "FitnessCalculationPartition";
+      ParameterOptimizationEvaluator.EvaluationPartitionParameter.ActualName = "FitnessCalculationPartition";
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(ParameterOptimizationEvaluatorParameterName)) {
+        if (Parameters.ContainsKey("ConstantOptimizationOperator")) {
+          Parameters.Add(new FixedValueParameter<SymbolicRegressionParameterOptimizationEvaluator>(ParameterOptimizationEvaluatorParameterName, "The operator used to perform the parameter optimization"));
+          Parameters.Remove("ConstantOptimizationOperator");
+        } else {
+          Parameters.Add(new FixedValueParameter<SymbolicRegressionParameterOptimizationEvaluator>(ParameterOptimizationEvaluatorParameterName, "The operator used to perform the parameter optimization"));
+        }
+      }
     }
 
@@ -134 +146 @@
         operationCollection.Parallel = true;
         foreach (var scopeIndex in scopeIndexes) {
-          var childOperation = ExecutionContext.CreateChildOperation(ConstantOptimizationEvaluator, ExecutionContext.Scope.SubScopes[scopeIndex]);
+          var childOperation = ExecutionContext.CreateChildOperation(ParameterOptimizationEvaluator, ExecutionContext.Scope.SubScopes[scopeIndex]);
           operationCollection.Add(childOperation);
         }
@@ -141 +153 @@
       }
 
-      //code executed to analyze results of constant optimization
+      //code executed to analyze results of parameter optimization
       double[] qualitiesAfterCoOp = scopeIndexes.Select(x => Quality[x].Value).ToArray();
       var qualityImprovement = qualitiesBeforeCoOp.Zip(qualitiesAfterCoOp, (b, a) => a - b).ToArray();
 
-      if (!ResultCollection.ContainsKey(DataTableNameConstantOptimizationImprovement)) {
-        var dataTable = new DataTable(DataTableNameConstantOptimizationImprovement);
-        ResultCollection.Add(new Result(DataTableNameConstantOptimizationImprovement, dataTable));
+      if (!ResultCollection.ContainsKey(DataTableNameParameterOptimizationImprovement)) {
+        var dataTable = new DataTable(DataTableNameParameterOptimizationImprovement);
+        ResultCollection.Add(new Result(DataTableNameParameterOptimizationImprovement, dataTable));
         dataTable.VisualProperties.YAxisTitle = "R²";
 

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

@@ -41 +41 @@
     }
 
-    private static readonly Constant constantSy = new Constant();
+    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();
@@ -52 +53 @@
 
     public static ISymbolicExpressionTreeNode Derive(ISymbolicExpressionTreeNode branch, string variableName) {
-      if (branch.Symbol is Constant) {
-        return CreateConstant(0.0);
+      if (branch.Symbol is INumericSymbol) {
+        return CreateNumber(0.0);
       }
       if (branch.Symbol is Variable) {
         var varNode = branch as VariableTreeNode;
         if (varNode.VariableName == variableName) {
-          return CreateConstant(varNode.Weight);
+          return CreateNumber(varNode.Weight);
         } else {
-          return CreateConstant(0.0);
+          return CreateNumber(0.0);
         }
       }
@@ -102 +103 @@
         if (branch.SubtreeCount == 1) {
           var g = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-          var gPrime = Product(CreateConstant(-1.0), Derive(g, variableName));
+          var gPrime = Product(CreateNumber(-1.0), Derive(g, variableName));
           var sqrNode = new Square().CreateTreeNode();
           sqrNode.AddSubtree(g);
@@ -125 +126 @@
       if (branch.Symbol is Logarithm) {
         var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Div(CreateConstant(1.0), f), Derive(f, variableName));
+        return Product(Div(CreateNumber(1.0), f), Derive(f, variableName));
       }
       if (branch.Symbol is Exponential) {
@@ -133 +134 @@
       if (branch.Symbol is Square) {
         var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Product(CreateConstant(2.0), f), Derive(f, variableName));
+        return Product(Product(CreateNumber(2.0), f), Derive(f, variableName));
       }
       if (branch.Symbol is SquareRoot) {
         var f = (ISymbolicExpressionTreeNode)branch.Clone();
         var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Div(CreateConstant(1.0), Product(CreateConstant(2.0), f)), Derive(u, variableName));
+        return Product(Div(CreateNumber(1.0), Product(CreateNumber(2.0), f)), Derive(u, variableName));
       }
       if (branch.Symbol is CubeRoot) {
         var f = (ISymbolicExpressionTreeNode)branch.Clone();
         var u = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Div(CreateConstant(1.0), Product(CreateConstant(3.0), Square(f))), Derive(u, variableName));  // 1/3 1/cbrt(f(x))^2 d/dx f(x)
+        return Product(Div(CreateNumber(1.0), Product(CreateNumber(3.0), Square(f))), Derive(u, variableName));  // 1/3 1/cbrt(f(x))^2 d/dx f(x)
       }
       if (branch.Symbol is Cube) {
         var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-        return Product(Product(CreateConstant(3.0), Square(f)), Derive(f, variableName));
+        return Product(Product(CreateNumber(3.0), Square(f)), Derive(f, variableName));
       }
       if (branch.Symbol is Power) {
         // HL evaluators handle power strangely (exponent is rounded to an integer)
         // here we only support the case when the exponent is a constant integer 
-        var exponent = branch.GetSubtree(1) as ConstantTreeNode;
+        var exponent = branch.GetSubtree(1) as INumericTreeNode;
         if (exponent != null && Math.Truncate(exponent.Value) == exponent.Value) {
           var newPower = (ISymbolicExpressionTreeNode)branch.Clone();
           var f = (ISymbolicExpressionTreeNode)newPower.GetSubtree(0).Clone();
-          var newExponent = (ConstantTreeNode)newPower.GetSubtree(1);
+          var newExponent = (INumericTreeNode)newPower.GetSubtree(1);
           newExponent.Value -= 1;
-          return Product(Product(CreateConstant(exponent.Value), newPower), Derive(f, variableName));
+          return Product(Product(CreateNumber(exponent.Value), newPower), Derive(f, variableName));
         } else throw new NotSupportedException("Cannot derive non-integer powers");
       }
@@ -171 +172 @@
         var b = (ISymbolicExpressionTreeNode)branch.GetSubtree(1).Clone();
 
-        var definition = Div(a, SquareRoot(Sum(Square(b), CreateConstant(1.0))));
+        var definition = Div(a, SquareRoot(Sum(Square(b), CreateNumber(1.0))));
         return Derive(definition, variableName);
       }
@@ -184 +185 @@
         var sin = (new Sine()).CreateTreeNode();
         sin.AddSubtree(u);
-        return Product(CreateConstant(-1.0), Product(sin, Derive(u, variableName)));
+        return Product(CreateNumber(-1.0), Product(sin, Derive(u, variableName)));
       }
       if (branch.Symbol is Tangent) {
@@ -196 +197 @@
         var fxp = Derive(branch.GetSubtree(0), variableName);
         var tanh = (ISymbolicExpressionTreeNode)branch.Clone();
-        return Product(fxp, Subtract(CreateConstant(1.0), Square(tanh)));
+        return Product(fxp, Subtract(CreateNumber(1.0), Square(tanh)));
       }
       throw new NotSupportedException(string.Format("Symbol {0} is not supported.", branch.Symbol));
@@ -253 +254 @@
     }
 
-    private static ISymbolicExpressionTreeNode CreateConstant(double v) {
-      var constNode = (ConstantTreeNode)constantSy.CreateTreeNode();
-      constNode.Value = v;
-      return constNode;
+    private static ISymbolicExpressionTreeNode CreateNumber(double v) {
+      var numberNode = (NumberTreeNode)numberSy.CreateTreeNode();
+      numberNode.Value = v;
+      return numberNode;
     }
 
@@ -264 +265 @@
         where
           !(n.Symbol is Variable) &&
+          !(n.Symbol is Number) &&
           !(n.Symbol is Constant) &&
           !(n.Symbol is Addition) &&

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

@@ -36 +36 @@
     private static readonly Multiplication mulSymbol = new Multiplication();
     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();
@@ -240 +241 @@
     }
 
+    private static bool IsNumber(ISymbolicExpressionTreeNode node) {
+      return node.Symbol is Number;
+    }
+
     private static bool IsConstant(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Constant;
     }
-
     // dynamic
     private static bool IsTimeLag(ISymbolicExpressionTreeNode node) {
@@ -261 +265 @@
     /// <returns></returns>
     public static ISymbolicExpressionTreeNode GetSimplifiedTree(ISymbolicExpressionTreeNode original) {
-      if (IsConstant(original) || IsVariableBase(original)) {
+      if (IsNumber(original) || IsConstant(original) || IsVariableBase(original)) {
         return (ISymbolicExpressionTreeNode)original.Clone();
       } else if (IsAbsolute(original)) {
@@ -335 +339 @@
         clone.AddSubtree(simplifiedSubtree);
       }
-      if (simplifiedSubtrees.TrueForAll(t => IsConstant(t))) {
+      if (simplifiedSubtrees.TrueForAll(IsNumber)) {
         SimplifyConstantExpression(clone);
       }
@@ -501 +505 @@
       var laggedTreeNode = original as ILaggedTreeNode;
       var simplifiedSubtree = GetSimplifiedTree(original.GetSubtree(0));
-      if (IsConstant(simplifiedSubtree)) {
+      if (IsNumber(simplifiedSubtree)) {
         return GetSimplifiedTree(MakeProduct(simplifiedSubtree, MakeConstant(-laggedTreeNode.Lag)));
       } else {
@@ -514 +518 @@
     private static ISymbolicExpressionTreeNode MakeTimeLag(ISymbolicExpressionTreeNode subtree, int lag) {
       if (lag == 0) return subtree;
-      if (IsConstant(subtree)) return subtree;
+      if (IsNumber(subtree)) return subtree;
       var lagNode = (LaggedTreeNode)timeLagSymbol.CreateTreeNode();
       lagNode.Lag = lag;
@@ -534 +538 @@
 
     private static ISymbolicExpressionTreeNode MakeNot(ISymbolicExpressionTreeNode t) {
-      if (IsConstant(t)) {
-        var constNode = t as ConstantTreeNode;
+      if (IsNumber(t)) {
+        var constNode = t as NumberTreeNode;
         if (constNode.Value > 0) return MakeConstant(-1.0);
         else return MakeConstant(1.0);
@@ -555 +559 @@
 
     private static ISymbolicExpressionTreeNode MakeOr(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
-        var constA = a as ConstantTreeNode;
-        var constB = b as ConstantTreeNode;
+      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);
@@ -563 +567 @@
           return MakeConstant(-1.0);
         }
-      } else if (IsConstant(a)) {
+      } else if (IsNumber(a)) {
         return MakeOr(b, a);
-      } else if (IsConstant(b)) {
-        var constT = b as ConstantTreeNode;
+      } else if (IsNumber(b)) {
+        var constT = b as NumberTreeNode;
         if (constT.Value > 0.0) {
           // boolean expression is necessarily true
@@ -585 +589 @@
 
     private static ISymbolicExpressionTreeNode MakeAnd(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
-        var constA = a as ConstantTreeNode;
-        var constB = b as ConstantTreeNode;
+      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);
@@ -593 +597 @@
           return MakeConstant(-1.0);
         }
-      } else if (IsConstant(a)) {
+      } else if (IsNumber(a)) {
         return MakeAnd(b, a);
-      } else if (IsConstant(b)) {
-        var constB = b as ConstantTreeNode;
+      } else if (IsNumber(b)) {
+        var constB = b as NumberTreeNode;
         if (constB.Value > 0.0) {
           // the constant value has no effect on the result of the boolean condition so we can drop the constant term
@@ -616 +620 @@
     private static ISymbolicExpressionTreeNode MakeLessThan(ISymbolicExpressionTreeNode leftSide,
       ISymbolicExpressionTreeNode rightSide) {
-      if (IsConstant(leftSide) && IsConstant(rightSide)) {
-        var lsConst = leftSide as ConstantTreeNode;
-        var rsConst = rightSide as ConstantTreeNode;
+      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);
@@ -631 +635 @@
     private static ISymbolicExpressionTreeNode MakeGreaterThan(ISymbolicExpressionTreeNode leftSide,
       ISymbolicExpressionTreeNode rightSide) {
-      if (IsConstant(leftSide) && IsConstant(rightSide)) {
-        var lsConst = leftSide as ConstantTreeNode;
-        var rsConst = rightSide as ConstantTreeNode;
+      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);
@@ -646 +650 @@
     private static ISymbolicExpressionTreeNode MakeIfThenElse(ISymbolicExpressionTreeNode condition,
       ISymbolicExpressionTreeNode trueBranch, ISymbolicExpressionTreeNode falseBranch) {
-      if (IsConstant(condition)) {
-        var constT = condition as ConstantTreeNode;
+      if (IsNumber(condition)) {
+        var constT = condition as NumberTreeNode;
         if (constT.Value > 0.0) return trueBranch;
         else return falseBranch;
@@ -667 +671 @@
 
     private static ISymbolicExpressionTreeNode MakeSine(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
+      if (IsNumber(node)) {
+        var constT = node as NumberTreeNode;
         return MakeConstant(Math.Sin(constT.Value));
       } else if (IsFactor(node)) {
@@ -684 +688 @@
 
     private static ISymbolicExpressionTreeNode MakeTangent(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
+      if (IsNumber(node)) {
+        var constT = node as NumberTreeNode;
         return MakeConstant(Math.Tan(constT.Value));
       } else if (IsFactor(node)) {
@@ -701 +705 @@
 
     private static ISymbolicExpressionTreeNode MakeCosine(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
+      if (IsNumber(node)) {
+        var constT = node as NumberTreeNode;
         return MakeConstant(Math.Cos(constT.Value));
       } else if (IsFactor(node)) {
@@ -720 +724 @@
 
     private static ISymbolicExpressionTreeNode MakeExp(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
+      if (IsNumber(node)) {
+        var constT = node as NumberTreeNode;
         return MakeConstant(Math.Exp(constT.Value));
       } else if (IsFactor(node)) {
@@ -744 +748 @@
     }
     private static ISymbolicExpressionTreeNode MakeLog(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
+      if (IsNumber(node)) {
+        var constT = node as NumberTreeNode;
         return MakeConstant(Math.Log(constT.Value));
       } else if (IsFactor(node)) {
@@ -762 +766 @@
 
     private static ISymbolicExpressionTreeNode MakeSquare(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
+      if (IsNumber(node)) {
+        var constT = node as NumberTreeNode;
         return MakeConstant(constT.Value * constT.Value);
       } else if (IsFactor(node)) {
@@ -796 +800 @@
 
     private static ISymbolicExpressionTreeNode MakeCube(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
+      if (IsNumber(node)) {
+        var constT = node as NumberTreeNode;
         return MakeConstant(constT.Value * constT.Value * constT.Value);
       } else if (IsFactor(node)) {
@@ -821 +825 @@
 
     private static ISymbolicExpressionTreeNode MakeAbs(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
+      if (IsNumber(node)) {
+        var constT = node as NumberTreeNode;
         return MakeConstant(Math.Abs(constT.Value));
       } else if (IsFactor(node)) {
@@ -853 +857 @@
     // constant folding only
     private static ISymbolicExpressionTreeNode MakeAnalyticalQuotient(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(b)) {
-        var c = b as ConstantTreeNode;
+      if (IsNumber(b)) {
+        var c = b as NumberTreeNode;
         return MakeFraction(a, MakeConstant(Math.Sqrt(1.0 + c.Value * c.Value)));
       } else if (IsFactor(b)) {
@@ -871 +875 @@
 
     private static ISymbolicExpressionTreeNode MakeSquareRoot(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
+      if (IsNumber(node)) {
+        var constT = node as NumberTreeNode;
         return MakeConstant(Math.Sqrt(constT.Value));
       } else if (IsFactor(node)) {
@@ -890 +894 @@
 
     private static ISymbolicExpressionTreeNode MakeCubeRoot(ISymbolicExpressionTreeNode node) {
-      if (IsConstant(node)) {
-        var constT = node as ConstantTreeNode;
+      if (IsNumber(node)) {
+        var constT = node as NumberTreeNode;
         return MakeConstant(Math.Pow(constT.Value, 1.0 / 3.0));
       } else if (IsFactor(node)) {
@@ -909 +913 @@
 
     private static ISymbolicExpressionTreeNode MakeRoot(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
-        var constA = a as ConstantTreeNode;
-        var constB = b as ConstantTreeNode;
+      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)));
-      } else if (IsFactor(a) && IsConstant(b)) {
+      } else if (IsFactor(a) && IsNumber(b)) {
         var factNode = a as FactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
+        var constNode = b as NumberTreeNode;
         return MakeFactor(factNode.Symbol, factNode.VariableName,
           factNode.Weights.Select(w => Math.Pow(w, 1.0 / Math.Round(constNode.Value))));
-      } else if (IsBinFactor(a) && IsConstant(b)) {
+      } else if (IsBinFactor(a) && IsNumber(b)) {
         var binFactor = a as BinaryFactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
+        var constNode = b as NumberTreeNode;
         return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Pow(binFactor.Weight, 1.0 / Math.Round(constNode.Value)));
-      } else if (IsConstant(a) && IsFactor(b)) {
-        var constNode = a as ConstantTreeNode;
+      } 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))));
-      } else if (IsConstant(a) && IsBinFactor(b)) {
-        var constNode = a as ConstantTreeNode;
+      } 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)));
@@ -934 +938 @@
         var node1 = b as FactorVariableTreeNode;
         return MakeFactor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => Math.Pow(u, 1.0 / Math.Round(v))));
-      } else if (IsConstant(b)) {
-        var constB = b as ConstantTreeNode;
+      } else if (IsNumber(b)) {
+        var constB = b as NumberTreeNode;
         var constBValue = Math.Round(constB.Value);
         if (constBValue == 1.0) {
@@ -969 +973 @@
 
     private static ISymbolicExpressionTreeNode MakePower(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
-        var constA = a as ConstantTreeNode;
-        var constB = b as ConstantTreeNode;
+      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)));
-      } else if (IsFactor(a) && IsConstant(b)) {
+      } else if (IsFactor(a) && IsNumber(b)) {
         var factNode = a as FactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
+        var constNode = b as NumberTreeNode;
         return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => Math.Pow(w, Math.Round(constNode.Value))));
-      } else if (IsBinFactor(a) && IsConstant(b)) {
+      } else if (IsBinFactor(a) && IsNumber(b)) {
         var binFactor = a as BinaryFactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
+        var constNode = b as NumberTreeNode;
         return MakeBinFactor(binFactor.Symbol, binFactor.VariableName, binFactor.VariableValue, Math.Pow(binFactor.Weight, Math.Round(constNode.Value)));
-      } else if (IsConstant(a) && IsFactor(b)) {
-        var constNode = a as ConstantTreeNode;
+      } 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))));
-      } else if (IsConstant(a) && IsBinFactor(b)) {
-        var constNode = a as ConstantTreeNode;
+      } 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)));
@@ -993 +997 @@
         var node1 = b as FactorVariableTreeNode;
         return MakeFactor(node0.Symbol, node0.VariableName, node0.Weights.Zip(node1.Weights, (u, v) => Math.Pow(u, Math.Round(v))));
-      } else if (IsConstant(b)) {
-        var constB = b as ConstantTreeNode;
+      } else if (IsNumber(b)) {
+        var constB = b as NumberTreeNode;
         double exponent = Math.Round(constB.Value);
         if (exponent == 0.0) {
@@ -1028 +1032 @@
     // MakeFraction, MakeProduct and MakeSum take two already simplified trees and create a new simplified tree
     private static ISymbolicExpressionTreeNode MakeFraction(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
+      if (IsNumber(a) && IsNumber(b)) {
         // fold constants
-        return MakeConstant(((ConstantTreeNode)a).Value / ((ConstantTreeNode)b).Value);
-      } else if ((IsConstant(a) && ((ConstantTreeNode)a).Value != 1.0)) {
+        return MakeConstant(((NumberTreeNode)a).Value / ((NumberTreeNode)b).Value);
+      } else if ((IsNumber(a) && ((NumberTreeNode)a).Value != 1.0)) {
         // a / x => (a * 1/a) / (x * 1/a) => 1 / (x * 1/a)
         return MakeFraction(MakeConstant(1.0), MakeProduct(b, Invert(a)));
-      } else if (IsVariableBase(a) && IsConstant(b)) {
+      } else if (IsVariableBase(a) && IsNumber(b)) {
         // merge constant values into variable weights
-        var constB = ((ConstantTreeNode)b).Value;
+        var constB = ((NumberTreeNode)b).Value;
         ((VariableTreeNodeBase)a).Weight /= constB;
         return a;
-      } else if (IsFactor(a) && IsConstant(b)) {
+      } else if (IsFactor(a) && IsNumber(b)) {
         var factNode = a as FactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
+        var constNode = b as NumberTreeNode;
         return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select(w => w / constNode.Value));
-      } else if (IsBinFactor(a) && IsConstant(b)) {
+      } else if (IsBinFactor(a) && IsNumber(b)) {
         var factNode = a as BinaryFactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
+        var constNode = b as NumberTreeNode;
         return MakeBinFactor(factNode.Symbol, factNode.VariableName, factNode.VariableValue, factNode.Weight / constNode.Value);
       } else if (IsFactor(a) && IsFactor(b) && AreSameTypeAndVariable(a, b)) {
@@ -1070 +1074 @@
         var bVar = b as VariableTreeNode;
         return MakeConstant(aVar.Weight / bVar.Weight);
-      } else if (IsAddition(a) && IsConstant(b)) {
+      } else if (IsAddition(a) && IsNumber(b)) {
         return a.Subtrees
           .Select(x => GetSimplifiedTree(x))
           .Select(x => MakeFraction(x, GetSimplifiedTree(b)))
           .Aggregate((c, d) => MakeSum(c, d));
-      } else if (IsMultiplication(a) && IsConstant(b)) {
+      } else if (IsMultiplication(a) && IsNumber(b)) {
         return MakeProduct(a, Invert(b));
-      } else if (IsDivision(a) && IsConstant(b)) {
+      } else if (IsDivision(a) && IsNumber(b)) {
         // (a1 / a2) / c => (a1 / (a2 * c))
         return MakeFraction(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
@@ -1100 +1104 @@
 
     private static ISymbolicExpressionTreeNode MakeSum(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
+      if (IsNumber(a) && IsNumber(b)) {
         // fold constants
-        ((ConstantTreeNode)a).Value += ((ConstantTreeNode)b).Value;
+        ((NumberTreeNode)a).Value += ((NumberTreeNode)b).Value;
         return a;
-      } else if (IsConstant(a)) {
+      } else if (IsNumber(a)) {
         // c + x => x + c
         // b is not constant => make sure constant is on the right
         return MakeSum(b, a);
-      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value == 0.0) {
+      } else if (IsNumber(b) && ((NumberTreeNode)b).Value == 0.0) {
         // x + 0 => x
         return a;
-      } else if (IsFactor(a) && IsConstant(b)) {
+      } else if (IsFactor(a) && IsNumber(b)) {
         var factNode = a as FactorVariableTreeNode;
-        var constNode = b as ConstantTreeNode;
+        var constNode = b as NumberTreeNode;
         return MakeFactor(factNode.Symbol, factNode.VariableName, factNode.Weights.Select((w) => w + constNode.Value));
       } else if (IsFactor(a) && IsFactor(b) && AreSameTypeAndVariable(a, b)) {
@@ -1138 +1142 @@
         for (int i = 0; i < a.Subtrees.Count() - 1; i++) add.AddSubtree(a.GetSubtree(i));
         for (int i = 0; i < b.Subtrees.Count() - 1; i++) add.AddSubtree(b.GetSubtree(i));
-        if (IsConstant(a.Subtrees.Last()) && IsConstant(b.Subtrees.Last())) {
+        if (IsNumber(a.Subtrees.Last()) && IsNumber(b.Subtrees.Last())) {
           add.AddSubtree(MakeSum(a.Subtrees.Last(), b.Subtrees.Last()));
-        } else if (IsConstant(a.Subtrees.Last())) {
+        } else if (IsNumber(a.Subtrees.Last())) {
           add.AddSubtree(b.Subtrees.Last());
           add.AddSubtree(a.Subtrees.Last());
@@ -1155 +1159 @@
       } else if (IsAddition(b)) {
         return MakeSum(b, a);
-      } else if (IsAddition(a) && IsConstant(b)) {
+      } else if (IsAddition(a) && IsNumber(b)) {
         // a is an addition and b is a constant => append b to a and make sure the constants are merged
         var add = addSymbol.CreateTreeNode();
         // add all sub trees except for the last
         for (int i = 0; i < a.Subtrees.Count() - 1; i++) add.AddSubtree(a.GetSubtree(i));
-        if (IsConstant(a.Subtrees.Last()))
+        if (IsNumber(a.Subtrees.Last()))
           add.AddSubtree(MakeSum(a.Subtrees.Last(), b));
         else {
@@ -1201 +1205 @@
                             group node by GroupId(node) into g
                             select g;
-      var constant = (from node in subtrees.OfType<ConstantTreeNode>()
+      var constant = (from node in subtrees.OfType<NumberTreeNode>()
                       select node.Value).DefaultIfEmpty(0.0).Sum();
-      var unchangedSubtrees = subtrees.Where(t => t.SubtreeCount > 0 || !(t is IVariableTreeNode) && !(t is ConstantTreeNode));
+      var unchangedSubtrees = subtrees.Where(t => t.SubtreeCount > 0 || !(t is IVariableTreeNode) && !(t is NumberTreeNode));
 
       foreach (var variableNodeGroup in groupedVarNodes) {
@@ -1250 +1254 @@
 
     private static ISymbolicExpressionTreeNode MakeProduct(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
-      if (IsConstant(a) && IsConstant(b)) {
+      if (IsNumber(a) && IsNumber(b)) {
         // fold constants
-        return MakeConstant(((ConstantTreeNode)a).Value * ((ConstantTreeNode)b).Value);
-      } else if (IsConstant(a)) {
+        return MakeConstant(((NumberTreeNode)a).Value * ((NumberTreeNode)b).Value);
+      } else if (IsNumber(a)) {
         // a * $ => $ * a
         return MakeProduct(b, a);
@@ -1264 +1268 @@
         var node1 = b as BinaryFactorVariableTreeNode;
         return MakeBinFactor(node0.Symbol, node0.VariableName, node0.VariableValue, node0.Weight * node1.Weight);
-      } else if (IsFactor(a) && IsConstant(b)) {
+      } else if (IsFactor(a) && IsNumber(b)) {
         var node0 = a as FactorVariableTreeNode;
-        var node1 = b as ConstantTreeNode;
+        var node1 = b as NumberTreeNode;
         return MakeFactor(node0.Symbol, node0.VariableName, node0.Weights.Select(w => w * node1.Value));
-      } else if (IsBinFactor(a) && IsConstant(b)) {
+      } else if (IsBinFactor(a) && IsNumber(b)) {
         var node0 = a as BinaryFactorVariableTreeNode;
-        var node1 = b as ConstantTreeNode;
+        var node1 = b as NumberTreeNode;
         return MakeBinFactor(node0.Symbol, node0.VariableName, node0.VariableValue, node0.Weight * node1.Value);
       } else if (IsBinFactor(a) && IsFactor(b)) {
@@ -1282 +1286 @@
         if (wi < 0) throw new ArgumentException();
         return MakeBinFactor(node1.Symbol, node1.VariableName, node1.VariableValue, node1.Weight * node0.Weights[wi]);
-      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value == 1.0) {
+      } else if (IsNumber(b) && ((NumberTreeNode)b).Value == 1.0) {
         // $ * 1.0 => $
         return a;
-      } else if (IsConstant(b) && ((ConstantTreeNode)b).Value == 0.0) {
+      } else if (IsNumber(b) && ((NumberTreeNode)b).Value == 0.0) {
         return MakeConstant(0);
-      } else if (IsConstant(b) && IsVariableBase(a)) {
+      } else if (IsNumber(b) && IsVariableBase(a)) {
         // multiply constants into variables weights
-        ((VariableTreeNodeBase)a).Weight *= ((ConstantTreeNode)b).Value;
+        ((VariableTreeNodeBase)a).Weight *= ((NumberTreeNode)b).Value;
         return a;
-      } else if (IsConstant(b) && IsAddition(a) ||
+      } else if (IsNumber(b) && IsAddition(a) ||
           IsFactor(b) && IsAddition(a) ||
           IsBinFactor(b) && IsAddition(a)) {
@@ -1321 +1325 @@
       } else if (IsAbsolute(a) && IsAbsolute(b)) {
         return MakeAbs(MakeProduct(a.GetSubtree(0), b.GetSubtree(0)));
-      } else if (IsAbsolute(a) && IsConstant(b)) {
-        var constNode = b as ConstantTreeNode;
+      } else if (IsAbsolute(a) && IsNumber(b)) {
+        var constNode = b as NumberTreeNode;
         var posF = Math.Abs(constNode.Value);
         if (constNode.Value > 0) {
@@ -1391 +1395 @@
       var constantProduct = (from node in subtrees.OfType<VariableTreeNodeBase>()
                              select node.Weight)
-        .Concat(from node in subtrees.OfType<ConstantTreeNode>()
+        .Concat(from node in subtrees.OfType<NumberTreeNode>()
                 select node.Value)
         .DefaultIfEmpty(1.0)
@@ -1397 +1401 @@
 
       var unchangedSubtrees = from tree in subtrees
-                              where tree.SubtreeCount > 0 || !(tree is IVariableTreeNode) && !(tree is ConstantTreeNode)
+                              where tree.SubtreeCount > 0 || !(tree is IVariableTreeNode) && !(tree is NumberTreeNode)
                               select tree;
 
@@ -1446 +1450 @@
     /// <returns>-x</returns>
     private static ISymbolicExpressionTreeNode Negate(ISymbolicExpressionTreeNode x) {
-      if (IsConstant(x)) {
-        ((ConstantTreeNode)x).Value *= -1;
+      if (IsNumber(x)) {
+        ((NumberTreeNode)x).Value *= -1;
       } else if (IsVariableBase(x)) {
         var variableTree = (VariableTreeNodeBase)x;
@@ -1483 +1487 @@
     /// <returns></returns>
     private static ISymbolicExpressionTreeNode Invert(ISymbolicExpressionTreeNode x) {
-      if (IsConstant(x)) {
-        return MakeConstant(1.0 / ((ConstantTreeNode)x).Value);
+      if (IsNumber(x)) {
+        return MakeConstant(1.0 / ((NumberTreeNode)x).Value);
       } else if (IsFactor(x)) {
         var factorNode = (FactorVariableTreeNode)x;
@@ -1497 +1501 @@
 
     private static ISymbolicExpressionTreeNode MakeConstant(double value) {
-      ConstantTreeNode constantTreeNode = (ConstantTreeNode)(constSymbol.CreateTreeNode());
-      constantTreeNode.Value = value;
-      return constantTreeNode;
+      NumberTreeNode numberTreeNode = (NumberTreeNode)(numberSymbol.CreateTreeNode());
+      numberTreeNode.Value = value;
+      return numberTreeNode;
     }
 

branches/3140_NumberSymbol/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Hashing/SymbolicExpressionTreeHash.cs

@@ -36 +36 @@
     private static readonly Sine sin = new Sine();
     private static readonly Cosine cos = new Cosine();
-    private static readonly Num Num = new Num();
+    private static readonly Number number = new Number();
 
     private static ISymbolicExpressionTreeNode ActualRoot(this ISymbolicExpressionTree tree) => tree.Root.GetSubtree(0).GetSubtree(0);
@@ -66 +66 @@
       var symbol = node.Symbol;
       var name = symbol.Name;
-      if (node is NumTreeNode constantNode) {
+      if (node is NumberTreeNode constantNode) {
         name = strict ? constantNode.Value.ToString() : symbol.Name;
       } else if (node is VariableTreeNode variableNode) {
@@ -222 +222 @@
             variableTreeNode.VariableName = variable.VariableName;
             variableTreeNode.Weight = variable.Weight;
-          } else if (node.Data is NumTreeNode @const) {
-            var constantTreeNode = (NumTreeNode)treeNodes[i];
+          } else if (node.Data is NumberTreeNode @const) {
+            var constantTreeNode = (NumberTreeNode)treeNodes[i];
             constantTreeNode.Value = @const.Value;
           }
@@ -285 +285 @@
 
         var symbol = child.Data.Symbol;
-        if (child.Data is NumTreeNode firstConst) {
+        if (child.Data is NumberTreeNode firstConst) {
           // fold sibling constant nodes into the first constant
           for (int k = j + 1; k < children.Length; ++k) {
             var sibling = nodes[children[k]];
-            if (sibling.Data is NumTreeNode otherConst) {
+            if (sibling.Data is NumberTreeNode otherConst) {
               sibling.Enabled = false;
               node.Arity--;
@@ -301 +301 @@
           for (int k = j + 1; k < children.Length; ++k) {
             var sibling = nodes[children[k]];
-            if (sibling.Data is NumTreeNode constantNode) {
+            if (sibling.Data is NumberTreeNode constantNode) {
               sibling.Enabled = false;
               node.Arity--;
@@ -329 +329 @@
 
         if (node.Arity == 0) { // if everything is simplified this node becomes constant
-          var constantTreeNode = Num.CreateTreeNode<NumTreeNode>();
+          var constantTreeNode = number.CreateTreeNode<NumberTreeNode>();
           constantTreeNode.Value = 1;
           nodes[i] = constantTreeNode.ToHashNode();
@@ -344 +344 @@
       var tmp = nodes;
 
-      if (children.All(x => tmp[x].Data.Symbol is Num)) {
-        var v = ((NumTreeNode)nodes[children.First()].Data).Value;
+      if (children.All(x => tmp[x].Data.Symbol is Number)) {
+        var v = ((NumberTreeNode)nodes[children.First()].Data).Value;
         if (node.Arity == 1) {
           v = 1 / v;
         } else if (node.Arity > 1) {
           foreach (var j in children.Skip(1)) {
-            v /= ((NumTreeNode)nodes[j].Data).Value;
+            v /= ((NumberTreeNode)nodes[j].Data).Value;
           }
         }
-        var constantTreeNode = Num.CreateTreeNode<NumTreeNode>();
+        var constantTreeNode = number.CreateTreeNode<NumberTreeNode>();
         constantTreeNode.Value = v;
         nodes[i] = constantTreeNode.ToHashNode();
@@ -368 +368 @@
         }
         if (node.Arity == 0) {
-          var constantTreeNode = Num.CreateTreeNode<NumTreeNode>();
+          var constantTreeNode = number.CreateTreeNode<NumberTreeNode>();
           constantTreeNode.Value = 1; // x / x = 1
           nodes[i] = constantTreeNode.ToHashNode();
@@ -383 +383 @@
       var childSymbol = child.Data.Symbol;
 
-      if (childSymbol is Num) {
+      if (childSymbol is Number) {
         nodes[i].Enabled = false;
       } else if ((parentSymbol is Exponential && childSymbol is Logarithm) || (parentSymbol is Logarithm && childSymbol is Exponential)) {
@@ -393 +393 @@
       var children = nodes.IterateChildren(i);
       var tmp = nodes;
-      if (children.All(x => tmp[x].Data.Symbol is Num)) {
+      if (children.All(x => tmp[x].Data.Symbol is Number)) {
         foreach (var j in children) {
           nodes[j].Enabled = false;
         }
-        nodes[i] = Num.CreateTreeNode().ToHashNode();
+        nodes[i] = number.CreateTreeNode().ToHashNode();
       }
     }

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

@@ -115 +115 @@
       if (linearScalingCalculator.ErrorState != OnlineCalculatorError.None) return;
 
-      NumTreeNode alphaTreeNode = null;
-      NumTreeNode betaTreeNode = null;
+      NumberTreeNode alphaTreeNode = null;
+      NumberTreeNode betaTreeNode = null;
       // check if model has a structure that can be re-used for scaling
       var startNode = SymbolicExpressionTree.Root.GetSubtree(0);
       var addNode = startNode.GetSubtree(0);
       if (addNode.Symbol is Addition && addNode.SubtreeCount == 2) {
-        alphaTreeNode = (NumTreeNode)addNode.Subtrees.LastOrDefault(n => n is NumTreeNode);
+        alphaTreeNode = (NumberTreeNode)addNode.Subtrees.LastOrDefault(n => n is NumberTreeNode);
         var mulNode = addNode.Subtrees.FirstOrDefault(n => n.Symbol is Multiplication);
         if (mulNode != null) {
-          betaTreeNode = (NumTreeNode)mulNode.Subtrees.LastOrDefault(n => n is NumTreeNode);
+          betaTreeNode = (NumberTreeNode)mulNode.Subtrees.LastOrDefault(n => n is NumberTreeNode);
         }
       }
@@ -146 +146 @@
         var addition = new Addition();
         var node = addition.CreateTreeNode();
-        var alphaConst = MakeConstant(alpha);
+        var alphaConst = MakeNumber(alpha);
         node.AddSubtree(treeNode);
         node.AddSubtree(alphaConst);
@@ -157 +157 @@
         return treeNode;
       } else {
-        var multipliciation = new Multiplication();
-        var node = multipliciation.CreateTreeNode();
-        var betaConst = MakeConstant(beta);
+        var multiplication = new Multiplication();
+        var node = multiplication.CreateTreeNode();
+        var betaConst = MakeNumber(beta);
         node.AddSubtree(treeNode);
         node.AddSubtree(betaConst);
@@ -166 +166 @@
     }
 
-    private static ISymbolicExpressionTreeNode MakeConstant(double c) {
-      var node = (NumTreeNode)(new Num()).CreateTreeNode();
+    private static ISymbolicExpressionTreeNode MakeNumber(double c) {
+      var node = (NumberTreeNode)(new Number()).CreateTreeNode();
       node.Value = c;
       return node;