Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisComplexityAnalyzer.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisComplexityAnalyzer.cs	(revision 8085)
+++ 	(revision )
@@ -1,147 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Analysis;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.PluginInfrastructure.Manager;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  /// <summary>
-  /// Calculates the complexity of all trees in the population.
-  /// </summary>
-  [Item("SymbolicDataAnalysisComplexityAnalyzer", "Calculates the complexity of all trees in the population.")]
-  [StorableClass]
-  public sealed class SymbolicDataAnalysisComplexityAnalyzer : SymbolicDataAnalysisAnalyzer {
-    private const string ComplexityParameterName = "Complexity";
-    private const string WeightsParameterName = "Weights";
-    
-    public override bool EnabledByDefault {
-      get { return false; }
-    }
-
-    #region parameter properties
-    public IScopeTreeLookupParameter<DoubleValue> ComplexityParameter {
-      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[ComplexityParameterName]; }
-    }
-    public IValueParameter<ItemDictionary<StringValue, DoubleValue>> WeightsParameter {
-      get { return (IValueParameter<ItemDictionary<StringValue, DoubleValue>>)Parameters[WeightsParameterName]; }
-    }
-    #endregion
-
-    [StorableConstructor]
-    private SymbolicDataAnalysisComplexityAnalyzer(bool deserializing) : base(deserializing) { }
-    private SymbolicDataAnalysisComplexityAnalyzer(SymbolicDataAnalysisComplexityAnalyzer original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public SymbolicDataAnalysisComplexityAnalyzer()
-      : base() {
-      var defaultWeights = new Dictionary<string, double>()
-                             {
-                                { "StartSymbol", 0.0},
-                                { "ProgramRootSymbol", 0.0},
-                                { "Addition", 1.0 },
-                                { "AiryA", 10.0 },
-                                { "AiryB", 10.0 },
-                                { "And", 2.0 },
-                                { "Average", 2.0 },
-                                { "Bessel", 10.0 },
-                                { "Constant", 1.0 },
-                                { "Cosine", 5.0 },
-                                { "CosineIntegral", 10.0 },
-                                { "Dawson", 10.0 },
-                                { "Derivative", 5.0 },
-                                { "Division", 2.0 },
-                                { "Erf", 10.0 },
-                                { "Exponential", 5.0 },
-                                { "ExponentialIntegralEi", 10.0 },
-                                { "FresnelCosineIntegral", 10.0 },
-                                { "FresnelSineIntegral", 10.0 },
-                                { "Gamma", 10.0 },
-                                { "GreaterThan", 2.0 },
-                                { "HyperbolicCosineIntegral", 10.0 },
-                                { "HyperbolicSineIntegral", 10.0 },
-                                { "IfThenElse", 3.0 },
-                                { "Integral", 5.0},
-                                { "LaggedVariable", 2.0 },
-                                { "LessThan", 2.0 },
-                                { "Logarithm", 5.0 },
-                                { "Multiplication", 2.0 },
-                                { "Norm", 10.0 },
-                                { "Not", 2.0 },
-                                { "Or", 1.0 },
-                                { "Power", 5.0 },
-                                { "Psi", 10.0 },
-                                { "Root", 5.0 },
-                                { "Sine", 5.0 },
-                                { "SineIntegral", 10.0 },
-                                { "Square", 2.0 },
-                                { "SquareRoot", 2.0 },
-                                { "Subtraction", 1.0 },
-                                { "Tangent", 3.0 },
-                                { "TimeLag", 3.0 },
-                                { "Variable", 1.0 },
-                                { "Variable Condition", 5.0 },
-                             };
-
-      var defaultWeightsTable = new ItemDictionary<StringValue, DoubleValue>();
-      foreach (var p in defaultWeights) {
-        defaultWeightsTable.Add(new StringValue(p.Key), new DoubleValue(p.Value));
-      }
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(ComplexityParameterName, "The complexity of the tree."));
-      Parameters.Add(new ValueParameter<ItemDictionary<StringValue, DoubleValue>>(WeightsParameterName, "A table with complexity weights for each symbol.", defaultWeightsTable));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicDataAnalysisComplexityAnalyzer(this, cloner);
-    }
-
-    public override IOperation Apply() {
-      ItemArray<ISymbolicExpressionTree> expressions = SymbolicExpressionTreeParameter.ActualValue;
-      var weightsTable = WeightsParameter.Value;
-      var weights = new Dictionary<string, double>();
-      foreach (var p in weightsTable)
-        weights.Add(p.Key.Value, p.Value.Value);
-      var complexities = from t in expressions
-                         select CalculateComplexity(t, weights);
-      ComplexityParameter.ActualValue = new ItemArray<DoubleValue>(complexities.Select(x => new DoubleValue(x)).ToArray());
-      return base.Apply();
-    }
-
-    private double CalculateComplexity(ISymbolicExpressionTree t, Dictionary<string, double> weights) {
-      double c = 0.0;
-      foreach (var n in t.Root.IterateNodesPrefix()) {
-        if (!weights.ContainsKey(n.Symbol.Name)) throw new ArgumentException("Weight for symbol " + n.Symbol.Name + " is not defined.");
-        c += weights[n.Symbol.Name];
-      }
-      return c;
-    }
-  }
-}
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs	(revision 8206)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -26,9 +27,7 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -38,9 +37,13 @@
   [Item("SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer", "An operator that analyzes the Pareto-best symbolic data analysis solution for single objective symbolic data analysis problems.")]
   [StorableClass]
