Index: /trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGA.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGA.cs	(revision 3079)
+++ /trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGA.cs	(revision 3080)
@@ -249,4 +249,5 @@
     }
     private void ParameterizeSGAMainLoop() {
+      SGAMainLoop.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
       SGAMainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
       SGAMainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
Index: /trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGAMainLoop.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGAMainLoop.cs	(revision 3079)
+++ /trunk/sources/HeuristicLab.Algorithms.SGA/3.3/SGAMainLoop.cs	(revision 3080)
@@ -36,5 +36,5 @@
   [Creatable("Test")]
   [StorableClass]
-  public class SGAMainLoop : AlgorithmOperator {
+  public sealed class SGAMainLoop : AlgorithmOperator {
     #region Parameter properties
     public ValueLookupParameter<IRandom> RandomParameter {
@@ -47,4 +47,7 @@
       get { return (SubScopesLookupParameter<DoubleValue>)Parameters["Quality"]; }
     }
+    public ValueLookupParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
     public ValueLookupParameter<IOperator> SelectorParameter {
       get { return (ValueLookupParameter<IOperator>)Parameters["Selector"]; }
@@ -80,10 +83,17 @@
     #endregion
 
+    [StorableConstructor]
+    private SGAMainLoop(bool deserializing) : base() { }
     public SGAMainLoop()
       : base() {
+      Initialize();
+    }
+
+    private void Initialize() {
       #region Create parameters
       Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
       Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
       Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("BestKnownQuality", "The best known quality value found so far."));
       Parameters.Add(new ValueLookupParameter<IOperator>("Selector", "The operator used to select solutions for reproduction."));
       Parameters.Add(new ValueLookupParameter<IOperator>("Crossover", "The operator used to cross solutions."));
@@ -97,6 +107,9 @@
       #endregion
 
-      #region Create operator graph
+      #region Create operators
       VariableCreator variableCreator = new VariableCreator();
+      BestQualityMemorizer bestQualityMemorizer1 = new BestQualityMemorizer();
+      BestAverageWorstQualityCalculator bestAverageWorstQualityCalculator1 = new BestAverageWorstQualityCalculator();
+      DataTableValuesCollector dataTableValuesCollector1 = new DataTableValuesCollector();
       ResultsCollector resultsCollector = new ResultsCollector();
       SubScopesSorter subScopesSorter1 = new SubScopesSorter();
@@ -117,83 +130,67 @@
       IntCounter intCounter = new IntCounter();
       Comparator comparator = new Comparator();
-      BestAverageWorstQualityCalculator bestAverageWorstQualityCalculator = new BestAverageWorstQualityCalculator();
-      DataTableValuesCollector dataTableValuesCollector = new DataTableValuesCollector();
+      BestQualityMemorizer bestQualityMemorizer2 = new BestQualityMemorizer();
+      BestAverageWorstQualityCalculator bestAverageWorstQualityCalculator2 = new BestAverageWorstQualityCalculator();
+      DataTableValuesCollector dataTableValuesCollector2 = new DataTableValuesCollector();
       ConditionalBranch conditionalBranch = new ConditionalBranch();
 
-      OperatorGraph.InitialOperator = variableCreator;
-
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Best Quality", new DoubleValue(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Average Quality", new DoubleValue(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("Worst Quality", new DoubleValue(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<DataTable>("Qualities", new DataTable("Qualities")));
-      variableCreator.Successor = resultsCollector;
+
+      bestQualityMemorizer1.BestQualityParameter.ActualName = "Best Quality";
+      bestQualityMemorizer1.MaximizationParameter.ActualName = "Maximization";
+      bestQualityMemorizer1.QualityParameter.ActualName = "Quality";
+
+      bestAverageWorstQualityCalculator1.AverageQualityParameter.ActualName = "Current Average Quality";
+      bestAverageWorstQualityCalculator1.BestQualityParameter.ActualName = "Current Best Quality";
+      bestAverageWorstQualityCalculator1.MaximizationParameter.ActualName = "Maximization";
+      bestAverageWorstQualityCalculator1.QualityParameter.ActualName = "Quality";
+      bestAverageWorstQualityCalculator1.WorstQualityParameter.ActualName = "Current Worst Quality";
+
+      dataTableValuesCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best Quality"));
+      dataTableValuesCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Average Quality"));
+      dataTableValuesCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Worst Quality"));
+      dataTableValuesCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality"));
+      dataTableValuesCollector1.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Known Quality", null, "BestKnownQuality"));
+      dataTableValuesCollector1.DataTableParameter.ActualName = "Qualities";
 
       resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Average Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Worst Quality"));
       resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality"));
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Average Quality"));
-      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Worst Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Known Quality", null, "BestKnownQuality"));
       resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("Qualities"));
       resultsCollector.ResultsParameter.ActualName = "Results";
-      resultsCollector.Successor = subScopesSorter1;
 
       subScopesSorter1.DescendingParameter.ActualName = "Maximization";
       subScopesSorter1.ValueParameter.ActualName = "Quality";
-      subScopesSorter1.Successor = selector;
 
       selector.Name = "Selector";
       selector.OperatorParameter.ActualName = "Selector";
-      selector.Successor = sequentialSubScopesProcessor1;
-
-      sequentialSubScopesProcessor1.Operators.Add(new EmptyOperator());
-      sequentialSubScopesProcessor1.Operators.Add(childrenCreator);
-      sequentialSubScopesProcessor1.Successor = sequentialSubScopesProcessor2;
 
       childrenCreator.ParentsPerChild = new IntValue(2);
-      childrenCreator.Successor = uniformSequentialSubScopesProcessor;
-
-      uniformSequentialSubScopesProcessor.Operator = crossover;
-      uniformSequentialSubScopesProcessor.Successor = subScopesSorter2;
 
       crossover.Name = "Crossover";
       crossover.OperatorParameter.ActualName = "Crossover";
-      crossover.Successor = stochasticBranch;
-
-      stochasticBranch.FirstBranch = mutator;
+
       stochasticBranch.ProbabilityParameter.ActualName = "MutationProbability";
       stochasticBranch.RandomParameter.ActualName = "Random";
-      stochasticBranch.SecondBranch = null;
-      stochasticBranch.Successor = evaluator;
 
       mutator.Name = "Mutator";
       mutator.OperatorParameter.ActualName = "Mutator";
-      mutator.Successor = null;
 
       evaluator.Name = "Evaluator";
       evaluator.OperatorParameter.ActualName = "Evaluator";
-      evaluator.Successor = subScopesRemover;
 
       subScopesRemover.RemoveAllSubScopes = true;
-      subScopesRemover.Successor = null;
 
       subScopesSorter2.DescendingParameter.ActualName = "Maximization";
       subScopesSorter2.ValueParameter.ActualName = "Quality";
-      subScopesSorter2.Successor = null;
-
-      sequentialSubScopesProcessor2.Operators.Add(leftSelector);
-      sequentialSubScopesProcessor2.Operators.Add(new EmptyOperator());
-      sequentialSubScopesProcessor2.Successor = mergingReducer;
 
       leftSelector.CopySelected = new BoolValue(false);
       leftSelector.NumberOfSelectedSubScopesParameter.ActualName = "Elites";
-      leftSelector.Successor = rightReducer;
-
-      rightReducer.Successor = null;
-
-      mergingReducer.Successor = intCounter;
 
       intCounter.Increment = new IntValue(1);
       intCounter.ValueParameter.ActualName = "Generations";
-      intCounter.Successor = comparator;
 
       comparator.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
@@ -201,20 +198,59 @@
       comparator.ResultParameter.ActualName = "Terminate";
       comparator.RightSideParameter.ActualName = "MaximumGenerations";
-      comparator.Successor = bestAverageWorstQualityCalculator;
-
-      bestAverageWorstQualityCalculator.AverageQualityParameter.ActualName = "Average Quality";
-      bestAverageWorstQualityCalculator.BestQualityParameter.ActualName = "Best Quality";
-      bestAverageWorstQualityCalculator.MaximizationParameter.ActualName = "Maximization";
-      bestAverageWorstQualityCalculator.QualityParameter.ActualName = "Quality";
-      bestAverageWorstQualityCalculator.WorstQualityParameter.ActualName = "Worst Quality";
-      bestAverageWorstQualityCalculator.Successor = dataTableValuesCollector;
-
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality"));
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Average Quality"));
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Worst Quality"));
-      dataTableValuesCollector.DataTableParameter.ActualName = "Qualities";
-      dataTableValuesCollector.Successor = conditionalBranch;
+
+      bestQualityMemorizer2.BestQualityParameter.ActualName = "Best Quality";
+      bestQualityMemorizer2.MaximizationParameter.ActualName = "Maximization";
+      bestQualityMemorizer2.QualityParameter.ActualName = "Quality";
+
+      bestAverageWorstQualityCalculator2.AverageQualityParameter.ActualName = "Current Average Quality";
+      bestAverageWorstQualityCalculator2.BestQualityParameter.ActualName = "Current Best Quality";
+      bestAverageWorstQualityCalculator2.MaximizationParameter.ActualName = "Maximization";
+      bestAverageWorstQualityCalculator2.QualityParameter.ActualName = "Quality";
+      bestAverageWorstQualityCalculator2.WorstQualityParameter.ActualName = "Current Worst Quality";
+
+      dataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best Quality"));
+      dataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Average Quality"));
+      dataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Worst Quality"));
+      dataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Quality"));
+      dataTableValuesCollector2.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Known Quality", null, "BestKnownQuality"));
+      dataTableValuesCollector2.DataTableParameter.ActualName = "Qualities";
 
       conditionalBranch.ConditionParameter.ActualName = "Terminate";
+      #endregion
+
+      #region Create operator graph
+      OperatorGraph.InitialOperator = variableCreator;
+      variableCreator.Successor = bestQualityMemorizer1;
+      bestQualityMemorizer1.Successor = bestAverageWorstQualityCalculator1;
+      bestAverageWorstQualityCalculator1.Successor = dataTableValuesCollector1;
+      dataTableValuesCollector1.Successor = resultsCollector;
+      resultsCollector.Successor = subScopesSorter1;
+      subScopesSorter1.Successor = selector;
+      selector.Successor = sequentialSubScopesProcessor1;
+      sequentialSubScopesProcessor1.Operators.Add(new EmptyOperator());
+      sequentialSubScopesProcessor1.Operators.Add(childrenCreator);
+      sequentialSubScopesProcessor1.Successor = sequentialSubScopesProcessor2;
+      childrenCreator.Successor = uniformSequentialSubScopesProcessor;
+      uniformSequentialSubScopesProcessor.Operator = crossover;
+      uniformSequentialSubScopesProcessor.Successor = subScopesSorter2;
+      crossover.Successor = stochasticBranch;
+      stochasticBranch.FirstBranch = mutator;
+      stochasticBranch.SecondBranch = null;
+      stochasticBranch.Successor = evaluator;
+      mutator.Successor = null;
+      evaluator.Successor = subScopesRemover;
+      subScopesRemover.Successor = null;
+      subScopesSorter2.Successor = null;
+      sequentialSubScopesProcessor2.Operators.Add(leftSelector);
+      sequentialSubScopesProcessor2.Operators.Add(new EmptyOperator());
+      sequentialSubScopesProcessor2.Successor = mergingReducer;
+      leftSelector.Successor = rightReducer;
+      rightReducer.Successor = null;
+      mergingReducer.Successor = intCounter;
+      intCounter.Successor = comparator;
+      comparator.Successor = bestQualityMemorizer2;
+      bestQualityMemorizer2.Successor = bestAverageWorstQualityCalculator2;
+      bestAverageWorstQualityCalculator2.Successor = dataTableValuesCollector2;
+      dataTableValuesCollector2.Successor = conditionalBranch;
       conditionalBranch.FalseBranch = subScopesSorter1;
       conditionalBranch.TrueBranch = null;
Index: /trunk/sources/HeuristicLab.Analysis.Views/3.3/DataTableView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Analysis.Views/3.3/DataTableView.cs	(revision 3079)
+++ /trunk/sources/HeuristicLab.Analysis.Views/3.3/DataTableView.cs	(revision 3080)
@@ -111,6 +111,13 @@
       series.ChartType = SeriesChartType.FastLine;
       series.ToolTip = "#VAL";
-      for (int i = 0; i < row.Values.Count; i++)
-        series.Points.Add(row.Values[i]);
+      for (int i = 0; i < row.Values.Count; i++) {
+        if (double.IsNaN(row.Values[i])) {
+          DataPoint point = new DataPoint();
+          point.IsEmpty = true;
+          series.Points.Add(point);
+        } else {
+          series.Points.Add(row.Values[i]);
+        }
+      }
       chart.Series.Add(series);
     }
@@ -208,6 +215,13 @@
       else {
         DataRow row = valuesRowsTable[(IObservableList<double>)sender];
-        foreach (IndexedItem<double> item in e.Items)
-          chart.Series[row.Name].Points.InsertY(item.Index, item.Value);
+        foreach (IndexedItem<double> item in e.Items) {
+          if (double.IsNaN(item.Value)) {
+            DataPoint point = new DataPoint();
+            point.IsEmpty = true;
+            chart.Series[row.Name].Points.Insert(item.Index, point);
+          } else {
+            chart.Series[row.Name].Points.InsertY(item.Index, item.Value);
+          }
+        }
       }
     }
@@ -229,6 +243,10 @@
       else {
         DataRow row = valuesRowsTable[(IObservableList<double>)sender];
-        foreach (IndexedItem<double> item in e.Items)
-          chart.Series[row.Name].Points[item.Index].YValues = new double[] { item.Value };
+        foreach (IndexedItem<double> item in e.Items) {
+          if (double.IsNaN(item.Value))
+            chart.Series[row.Name].Points[item.Index].IsEmpty = true;
+          else
+            chart.Series[row.Name].Points[item.Index].YValues = new double[] { item.Value };
+        }
       }
     }
@@ -238,6 +256,10 @@
       else {
         DataRow row = valuesRowsTable[(IObservableList<double>)sender];
-        foreach (IndexedItem<double> item in e.Items)
-          chart.Series[row.Name].Points[item.Index].YValues = new double[] { item.Value };
+        foreach (IndexedItem<double> item in e.Items) {
+          if (double.IsNaN(item.Value))
+            chart.Series[row.Name].Points[item.Index].IsEmpty = true;
+          else
+            chart.Series[row.Name].Points[item.Index].YValues = new double[] { item.Value };
+        }
       }
     }
@@ -248,6 +270,10 @@
         DataRow row = valuesRowsTable[(IObservableList<double>)sender];
         chart.Series[row.Name].Points.Clear();
-        foreach (IndexedItem<double> item in e.Items)
-          chart.Series[row.Name].Points[item.Index].YValues = new double[] { item.Value };
+        foreach (IndexedItem<double> item in e.Items) {
+          if (double.IsNaN(item.Value))
+            chart.Series[row.Name].Points[item.Index].IsEmpty = true;
+          else
+            chart.Series[row.Name].Points[item.Index].YValues = new double[] { item.Value };
+        }
       }
     }
