Index: branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/Analyzers/PopulationSizeAnalyzer.cs
===================================================================
--- branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/Analyzers/PopulationSizeAnalyzer.cs	(revision 8377)
+++ branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/Analyzers/PopulationSizeAnalyzer.cs	(revision 8377)
@@ -0,0 +1,107 @@
+﻿#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 HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.RAPGA {
+  /// <summary>
+  /// An operator which analyzes the size of the population in a scope tree.
+  /// </summary>
+  [Item("PopulationSizeAnalyzer", "An operator which analyzes the size of the population in a scope tree.")]
+  [StorableClass]
+  public sealed class PopulationSizeAnalyzer : AlgorithmOperator, IAnalyzer {
+    #region Parameter properties
+    public ILookupParameter<IntValue> CurrentPopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["CurrentPopulationSize"]; }
+    }
+    public ILookupParameter<IntValue> MaximumPopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["MaximumPopulationSize"]; }
+    }
+    public ILookupParameter<IntValue> MinimumPopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["MinimumPopulationSize"]; }
+    }
+    public IValueLookupParameter<DataTable> PopulationSizesParameter {
+      get { return (IValueLookupParameter<DataTable>)Parameters["PopulationSizes"]; }
+    }
+    public IValueLookupParameter<VariableCollection> ResultsParameter {
+      get { return (IValueLookupParameter<VariableCollection>)Parameters["Results"]; }
+    }
+    #endregion
+
+    #region Properties
+    public bool EnabledByDefault {
+      get { return true; }
+    }
+    private DataTableValuesCollector DataTableValuesCollector {
+      get { return (DataTableValuesCollector)OperatorGraph.InitialOperator; }
+    }
+    private ResultsCollector ResultsCollector {
+      get { return (ResultsCollector)DataTableValuesCollector.Successor; }
+    }
+    #endregion
+
+    #region Storing & Cloning
+    [StorableConstructor]
+    private PopulationSizeAnalyzer(bool deserializing) : base(deserializing) { }
+    private PopulationSizeAnalyzer(PopulationSizeAnalyzer original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PopulationSizeAnalyzer(this, cloner);
+    }
+    #endregion
+    public PopulationSizeAnalyzer()
+      : base() {
+      #region Create parameters
+      Parameters.Add(new LookupParameter<IntValue>("CurrentPopulationSize", "The current size of the population in the scope tree which should be analyzed."));
+      Parameters.Add(new LookupParameter<IntValue>("MaximumPopulationSize", "The maximum size of the population in the scope tree which should be analyzed."));
+      Parameters.Add(new LookupParameter<IntValue>("MinimumPopulationSize", "The minimum size of the population in the scope tree which should be analyzed."));
+      Parameters.Add(new ValueLookupParameter<DataTable>("PopulationSizes", "The data table to store the values."));
+      Parameters.Add(new ValueLookupParameter<VariableCollection>("Results", "The results collection where the analysis values should be stored."));
+      #endregion
+
+      #region Create operators
+      DataTableValuesCollector dataTableValuesCollector = new DataTableValuesCollector();
+      ResultsCollector resultsCollector = new ResultsCollector();
+
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<IntValue>("CurrentPopulationSize", null, CurrentPopulationSizeParameter.Name));
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<IntValue>("MaximumPopulationSize", null, MaximumPopulationSizeParameter.Name));
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<IntValue>("MinimumPopulationSize", null, MinimumPopulationSizeParameter.Name));
+      dataTableValuesCollector.DataTableParameter.ActualName = PopulationSizesParameter.Name;
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(PopulationSizesParameter.Name));
+      resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
+      #endregion
+
+      #region Create operator graph
+      OperatorGraph.InitialOperator = dataTableValuesCollector;
+      dataTableValuesCollector.Successor = resultsCollector;
+      resultsCollector.Successor = null;
+      #endregion
+    }
+  }
+}
Index: branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/DuplicateSelector.cs
===================================================================
--- branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/DuplicateSelector.cs	(revision 8359)
+++ 	(revision )
@@ -1,82 +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.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Optimization;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Selection {
-  /// <summary>
-  /// A selection operator which considers a single solution representation and selects duplicates.
-  /// </summary>
-  [Item("DuplicateSelector", "A selection operator which considers a single solution representation and selects duplicates.")]
-  [StorableClass]
-  public sealed class DuplicateSelector : SingleObjectiveSelector, ISingleObjectiveSelector, ISimilarityBasedOperator {
-    #region ISimilarityBasedOperator Members
-    [Storable]
-    public ISolutionSimilarityCalculator SimilarityCalculator { get; set; }
-    #endregion
-
-    public DuplicateSelector() : base() { }
-    [StorableConstructor]
-    private DuplicateSelector(bool deserializing) : base(deserializing) { }
-    private DuplicateSelector(DuplicateSelector original, Cloner cloner)
-      : base(original, cloner) {
-      this.SimilarityCalculator = cloner.Clone(original.SimilarityCalculator);
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new DuplicateSelector(this, cloner);
-    }
-
-
-    protected override IScope[] Select(List<IScope> scopes) {
-      bool copy = CopySelected.Value;
-
-      var marks = new bool[scopes.Count];
-      for (int i = 0; i < scopes.Count; i++) {
-        for (int j = i + 1; j < scopes.Count; j++) {
-          if (SimilarityCalculator.Equals(scopes[i], scopes[j])) marks[j] = true;
-        }
-      }
-
-      var selected = new IScope[marks.Count(x => x)];
-      int k = 0;
-      if (copy) {
-        for (int i = 0; i < scopes.Count; i++)
-          if (marks[i]) {
-            selected[k++] = (IScope)scopes[i].Clone();
-          }
-      } else {
-        for (int i = 0; i < scopes.Count; i++)
-          if (marks[i]) {
-            selected[k++] = scopes[i];
-            scopes[i] = null;
-          }
-        scopes.RemoveAll(x => x == null);
-      }
-
-      return selected;
-    }
-  }
-}
Index: branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/DuplicatesSelector.cs
===================================================================
--- branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/DuplicatesSelector.cs	(revision 8377)
+++ branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/DuplicatesSelector.cs	(revision 8377)
@@ -0,0 +1,86 @@
+﻿#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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Algorithms.RAPGA {
+  /// <summary>
+  /// A selection operator which considers a single solution representation and selects duplicates.
+  /// </summary>
+  /// <remarks>
+  /// The remaining scope then contains unique solutions and the selected scope their duplicates.
+  /// </remarks>
+  [Item("DuplicatesSelector", "A selection operator which considers a single solution representation and selects duplicates. The remaining scope then contains unique solutions and the selected scope their duplicates.")]
+  [StorableClass]
+  public sealed class DuplicatesSelector : SingleObjectiveSelector, ISingleObjectiveSelector, ISimilarityBasedOperator {
+    #region ISimilarityBasedOperator Members
+    [Storable]
+    public ISolutionSimilarityCalculator SimilarityCalculator { get; set; }
+    #endregion
+
+    [StorableConstructor]
+    private DuplicatesSelector(bool deserializing) : base(deserializing) { }
+    private DuplicatesSelector(DuplicatesSelector original, Cloner cloner)
+      : base(original, cloner) {
+      this.SimilarityCalculator = cloner.Clone(original.SimilarityCalculator);
+    }
+    public DuplicatesSelector() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DuplicatesSelector(this, cloner);
+    }
+
+    protected override IScope[] Select(List<IScope> scopes) {
+      bool copy = CopySelected.Value;
+
+      var marks = new bool[scopes.Count];
+      for (int i = 0; i < scopes.Count; i++) {
+        for (int j = i + 1; j < scopes.Count; j++) {
+          if (SimilarityCalculator.Equals(scopes[i], scopes[j])) marks[j] = true;
+        }
+      }
+
+      var selected = new IScope[marks.Count(x => x)];
+      int k = 0;
+      if (copy) {
+        for (int i = 0; i < scopes.Count; i++)
+          if (marks[i]) {
+            selected[k++] = (IScope)scopes[i].Clone();
+          }
+      } else {
+        for (int i = 0; i < scopes.Count; i++)
+          if (marks[i]) {
+            selected[k++] = scopes[i];
+            scopes[i] = null;
+          }
+        scopes.RemoveAll(x => x == null);
+      }
+
+      return selected;
+    }
+  }
+}
Index: branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/HeuristicLab.Algorithms.RAPGA-3.3.csproj
===================================================================
--- branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/HeuristicLab.Algorithms.RAPGA-3.3.csproj	(revision 8359)
+++ branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/HeuristicLab.Algorithms.RAPGA-3.3.csproj	(revision 8377)
@@ -97,5 +97,8 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="DuplicateSelector.cs" />
+    <Compile Include="Analyzers\PopulationSizeAnalyzer.cs" />
+    <Compile Include="DuplicatesSelector.cs" />
+    <Compile Include="OffspringRestorer.cs" />
+    <Compile Include="ProgressiveOffspringPreserver.cs" />
     <Compile Include="RAPGA.cs" />
     <Compile Include="RAPGAMainLoop.cs" />