-  public abstract class SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<T> : SymbolicDataAnalysisSingleObjectiveAnalyzer
-    where T : class, ISymbolicDataAnalysisSolution {
+  public abstract class SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<S, T> : SymbolicDataAnalysisSingleObjectiveAnalyzer, ISymbolicDataAnalysisInterpreterOperator, ISymbolicDataAnalysisBoundedOperator
+    where T : class, ISymbolicDataAnalysisSolution
+    where S : class, IDataAnalysisProblemData {
+    private const string ProblemDataParameterName = "ProblemData";
     private const string TrainingBestSolutionsParameterName = "Best training solutions";
     private const string TrainingBestSolutionQualitiesParameterName = "Best training solution qualities";
     private const string ComplexityParameterName = "Complexity";
+    private const string SymbolicDataAnalysisTreeInterpreterParameterName = "SymbolicDataAnalysisTreeInterpreter";
+    private const string EstimationLimitsParameterName = "EstimationLimits";
 
     public override bool EnabledByDefault {
@@ -58,4 +61,13 @@
       get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[ComplexityParameterName]; }
     }
+    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> SymbolicDataAnalysisTreeInterpreterParameter {
+      get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicDataAnalysisTreeInterpreterParameterName]; }
+    }
+    public ILookupParameter<S> ProblemDataParameter {
+      get { return (ILookupParameter<S>)Parameters[ProblemDataParameterName]; }
+    }
+    public IValueLookupParameter<DoubleLimit> EstimationLimitsParameter {
+      get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
+    }
     #endregion
     #region properties
@@ -72,10 +84,13 @@
     [StorableConstructor]
     protected SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer(bool deserializing) : base(deserializing) { }
-    protected SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer(SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<T> original, Cloner cloner) : base(original, cloner) { }
+    protected SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer(SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<S, T> original, Cloner cloner) : base(original, cloner) { }
     public SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer()
       : base() {
+      Parameters.Add(new LookupParameter<S>(ProblemDataParameterName, "The problem data for the symbolic data analysis solution."));
       Parameters.Add(new LookupParameter<ItemList<T>>(TrainingBestSolutionsParameterName, "The training best (Pareto-optimal) symbolic data analysis solutions."));
       Parameters.Add(new LookupParameter<ItemList<DoubleArray>>(TrainingBestSolutionQualitiesParameterName, "The qualities of the training best (Pareto-optimal) solutions."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(ComplexityParameterName, "The complexity of each tree."));
+      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName, "The symbolic data analysis tree interpreter for the symbolic expression tree."));
+      Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The lower and upper limit for the estimated values produced by the symbolic classification model."));
     }
 
@@ -100,5 +115,5 @@
 
       List<double> complexities;
-      if (ComplexityParameter.ActualValue != null) {
+      if (ComplexityParameter.ActualValue != null && ComplexityParameter.ActualValue.Length == qualities.Count) {
         complexities = ComplexityParameter.ActualValue.Select(x => x.Value).ToList();
       } else {
Index: branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer.cs
===================================================================
--- branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer.cs	(revision 8085)
+++ branches/GP-MoveOperators/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer.cs	(revision 8206)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -26,9 +27,7 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -38,5 +37,5 @@
   [Item("SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer", "An operator that analyzes the Pareto-best symbolic data analysis solution for single objective symbolic data analysis problems.")]
   [StorableClass]
-  public abstract class SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer<S, T, U> : SymbolicDataAnalysisSingleObjectiveValidationAnalyzer<T, U>
+  public abstract class SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer<S, T, U> : SymbolicDataAnalysisSingleObjectiveValidationAnalyzer<T, U>, ISymbolicDataAnalysisBoundedOperator
     where S : class, ISymbolicDataAnalysisSolution
     where T : class, ISymbolicDataAnalysisSingleObjectiveEvaluator<U>
@@ -45,4 +44,5 @@
     private const string ValidationBestSolutionQualitiesParameterName = "Best validation solution qualities";
     private const string ComplexityParameterName = "Complexity";
+    private const string EstimationLimitsParameterName = "EstimationLimits";
 
     public override bool EnabledByDefault {
@@ -60,4 +60,8 @@
       get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[ComplexityParameterName]; }
     }
+    public IValueLookupParameter<DoubleLimit> EstimationLimitsParameter {
+      get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
+    }
+
     #endregion
     #region properties
@@ -80,4 +84,5 @@
       Parameters.Add(new LookupParameter<ItemList<DoubleArray>>(ValidationBestSolutionQualitiesParameterName, "The qualities of the validation best (Pareto-optimal) solutions."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(ComplexityParameterName, "The complexity of each tree."));
+      Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The lower and upper limit for the estimated values produced by the symbolic classification model."));
     }
 
@@ -137,5 +142,5 @@
 
       List<double> complexities;
-      if (ComplexityParameter.ActualValue != null) {
+      if (ComplexityParameter.ActualValue != null && ComplexityParameter.ActualValue.Length == trainingQuality.Length) {
         complexities = ComplexityParameter.ActualValue.Select(x => x.Value).ToList();
       } else {