Index: /trunk/sources/HeuristicLab.Analysis/3.3/BestQualityMemorizer.cs
===================================================================
--- /trunk/sources/HeuristicLab.Analysis/3.3/BestQualityMemorizer.cs	(revision 3079)
+++ /trunk/sources/HeuristicLab.Analysis/3.3/BestQualityMemorizer.cs	(revision 3080)
@@ -55,5 +55,5 @@
       DoubleValue best = BestQualityParameter.ActualValue;
       double max = (best != null) ? (best.Value) : ((maximization) ? (double.MinValue) : (double.MaxValue));
-      
+
       foreach (DoubleValue quality in qualities)
         if (IsBetter(maximization, quality.Value, max)) max = quality.Value;
Index: /trunk/sources/HeuristicLab.Analysis/3.3/DataTableValuesCollector.cs
===================================================================
--- /trunk/sources/HeuristicLab.Analysis/3.3/DataTableValuesCollector.cs	(revision 3079)
+++ /trunk/sources/HeuristicLab.Analysis/3.3/DataTableValuesCollector.cs	(revision 3080)
@@ -53,5 +53,5 @@
       foreach (IParameter param in CollectedValues) {
         DoubleValue data = param.ActualValue as DoubleValue;
-        if (data == null) throw new InvalidOperationException("Only double data values can be collected by a DataTableValuesCollector.");
+        if (data == null) data = new DoubleValue(double.NaN);
 
         DataRow row;
Index: /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveProblem.cs
===================================================================
--- /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveProblem.cs	(revision 3079)
+++ /trunk/sources/HeuristicLab.Optimization/3.3/Interfaces/ISingleObjectiveProblem.cs	(revision 3080)
@@ -28,4 +28,5 @@
   public interface ISingleObjectiveProblem : IProblem {
     IParameter MaximizationParameter { get; }
+    IParameter BestKnownQualityParameter { get; }
     new ISingleObjectiveEvaluator Evaluator { get; }
   }
Index: /trunk/sources/HeuristicLab.Parameters/3.3/LookupParameter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Parameters/3.3/LookupParameter.cs	(revision 3079)
+++ /trunk/sources/HeuristicLab.Parameters/3.3/LookupParameter.cs	(revision 3080)
@@ -57,13 +57,17 @@
     public LookupParameter()
       : base("Anonymous", typeof(T)) {
-      actualName = Name;
+      this.actualName = Name;
     }
     public LookupParameter(string name)
       : base(name, typeof(T)) {
-      actualName = Name;
+      this.actualName = Name;
     }
     public LookupParameter(string name, string description)
       : base(name, description, typeof(T)) {
-      actualName = Name;
+      this.actualName = Name;
+    }
+    public LookupParameter(string name, string description, string actualName)
+      : base(name, description, typeof(T)) {
+      this.actualName = actualName == null ? string.Empty : actualName;
     }
 
Index: /trunk/sources/HeuristicLab.Parameters/3.3/ValueLookupParameter.cs
===================================================================
--- /trunk/sources/HeuristicLab.Parameters/3.3/ValueLookupParameter.cs	(revision 3079)
+++ /trunk/sources/HeuristicLab.Parameters/3.3/ValueLookupParameter.cs	(revision 3080)
@@ -75,4 +75,7 @@
       Value = value;
     }