Index: branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/OffspringRestorer.cs
===================================================================
--- branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/OffspringRestorer.cs	(revision 8377)
+++ branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/OffspringRestorer.cs	(revision 8377)
@@ -0,0 +1,76 @@
+﻿#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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.RAPGA {
+  /// <summary>
+  /// An operator that restores created offspring from a scope list.
+  /// </summary>
+  /// <remarks>
+  /// It adds all scopes in the list as sub-scopes to the current scope.
+  /// </remarks>
+  [Item("OffspringRestorer", "An operator that restores created offspring from a scope list. It adds all scopes in the list as sub-scopes to the current scope.")]
+  [StorableClass]
+  public class OffspringRestorer : SingleSuccessorOperator {
+    #region Parameter Properties
+    public ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+    public ILookupParameter<ScopeList> OffspringListParameter {
+      get { return (ILookupParameter<ScopeList>)Parameters["OffspringList"]; }
+    }
+    #endregion
+
+    #region Properties
+    private IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
+    }
+    private ScopeList OffspringList {
+      get { return OffspringListParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected OffspringRestorer(bool deserializing) : base(deserializing) { }
+    protected OffspringRestorer(OffspringRestorer original, Cloner cloner) : base(original, cloner) { }
+    public OffspringRestorer()
+      : base() {
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope that contains the offspring."));
+      Parameters.Add(new LookupParameter<ScopeList>("OffspringList", "The list that contains the offspring."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new OffspringRestorer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      CurrentScope.SubScopes.AddRange(OffspringList);
+      return base.Apply();
+    }
+  }
+}
Index: branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/ProgressiveOffspringPreserver.cs
===================================================================
--- branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/ProgressiveOffspringPreserver.cs	(revision 8377)
+++ branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/ProgressiveOffspringPreserver.cs	(revision 8377)
@@ -0,0 +1,110 @@
+﻿#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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.RAPGA {
+  /// <summary>
+  /// An operator that progressively selects offspring by adding it to a scope list.
+  /// </summary>
+  /// <remarks>
+  /// The operator also performs duplication control.
+  /// </remarks>
+  [Item("ProgressiveOffspringPreserver", "An operator that progressively selects offspring by adding it to a scope list. The operator also performs duplication control.")]
+  [StorableClass]
+  public sealed class ProgressiveOffspringPreserver : SingleSuccessorOperator, ISimilarityBasedOperator {
+    #region ISimilarityBasedOperator Members
+    [Storable]
+    public ISolutionSimilarityCalculator SimilarityCalculator { get; set; }
+    #endregion
+
+    #region Parameter Properties
+    public ScopeParameter CurrentScopeParameter {
+      get { return (ScopeParameter)Parameters["CurrentScope"]; }
+    }
+    public ILookupParameter<ScopeList> OffspringListParameter {
+      get { return (ILookupParameter<ScopeList>)Parameters["OffspringList"]; }
+    }
+    public ILookupParameter<IntValue> ElitesParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Elites"]; }
+    }
+    public ILookupParameter<IntValue> MaximumPopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["MaximumPopulationSize"]; }
+    }
+    #endregion
+
+    #region Properties
+    private IScope CurrentScope {
+      get { return CurrentScopeParameter.ActualValue; }
+    }
+    private ScopeList OffspringList {
+      get { return OffspringListParameter.ActualValue; }
+    }
+    private IntValue Elites {
+      get { return ElitesParameter.ActualValue; }
+    }
+    private IntValue MaximumPopulationSize {
+      get { return MaximumPopulationSizeParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private ProgressiveOffspringPreserver(bool deserializing) : base(deserializing) { }
+    private ProgressiveOffspringPreserver(ProgressiveOffspringPreserver original, Cloner cloner)
+      : base(original, cloner) {
+      this.SimilarityCalculator = cloner.Clone(original.SimilarityCalculator);
+    }
+    public ProgressiveOffspringPreserver()
+      : base() {
+      Parameters.Add(new ScopeParameter("CurrentScope", "The current scope that contains the offspring."));
+      Parameters.Add(new LookupParameter<ScopeList>("OffspringList", "The list that contains the offspring."));
+      Parameters.Add(new LookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
+      Parameters.Add(new LookupParameter<IntValue>("MaximumPopulationSize", "The maximum size of the population of solutions."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ProgressiveOffspringPreserver(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      if (CurrentScope.SubScopes.Any()) {
+        if (OffspringList.Any()) {
+          var currentOffspring = new Scope();
+          currentOffspring.SubScopes.AddRange(OffspringList);
+          var similarityMatrix = SimilarityCalculator.CalculateSolutionCrowdSimilarity(CurrentScope, currentOffspring);
+          for (int i = CurrentScope.SubScopes.Count - 1; i >= 0 && OffspringList.Count < MaximumPopulationSize.Value - Elites.Value; i--)
+            if (similarityMatrix[i].Any(x => x == 1.0)) CurrentScope.SubScopes.RemoveAt(i);
+            else OffspringList.Add(CurrentScope.SubScopes[i]);
+        } else OffspringList.AddRange(CurrentScope.SubScopes);
+      }
+      return base.Apply();
+    }
+  }
+}
Index: branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/RAPGA.cs
===================================================================
--- branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/RAPGA.cs	(revision 8359)
+++ branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/RAPGA.cs	(revision 8377)
@@ -76,4 +76,7 @@
       get { return (IValueParameter<IntValue>)Parameters["Effort"]; }
     }
+    private IValueParameter<IntValue> BatchSizeParameter {
+      get { return (IValueParameter<IntValue>)Parameters["BatchSize"]; }
+    }
     public IConstrainedValueParameter<ISelector> SelectorParameter {
       get { return (IConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
@@ -131,4 +134,8 @@
       set { EffortParameter.Value = value; }
     }
+    public IntValue BatchSize {
+      get { return BatchSizeParameter.Value; }
+      set { BatchSizeParameter.Value = value; }
+    }
     public ISelector Selector {
       get { return SelectorParameter.Value; }
@@ -174,4 +181,6 @@
     [Storable]
     private BestAverageWorstQualityAnalyzer qualityAnalyzer;
+    [Storable]
+    private PopulationSizeAnalyzer populationSizeAnalyzer;
     #endregion
 
@@ -183,4 +192,5 @@
       : base(original, cloner) {
       qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
+      populationSizeAnalyzer = cloner.Clone(original.populationSizeAnalyzer);
       Initialize();
     }
@@ -191,7 +201,8 @@
       Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions.", new IntValue(100)));
       Parameters.Add(new ValueParameter<IntValue>("MinimumPopulationSize", "The minimum size of the population of solutions.", new IntValue(2)));
-      Parameters.Add(new ValueParameter<IntValue>("MaximumPopulationSize", "The maximum size of the population of solutions.", new IntValue(299)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumPopulationSize", "The maximum size of the population of solutions.", new IntValue(300)));
       Parameters.Add(new ValueParameter<DoubleValue>("ComparisonFactor", "The comparison factor.", new DoubleValue(0.0)));
-      Parameters.Add(new ValueParameter<IntValue>("Effort", "The maximum number of offspring created in each generation.", new IntValue(400)));
+      Parameters.Add(new ValueParameter<IntValue>("Effort", "The maximum number of offspring created in each generation.", new IntValue(1000)));
+      Parameters.Add(new ValueParameter<IntValue>("BatchSize", "The number of children that should be created during one iteration of the offspring creation process.", new IntValue(10)));
       Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
       Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
@@ -247,4 +258,5 @@
 
       qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      populationSizeAnalyzer = new PopulationSizeAnalyzer();
       ParameterizeAnalyzers();
       UpdateAnalyzers();
@@ -302,9 +314,9 @@
       base.Problem_OperatorsChanged(sender, e);
     }
-    void EffortParameter_ValueChanged(object sender, EventArgs e) {
-      Effort.ValueChanged +=new EventHandler(Effort_ValueChanged);
-      ParameterizeSelectors();
-    }
-    void Effort_ValueChanged(object sender, EventArgs e) {
+    void BatchSizeParameter_ValueChanged(object sender, EventArgs e) {
+      BatchSize.ValueChanged += new EventHandler(BatchSize_ValueChanged);
+      ParameterizeSelectors();
+    }
+    void BatchSize_ValueChanged(object sender, EventArgs e) {
       ParameterizeSelectors();
     }
@@ -337,6 +349,6 @@
       ElitesParameter.ValueChanged += new EventHandler(ElitesParameter_ValueChanged);
       Elites.ValueChanged += new EventHandler(Elites_ValueChanged);
-      EffortParameter.ValueChanged += new EventHandler(EffortParameter_ValueChanged);
-      Effort.ValueChanged += new EventHandler(Effort_ValueChanged);
+      BatchSizeParameter.ValueChanged += new EventHandler(BatchSizeParameter_ValueChanged);
+      BatchSize.ValueChanged += new EventHandler(BatchSize_ValueChanged);
       if (Problem != null) {
         Problem.Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
@@ -365,5 +377,5 @@
       foreach (ISelector selector in SelectorParameter.ValidValues) {
         selector.CopySelected = new BoolValue(true);
-        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(2 * EffortParameter.Value.Value);
+        selector.NumberOfSelectedSubScopesParameter.Value = new IntValue(2 * BatchSize.Value);
         selector.NumberOfSelectedSubScopesParameter.Hidden = true;
         ParameterizeStochasticOperator(selector);
@@ -381,4 +393,6 @@
       qualityAnalyzer.ResultsParameter.ActualName = "Results";
       qualityAnalyzer.ResultsParameter.Hidden = true;
+      populationSizeAnalyzer.ResultsParameter.ActualName = "Results";
+      populationSizeAnalyzer.ResultsParameter.Hidden = true;
       if (Problem != null) {
         qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
@@ -437,4 +451,5 @@
       }
       Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(populationSizeAnalyzer, populationSizeAnalyzer.EnabledByDefault);
     }
     private void UpdateSimilarityCalculators() {
Index: branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/RAPGAMainLoop.cs
===================================================================
--- branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/RAPGAMainLoop.cs	(revision 8359)
+++ branches/RAPGA/HeuristicLab.Algorithms.RAPGA/3.3/RAPGAMainLoop.cs	(revision 8377)
@@ -136,5 +136,5 @@
       #region Create operators
       VariableCreator variableCreator = new VariableCreator();
-      IntCounter intCounter1 = new IntCounter();
+      Assigner assigner1 = new Assigner();
       ResultsCollector resultsCollector = new ResultsCollector();
       Placeholder analyzer1 = new Placeholder();
@@ -142,43 +142,50 @@
       SubScopesProcessor subScopesProcessor1 = new SubScopesProcessor();
       ChildrenCreator childrenCreator = new ChildrenCreator();
-      UniformSubScopesProcessor uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
+      UniformSubScopesProcessor uniformSubScopesProcessor = new UniformSubScopesProcessor();
       Placeholder crossover = new Placeholder();
       StochasticBranch stochasticBranch = new StochasticBranch();
       Placeholder mutator = new Placeholder();
-      UniformSubScopesProcessor uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
       Placeholder evaluator = new Placeholder();
-      WeightedParentsQualityComparator comparator1 = new WeightedParentsQualityComparator();
+      WeightedParentsQualityComparator weightedParentsQualityComparator = new WeightedParentsQualityComparator();
+      SubScopesRemover subScopesRemover = new SubScopesRemover();
       SubScopesCounter subScopesCounter1 = new SubScopesCounter();
+      IntCounter intCounter1 = new IntCounter();
       ConditionalSelector conditionalSelector = new ConditionalSelector();
       RightReducer rightReducer1 = new RightReducer();
-      UniformSubScopesProcessor uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
-      SubScopesRemover subScopesRemover = new SubScopesRemover();
-      DuplicateSelector duplicateSelector = new DuplicateSelector();
-      LeftReducer leftReducer = new LeftReducer();
+      DuplicatesSelector duplicateSelector = new DuplicatesSelector();
+      LeftReducer leftReducer1 = new LeftReducer();
+      ProgressiveOffspringPreserver progressiveOffspringSelector = new ProgressiveOffspringPreserver();
       SubScopesCounter subScopesCounter2 = new SubScopesCounter();
+      Comparator comparator1 = new Comparator();
+      ConditionalBranch conditionalBranch1 = new ConditionalBranch();
       Comparator comparator2 = new Comparator();
-      ConditionalBranch conditionalBranch1 = new ConditionalBranch();
-      BestSelector bestSelector1 = new BestSelector();
-      BestSelector bestSelector2 = new BestSelector();
+      ConditionalBranch conditionalBranch2 = new ConditionalBranch();
+      LeftReducer leftReducer2 = new LeftReducer();
+      SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
+      BestSelector bestSelector = new BestSelector();
       RightReducer rightReducer2 = new RightReducer();
-      SubScopesProcessor subScopesProcessor2 = new SubScopesProcessor();
-      BestSelector bestSelector3 = new BestSelector();
-      RightReducer rightReducer3 = new RightReducer();
+      ScopeCleaner scopeCleaner = new ScopeCleaner();
+      OffspringRestorer offspringRestorer = new OffspringRestorer();
       MergingReducer mergingReducer = new MergingReducer();
       IntCounter intCounter2 = new IntCounter();
+      SubScopesCounter subScopesCounter3 = new SubScopesCounter();
       Comparator comparator3 = new Comparator();
       Placeholder analyzer2 = new Placeholder();
-      ConditionalBranch conditionalBranch2 = new ConditionalBranch();
-      SubScopesCounter subScopesCounter3 = new SubScopesCounter();
+      ConditionalBranch conditionalBranch3 = new ConditionalBranch();
       Comparator comparator4 = new Comparator();
-      ConditionalBranch conditionalBranch3 = new ConditionalBranch();
+      ConditionalBranch conditionalBranch4 = new ConditionalBranch();
+      Assigner assigner2 = new Assigner();
+      Assigner assigner3 = new Assigner();
+      Assigner assigner4 = new Assigner();
 
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0))); // Class RAPGA expects this to be called Generations
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("CurrentPopulationSize", new IntValue(0)));
-
-      intCounter1.Name = "Initialize CurrentPopulationSize";
-      intCounter1.IncrementParameter.ActualName = PopulationSizeParameter.Name;
-      intCounter1.IncrementParameter.Value = null;
-      intCounter1.ValueParameter.ActualName = "CurrentPopulationSize";
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("NumberOfCreatedOffspring", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("NumberOfSuccessfulOffspring", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<ScopeList>("OffspringList", new ScopeList()));
+
+      assigner1.Name = "Initialize CurrentPopulationSize";
+      assigner1.LeftSideParameter.ActualName = "CurrentPopulationSize";
+      assigner1.RightSideParameter.ActualName = PopulationSizeParameter.Name;
 
       resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
@@ -194,4 +201,6 @@
       childrenCreator.ParentsPerChild = new IntValue(2);
 
+      uniformSubScopesProcessor.Parallel.Value = true;
+
       crossover.Name = "Crossover";
       crossover.OperatorParameter.ActualName = "Crossover";
@@ -203,17 +212,22 @@
       mutator.OperatorParameter.ActualName = "Mutator";
 
-      uniformSubScopesProcessor2.Parallel.Value = true;
-
       evaluator.Name = "Evaluator";
       evaluator.OperatorParameter.ActualName = "Evaluator";
 
-      comparator1.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
-      comparator1.LeftSideParameter.ActualName = QualityParameter.Name;
-      comparator1.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      comparator1.RightSideParameter.ActualName = QualityParameter.Name;
-      comparator1.ResultParameter.ActualName = "SuccessfulOffspring";
-
-      subScopesCounter1.Name = "Increment EvaluatedSolutions";
-      subScopesCounter1.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      weightedParentsQualityComparator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      weightedParentsQualityComparator.LeftSideParameter.ActualName = QualityParameter.Name;
+      weightedParentsQualityComparator.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      weightedParentsQualityComparator.RightSideParameter.ActualName = QualityParameter.Name;
+      weightedParentsQualityComparator.ResultParameter.ActualName = "SuccessfulOffspring";
+
+      subScopesRemover.RemoveAllSubScopes = true;
+
+      subScopesCounter1.Name = "Increment NumberOfCreatedOffspring";
+      subScopesCounter1.ValueParameter.ActualName = "NumberOfCreatedOffspring";
+
+      intCounter1.Name = "Increment EvaluatedSolutions";
+      intCounter1.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      intCounter1.Increment = null;
+      intCounter1.IncrementParameter.ActualName = "NumberOfCreatedOffspring";
 
       conditionalSelector.ConditionParameter.ActualName = "SuccessfulOffspring";
@@ -223,36 +237,43 @@
       duplicateSelector.CopySelected.Value = false;
 
-      uniformSubScopesProcessor3.Parallel.Value = true;
-
-      subScopesRemover.RemoveAllSubScopes = true;
+      progressiveOffspringSelector.OffspringListParameter.ActualName = "OffspringList";
+      progressiveOffspringSelector.ElitesParameter.ActualName = ElitesParameter.Name;
+      progressiveOffspringSelector.MaximumPopulationSizeParameter.ActualName = MaximumPopulationSizeParameter.Name;
 
       subScopesCounter2.Name = "Count Successful Offspring";
       subScopesCounter2.ValueParameter.ActualName = "NumberOfSuccessfulOffspring";
 
+      comparator1.Name = "NumberOfSuccessfulOffspring >= MaximumPopulationSize";
+      comparator1.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      comparator1.LeftSideParameter.ActualName = "NumberOfSuccessfulOffspring";
+      comparator1.RightSideParameter.ActualName = MaximumPopulationSizeParameter.Name;
+      comparator1.ResultParameter.ActualName = "Break";
+
+      conditionalBranch1.Name = "Break?";
+      conditionalBranch1.ConditionParameter.ActualName = "Break";
+
+      comparator2.Name = "NumberOfCreatedOffspring >= Effort";
       comparator2.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
-      comparator2.LeftSideParameter.ActualName = "NumberOfSuccessfulOffspring";
-      comparator2.RightSideParameter.ActualName = MaximumPopulationSizeParameter.Name;
-      comparator2.ResultParameter.ActualName = "SelectMaximum";
-
-      conditionalBranch1.ConditionParameter.ActualName = "SelectMaximum";
-
-      bestSelector1.CopySelected = new BoolValue(false);
-      bestSelector1.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      bestSelector1.NumberOfSelectedSubScopesParameter.ActualName = MaximumPopulationSizeParameter.Name;
-      bestSelector1.QualityParameter.ActualName = QualityParameter.Name;
-
-      bestSelector2.CopySelected = new BoolValue(false);
-      bestSelector2.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      bestSelector2.NumberOfSelectedSubScopesParameter.ActualName = "NumberOfSuccessfulOffspring";
-      bestSelector2.QualityParameter.ActualName = QualityParameter.Name;
-
-      bestSelector3.CopySelected = new BoolValue(false);
-      bestSelector3.MaximizationParameter.ActualName = MaximizationParameter.Name;
-      bestSelector3.NumberOfSelectedSubScopesParameter.ActualName = "Elites";
-      bestSelector3.QualityParameter.ActualName = QualityParameter.Name;
-
+      comparator2.LeftSideParameter.ActualName = "NumberOfCreatedOffspring";
+      comparator2.RightSideParameter.ActualName = EffortParameter.Name;
+      comparator2.ResultParameter.ActualName = "Break";
+
+      conditionalBranch2.Name = "Break?";
+      conditionalBranch2.ConditionParameter.ActualName = "Break";
+
+      bestSelector.CopySelected = new BoolValue(false);
+      bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = "Elites";
+      bestSelector.QualityParameter.ActualName = QualityParameter.Name;
+
+      intCounter2.Name = "Increment Generations";
       intCounter2.Increment = new IntValue(1);
       intCounter2.ValueParameter.ActualName = "Generations";
-
+      subScopesCounter3.Name = "Set CurrentPopulationSize";
+
+      subScopesCounter3.ValueParameter.ActualName = "CurrentPopulationSize";
+      subScopesCounter3.AccumulateParameter.Value = new BoolValue(false);
+
+      comparator3.Name = "Generations >= MaximumGenerations";
       comparator3.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
       comparator3.LeftSideParameter.ActualName = "Generations";
@@ -263,10 +284,8 @@
       analyzer2.OperatorParameter.ActualName = "Analyzer";
 
-      conditionalBranch2.ConditionParameter.ActualName = "Terminate";
-
-      subScopesCounter3.Name = "Set CurrentPopulationSize";
-      subScopesCounter3.ValueParameter.ActualName = "CurrentPopulationSize";
-      subScopesCounter3.AccumulateParameter.Value = new BoolValue(false);
-
+      conditionalBranch3.Name = "Terminate?";
+      conditionalBranch3.ConditionParameter.ActualName = "Terminate";
+
+      comparator4.Name = "CurrentPopulationSize < MinimumPopulationSize";
       comparator4.Comparison = new Comparison(ComparisonType.Less);
       comparator4.LeftSideParameter.ActualName = "CurrentPopulationSize";
@@ -274,11 +293,24 @@
       comparator4.ResultParameter.ActualName = "Terminate";
 
-      conditionalBranch3.ConditionParameter.ActualName = "Terminate";
+      conditionalBranch4.Name = "Terminate?";
+      conditionalBranch4.ConditionParameter.ActualName = "Terminate";
+
+      assigner2.Name = "Reset NumberOfCreatedOffspring";
+      assigner2.LeftSideParameter.ActualName = "NumberOfCreatedOffspring";
+      assigner2.RightSideParameter.Value = new IntValue(0);
+
+      assigner3.Name = "Reset NumberOfSuccessfulOffspring";
+      assigner3.LeftSideParameter.ActualName = "NumberOfSuccessfulOffspring";
+      assigner3.RightSideParameter.Value = new IntValue(0);
+
+      assigner4.Name = "Reset OffspringList";
+      assigner4.LeftSideParameter.ActualName = "OffspringList";
+      assigner4.RightSideParameter.Value = new ScopeList();
       #endregion
 
       #region Create operator graph
       OperatorGraph.InitialOperator = variableCreator;
-      variableCreator.Successor = intCounter1;
-      intCounter1.Successor = resultsCollector;
+      variableCreator.Successor = assigner1;
+      assigner1.Successor = resultsCollector;
       resultsCollector.Successor = analyzer1;
       analyzer1.Successor = selector;
@@ -286,47 +318,51 @@
       subScopesProcessor1.Operators.Add(new EmptyOperator());
       subScopesProcessor1.Operators.Add(childrenCreator);
-      subScopesProcessor1.Successor = subScopesProcessor2;
-      childrenCreator.Successor = uniformSubScopesProcessor1;
-      uniformSubScopesProcessor1.Operator = crossover;
-      uniformSubScopesProcessor1.Successor = uniformSubScopesProcessor2;
+      subScopesProcessor1.Successor = comparator1;
+      childrenCreator.Successor = uniformSubScopesProcessor;
+      uniformSubScopesProcessor.Operator = crossover;
+      uniformSubScopesProcessor.Successor = subScopesCounter1;
       crossover.Successor = stochasticBranch;
       stochasticBranch.FirstBranch = mutator;
       stochasticBranch.SecondBranch = null;
-      stochasticBranch.Successor = null;
       mutator.Successor = null;
-      subScopesRemover.Successor = null;
-      uniformSubScopesProcessor2.Operator = evaluator;
-      uniformSubScopesProcessor2.Successor = subScopesCounter1;
-      evaluator.Successor = comparator1;
-      subScopesCounter1.Successor = conditionalSelector;
+      stochasticBranch.Successor = evaluator;
+      evaluator.Successor = weightedParentsQualityComparator;
+      weightedParentsQualityComparator.Successor = subScopesRemover;
+      subScopesCounter1.Successor = intCounter1;
+      intCounter1.Successor = conditionalSelector;
       conditionalSelector.Successor = rightReducer1;
-      rightReducer1.Successor = uniformSubScopesProcessor3;
-      uniformSubScopesProcessor3.Operator = subScopesRemover;
-      uniformSubScopesProcessor3.Successor = duplicateSelector;
-      duplicateSelector.Successor = leftReducer;
-      leftReducer.Successor = subScopesCounter2;
-      subScopesCounter2.Successor = comparator2;
-      comparator2.Successor = conditionalBranch1;
-      conditionalBranch1.TrueBranch = bestSelector1;
-      conditionalBranch1.FalseBranch = bestSelector2;
-      bestSelector1.Successor = rightReducer2;
-      bestSelector2.Successor = rightReducer2;
-      subScopesProcessor2.Operators.Add(bestSelector3);
-      subScopesProcessor2.Operators.Add(new EmptyOperator());
+      rightReducer1.Successor = duplicateSelector;
+      duplicateSelector.Successor = leftReducer1;
+      leftReducer1.Successor = progressiveOffspringSelector;
+      progressiveOffspringSelector.Successor = subScopesCounter2;
+      comparator1.Successor = conditionalBranch1;
+      conditionalBranch1.FalseBranch = comparator2;
+      conditionalBranch1.TrueBranch = subScopesProcessor2;
+      comparator2.Successor = conditionalBranch2;
+      conditionalBranch2.FalseBranch = leftReducer2;
+      conditionalBranch2.TrueBranch = subScopesProcessor2;
+      leftReducer2.Successor = selector;
+      subScopesProcessor2.Operators.Add(bestSelector);
+      subScopesProcessor2.Operators.Add(scopeCleaner);
       subScopesProcessor2.Successor = mergingReducer;
-      bestSelector3.Successor = rightReducer3;
-      rightReducer3.Successor = null;
+      bestSelector.Successor = rightReducer2;
+      rightReducer2.Successor = null;
+      scopeCleaner.Successor = offspringRestorer;
       mergingReducer.Successor = intCounter2;
-      intCounter2.Successor = comparator3;
-      comparator3.Successor = analyzer2;
-      analyzer2.Successor = conditionalBranch2;
-      conditionalBranch2.FalseBranch = subScopesCounter3;
-      conditionalBranch2.TrueBranch = null;
-      conditionalBranch2.Successor = null;
-      subScopesCounter3.Successor = comparator4;
-      comparator4.Successor = conditionalBranch3;
-      conditionalBranch3.FalseBranch = selector;
+      intCounter2.Successor = subScopesCounter3;
+      subScopesCounter3.Successor = analyzer2;
+      analyzer2.Successor = comparator3;
+      comparator3.Successor = conditionalBranch3;
+      conditionalBranch3.FalseBranch = comparator4;
       conditionalBranch3.TrueBranch = null;
       conditionalBranch3.Successor = null;
+      comparator4.Successor = conditionalBranch4;
+      conditionalBranch4.FalseBranch = assigner2;
+      conditionalBranch4.TrueBranch = null;
+      conditionalBranch4.Successor = null;
+      assigner2.Successor = assigner3;
+      assigner3.Successor = assigner4;
+      assigner4.Successor = selector;
+
       #endregion
     }
