Index: trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/BestOneMaxSolutionAnalyzer.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/BestOneMaxSolutionAnalyzer.cs	(revision 3642)
+++ trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/BestOneMaxSolutionAnalyzer.cs	(revision 3642)
@@ -0,0 +1,90 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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 System.Text;
+using HeuristicLab.Optimization;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.OneMax.Analyzers {
+  /// <summary>
+  /// An operator for analyzing the best solution for a OneMax problem.
+  /// </summary>
+  [Item("BestOneMaxSolutionAnalyzer", "An operator for analyzing the best solution for a OneMax problem.")]
+  [StorableClass]
+  class BestOneMaxSolutionAnalyzer : SingleSuccessorOperator, IBestOneMaxSolutionAnalyzer, ISolutionAnalyzer {
+
+    public ILookupParameter<BinaryVector> BinaryVectorParameter {
+      get { return (ILookupParameter<BinaryVector>)Parameters["BinaryVector"]; }
+    }
+    ILookupParameter IBestOneMaxSolutionAnalyzer.BinaryVectorParameter {
+      get { return BinaryVectorParameter; }
+    }
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    ILookupParameter IBestOneMaxSolutionAnalyzer.QualityParameter {
+      get { return QualityParameter; }
+    }
+    public ILookupParameter<OneMaxSolution> BestSolutionParameter {
+      get { return (ILookupParameter<OneMaxSolution>)Parameters["BestSolution"]; }
+    }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    public BestOneMaxSolutionAnalyzer()
+      : base() {
+      Parameters.Add(new LookupParameter<BinaryVector>("BinaryVector", "The Onemax solutions from which the best solution should be visualized."));
+
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The qualities of the Onemax solutions which should be visualized."));
+      Parameters.Add(new LookupParameter<OneMaxSolution>("BestSolution", "The best Onemax solution."));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the Onemax solution should be stored."));
+    }
+
+    public override IOperation Apply() {
+      BinaryVector binaryVector = BinaryVectorParameter.ActualValue;
+      DoubleValue quality = QualityParameter.ActualValue;
+      ResultCollection results = ResultsParameter.ActualValue;
+
+      OneMaxSolution solution = BestSolutionParameter.ActualValue;
+      if (solution == null) {
+        solution = new OneMaxSolution(binaryVector, QualityParameter.ActualValue);
+        BestSolutionParameter.ActualValue = solution;
+        results.Add(new Result("Best OneMax Solution", solution));
+      }  else {
+        solution.BinaryVector = binaryVector;
+        solution.Quality = QualityParameter.ActualValue;
+
+        results["Best OneMax Solution"].Value = solution;
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/MultiPopulationBestOneMaxSolutionAnalyzer.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/MultiPopulationBestOneMaxSolutionAnalyzer.cs	(revision 3642)
+++ trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/MultiPopulationBestOneMaxSolutionAnalyzer.cs	(revision 3642)
@@ -0,0 +1,105 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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 System.Text;
+using HeuristicLab.Optimization;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.OneMax.Analyzers {
+  /// <summary>
+  /// An operator for analyzing the best solution for a OneMax problem.
+  /// </summary>
+  [Item("MultiPopulationBestOneMaxSolutionAnalyzer", "An operator for analyzing the best solution for a OneMax problem.")]
+  [StorableClass]
+  class MultiPopulationBestOneMaxSolutionAnalyzer : SingleSuccessorOperator, IBestOneMaxSolutionAnalyzer, IMultiPopulationAnalyzer {
+
+    public ILookupParameter<ItemArray<ItemArray<BinaryVector>>> BinaryVectorParameter {
+      get { return (ILookupParameter<ItemArray<ItemArray<BinaryVector>>>)Parameters["BinaryVector"]; }
+    }
+    ILookupParameter IBestOneMaxSolutionAnalyzer.BinaryVectorParameter {
+      get { return BinaryVectorParameter; }
+    }
+    public ILookupParameter<ItemArray<ItemArray<DoubleValue>>> QualityParameter {
+      get { return (ILookupParameter<ItemArray<ItemArray<DoubleValue>>>)Parameters["Quality"]; }
+    }
+    ILookupParameter IBestOneMaxSolutionAnalyzer.QualityParameter {
+      get { return QualityParameter; }
+    }
+    public ILookupParameter<OneMaxSolution> BestSolutionParameter {
+      get { return (ILookupParameter<OneMaxSolution>)Parameters["BestSolution"]; }
+    }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    public MultiPopulationBestOneMaxSolutionAnalyzer()
+      : base() {
+      Parameters.Add(new SubScopesLookupParameter<ItemArray<BinaryVector>>("BinaryVector", "The Onemax solutions from which the best solution should be visualized."));
+
+      Parameters.Add(new SubScopesLookupParameter<ItemArray<DoubleValue>>("Quality", "The qualities of the Onemax solutions which should be visualized."));
+      Parameters.Add(new LookupParameter<OneMaxSolution>("BestSolution", "The best Onemax solution."));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the Onemax solution should be stored."));
+    }
+
+    public override IOperation Apply() {
+      ItemArray<ItemArray<BinaryVector>> binaryVectors = BinaryVectorParameter.ActualValue;
+      ItemArray<ItemArray<DoubleValue>> qualities = QualityParameter.ActualValue;
+      ResultCollection results = ResultsParameter.ActualValue;
+
+      DoubleValue bestQuality = new DoubleValue(double.MaxValue);
+      BinaryVector bestBinaryVector = null;
+
+      for (int i = 0; i < qualities.Length; i++) {
+        for (int j = 0; j < qualities[i].Length; j++) {
+          if (qualities[i][j].Value < bestQuality.Value) {
+            bestQuality = qualities[i][j];
+            bestBinaryVector = binaryVectors[i][j];
+          }
+        }
+      }
+
+      OneMaxSolution solution = BestSolutionParameter.ActualValue;
+      if (solution == null) {
+        solution = new OneMaxSolution(bestBinaryVector, bestQuality);
+        BestSolutionParameter.ActualValue = solution;
+
+        results.Add(new Result("Best OneMax Solution", solution));
+      } else {
+        if (solution.Quality.Value > bestQuality.Value) {
+          solution.BinaryVector = bestBinaryVector;
+          solution.Quality = bestQuality;
+
+          results["Best OneMax Solution"].Value = solution;
+        }
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/PopulationBestOneMaxSolutionAnalyzer.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/PopulationBestOneMaxSolutionAnalyzer.cs	(revision 3642)
+++ trunk/sources/HeuristicLab.Problems.OneMax/3.3/Analyzers/PopulationBestOneMaxSolutionAnalyzer.cs	(revision 3642)
@@ -0,0 +1,92 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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 System.Text;
+using HeuristicLab.Optimization;
+using HeuristicLab.Data;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.OneMax.Analyzers {
+  /// <summary>
+  /// An operator for analyzing the best solution for a OneMax problem.
+  /// </summary>
+  [Item("PopulationBestOneMaxSolutionAnalyzer", "An operator for analyzing the best solution for a OneMax problem.")]
+  [StorableClass]
+  class PopulationBestOneMaxSolutionAnalyzer : SingleSuccessorOperator, IBestOneMaxSolutionAnalyzer, IPopulationAnalyzer {
+
+    public ILookupParameter<ItemArray<BinaryVector>> BinaryVectorParameter {
+      get { return (ILookupParameter<ItemArray<BinaryVector>>)Parameters["BinaryVector"]; }
+    }
+    ILookupParameter IBestOneMaxSolutionAnalyzer.BinaryVectorParameter {
+      get { return BinaryVectorParameter; }
+    }
+    public ILookupParameter<ItemArray<DoubleValue>> QualityParameter {
+      get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Quality"]; }
+    }
+    ILookupParameter IBestOneMaxSolutionAnalyzer.QualityParameter {
+      get { return QualityParameter; }
+    }
+    public ILookupParameter<OneMaxSolution> BestSolutionParameter {
+      get { return (ILookupParameter<OneMaxSolution>)Parameters["BestSolution"]; }
+    }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    public PopulationBestOneMaxSolutionAnalyzer()
+      : base() {
+      Parameters.Add(new SubScopesLookupParameter<BinaryVector>("BinaryVector", "The Onemax solutions from which the best solution should be visualized."));
+
+      Parameters.Add(new SubScopesLookupParameter<DoubleValue>("Quality", "The qualities of the Onemax solutions which should be visualized."));
+      Parameters.Add(new LookupParameter<OneMaxSolution>("BestSolution", "The best Onemax solution."));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The result collection where the Onemax solution should be stored."));
+    }
+
+    public override IOperation Apply() {
+      ItemArray<BinaryVector> binaryVectors = BinaryVectorParameter.ActualValue;
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
+      ResultCollection results = ResultsParameter.ActualValue;
+
+      int i = qualities.Select((x, index) => new { index, x.Value }).OrderBy(x => x.Value).First().index;
+      OneMaxSolution solution = BestSolutionParameter.ActualValue;
+      if (solution == null) {
+        solution = new OneMaxSolution(binaryVectors[i], QualityParameter.ActualValue[i]);
+        BestSolutionParameter.ActualValue = solution;
+
+        results.Add(new Result("Best OneMax Solution", solution));
+      } else {
+        solution.BinaryVector = binaryVectors[i];
+        solution.Quality = QualityParameter.ActualValue[i];
+
+        results["Best OneMax Solution"].Value = solution;
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.OneMax/3.3/HeuristicLab.Problems.OneMax-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Problems.OneMax/3.3/HeuristicLab.Problems.OneMax-3.3.csproj	(revision 3616)
+++ trunk/sources/HeuristicLab.Problems.OneMax/3.3/HeuristicLab.Problems.OneMax-3.3.csproj	(revision 3642)
@@ -86,6 +86,11 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Analyzers\BestOneMaxSolutionAnalyzer.cs" />
+    <Compile Include="Analyzers\MultiPopulationBestOneMaxSolutionAnalyzer.cs" />
+    <Compile Include="Analyzers\PopulationBestOneMaxSolutionAnalyzer.cs" />
+    <Compile Include="Interfaces\IBestOneMaxSolutionAnalyzer.cs" />
     <Compile Include="Interfaces\IOneMaxSolutionsVisualizer.cs" />
     <Compile Include="Interfaces\IOneMaxMoveEvaluator.cs" />
+    <Compile Include="OneMaxSolution.cs" />
     <Compile Include="MoveEvaluators\OneMaxMoveEvaluator.cs" />
     <Compile Include="MoveEvaluators\OneMaxOneBitflipMoveEvaluator.cs" />
Index: trunk/sources/HeuristicLab.Problems.OneMax/3.3/Interfaces/IBestOneMaxSolutionAnalyzer.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.OneMax/3.3/Interfaces/IBestOneMaxSolutionAnalyzer.cs	(revision 3642)
+++ trunk/sources/HeuristicLab.Problems.OneMax/3.3/Interfaces/IBestOneMaxSolutionAnalyzer.cs	(revision 3642)
@@ -0,0 +1,36 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+
+namespace HeuristicLab.Problems.OneMax {
+  /// <summary>
+  /// An interface which represents operators for analyzing the best solution of OneMax Problems given in bit vector representation.
+  /// </summary>
+  public interface IBestOneMaxSolutionAnalyzer : IAnalyzer {
+    ILookupParameter BinaryVectorParameter { get; }
+    ILookupParameter QualityParameter { get; }
+    ILookupParameter<OneMaxSolution> BestSolutionParameter { get; }
+    IValueLookupParameter<ResultCollection> ResultsParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.OneMax/3.3/OneMaxSolution.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.OneMax/3.3/OneMaxSolution.cs	(revision 3642)
+++ trunk/sources/HeuristicLab.Problems.OneMax/3.3/OneMaxSolution.cs	(revision 3642)
@@ -0,0 +1,139 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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 System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Drawing;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.OneMax {
+  /// <summary>
+  /// Represents a OneMax solution.
+  /// </summary>
+  [Item("OneMaxSolution", "Represents a OneMax solution.")]
+  [StorableClass]
+  public class OneMaxSolution : Item {
+    public override Image ItemImage {
+      get { return HeuristicLab.Common.Resources.VS2008ImageLibrary.Image; }
+    }
+
+    [Storable]
+    private BinaryVector binaryVector;
+    public BinaryVector BinaryVector {
+      get { return binaryVector; }
+      set {
+        if (binaryVector != value) {
+          if (binaryVector != null) DeregisterBinaryVectorEvents();
+          binaryVector = value;
+          if (binaryVector != null) RegisterBinaryVectorEvents();
+          OnBinaryVectorChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private DoubleValue quality;
+    public DoubleValue Quality {
+      get { return quality; }
+      set {
+        if (quality != value) {
+          if (quality != null) DeregisterQualityEvents();
+          quality = value;
+          if (quality != null) RegisterQualityEvents();
+          OnQualityChanged();
+        }
+      }
+    }
+
+    public OneMaxSolution() : base() { }
+    public OneMaxSolution(BinaryVector binaryVector, DoubleValue quality)
+      : base() {
+      this.binaryVector = binaryVector;
+      this.quality = quality;
+      Initialize();
+    }
+    [StorableConstructor]
+    private OneMaxSolution(bool deserializing) : base(deserializing) { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      if (binaryVector != null) RegisterBinaryVectorEvents();
+      if (quality != null) RegisterQualityEvents();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      OneMaxSolution clone = new OneMaxSolution();
+      cloner.RegisterClonedObject(this, clone);
+      clone.binaryVector = (BinaryVector)cloner.Clone(binaryVector);
+      clone.quality = (DoubleValue)cloner.Clone(quality);
+      clone.Initialize();
+      return clone;
+    }
+
+    #region Events
+    public event EventHandler BinaryVectorChanged;
+    private void OnBinaryVectorChanged() {
+      var changed = BinaryVectorChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+
+    public event EventHandler QualityChanged;
+    private void OnQualityChanged() {
+      var changed = QualityChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+
+    private void RegisterBinaryVectorEvents() {
+      BinaryVector.ItemChanged += new EventHandler<EventArgs<int>>(BinaryVector_ItemChanged);
+      BinaryVector.Reset += new EventHandler(BinaryVector_Reset);
+    }
+
+    private void DeregisterBinaryVectorEvents() {
+      BinaryVector.ItemChanged -= new EventHandler<EventArgs<int>>(BinaryVector_ItemChanged);
+      BinaryVector.Reset -= new EventHandler(BinaryVector_Reset);
+    }
+    private void RegisterQualityEvents() {
+      Quality.ValueChanged += new EventHandler(Quality_ValueChanged);
+    }
+    private void DeregisterQualityEvents() {
+      Quality.ValueChanged -= new EventHandler(Quality_ValueChanged);
+    }
+
+    private void BinaryVector_ItemChanged(object sender, EventArgs<int> e) {
+      OnBinaryVectorChanged();
+    }
+    private void BinaryVector_Reset(object sender, EventArgs e) {
+      OnBinaryVectorChanged();
+    }
+    private void Quality_ValueChanged(object sender, EventArgs e) {
+      OnQualityChanged();
+    }
+    #endregion
+  }
+}
Index: trunk/sources/HeuristicLab.Problems.OneMax/3.3/OnemaxProblem.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.OneMax/3.3/OnemaxProblem.cs	(revision 3616)
+++ trunk/sources/HeuristicLab.Problems.OneMax/3.3/OnemaxProblem.cs	(revision 3642)
@@ -32,4 +32,5 @@
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Problems.OneMax.Analyzers;
 
 namespace HeuristicLab.Problems.OneMax {
@@ -97,7 +98,10 @@
       get { return BestKnownQualityParameter.Value; }
     }
-    private List<IBinaryVectorOperator> operators;
+    private List<IOperator> operators;
     public IEnumerable<IOperator> Operators {
       get { return operators.Cast<IOperator>(); }
+    }
+    private IEnumerable<IBestOneMaxSolutionAnalyzer> BestOneMaxSolutionAnalyzers {
+      get { return operators.OfType<IBestOneMaxSolutionAnalyzer>(); }
     }
     #endregion
@@ -150,16 +154,19 @@
 
     private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
-      SolutionCreator.BinaryVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_PermutationParameter_ActualNameChanged);
+      SolutionCreator.BinaryVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_BinaryVectorParameter_ActualNameChanged);
       ParameterizeSolutionCreator();
       ParameterizeEvaluator();
+      ParameterizeAnalyzers();
       ParameterizeOperators();
       OnSolutionCreatorChanged();
     }
-    private void SolutionCreator_PermutationParameter_ActualNameChanged(object sender, EventArgs e) {
-      ParameterizeEvaluator();
+    private void SolutionCreator_BinaryVectorParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeEvaluator();
+      ParameterizeAnalyzers();
       ParameterizeOperators();
     }
     private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
       ParameterizeEvaluator();
+      ParameterizeAnalyzers();
       OnEvaluatorChanged();
     }
@@ -188,5 +195,5 @@
       InitializeOperators();
       SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
-      SolutionCreator.BinaryVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_PermutationParameter_ActualNameChanged);
+      SolutionCreator.BinaryVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_BinaryVectorParameter_ActualNameChanged);
       EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
       LengthParameter.ValueChanged += new EventHandler(LengthParameter_ValueChanged);
@@ -202,6 +209,16 @@
         ((OneMaxEvaluator)Evaluator).BinaryVectorParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
     }
+    private void ParameterizeAnalyzers() {
+      foreach (IBestOneMaxSolutionAnalyzer analyzer in BestOneMaxSolutionAnalyzers) {
+        analyzer.BinaryVectorParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
+        analyzer.ResultsParameter.ActualName = "Results";
+      }
+    }
     private void InitializeOperators() {
-      operators = new List<IBinaryVectorOperator>();
+      operators = new List<IOperator>();
+      operators.Add(new BestOneMaxSolutionAnalyzer());
+      operators.Add(new PopulationBestOneMaxSolutionAnalyzer());
+      operators.Add(new MultiPopulationBestOneMaxSolutionAnalyzer());
+      ParameterizeAnalyzers();
       foreach(IBinaryVectorOperator op in ApplicationManager.Manager.GetInstances<IBinaryVectorOperator>()) {
         if (!(op is ISingleObjectiveMoveEvaluator) || (op is IOneMaxMoveEvaluator)) {