+    public ValueLookupParameter(string name, string description, string actualName)
+      : base(name, description, actualName) {
+    }
 
     public override IDeepCloneable Clone(Cloner cloner) {
Index: /trunk/sources/HeuristicLab.Problems.Knapsack/3.3/Knapsack.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.Knapsack/3.3/Knapsack.cs	(revision 3079)
+++ /trunk/sources/HeuristicLab.Problems.Knapsack/3.3/Knapsack.cs	(revision 3080)
@@ -76,4 +76,7 @@
       get { return (OptionalValueParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
     }
+    IParameter ISingleObjectiveProblem.BestKnownQualityParameter {
+      get { return BestKnownQualityParameter; }
+    }
     #endregion
 
Index: /trunk/sources/HeuristicLab.Problems.OneMax/3.3/Onemax.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.OneMax/3.3/Onemax.cs	(revision 3079)
+++ /trunk/sources/HeuristicLab.Problems.OneMax/3.3/Onemax.cs	(revision 3080)
@@ -64,4 +64,10 @@
       get { return EvaluatorParameter; }
     }
+    public ValueParameter<DoubleValue> BestKnownQualityParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
+    }
+    IParameter ISingleObjectiveProblem.BestKnownQualityParameter {
+      get { return BestKnownQualityParameter; }
+    }
     #endregion
 
@@ -84,4 +90,7 @@
       get { return EvaluatorParameter.Value; }
     }
+    public DoubleValue BestKnownQuality {
+      get { return BestKnownQualityParameter.Value; }
+    }
     private List<IBinaryVectorOperator> operators;
     public IEnumerable<IOperator> Operators {
@@ -99,4 +108,5 @@
       Parameters.Add(new ValueParameter<IBinaryVectorCreator>("SolutionCreator", "The operator which should be used to create new OneMax solutions.", creator));
       Parameters.Add(new ValueParameter<IOneMaxEvaluator>("Evaluator", "The operator which should be used to evaluate OneMax solutions.", evaluator));
+      Parameters.Add(new ValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this OneMax instance.", new DoubleValue(5)));
 
       creator.BinaryVectorParameter.ActualName = "OneMaxSolution";
Index: /trunk/sources/HeuristicLab.Problems.TSP/3.3/TSP.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.TSP/3.3/TSP.cs	(revision 3079)
+++ /trunk/sources/HeuristicLab.Problems.TSP/3.3/TSP.cs	(revision 3080)
@@ -73,4 +73,7 @@
       get { return (OptionalValueParameter<DoubleValue>)Parameters["BestKnownQuality"]; }
     }
+    IParameter ISingleObjectiveProblem.BestKnownQualityParameter {
+      get { return BestKnownQualityParameter; }
+    }
     #endregion
 
