Index: stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelectionGeneticAlgorithm.cs
===================================================================
--- stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelectionGeneticAlgorithm.cs	(revision 14173)
+++ stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelectionGeneticAlgorithm.cs	(revision 14173)
@@ -0,0 +1,788 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Collections;
+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;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Random;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  [Item("ALPS OffspringSelection Genetic Algorithm", "An offspring selection genetic algorithm within an age-layered population structure.")]
+  [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 162)]
+  [StorableClass]
+  public sealed class AlpsOffspringSelectionGeneticAlgorithm : HeuristicOptimizationEngineAlgorithm, IStorableContent {
+    public string Filename { get; set; }
+
+    #region Problem Properties
+    public override Type ProblemType {
+      get { return typeof(ISingleObjectiveHeuristicOptimizationProblem); }
+    }
+    public new ISingleObjectiveHeuristicOptimizationProblem Problem {
+      get { return (ISingleObjectiveHeuristicOptimizationProblem)base.Problem; }
+      set { base.Problem = value; }
+    }
+    #endregion
+
+    #region Parameter Properties
+    private IFixedValueParameter<IntValue> SeedParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["Seed"]; }
+    }
+    private IFixedValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
+    }
+
+    private IFixedValueParameter<MultiAnalyzer> AnalyzerParameter {
+      get { return (IFixedValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
+    }
+    private IFixedValueParameter<MultiAnalyzer> LayerAnalyzerParameter {
+      get { return (IFixedValueParameter<MultiAnalyzer>)Parameters["LayerAnalyzer"]; }
+    }
+
+    private IFixedValueParameter<IntValue> NumberOfLayersParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["NumberOfLayers"]; }
+    }
+    private IFixedValueParameter<IntValue> PopulationSizeParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["PopulationSize"]; }
+    }
+
+    public IConstrainedValueParameter<ISelector> SelectorParameter {
+      get { return (IConstrainedValueParameter<ISelector>)Parameters["Selector"]; }
+    }
+    public IConstrainedValueParameter<ICrossover> CrossoverParameter {
+      get { return (IConstrainedValueParameter<ICrossover>)Parameters["Crossover"]; }
+    }
+    public IConstrainedValueParameter<IManipulator> MutatorParameter {
+      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
+    }
+    private IFixedValueParameter<PercentValue> MutationProbabilityParameter {
+      get { return (IFixedValueParameter<PercentValue>)Parameters["MutationProbability"]; }
+    }
+    private IFixedValueParameter<IntValue> ElitesParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["Elites"]; }
+    }
+    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
+    }
+
+    private IFixedValueParameter<DoubleValue> SuccessRatioParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["SuccessRatio"]; }
+    }
+    private IFixedValueParameter<DoubleValue> ComparisonFactorParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["ComparisonFactor"]; }
+    }
+    private IFixedValueParameter<DoubleValue> MaximumSelectionPressureParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["MaximumSelectionPressure"]; }
+    }
+    private IFixedValueParameter<BoolValue> OffspringSelectionBeforeMutationParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters["OffspringSelectionBeforeMutation"]; }
+    }
+    private IFixedValueParameter<IntValue> SelectedParentsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["SelectedParents"]; }
+    }
+    private IFixedValueParameter<BoolValue> FillPopulationWithParentsParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters["FillPopulationWithParents"]; }
+    }
+
+    private IFixedValueParameter<EnumValue<AgingScheme>> AgingSchemeParameter {
+      get { return (IFixedValueParameter<EnumValue<AgingScheme>>)Parameters["AgingScheme"]; }
+    }
+    private IFixedValueParameter<IntValue> AgeGapParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["AgeGap"]; }
+    }
+    private IFixedValueParameter<DoubleValue> AgeInheritanceParameter {
+      get { return (IFixedValueParameter<DoubleValue>)Parameters["AgeInheritance"]; }
+    }
+    private IFixedValueParameter<IntArray> AgeLimitsParameter {
+      get { return (IFixedValueParameter<IntArray>)Parameters["AgeLimits"]; }
+    }
+
+    private IFixedValueParameter<IntValue> MatingPoolRangeParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters["MatingPoolRange"]; }
+    }
+    private IFixedValueParameter<BoolValue> ReduceToPopulationSizeParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters["ReduceToPopulationSize"]; }
+    }
+
+    private IFixedValueParameter<MultiTerminator> TerminatorParameter {
+      get { return (IFixedValueParameter<MultiTerminator>)Parameters["Terminator"]; }
+    }
+    #endregion
+
+    #region Properties
+    public int Seed {
+      get { return SeedParameter.Value.Value; }
+      set { SeedParameter.Value.Value = value; }
+    }
+    public bool SetSeedRandomly {
+      get { return SetSeedRandomlyParameter.Value.Value; }
+      set { SetSeedRandomlyParameter.Value.Value = value; }
+    }
+
+    public MultiAnalyzer Analyzer {
+      get { return AnalyzerParameter.Value; }
+    }
+    public MultiAnalyzer LayerAnalyzer {
+      get { return LayerAnalyzerParameter.Value; }
+    }
+
+    public int NumberOfLayers {
+      get { return NumberOfLayersParameter.Value.Value; }
+      set { NumberOfLayersParameter.Value.Value = value; }
+    }
+    public int PopulationSize {
+      get { return PopulationSizeParameter.Value.Value; }
+      set { PopulationSizeParameter.Value.Value = value; }
+    }
+
+    public ISelector Selector {
+      get { return SelectorParameter.Value; }
+      set { SelectorParameter.Value = value; }
+    }
+    public ICrossover Crossover {
+      get { return CrossoverParameter.Value; }
+      set { CrossoverParameter.Value = value; }
+    }
+    public IManipulator Mutator {
+      get { return MutatorParameter.Value; }
+      set { MutatorParameter.Value = value; }
+    }
+    public double MutationProbability {
+      get { return MutationProbabilityParameter.Value.Value; }
+      set { MutationProbabilityParameter.Value.Value = value; }
+    }
+    public int Elites {
+      get { return ElitesParameter.Value.Value; }
+      set { ElitesParameter.Value.Value = value; }
+    }
+    public bool ReevaluteElites {
+      get { return ReevaluateElitesParameter.Value.Value; }
+      set { ReevaluateElitesParameter.Value.Value = value; }
+    }
+
+    public double SuccessRatio {
+      get { return SuccessRatioParameter.Value.Value; }
+      set { SuccessRatioParameter.Value.Value = value; }
+    }
+    public double ComparisonFactor {
+      get { return ComparisonFactorParameter.Value.Value; }
+      set { ComparisonFactorParameter.Value.Value = value; }
+    }
+    public double MaximumSelectionPressure {
+      get { return MaximumSelectionPressureParameter.Value.Value; }
+      set { MaximumSelectionPressureParameter.Value.Value = value; }
+    }
+    public bool OffspringSelectionBeforeMutation {
+      get { return OffspringSelectionBeforeMutationParameter.Value.Value; }
+      set { OffspringSelectionBeforeMutationParameter.Value.Value = value; }
+    }
+    public int SelectedParents {
+      get { return SelectedParentsParameter.Value.Value; }
+      set { SelectedParentsParameter.Value.Value = value; }
+    }
+    public bool FillPopulationWithParents {
+      get { return FillPopulationWithParentsParameter.Value.Value; }
+      set { FillPopulationWithParentsParameter.Value.Value = value; }
+    }
+
+    public AgingScheme AgingScheme {
+      get { return AgingSchemeParameter.Value.Value; }
+      set { AgingSchemeParameter.Value.Value = value; }
+    }
+    public int AgeGap {
+      get { return AgeGapParameter.Value.Value; }
+      set { AgeGapParameter.Value.Value = value; }
+    }
+    public double AgeInheritance {
+      get { return AgeInheritanceParameter.Value.Value; }
+      set { AgeInheritanceParameter.Value.Value = value; }
+    }
+    public IntArray AgeLimits {
+      get { return AgeLimitsParameter.Value; }
+      set {
+        AgeLimits.Length = value.Length;
+        for (int i = 0; i < value.Length; i++)
+          AgeLimits[i] = value[i];
+      }
+    }
+
+    public int MatingPoolRange {
+      get { return MatingPoolRangeParameter.Value.Value; }
+      set { MatingPoolRangeParameter.Value.Value = value; }
+    }
+
+    public MultiTerminator Terminators {
+      get { return TerminatorParameter.Value; }
+    }
+
+    public int MaximumGenerations {
+      get { return generationsTerminator.Threshold.Value; }
+      set { generationsTerminator.Threshold.Value = value; }
+    }
+    #endregion
+
+    #region Helper Properties
+    private SolutionsCreator SolutionsCreator {
+      get { return OperatorGraph.Iterate().OfType<SolutionsCreator>().First(); }
+    }
+    private AlpsOffspringSelectionGeneticAlgorithmMainLoop MainLoop {
+      get { return OperatorGraph.Iterate().OfType<AlpsOffspringSelectionGeneticAlgorithmMainLoop>().First(); }
+    }
+    #endregion
+
+    #region Preconfigured Analyzers
+    [Storable]
+    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
+    [Storable]
+    private BestAverageWorstQualityAnalyzer layerQualityAnalyzer;
+    [Storable]
+    private OldestAverageYoungestAgeAnalyzer ageAnalyzer;
+    [Storable]
+    private OldestAverageYoungestAgeAnalyzer layerAgeAnalyzer;
+    [Storable]
+    private AgeDistributionAnalyzer ageDistributionAnalyzer;
+    [Storable]
+    private AgeDistributionAnalyzer layerAgeDistributionAnalyzer;
+    [Storable]
+    private ValueAnalyzer selectionPressureAnalyzer;
+    [Storable]
+    private ValueAnalyzer layerSelectionPressureAnalyzer;
+    [Storable]
+    private ValueAnalyzer currentSuccessRatioAnalyzer;
+    #endregion
+
+    #region Preconfigured Terminators
+    [Storable]
+    private ComparisonTerminator<IntValue> generationsTerminator;
+    [Storable]
+    private ComparisonTerminator<IntValue> evaluationsTerminator;
+    [Storable]
+    private SingleObjectiveQualityTerminator qualityTerminator;
+    [Storable]
+    private ExecutionTimeTerminator executionTimeTerminator;
+    #endregion
+
+    #region Constructors
+    [StorableConstructor]
+    private AlpsOffspringSelectionGeneticAlgorithm(bool deserializing)
+      : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+    private AlpsOffspringSelectionGeneticAlgorithm(AlpsOffspringSelectionGeneticAlgorithm original, Cloner cloner)
+      : base(original, cloner) {
+      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
+      layerQualityAnalyzer = cloner.Clone(original.layerQualityAnalyzer);
+      ageAnalyzer = cloner.Clone(original.ageAnalyzer);
+      layerAgeAnalyzer = cloner.Clone(original.layerAgeAnalyzer);
+      ageDistributionAnalyzer = cloner.Clone(original.ageDistributionAnalyzer);
+      layerAgeDistributionAnalyzer = cloner.Clone(original.layerAgeDistributionAnalyzer);
+      selectionPressureAnalyzer = cloner.Clone(original.selectionPressureAnalyzer);
+      layerSelectionPressureAnalyzer = cloner.Clone(original.layerSelectionPressureAnalyzer);
+      currentSuccessRatioAnalyzer = cloner.Clone(original.currentSuccessRatioAnalyzer);
+      generationsTerminator = cloner.Clone(original.generationsTerminator);
+      evaluationsTerminator = cloner.Clone(original.evaluationsTerminator);
+      qualityTerminator = cloner.Clone(original.qualityTerminator);
+      executionTimeTerminator = cloner.Clone(original.executionTimeTerminator);
+      Initialize();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AlpsOffspringSelectionGeneticAlgorithm(this, cloner);
+    }
+    public AlpsOffspringSelectionGeneticAlgorithm()
+      : base() {
+      #region Add parameters
+      Parameters.Add(new FixedValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new FixedValueParameter<BoolValue>("SetSeedRandomly", "True if the random seed should be set to a random value, otherwise false.", new BoolValue(true)));
+
+      Parameters.Add(new FixedValueParameter<MultiAnalyzer>("Analyzer", "The operator used to analyze all individuals from all layers combined.", new MultiAnalyzer()));
+      Parameters.Add(new FixedValueParameter<MultiAnalyzer>("LayerAnalyzer", "The operator used to analyze each layer.", new MultiAnalyzer()));
+
+      Parameters.Add(new FixedValueParameter<IntValue>("NumberOfLayers", "The number of layers.", new IntValue(10)));
+      Parameters.Add(new FixedValueParameter<IntValue>("PopulationSize", "The size of the population of solutions in each layer.", new IntValue(100)));
+
+      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."));
+      Parameters.Add(new OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new FixedValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
+      Parameters.Add(new FixedValueParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation.", new IntValue(1)));
+      Parameters.Add(new FixedValueParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)", new BoolValue(false)) { Hidden = true });
+
+      Parameters.Add(new FixedValueParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved.", new DoubleValue(1)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1].", new DoubleValue(1)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm.", new DoubleValue(100)));
+      Parameters.Add(new FixedValueParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation.", new BoolValue(false)));
+      Parameters.Add(new FixedValueParameter<IntValue>("SelectedParents", "How much parents should be selected each time the offspring selection step is performed until the population is filled. This parameter should be about the same or twice the size of PopulationSize for smaller problems, and less for large problems.", new IntValue(200)));
+      Parameters.Add(new FixedValueParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded.", new BoolValue(false)) { Hidden = true });
+
+      Parameters.Add(new FixedValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
+      Parameters.Add(new FixedValueParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers.", new IntValue(20)));
+      Parameters.Add(new FixedValueParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent.", new DoubleValue(1.0)) { Hidden = true });
+      Parameters.Add(new FixedValueParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer.", new IntArray(new int[0])) { Hidden = true });
+
+      Parameters.Add(new FixedValueParameter<IntValue>("MatingPoolRange", "The range of layers used for creating a mating pool. (1 = current + previous layer)", new IntValue(1)) { Hidden = true });
+      Parameters.Add(new FixedValueParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize", new BoolValue(true)) { Hidden = true });
+
+      Parameters.Add(new FixedValueParameter<MultiTerminator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop.", new MultiTerminator()));
+      #endregion
+
+      #region Create operators
+      var globalRandomCreator = new RandomCreator();
+      var layer0Creator = new SubScopesCreator() { Name = "Create Layer Zero" };
+      var layer0Processor = new SubScopesProcessor();
+      var localRandomCreator = new LocalRandomCreator();
+      var layerSolutionsCreator = new SolutionsCreator();
+      var initializeAgeProcessor = new UniformSubScopesProcessor();
+      var initializeAge = new VariableCreator() { Name = "Initialize Age" };
+      var initializeCurrentPopulationSize = new SubScopesCounter() { Name = "Initialize CurrentPopulationCounter" };
+      var initializeLocalEvaluatedSolutions = new Assigner() { Name = "Initialize LayerEvaluatedSolutions" };
+      var initializeGlobalEvaluatedSolutions = new DataReducer() { Name = "Initialize EvaluatedSolutions" };
+      var resultsCollector = new ResultsCollector();
+      var mainLoop = new AlpsOffspringSelectionGeneticAlgorithmMainLoop();
+      #endregion
+
+      #region Create and parameterize operator graph
+      OperatorGraph.InitialOperator = globalRandomCreator;
+
+      globalRandomCreator.RandomParameter.ActualName = "GlobalRandom";
+      globalRandomCreator.SeedParameter.Value = null;
+      globalRandomCreator.SeedParameter.ActualName = SeedParameter.Name;
+      globalRandomCreator.SetSeedRandomlyParameter.Value = null;
+      globalRandomCreator.SetSeedRandomlyParameter.ActualName = SetSeedRandomlyParameter.Name;
+      globalRandomCreator.Successor = layer0Creator;
+
+      layer0Creator.NumberOfSubScopesParameter.Value = new IntValue(1);
+      layer0Creator.Successor = layer0Processor;
+
+      layer0Processor.Operators.Add(localRandomCreator);
+      layer0Processor.Successor = initializeGlobalEvaluatedSolutions;
+
+      localRandomCreator.Successor = layerSolutionsCreator;
+
+      layerSolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
+      layerSolutionsCreator.Successor = initializeAgeProcessor;
+
+      initializeAgeProcessor.Operator = initializeAge;
+      initializeAgeProcessor.Successor = initializeCurrentPopulationSize;
+
+      initializeCurrentPopulationSize.ValueParameter.ActualName = "CurrentPopulationSize";
+      initializeCurrentPopulationSize.Successor = initializeLocalEvaluatedSolutions;
+
+      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
+      initializeAge.Successor = null;
+
+      initializeLocalEvaluatedSolutions.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
+      initializeLocalEvaluatedSolutions.RightSideParameter.ActualName = "CurrentPopulationSize";
+      initializeLocalEvaluatedSolutions.Successor = null;
+
+      initializeGlobalEvaluatedSolutions.ReductionOperation.Value.Value = ReductionOperations.Sum;
+      initializeGlobalEvaluatedSolutions.TargetOperation.Value.Value = ReductionOperations.Assign;
+      initializeGlobalEvaluatedSolutions.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
+      initializeGlobalEvaluatedSolutions.TargetParameter.ActualName = "EvaluatedSolutions";
+      initializeGlobalEvaluatedSolutions.Successor = resultsCollector;
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
+      resultsCollector.Successor = mainLoop;
+
+      mainLoop.GlobalRandomParameter.ActualName = "GlobalRandom";
+      mainLoop.LocalRandomParameter.ActualName = localRandomCreator.LocalRandomParameter.Name;
+      mainLoop.EvaluatedSolutionsParameter.ActualName = "EvaluatedSolutions";
+      mainLoop.AnalyzerParameter.ActualName = AnalyzerParameter.Name;
+      mainLoop.LayerAnalyzerParameter.ActualName = LayerAnalyzerParameter.Name;
+      mainLoop.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
+      mainLoop.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+      mainLoop.CurrentPopulationSizeParameter.ActualName = "CurrentPopulationSize";
+      mainLoop.SelectorParameter.ActualName = SelectorParameter.Name;
+      mainLoop.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
+      mainLoop.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      mainLoop.ElitesParameter.ActualName = ElitesParameter.Name;
+      mainLoop.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
+      mainLoop.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
+      mainLoop.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      mainLoop.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
+      mainLoop.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
+      mainLoop.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
+      mainLoop.AgeParameter.ActualName = "Age";
+      mainLoop.AgeGapParameter.ActualName = AgeGapParameter.Name;
+      mainLoop.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
+      mainLoop.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
+      mainLoop.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
+      mainLoop.ReduceToPopulationSizeParameter.ActualName = ReduceToPopulationSizeParameter.Name;
+      mainLoop.TerminatorParameter.ActualName = TerminatorParameter.Name;
+      #endregion
+
+      #region Set operators
+      foreach (var selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(s => !(s is IMultiObjectiveSelector)).OrderBy(s => Name))
+        SelectorParameter.ValidValues.Add(selector);
+      var defaultSelector = SelectorParameter.ValidValues.OfType<GeneralizedRankSelector>().FirstOrDefault();
+      if (defaultSelector != null) {
+        defaultSelector.PressureParameter.Value = new DoubleValue(4.0);
+        SelectorParameter.Value = defaultSelector;
+      }
+      #endregion
+
+      #region Create analyzers
+      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      ageAnalyzer = new OldestAverageYoungestAgeAnalyzer();
+      layerAgeAnalyzer = new OldestAverageYoungestAgeAnalyzer();
+      ageDistributionAnalyzer = new AgeDistributionAnalyzer();
+      layerAgeDistributionAnalyzer = new AgeDistributionAnalyzer();
+      selectionPressureAnalyzer = new ValueAnalyzer();
+      layerSelectionPressureAnalyzer = new ValueAnalyzer();
+      currentSuccessRatioAnalyzer = new ValueAnalyzer();
+      #endregion
+
+      #region Create terminators
+      generationsTerminator = new ComparisonTerminator<IntValue>("Generations", ComparisonType.Less, new IntValue(1000)) { Name = "Generations" };
+      evaluationsTerminator = new ComparisonTerminator<IntValue>("EvaluatedSolutions", ComparisonType.Less, new IntValue(int.MaxValue)) { Name = "Evaluations" };
+      qualityTerminator = new SingleObjectiveQualityTerminator() { Name = "Quality" };
+      executionTimeTerminator = new ExecutionTimeTerminator(this, new TimeSpanValue(TimeSpan.FromMinutes(5)));
+      #endregion
+
+      #region Parameterize
+      UpdateAnalyzers();
+      ParameterizeAnalyzers();
+
+      ParameterizeSelectors();
+
+      UpdateTerminators();
+
+      ParameterizeAgeLimits();
+      #endregion
+
+      Initialize();
+    }
+    #endregion
+
+    #region Events
+    public override void Prepare() {
+      if (Problem != null)
+        base.Prepare();
+    }
+    protected override void OnProblemChanged() {
+      base.OnProblemChanged();
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
+      foreach (var @operator in Problem.Operators.OfType<IOperator>())
+        ParameterizeStochasticOperator(@operator);
+
+      ParameterizeIterationBasedOperators();
+
+      ParameterizeSolutionsCreator();
+      ParameterizeMainLoop();
+      ParameterizeAnalyzers();
+      ParameterizeSelectors();
+      ParameterizeTerminators();
+
+      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+
+      UpdateAnalyzers();
+      UpdateCrossovers();
+      UpdateMutators();
+      UpdateTerminators();
+    }
+
+    protected override void RegisterProblemEvents() {
+      base.RegisterProblemEvents();
+      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
+      if (maximizationParameter != null) maximizationParameter.ValueChanged += new EventHandler(MaximizationParameter_ValueChanged);
+    }
+    protected override void DeregisterProblemEvents() {
+      var maximizationParameter = (IValueParameter<BoolValue>)Problem.MaximizationParameter;
+      if (maximizationParameter != null) maximizationParameter.ValueChanged -= new EventHandler(MaximizationParameter_ValueChanged);
+      base.DeregisterProblemEvents();
+    }
+
+    protected override void Problem_SolutionCreatorChanged(object sender, EventArgs e) {
+      base.Problem_SolutionCreatorChanged(sender, e);
+      ParameterizeStochasticOperator(Problem.SolutionCreator);
+      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
+
+      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+
+      ParameterizeSolutionsCreator();
+      ParameterizeAnalyzers();
+    }
+    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
+      base.Problem_EvaluatorChanged(sender, e);
+      foreach (var @operator in Problem.Operators.OfType<IOperator>())
+        ParameterizeStochasticOperator(@operator);
+
+      UpdateAnalyzers();
+
+      ParameterizeSolutionsCreator();
+      ParameterizeMainLoop();
+      ParameterizeSelectors();
+    }
+    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
+      base.Problem_OperatorsChanged(sender, e);
+      ParameterizeIterationBasedOperators();
+      UpdateCrossovers();
+      UpdateMutators();
+      UpdateTerminators();
+    }
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      ParameterizeMainLoop();
+      ParameterizeAnalyzers();
+      ParameterizeSelectors();
+    }
+    private void MaximizationParameter_ValueChanged(object sender, EventArgs e) {
+      ParameterizeTerminators();
+    }
+    private void QualityAnalyzer_CurrentBestQualityParameter_NameChanged(object sender, EventArgs e) {
+      ParameterizeTerminators();
+    }
+
+    private void AgeGap_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeLimits();
+    }
+    private void AgingScheme_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeLimits();
+    }
+    private void NumberOfLayers_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeLimits();
+    }
+
+    private void AnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
+      foreach (var analyzer in e.Items) {
+        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
+          parameter.Depth = 2;
+        }
+      }
+    }
+    private void LayerAnalyzerOperators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IAnalyzer>> e) {
+      foreach (var analyzer in e.Items) {
+        IParameter resultParameter;
+        if (analyzer.Value.Parameters.TryGetValue("Results", out resultParameter)) {
+          var lookupParameter = resultParameter as ILookupParameter;
+          if (lookupParameter != null)
+            lookupParameter.ActualName = "LayerResults";
+        }
+        foreach (var parameter in analyzer.Value.Parameters.OfType<IScopeTreeLookupParameter>()) {
+          parameter.Depth = 1;
+        }
+      }
+    }
+    #endregion
+
+    #region Parameterization
+    private void Initialize() {
+      if (Problem != null)
+        Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
+
+      NumberOfLayersParameter.Value.ValueChanged += NumberOfLayers_ValueChanged;
+
+      Analyzer.Operators.ItemsAdded += AnalyzerOperators_ItemsAdded;
+      LayerAnalyzer.Operators.ItemsAdded += LayerAnalyzerOperators_ItemsAdded;
+
+      AgeGapParameter.Value.ValueChanged += AgeGap_ValueChanged;
+      AgingSchemeParameter.Value.ValueChanged += AgingScheme_ValueChanged;
+
+      qualityAnalyzer.CurrentBestQualityParameter.NameChanged += QualityAnalyzer_CurrentBestQualityParameter_NameChanged;
+    }
+    private void ParameterizeSolutionsCreator() {
+      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
+    }
+    private void ParameterizeMainLoop() {
+      MainLoop.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      MainLoop.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+      MainLoop.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+    }
+    private void ParameterizeAnalyzers() {
+      qualityAnalyzer.ResultsParameter.ActualName = "Results";
+      qualityAnalyzer.ResultsParameter.Hidden = true;
+      qualityAnalyzer.QualityParameter.Depth = 2;
+      layerQualityAnalyzer.ResultsParameter.ActualName = "LayerResults";
+      layerQualityAnalyzer.ResultsParameter.Hidden = true;
+      layerQualityAnalyzer.QualityParameter.Depth = 1;
+      selectionPressureAnalyzer.Name = "SelectionPressure Analyzer";
+      selectionPressureAnalyzer.ResultsParameter.ActualName = "Results";
+      selectionPressureAnalyzer.ValueParameter.ActualName = "SelectionPressure";
+      selectionPressureAnalyzer.ValueParameter.Depth = 1;
+      selectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
+      layerSelectionPressureAnalyzer.Name = "SelectionPressure Analyzer";
+      layerSelectionPressureAnalyzer.ResultsParameter.ActualName = "LayerResults";
+      layerSelectionPressureAnalyzer.ValueParameter.ActualName = "SelectionPressure";
+      layerSelectionPressureAnalyzer.ValueParameter.Depth = 0;
+      layerSelectionPressureAnalyzer.ValuesParameter.ActualName = "Selection Pressure History";
+      currentSuccessRatioAnalyzer.Name = "CurrentSuccessRatio Analyzer";
+      currentSuccessRatioAnalyzer.ResultsParameter.ActualName = "Results";
+      currentSuccessRatioAnalyzer.ValueParameter.ActualName = "CurrentSuccessRatio";
+      currentSuccessRatioAnalyzer.ValueParameter.Depth = 1;
+      currentSuccessRatioAnalyzer.ValuesParameter.ActualName = "Success Ratio History";
+      if (Problem != null) {
+        qualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        qualityAnalyzer.MaximizationParameter.Hidden = true;
+        qualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        qualityAnalyzer.QualityParameter.Hidden = true;
+        qualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+        qualityAnalyzer.BestKnownQualityParameter.Hidden = true;
+        layerQualityAnalyzer.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+        layerQualityAnalyzer.MaximizationParameter.Hidden = true;
+        layerQualityAnalyzer.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+        layerQualityAnalyzer.QualityParameter.Hidden = true;
+        layerQualityAnalyzer.BestKnownQualityParameter.ActualName = Problem.BestKnownQualityParameter.Name;
+        layerQualityAnalyzer.BestKnownQualityParameter.Hidden = true;
+      }
+    }
+    private void ParameterizeSelectors() {
+      foreach (var selector in SelectorParameter.ValidValues) {
+        selector.CopySelected = new BoolValue(true);
+        selector.NumberOfSelectedSubScopesParameter.Hidden = true;
+        selector.NumberOfSelectedSubScopesParameter.ActualName = SelectedParentsParameter.Name;
+        ParameterizeStochasticOperatorForLayer(selector);
+      }
+      if (Problem != null) {
+        foreach (var selector in SelectorParameter.ValidValues.OfType<ISingleObjectiveSelector>()) {
+          selector.MaximizationParameter.ActualName = Problem.MaximizationParameter.Name;
+          selector.MaximizationParameter.Hidden = true;
+          selector.QualityParameter.ActualName = Problem.Evaluator.QualityParameter.ActualName;
+          selector.QualityParameter.Hidden = true;
+        }
+      }
+    }
+    private void ParameterizeTerminators() {
+      qualityTerminator.Parameterize(qualityAnalyzer.CurrentBestQualityParameter, Problem);
+    }
+    private void ParameterizeIterationBasedOperators() {
+      if (Problem != null) {
+        foreach (var @operator in Problem.Operators.OfType<IIterationBasedOperator>()) {
+          @operator.IterationsParameter.ActualName = "Generations";
+          @operator.IterationsParameter.Hidden = true;
+          @operator.MaximumIterationsParameter.ActualName = generationsTerminator.ThresholdParameter.Name;
+          @operator.MaximumIterationsParameter.Hidden = true;
+        }
+      }
+    }
+    private void ParameterizeAgeLimits() {
+      AgeLimits = AgingScheme.CalculateAgeLimits(AgeGap, NumberOfLayers);
+    }
+
+    private void ParameterizeStochasticOperator(IOperator @operator) {
+      var stochasticOperator = @operator as IStochasticOperator;
+      if (stochasticOperator != null) {
+        stochasticOperator.RandomParameter.ActualName = "GlobalRandom";
+        stochasticOperator.RandomParameter.Hidden = true;
+      }
+    }
+
+    private void ParameterizeStochasticOperatorForLayer(IOperator @operator) {
+      var stochasticOperator = @operator as IStochasticOperator;
+      if (stochasticOperator != null) {
+        stochasticOperator.RandomParameter.ActualName = "LocalRandom";
+        stochasticOperator.RandomParameter.Hidden = true;
+      }
+    }
+
+    #endregion
+
+    #region Updates
+    private void UpdateAnalyzers() {
+      Analyzer.Operators.Clear();
+      LayerAnalyzer.Operators.Clear();
+
+      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(ageAnalyzer, ageAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(ageDistributionAnalyzer, ageDistributionAnalyzer.EnabledByDefault);
+      Analyzer.Operators.Add(selectionPressureAnalyzer, false);
+      selectionPressureAnalyzer.ValueParameter.Depth = 1; // Adding analyzer sets depth to 2
+      Analyzer.Operators.Add(currentSuccessRatioAnalyzer, false);
+      currentSuccessRatioAnalyzer.ValueParameter.Depth = 1; // Adding analyzer sets depth to 2
+      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, false);
+      LayerAnalyzer.Operators.Add(layerAgeAnalyzer, false);
+      LayerAnalyzer.Operators.Add(layerAgeDistributionAnalyzer, false);
+      LayerAnalyzer.Operators.Add(layerSelectionPressureAnalyzer, false);
+      layerSelectionPressureAnalyzer.ValueParameter.Depth = 0; // Adding layer-analyzer sets depth to 1
+
+
+      if (Problem != null) {
+        foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
+          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
+          LayerAnalyzer.Operators.Add((IAnalyzer)analyzer.Clone(), false);
+        }
+      }
+    }
+    private void UpdateCrossovers() {
+      var oldCrossover = CrossoverParameter.Value;
+      var defaultCrossover = Problem.Operators.OfType<ICrossover>().FirstOrDefault();
+      CrossoverParameter.ValidValues.Clear();
+      foreach (var crossover in Problem.Operators.OfType<ICrossover>().OrderBy(c => c.Name)) {
+        ParameterizeStochasticOperatorForLayer(crossover);
+        CrossoverParameter.ValidValues.Add(crossover);
+      }
+      if (oldCrossover != null) {
+        var crossover = CrossoverParameter.ValidValues.FirstOrDefault(c => c.GetType() == oldCrossover.GetType());
+        if (crossover != null)
+          CrossoverParameter.Value = crossover;
+        else
+          oldCrossover = null;
+      }
+      if (oldCrossover == null && defaultCrossover != null)
+        CrossoverParameter.Value = defaultCrossover;
+    }
+    private void UpdateMutators() {
+      var oldMutator = MutatorParameter.Value;
+      MutatorParameter.ValidValues.Clear();
+      foreach (var mutator in Problem.Operators.OfType<IManipulator>().OrderBy(m => m.Name)) {
+        ParameterizeStochasticOperatorForLayer(mutator);
+        MutatorParameter.ValidValues.Add(mutator);
+      }
+      if (oldMutator != null) {
+        var mutator = MutatorParameter.ValidValues.FirstOrDefault(m => m.GetType() == oldMutator.GetType());
+        if (mutator != null)
+          MutatorParameter.Value = mutator;
+      }
+    }
+    private void UpdateTerminators() {
+      var newTerminators = new Dictionary<ITerminator, bool> {
+        {generationsTerminator, !Terminators.Operators.Contains(generationsTerminator) || Terminators.Operators.ItemChecked(generationsTerminator)},
+        {evaluationsTerminator, Terminators.Operators.Contains(evaluationsTerminator) && Terminators.Operators.ItemChecked(evaluationsTerminator)},
+        {qualityTerminator, Terminators.Operators.Contains(qualityTerminator) && Terminators.Operators.ItemChecked(qualityTerminator) },
+        {executionTimeTerminator, Terminators.Operators.Contains(executionTimeTerminator) && Terminators.Operators.ItemChecked(executionTimeTerminator)}
+      };
+      if (Problem != null) {
+        foreach (var terminator in Problem.Operators.OfType<ITerminator>())
+          newTerminators.Add(terminator, !Terminators.Operators.Contains(terminator) || Terminators.Operators.ItemChecked(terminator));
+      }
+
+      Terminators.Operators.Clear();
+
+      foreach (var newTerminator in newTerminators)
+        Terminators.Operators.Add(newTerminator.Key, newTerminator.Value);
+    }
+    #endregion
+  }
+}
Index: stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelectionGeneticAlgorithmMainLoop.cs
===================================================================
--- stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelectionGeneticAlgorithmMainLoop.cs	(revision 14173)
+++ stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelectionGeneticAlgorithmMainLoop.cs	(revision 14173)
@@ -0,0 +1,469 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Algorithms.ALPS {
+
+  [Item("AlpsOffspringSelectionGeneticAlgorithmMainLoop", "An ALPS offspring selection genetic algorithm main loop operator.")]
+  [StorableClass]
+  public sealed class AlpsOffspringSelectionGeneticAlgorithmMainLoop : AlgorithmOperator {
+    #region Parameter Properties
+    public IValueLookupParameter<IRandom> GlobalRandomParameter {
+      get { return (IValueLookupParameter<IRandom>)Parameters["GlobalRandom"]; }
+    }
+    public IValueLookupParameter<IRandom> LocalRandomParameter {
+      get { return (IValueLookupParameter<IRandom>)Parameters["LocalRandom"]; }
+    }
+
+    public IValueLookupParameter<IOperator> EvaluatorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
+    }
+    public IValueLookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+
+    public ILookupParameter<IOperator> AnalyzerParameter {
+      get { return (ILookupParameter<IOperator>)Parameters["Analyzer"]; }
+    }
+    public ILookupParameter<IOperator> LayerAnalyzerParameter {
+      get { return (ILookupParameter<IOperator>)Parameters["LayerAnalyzer"]; }
+    }
+
+    public IValueLookupParameter<IntValue> NumberOfLayersParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["NumberOfLayers"]; }
+    }
+    public IValueLookupParameter<IntValue> PopulationSizeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["PopulationSize"]; }
+    }
+    public ILookupParameter<IntValue> CurrentPopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["CurrentPopulationSize"]; }
+    }
+
+    public IValueLookupParameter<IOperator> SelectorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Selector"]; }
+    }
+    public IValueLookupParameter<IOperator> CrossoverParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Crossover"]; }
+    }
+    public IValueLookupParameter<IOperator> MutatorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Mutator"]; }
+    }
+    public IValueLookupParameter<PercentValue> MutationProbabilityParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["MutationProbability"]; }
+    }
+    public IValueLookupParameter<IntValue> ElitesParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Elites"]; }
+    }
+    public IValueLookupParameter<BoolValue> ReevaluateElitesParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["ReevaluateElites"]; }
+    }
+
+    public IValueLookupParameter<DoubleValue> SuccessRatioParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["SuccessRatio"]; }
+    }
+    public ILookupParameter<DoubleValue> ComparisonFactorParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["ComparisonFactor"]; }
+    }
+    public IValueLookupParameter<DoubleValue> MaximumSelectionPressureParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["MaximumSelectionPressure"]; }
+    }
+    public IValueLookupParameter<BoolValue> OffspringSelectionBeforeMutationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["OffspringSelectionBeforeMutation"]; }
+    }
+    public IValueLookupParameter<BoolValue> FillPopulationWithParentsParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["FillPopulationWithParents"]; }
+    }
+
+    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Age"]; }
+    }
+    public IValueLookupParameter<IntValue> AgeGapParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["AgeGap"]; }
+    }
+    public IValueLookupParameter<DoubleValue> AgeInheritanceParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["AgeInheritance"]; }
+    }
+    public IValueLookupParameter<IntArray> AgeLimitsParameter {
+      get { return (IValueLookupParameter<IntArray>)Parameters["AgeLimits"]; }
+    }
+
+    public IValueLookupParameter<IntValue> MatingPoolRangeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MatingPoolRange"]; }
+    }
+    public IValueLookupParameter<BoolValue> ReduceToPopulationSizeParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["ReduceToPopulationSize"]; }
+    }
+
+    public IValueLookupParameter<IOperator> TerminatorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Terminator"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private AlpsOffspringSelectionGeneticAlgorithmMainLoop(bool deserializing)
+      : base(deserializing) { }
+    private AlpsOffspringSelectionGeneticAlgorithmMainLoop(AlpsOffspringSelectionGeneticAlgorithmMainLoop original, Cloner cloner)
+      : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AlpsOffspringSelectionGeneticAlgorithmMainLoop(this, cloner);
+    }
+    public AlpsOffspringSelectionGeneticAlgorithmMainLoop()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IRandom>("GlobalRandom", "A pseudo random number generator."));
+      Parameters.Add(new ValueLookupParameter<IRandom>("LocalRandom", "A pseudo random number generator."));
+
+      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("EvaluatedSolutions", "The number of times solutions have been evaluated."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+
+      Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze all individuals from all layers combined."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("LayerAnalyzer", "The operator used to analyze each layer."));
+
+      Parameters.Add(new ValueLookupParameter<IntValue>("NumberOfLayers", "The number of layers."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions in each layer."));
+      Parameters.Add(new LookupParameter<IntValue>("CurrentPopulationSize", "The current size of the population."));
+
+      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."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
+
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
+
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The age of individuals."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("AgeGap", "The frequency of reseeding the lowest layer and scaling factor for the age-limits for the layers."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent."));
+      Parameters.Add(new ValueLookupParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer."));
+
+      Parameters.Add(new ValueLookupParameter<IntValue>("MatingPoolRange", "The range of sub - populations used for creating a mating pool. (1 = current + previous sub-population)"));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize"));
+
+      Parameters.Add(new ValueLookupParameter<IOperator>("Terminator", "The termination criteria that defines if the algorithm should continue or stop"));
+
+
+      var variableCreator = new VariableCreator() { Name = "Initialize" };
+      var initLayerAnalyzerProcessor = new SubScopesProcessor();
+      var layerVariableCreator = new VariableCreator() { Name = "Initialize Layer" };
+      var initLayerAnalyzerPlaceholder = new Placeholder() { Name = "LayerAnalyzer (Placeholder)" };
+      var layerResultCollector = new ResultsCollector() { Name = "Collect layer results" };
+      var initAnalyzerPlaceholder = new Placeholder() { Name = "Analyzer (Placeholder)" };
+      var resultsCollector = new ResultsCollector();
+      var matingPoolCreator = new MatingPoolCreator() { Name = "Create Mating Pools" };
+      var matingPoolProcessor = new UniformSubScopesProcessor() { Name = "Process Mating Pools" };
+      var initializeLayer = new Assigner() { Name = "Reset LayerEvaluatedSolutions" };
+      var mainOperator = new AlpsOffspringSelectionGeneticAlgorithmMainOperator();
+      var generationsIcrementor = new IntCounter() { Name = "Increment Generations" };
+      var evaluatedSolutionsReducer = new DataReducer() { Name = "Increment EvaluatedSolutions" };
+      var eldersEmigrator = CreateEldersEmigrator();
+      var layerOpener = CreateLayerOpener();
+      var layerReseeder = CreateReseeder();
+      var layerAnalyzerProcessor = new UniformSubScopesProcessor();
+      var layerAnalyzerPlaceholder = new Placeholder() { Name = "LayerAnalyzer (Placeholder)" };
+      var analyzerPlaceholder = new Placeholder() { Name = "Analyzer (Placeholder)" };
+      var termination = new TerminationOperator();
+
+      OperatorGraph.InitialOperator = variableCreator;
+
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Generations", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OpenLayers", new IntValue(1)));
+      variableCreator.Successor = initLayerAnalyzerProcessor;
+
+      initLayerAnalyzerProcessor.Operators.Add(layerVariableCreator);
+      initLayerAnalyzerProcessor.Successor = initAnalyzerPlaceholder;
+
+      layerVariableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Layer", new IntValue(0)));
+      layerVariableCreator.CollectedValues.Add(new ValueParameter<ResultCollection>("LayerResults"));
+      layerVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("SelectionPressure", new DoubleValue(0)));
+      layerVariableCreator.CollectedValues.Add(new ValueParameter<DoubleValue>("CurrentSuccessRatio", new DoubleValue(0)));
+      layerVariableCreator.Successor = initLayerAnalyzerPlaceholder;
+
+      initLayerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
+      initLayerAnalyzerPlaceholder.Successor = layerResultCollector;
+
+      layerResultCollector.ResultsParameter.ActualName = "LayerResults";
+      layerResultCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Selection Pressure", "Displays the rising selection pressure during a generation.", "SelectionPressure"));
+      layerResultCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Success Ratio", "Indicates how many successful children were already found during a generation (relative to the population size).", "CurrentSuccessRatio"));
+      layerResultCollector.Successor = null;
+
+      initAnalyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
+      initAnalyzerPlaceholder.Successor = resultsCollector;
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      resultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("LayerResults", "Result set for each Layer", "LayerResults"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("OpenLayers"));
+      resultsCollector.CopyValue = new BoolValue(false);
+      resultsCollector.Successor = matingPoolCreator;
+
+      matingPoolCreator.MatingPoolRangeParameter.Value = null;
+      matingPoolCreator.MatingPoolRangeParameter.ActualName = MatingPoolRangeParameter.Name;
+      matingPoolCreator.Successor = matingPoolProcessor;
+
+      matingPoolProcessor.Parallel.Value = true;
+      matingPoolProcessor.Operator = initializeLayer;
+      matingPoolProcessor.Successor = generationsIcrementor;
+
+      initializeLayer.LeftSideParameter.ActualName = "LayerEvaluatedSolutions";
+      initializeLayer.RightSideParameter.Value = new IntValue(0);
+      initializeLayer.Successor = mainOperator;
+
+      mainOperator.RandomParameter.ActualName = LocalRandomParameter.Name;
+      mainOperator.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
+      mainOperator.EvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
+      mainOperator.QualityParameter.ActualName = QualityParameter.Name;
+      mainOperator.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      mainOperator.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+      mainOperator.SelectorParameter.ActualName = SelectorParameter.Name;
+      mainOperator.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      mainOperator.MutatorParameter.ActualName = MutatorParameter.ActualName;
+      mainOperator.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      mainOperator.ElitesParameter.ActualName = ElitesParameter.Name;
+      mainOperator.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
+      mainOperator.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      mainOperator.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
+      mainOperator.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
+      mainOperator.SelectionPressureParameter.ActualName = "SelectionPressure";
+      mainOperator.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
+      mainOperator.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
+      mainOperator.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
+      mainOperator.AgeParameter.ActualName = AgeParameter.Name;
+      mainOperator.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
+      mainOperator.AgeIncrementParameter.Value = new DoubleValue(1.0);
+      mainOperator.Successor = null;
+
+      generationsIcrementor.ValueParameter.ActualName = "Generations";
+      generationsIcrementor.Increment = new IntValue(1);
+      generationsIcrementor.Successor = evaluatedSolutionsReducer;
+
+      evaluatedSolutionsReducer.ParameterToReduce.ActualName = "LayerEvaluatedSolutions";
+      evaluatedSolutionsReducer.TargetParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      evaluatedSolutionsReducer.ReductionOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      evaluatedSolutionsReducer.TargetOperation.Value = new ReductionOperation(ReductionOperations.Sum);
+      evaluatedSolutionsReducer.Successor = eldersEmigrator;
+
+      eldersEmigrator.Successor = layerOpener;
+
+      layerOpener.Successor = layerReseeder;
+
+      layerReseeder.Successor = layerAnalyzerProcessor;
+
+      layerAnalyzerProcessor.Operator = layerAnalyzerPlaceholder;
+      layerAnalyzerProcessor.Successor = analyzerPlaceholder;
+
+      layerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
+
+      analyzerPlaceholder.OperatorParameter.ActualName = AnalyzerParameter.Name;
+      analyzerPlaceholder.Successor = termination;
+
+      termination.TerminatorParameter.ActualName = TerminatorParameter.Name;
+      termination.ContinueBranch = matingPoolCreator;
+    }
+
+    private CombinedOperator CreateEldersEmigrator() {
+      var eldersEmigrator = new CombinedOperator() { Name = "Emigrate Elders" };
+      var selectorProsessor = new UniformSubScopesProcessor();
+      var eldersSelector = new EldersSelector();
+      var shiftToRightMigrator = new UnidirectionalRingMigrator() { Name = "Shift elders to next layer" };
+      var mergingProsessor = new UniformSubScopesProcessor();
+      var mergingReducer = new MergingReducer();
+      var subScopesCounter = new SubScopesCounter();
+      var reduceToPopulationSizeBranch = new ConditionalBranch() { Name = "ReduceToPopulationSize?" };
+      var countCalculator = new ExpressionCalculator() { Name = "CurrentPopulationSize = Min(CurrentPopulationSize, PopulationSize)" };
+      var bestSelector = new BestSelector();
+      var rightReducer = new RightReducer();
+
+      eldersEmigrator.OperatorGraph.InitialOperator = selectorProsessor;
+
+      selectorProsessor.Operator = eldersSelector;
+      selectorProsessor.Successor = shiftToRightMigrator;
+
+      eldersSelector.AgeParameter.ActualName = AgeParameter.Name;
+      eldersSelector.AgeLimitsParameter.ActualName = AgeLimitsParameter.Name;
+      eldersSelector.NumberOfLayersParameter.ActualName = NumberOfLayersParameter.Name;
+      eldersSelector.LayerParameter.ActualName = "Layer";
+      eldersSelector.Successor = null;
+
+      shiftToRightMigrator.ClockwiseMigrationParameter.Value = new BoolValue(true);
+      shiftToRightMigrator.Successor = mergingProsessor;
+
+      mergingProsessor.Operator = mergingReducer;
+
+      mergingReducer.Successor = subScopesCounter;
+
+      subScopesCounter.ValueParameter.ActualName = CurrentPopulationSizeParameter.Name;
+      subScopesCounter.AccumulateParameter.Value = new BoolValue(false);
+      subScopesCounter.Successor = reduceToPopulationSizeBranch;
+
+      reduceToPopulationSizeBranch.ConditionParameter.ActualName = ReduceToPopulationSizeParameter.Name;
+      reduceToPopulationSizeBranch.TrueBranch = countCalculator;
+
+      countCalculator.CollectedValues.Add(new LookupParameter<IntValue>(PopulationSizeParameter.Name));
+      countCalculator.CollectedValues.Add(new LookupParameter<IntValue>(CurrentPopulationSizeParameter.Name));
+      countCalculator.ExpressionParameter.Value = new StringValue("CurrentPopulationSize PopulationSize CurrentPopulationSize PopulationSize < if toint");
+      countCalculator.ExpressionResultParameter.ActualName = CurrentPopulationSizeParameter.Name;
+      countCalculator.Successor = bestSelector;
+
+      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = CurrentPopulationSizeParameter.Name;
+      bestSelector.CopySelected = new BoolValue(false);
+      bestSelector.Successor = rightReducer;
+
+      return eldersEmigrator;
+    }
+
+    private CombinedOperator CreateLayerOpener() {
+      var layerOpener = new CombinedOperator() { Name = "Open new Layer if needed" };
+      var maxLayerReached = new Comparator() { Name = "MaxLayersReached = OpenLayers >= NumberOfLayers" };
+      var maxLayerReachedBranch = new ConditionalBranch() { Name = "MaxLayersReached?" };
+      var openNewLayerCalculator = new ExpressionCalculator() { Name = "OpenNewLayer = Generations >= AgeLimits[OpenLayers - 1]" };
+      var openNewLayerBranch = new ConditionalBranch() { Name = "OpenNewLayer?" };
+      var layerCreator = new LastLayerCloner() { Name = "Create Layer" };
+      var updateLayerNumber = new Assigner() { Name = "Layer = OpenLayers" };
+      var historyWiper = new ResultsHistoryWiper() { Name = "Clear History in Results" };
+      var createChildrenViaCrossover = new AlpsOffspringSelectionGeneticAlgorithmMainOperator();
+      var incrEvaluatedSolutionsForNewLayer = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
+      var incrOpenLayers = new IntCounter() { Name = "Incr. OpenLayers" };
+      var newLayerResultsCollector = new ResultsCollector() { Name = "Collect new Layer Results" };
+
+      layerOpener.OperatorGraph.InitialOperator = maxLayerReached;
+
+      maxLayerReached.LeftSideParameter.ActualName = "OpenLayers";
+      maxLayerReached.RightSideParameter.ActualName = NumberOfLayersParameter.Name;
+      maxLayerReached.ResultParameter.ActualName = "MaxLayerReached";
+      maxLayerReached.Comparison = new Comparison(ComparisonType.GreaterOrEqual);
+      maxLayerReached.Successor = maxLayerReachedBranch;
+
+      maxLayerReachedBranch.ConditionParameter.ActualName = "MaxLayerReached";
+      maxLayerReachedBranch.FalseBranch = openNewLayerCalculator;
+
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntArray>(AgeLimitsParameter.Name));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("Generations"));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>(NumberOfLayersParameter.Name));
+      openNewLayerCalculator.CollectedValues.Add(new LookupParameter<IntValue>("OpenLayers"));
+      openNewLayerCalculator.ExpressionResultParameter.ActualName = "OpenNewLayer";
+      openNewLayerCalculator.ExpressionParameter.Value = new StringValue("Generations 1 + AgeLimits OpenLayers 1 - [] >");
+      openNewLayerCalculator.Successor = openNewLayerBranch;
+
+      openNewLayerBranch.ConditionParameter.ActualName = "OpenNewLayer";
+      openNewLayerBranch.TrueBranch = layerCreator;
+
+      layerCreator.NewLayerOperator = updateLayerNumber;
+      layerCreator.Successor = incrOpenLayers;
+
+      updateLayerNumber.LeftSideParameter.ActualName = "Layer";
+      updateLayerNumber.RightSideParameter.ActualName = "OpenLayers";
+      updateLayerNumber.Successor = historyWiper;
+
+      historyWiper.ResultsParameter.ActualName = "LayerResults";
+      historyWiper.Successor = createChildrenViaCrossover;
+
+      // Maybe use only crossover and no elitism instead of "default operator"
+      createChildrenViaCrossover.RandomParameter.ActualName = LocalRandomParameter.Name;
+      createChildrenViaCrossover.EvaluatorParameter.ActualName = EvaluatorParameter.Name;
+      createChildrenViaCrossover.EvaluatedSolutionsParameter.ActualName = "LayerEvaluatedSolutions";
+      createChildrenViaCrossover.QualityParameter.ActualName = QualityParameter.Name;
+      createChildrenViaCrossover.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      createChildrenViaCrossover.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+      createChildrenViaCrossover.SelectorParameter.ActualName = SelectorParameter.Name;
+      createChildrenViaCrossover.CrossoverParameter.ActualName = CrossoverParameter.Name;
+      createChildrenViaCrossover.MutatorParameter.ActualName = MutatorParameter.ActualName;
+      createChildrenViaCrossover.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      createChildrenViaCrossover.ElitesParameter.ActualName = ElitesParameter.Name;
+      createChildrenViaCrossover.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
+      createChildrenViaCrossover.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      createChildrenViaCrossover.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
+      createChildrenViaCrossover.CurrentSuccessRatioParameter.ActualName = "CurrentSuccessRatio";
+      createChildrenViaCrossover.SelectionPressureParameter.ActualName = "SelectionPressure";
+      createChildrenViaCrossover.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
+      createChildrenViaCrossover.OffspringSelectionBeforeMutationParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
+      createChildrenViaCrossover.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
+      createChildrenViaCrossover.AgeParameter.ActualName = AgeParameter.Name;
+      createChildrenViaCrossover.AgeInheritanceParameter.ActualName = AgeInheritanceParameter.Name;
+      createChildrenViaCrossover.AgeIncrementParameter.Value = new DoubleValue(0.0);
+      createChildrenViaCrossover.Successor = incrEvaluatedSolutionsForNewLayer;
+
+      incrEvaluatedSolutionsForNewLayer.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      incrEvaluatedSolutionsForNewLayer.AccumulateParameter.Value = new BoolValue(true);
+
+      incrOpenLayers.ValueParameter.ActualName = "OpenLayers";
+      incrOpenLayers.Increment = new IntValue(1);
+      incrOpenLayers.Successor = newLayerResultsCollector;
+
+      newLayerResultsCollector.CollectedValues.Add(new ScopeTreeLookupParameter<ResultCollection>("LayerResults", "Result set for each layer", "LayerResults"));
+      newLayerResultsCollector.CopyValue = new BoolValue(false);
+      newLayerResultsCollector.Successor = null;
+
+      return layerOpener;
+    }
+
+    private CombinedOperator CreateReseeder() {
+      var reseeder = new CombinedOperator() { Name = "Reseed Layer Zero if needed" };
+      var reseedingController = new ReseedingController() { Name = "Reseeding needed (Generation % AgeGap == 0)?" };
+      var removeIndividuals = new SubScopesRemover();
+      var createIndividuals = new SolutionsCreator();
+      var initializeAgeProsessor = new UniformSubScopesProcessor();
+      var initializeAge = new VariableCreator() { Name = "Initialize Age" };
+      var incrEvaluatedSolutionsAfterReseeding = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
+
+      reseeder.OperatorGraph.InitialOperator = reseedingController;
+
+      reseedingController.GenerationsParameter.ActualName = "Generations";
+      reseedingController.AgeGapParameter.ActualName = AgeGapParameter.Name;
+      reseedingController.FirstLayerOperator = removeIndividuals;
+      reseedingController.Successor = null;
+
+      removeIndividuals.Successor = createIndividuals;
+
+      createIndividuals.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
+      createIndividuals.Successor = initializeAgeProsessor;
+
+      initializeAgeProsessor.Operator = initializeAge;
+      initializeAgeProsessor.Successor = incrEvaluatedSolutionsAfterReseeding;
+
+      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>(AgeParameter.Name, new DoubleValue(0)));
+
+      incrEvaluatedSolutionsAfterReseeding.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      incrEvaluatedSolutionsAfterReseeding.AccumulateParameter.Value = new BoolValue(true);
+
+      return reseeder;
+    }
+  }
+}
Index: stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelectionGeneticAlgorithmMainOperator.cs
===================================================================
--- stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelectionGeneticAlgorithmMainOperator.cs	(revision 14173)
+++ stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelectionGeneticAlgorithmMainOperator.cs	(revision 14173)
@@ -0,0 +1,409 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  /// <summary>
+  /// An operator which represents the main loop of an offspring selection genetic algorithm.
+  /// </summary>
+  [Item("AlpsOffspringSelectionGeneticAlgorithmMainOperator", "An operator that represents the core of an alps offspring selection genetic algorithm.")]
+  [StorableClass]
+  public sealed class AlpsOffspringSelectionGeneticAlgorithmMainOperator : AlgorithmOperator {
+    #region Parameter properties
+    public IValueLookupParameter<IRandom> RandomParameter {
+      get { return (IValueLookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public IValueLookupParameter<IOperator> EvaluatorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Evaluator"]; }
+    }
+    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
+    public IScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    public IValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+
+    public ILookupParameter<IntValue> PopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["PopulationSize"]; }
+    }
+
+    public IValueLookupParameter<IOperator> SelectorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Selector"]; }
+    }
+    public IValueLookupParameter<IOperator> CrossoverParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Crossover"]; }
+    }
+    public IValueLookupParameter<IOperator> MutatorParameter {
+      get { return (IValueLookupParameter<IOperator>)Parameters["Mutator"]; }
+    }
+    public IValueLookupParameter<PercentValue> MutationProbabilityParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["MutationProbability"]; }
+    }
+    public IValueLookupParameter<IntValue> ElitesParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Elites"]; }
+    }
+    public IValueLookupParameter<BoolValue> ReevaluateElitesParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["ReevaluateElites"]; }
+    }
+
+    public ILookupParameter<DoubleValue> ComparisonFactorParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["ComparisonFactor"]; }
+    }
+    public ILookupParameter<DoubleValue> CurrentSuccessRatioParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["CurrentSuccessRatio"]; }
+    }
+    public IValueLookupParameter<DoubleValue> SuccessRatioParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["SuccessRatio"]; }
+    }
+    public ILookupParameter<DoubleValue> SelectionPressureParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["SelectionPressure"]; }
+    }
+    public IValueLookupParameter<DoubleValue> MaximumSelectionPressureParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["MaximumSelectionPressure"]; }
+    }
+    public IValueLookupParameter<BoolValue> OffspringSelectionBeforeMutationParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["OffspringSelectionBeforeMutation"]; }
+    }
+    public IValueLookupParameter<BoolValue> FillPopulationWithParentsParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["FillPopulationWithParents"]; }
+    }
+
+    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Age"]; }
+    }
+    public IValueLookupParameter<DoubleValue> AgeInheritanceParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["AgeInheritance"]; }
+    }
+    public IValueLookupParameter<DoubleValue> AgeIncrementParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["AgeIncrement"]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private AlpsOffspringSelectionGeneticAlgorithmMainOperator(bool deserializing) : base(deserializing) { }
+    private AlpsOffspringSelectionGeneticAlgorithmMainOperator(AlpsOffspringSelectionGeneticAlgorithmMainOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AlpsOffspringSelectionGeneticAlgorithmMainOperator(this, cloner);
+    }
+    public AlpsOffspringSelectionGeneticAlgorithmMainOperator()
+      : base() {
+      Initialize();
+    }
+
+    private void Initialize() {
+      Parameters.Add(new ValueLookupParameter<IRandom>("Random", "A pseudo random number generator."));
+
+      Parameters.Add(new ValueLookupParameter<IOperator>("Evaluator", "The operator used to evaluate solutions. This operator is executed in parallel, if an engine is used which supports parallelization."));
+      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The number of evaluated solutions."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The value which represents the quality of a solution."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "True if the problem is a maximization problem, otherwise false."));
+
+      Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions in each layer."));
+      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."));
+      Parameters.Add(new ValueLookupParameter<IOperator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new ValueLookupParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Elites", "The numer of elite solutions which are kept in each generation."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("ReevaluateElites", "Flag to determine if elite individuals should be reevaluated (i.e., if stochastic fitness functions are used.)"));
+
+      Parameters.Add(new LookupParameter<DoubleValue>("ComparisonFactor", "The comparison factor is used to determine whether the offspring should be compared to the better parent, the worse parent or a quality value linearly interpolated between them. It is in the range [0;1]."));
+      Parameters.Add(new LookupParameter<DoubleValue>("CurrentSuccessRatio", "The current success ratio."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful to total children that should be achieved."));
+      Parameters.Add(new LookupParameter<DoubleValue>("SelectionPressure", "The actual selection pressure."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure that terminates the algorithm."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("OffspringSelectionBeforeMutation", "True if the offspring selection step should be applied before mutation, false if it should be applied after mutation."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
+
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The age of individuals."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("AgeInheritance", "A weight that determines the age of a child after crossover based on the older (1.0) and younger (0.0) parent."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("AgeIncrement", "The value the age the individuals is incremented if they survives a generation."));
+
+
+      var selector = new Placeholder();
+      var subScopesProcessor1 = new SubScopesProcessor();
+      var childrenCreator = new ChildrenCreator();
+      var osBeforeMutationBranch = new ConditionalBranch();
+      var uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
+      var crossover1 = new Placeholder();
+      var uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
+      var evaluator1 = new Placeholder();
+      var subScopesCounter1 = new SubScopesCounter();
+      var qualityComparer1 = new WeightedParentsQualityComparator();
+      var ageCalculator1 = new WeightingReducer() { Name = "Calculate Age" };
+      var subScopesRemover1 = new SubScopesRemover();
+      var uniformSubScopesProcessor3 = new UniformSubScopesProcessor();
+      var mutationBranch1 = new StochasticBranch();
+      var mutator1 = new Placeholder();
+      var variableCreator1 = new VariableCreator();
+      var variableCreator2 = new VariableCreator();
+      var conditionalSelector = new ConditionalSelector();
+      var subScopesProcessor2 = new SubScopesProcessor();
+      var uniformSubScopesProcessor4 = new UniformSubScopesProcessor();
+      var evaluator2 = new Placeholder();
+      var subScopesCounter2 = new SubScopesCounter();
+      var mergingReducer1 = new MergingReducer();
+      var uniformSubScopesProcessor5 = new UniformSubScopesProcessor();
+      var crossover2 = new Placeholder();
+      var mutationBranch2 = new StochasticBranch();
+      var mutator2 = new Placeholder();
+      var uniformSubScopesProcessor6 = new UniformSubScopesProcessor();
+      var evaluator3 = new Placeholder();
+      var subScopesCounter3 = new SubScopesCounter();
+      var qualityComparer2 = new WeightedParentsQualityComparator();
+      var ageCalculator2 = new WeightingReducer() { Name = "Calculate Age" };
+      var subScopesRemover2 = new SubScopesRemover();
+      var offspringSelector = new AlpsOffspringSelector();
+      var subScopesProcessor3 = new SubScopesProcessor();
+      var bestSelector = new BestSelector();
+      var worstSelector = new WorstSelector();
+      var rightReducer = new RightReducer();
+      var leftReducer = new LeftReducer();
+      var mergingReducer2 = new MergingReducer();
+      var reevaluateElitesBranch = new ConditionalBranch();
+      var uniformSubScopesProcessor7 = new UniformSubScopesProcessor();
+      var evaluator4 = new Placeholder();
+      var subScopesCounter4 = new SubScopesCounter();
+      var incrementAgeProcessor = new UniformSubScopesProcessor();
+      var ageIncrementor = new DoubleCounter() { Name = "Increment Age" };
+
+
+      OperatorGraph.InitialOperator = selector;
+
+      selector.Name = "Selector (placeholder)";
+      selector.OperatorParameter.ActualName = SelectorParameter.Name;
+      selector.Successor = subScopesProcessor1;
+
+      subScopesProcessor1.Operators.Add(new EmptyOperator());
+      subScopesProcessor1.Operators.Add(childrenCreator);
+      subScopesProcessor1.Successor = offspringSelector;
+
+      childrenCreator.ParentsPerChild = new IntValue(2);
+      childrenCreator.Successor = osBeforeMutationBranch;
+
+      osBeforeMutationBranch.Name = "Apply OS before mutation?";
+      osBeforeMutationBranch.ConditionParameter.ActualName = OffspringSelectionBeforeMutationParameter.Name;
+      osBeforeMutationBranch.TrueBranch = uniformSubScopesProcessor1;
+      osBeforeMutationBranch.FalseBranch = uniformSubScopesProcessor5;
+      osBeforeMutationBranch.Successor = null;
+
+      uniformSubScopesProcessor1.Operator = crossover1;
+      uniformSubScopesProcessor1.Successor = uniformSubScopesProcessor2;
+
+      crossover1.Name = "Crossover (placeholder)";
+      crossover1.OperatorParameter.ActualName = CrossoverParameter.Name;
+      crossover1.Successor = null;
+
+      uniformSubScopesProcessor2.Parallel.Value = true;
+      uniformSubScopesProcessor2.Operator = evaluator1;
+      uniformSubScopesProcessor2.Successor = subScopesCounter1;
+
+      evaluator1.Name = "Evaluator (placeholder)";
+      evaluator1.OperatorParameter.ActualName = EvaluatorParameter.Name;
+      evaluator1.Successor = qualityComparer1;
+
+      subScopesCounter1.Name = "Increment EvaluatedSolutions";
+      subScopesCounter1.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      subScopesCounter1.Successor = uniformSubScopesProcessor3;
+
+      uniformSubScopesProcessor3.Operator = mutationBranch1;
+      uniformSubScopesProcessor3.Successor = conditionalSelector;
+
+      qualityComparer1.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      qualityComparer1.LeftSideParameter.ActualName = QualityParameter.Name;
+      qualityComparer1.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      qualityComparer1.RightSideParameter.ActualName = QualityParameter.Name;
+      qualityComparer1.ResultParameter.ActualName = "SuccessfulOffspring";
+      qualityComparer1.Successor = ageCalculator1;
+
+      ageCalculator1.ParameterToReduce.ActualName = AgeParameter.Name;
+      ageCalculator1.TargetParameter.ActualName = AgeParameter.Name;
+      ageCalculator1.WeightParameter.ActualName = AgeInheritanceParameter.Name;
+      ageCalculator1.Successor = subScopesRemover1;
+
+      subScopesRemover1.RemoveAllSubScopes = true;
+      subScopesRemover1.Successor = null;
+
+      mutationBranch1.ProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      mutationBranch1.RandomParameter.ActualName = RandomParameter.Name;
+      mutationBranch1.FirstBranch = mutator1;
+      mutationBranch1.SecondBranch = variableCreator2;
+      mutationBranch1.Successor = null;
+
+      mutator1.Name = "Mutator (placeholder)";
+      mutator1.OperatorParameter.ActualName = MutatorParameter.Name;
+      mutator1.Successor = variableCreator1;
+
+      variableCreator1.Name = "MutatedOffspring = true";
+      variableCreator1.CollectedValues.Add(new ValueParameter<BoolValue>("MutatedOffspring", null, new BoolValue(true), false));
+      variableCreator1.Successor = null;
+
+      variableCreator2.Name = "MutatedOffspring = false";
+      variableCreator2.CollectedValues.Add(new ValueParameter<BoolValue>("MutatedOffspring", null, new BoolValue(false), false));
+      variableCreator2.Successor = null;
+
+      conditionalSelector.ConditionParameter.ActualName = "MutatedOffspring";
+      conditionalSelector.ConditionParameter.Depth = 1;
+      conditionalSelector.CopySelected.Value = false;
+      conditionalSelector.Successor = subScopesProcessor2;
+
+      subScopesProcessor2.Operators.Add(new EmptyOperator());
+      subScopesProcessor2.Operators.Add(uniformSubScopesProcessor4);
+      subScopesProcessor2.Successor = mergingReducer1;
+
+      mergingReducer1.Successor = null;
+
+      uniformSubScopesProcessor4.Parallel.Value = true;
+      uniformSubScopesProcessor4.Operator = evaluator2;
+      uniformSubScopesProcessor4.Successor = subScopesCounter2;
+
+      evaluator2.Name = "Evaluator (placeholder)";
+      evaluator2.OperatorParameter.ActualName = EvaluatorParameter.Name;
+      evaluator2.Successor = null;
+
+      subScopesCounter2.Name = "Increment EvaluatedSolutions";
+      subScopesCounter2.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      subScopesCounter2.Successor = null;
+
+      uniformSubScopesProcessor5.Operator = crossover2;
+      uniformSubScopesProcessor5.Successor = uniformSubScopesProcessor6;
+
+      crossover2.Name = "Crossover (placeholder)";
+      crossover2.OperatorParameter.ActualName = CrossoverParameter.Name;
+      crossover2.Successor = mutationBranch2;
+
+      mutationBranch2.ProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      mutationBranch2.RandomParameter.ActualName = RandomParameter.Name;
+      mutationBranch2.FirstBranch = mutator2;
+      mutationBranch2.SecondBranch = null;
+      mutationBranch2.Successor = null;
+
+      mutator2.Name = "Mutator (placeholder)";
+      mutator2.OperatorParameter.ActualName = MutatorParameter.Name;
+      mutator2.Successor = null;
+
+      uniformSubScopesProcessor6.Parallel.Value = true;
+      uniformSubScopesProcessor6.Operator = evaluator3;
+      uniformSubScopesProcessor6.Successor = subScopesCounter3;
+
+      evaluator3.Name = "Evaluator (placeholder)";
+      evaluator3.OperatorParameter.ActualName = EvaluatorParameter.Name;
+      evaluator3.Successor = qualityComparer2;
+
+      subScopesCounter3.Name = "Increment EvaluatedSolutions";
+      subScopesCounter3.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+
+      qualityComparer2.ComparisonFactorParameter.ActualName = ComparisonFactorParameter.Name;
+      qualityComparer2.LeftSideParameter.ActualName = QualityParameter.Name;
+      qualityComparer2.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      qualityComparer2.RightSideParameter.ActualName = QualityParameter.Name;
+      qualityComparer2.ResultParameter.ActualName = "SuccessfulOffspring";
+      qualityComparer2.Successor = ageCalculator2;
+
+      ageCalculator2.ParameterToReduce.ActualName = AgeParameter.Name;
+      ageCalculator2.TargetParameter.ActualName = AgeParameter.Name;
+      ageCalculator2.WeightParameter.ActualName = AgeInheritanceParameter.Name;
+      ageCalculator2.Successor = subScopesRemover2;
+
+      subScopesRemover2.RemoveAllSubScopes = true;
+      subScopesRemover2.Successor = null;
+
+      subScopesCounter3.Successor = null;
+
+      offspringSelector.CurrentSuccessRatioParameter.ActualName = CurrentSuccessRatioParameter.Name;
+      offspringSelector.MaximumSelectionPressureParameter.ActualName = MaximumSelectionPressureParameter.Name;
+      offspringSelector.SelectionPressureParameter.ActualName = SelectionPressureParameter.Name;
+      offspringSelector.SuccessRatioParameter.ActualName = SuccessRatioParameter.Name;
+      offspringSelector.OffspringPopulationParameter.ActualName = "OffspringPopulation";
+      offspringSelector.OffspringPopulationWinnersParameter.ActualName = "OffspringPopulationWinners";
+      offspringSelector.SuccessfulOffspringParameter.ActualName = "SuccessfulOffspring";
+      offspringSelector.FillPopulationWithParentsParameter.ActualName = FillPopulationWithParentsParameter.Name;
+      offspringSelector.PopulationSizeParameter.ActualName = PopulationSizeParameter.Name;
+      offspringSelector.OffspringCreator = selector;
+      offspringSelector.Successor = subScopesProcessor3;
+
+      subScopesProcessor3.Operators.Add(bestSelector);
+      subScopesProcessor3.Operators.Add(worstSelector);
+      subScopesProcessor3.Successor = mergingReducer2;
+
+      bestSelector.CopySelected = new BoolValue(false);
+      bestSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      bestSelector.NumberOfSelectedSubScopesParameter.ActualName = ElitesParameter.Name;
+      bestSelector.QualityParameter.ActualName = QualityParameter.Name;
+      bestSelector.Successor = rightReducer;
+
+      rightReducer.Successor = reevaluateElitesBranch;
+
+      reevaluateElitesBranch.ConditionParameter.ActualName = "ReevaluateElites";
+      reevaluateElitesBranch.Name = "Reevaluate elites ?";
+      reevaluateElitesBranch.TrueBranch = uniformSubScopesProcessor7;
+      reevaluateElitesBranch.FalseBranch = null;
+      reevaluateElitesBranch.Successor = null;
+
+      uniformSubScopesProcessor7.Parallel.Value = true;
+      uniformSubScopesProcessor7.Operator = evaluator4;
+      uniformSubScopesProcessor7.Successor = subScopesCounter4;
+
+      evaluator4.Name = "Evaluator (placeholder)";
+      evaluator4.OperatorParameter.ActualName = EvaluatorParameter.Name;
+
+      subScopesCounter4.Name = "Increment EvaluatedSolutions";
+      subScopesCounter4.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      subScopesCounter4.Successor = null;
+
+      worstSelector.CopySelected = new BoolValue(false);
+      worstSelector.MaximizationParameter.ActualName = MaximizationParameter.Name;
+      worstSelector.NumberOfSelectedSubScopesParameter.ActualName = ElitesParameter.Name;
+      worstSelector.QualityParameter.ActualName = QualityParameter.Name;
+      worstSelector.Successor = leftReducer;
+
+      leftReducer.Successor = null;
+
+      mergingReducer2.Successor = incrementAgeProcessor;
+
+      incrementAgeProcessor.Operator = ageIncrementor;
+      incrementAgeProcessor.Successor = null;
+
+      ageIncrementor.ValueParameter.ActualName = AgeParameter.Name;
+      ageIncrementor.IncrementParameter.Value = null;
+      ageIncrementor.IncrementParameter.ActualName = AgeIncrementParameter.Name;
+      ageIncrementor.Successor = null;
+    }
+
+    public override IOperation Apply() {
+      if (CrossoverParameter.ActualValue == null)
+        return null;
+      return base.Apply();
+    }
+  }
+}
Index: stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelector.cs
===================================================================
--- stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelector.cs	(revision 14173)
+++ stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsOffspringSelector.cs	(revision 14173)
@@ -0,0 +1,192 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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 HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  [Item("AlpsOffspringSelector", "Selects among the offspring population those that are designated successful and discards the unsuccessful offspring, except for some lucky losers. It expects the parent scopes to be below the first sub-scope, and offspring scopes to be below the second sub-scope separated again in two sub-scopes, the first with the failed offspring and the second with successful offspring.")]
+  [StorableClass]
+  public class AlpsOffspringSelector : SingleSuccessorOperator {
+    public IValueLookupParameter<DoubleValue> MaximumSelectionPressureParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["MaximumSelectionPressure"]; }
+    }
+    public IValueLookupParameter<DoubleValue> SuccessRatioParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["SuccessRatio"]; }
+    }
+    public ILookupParameter<DoubleValue> SelectionPressureParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["SelectionPressure"]; }
+    }
+    public ILookupParameter<DoubleValue> CurrentSuccessRatioParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["CurrentSuccessRatio"]; }
+    }
+    public ILookupParameter<ItemList<IScope>> OffspringPopulationParameter {
+      get { return (ILookupParameter<ItemList<IScope>>)Parameters["OffspringPopulation"]; }
+    }
+    public ILookupParameter<IntValue> OffspringPopulationWinnersParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["OffspringPopulationWinners"]; }
+    }
+    public IScopeTreeLookupParameter<BoolValue> SuccessfulOffspringParameter {
+      get { return (IScopeTreeLookupParameter<BoolValue>)Parameters["SuccessfulOffspring"]; }
+    }
+    public OperatorParameter OffspringCreatorParameter {
+      get { return (OperatorParameter)Parameters["OffspringCreator"]; }
+    }
+    public IValueLookupParameter<BoolValue> FillPopulationWithParentsParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["FillPopulationWithParents"]; }
+    }
+    public ILookupParameter<IntValue> PopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["PopulationSize"]; }
+    }
+
+    public IOperator OffspringCreator {
+      get { return OffspringCreatorParameter.Value; }
+      set { OffspringCreatorParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected AlpsOffspringSelector(bool deserializing) : base(deserializing) { }
+    protected AlpsOffspringSelector(AlpsOffspringSelector original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AlpsOffspringSelector(this, cloner);
+    }
+    public AlpsOffspringSelector()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("MaximumSelectionPressure", "The maximum selection pressure which prematurely terminates the offspring selection step."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("SuccessRatio", "The ratio of successful offspring that has to be produced."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("SelectionPressure", "The amount of selection pressure currently necessary to fulfill the success ratio."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentSuccessRatio", "The current success ratio indicates how much of the successful offspring have already been generated."));
+      Parameters.Add(new LookupParameter<ItemList<IScope>>("OffspringPopulation", "Temporary store of the offspring population."));
+      Parameters.Add(new LookupParameter<IntValue>("OffspringPopulationWinners", "Temporary store the number of successful offspring in the offspring population."));
+      Parameters.Add(new ScopeTreeLookupParameter<BoolValue>("SuccessfulOffspring", "True if the offspring was more successful than its parents.", 2));
+      Parameters.Add(new OperatorParameter("OffspringCreator", "The operator used to create new offspring."));
+      Parameters.Add(new ValueLookupParameter<BoolValue>("FillPopulationWithParents", "True if the population should be filled with parent individual or false if worse children should be used when the maximum selection pressure is exceeded."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("PopulationSize", "The size of the population of solutions in each layer."));
+    }
+
+    public override IOperation Apply() {
+      double maxSelPress = MaximumSelectionPressureParameter.ActualValue.Value;
+      double successRatio = SuccessRatioParameter.ActualValue.Value;
+      bool fillPopulationWithParents = false;
+      if (FillPopulationWithParentsParameter.ActualValue != null)
+        fillPopulationWithParents = FillPopulationWithParentsParameter.ActualValue.Value;
+      IScope scope = ExecutionContext.Scope;
+      IScope parents = scope.SubScopes[0];
+      IScope offspring = scope.SubScopes[1];
+      int populationSize = PopulationSizeParameter.ActualValue.Value;
+
+      // retrieve actual selection pressure and success ratio
+      DoubleValue selectionPressure = SelectionPressureParameter.ActualValue;
+      if (selectionPressure == null) {
+        selectionPressure = new DoubleValue(0);
+        SelectionPressureParameter.ActualValue = selectionPressure;
+      }
+      DoubleValue currentSuccessRatio = CurrentSuccessRatioParameter.ActualValue;
+      if (currentSuccessRatio == null) {
+        currentSuccessRatio = new DoubleValue(0);
+        CurrentSuccessRatioParameter.ActualValue = currentSuccessRatio;
+      }
+
+      // retrieve next population
+      ItemList<IScope> population = OffspringPopulationParameter.ActualValue;
+      IntValue successfulOffspring;
+      if (population == null) {
+        population = new ItemList<IScope>();
+        OffspringPopulationParameter.ActualValue = population;
+        selectionPressure.Value = 0; // initialize selection pressure for this round
+        currentSuccessRatio.Value = 0; // initialize current success ratio for this round
+        successfulOffspring = new IntValue(0);
+        OffspringPopulationWinnersParameter.ActualValue = successfulOffspring;
+      } else successfulOffspring = OffspringPopulationWinnersParameter.ActualValue;
+
+      int worseOffspringNeeded = (int)((1 - successRatio) * populationSize) - (population.Count - successfulOffspring.Value);
+      int successfulOffspringAdded = 0;
+
+      // implement the ActualValue fetch here - otherwise the parent scope would also be included, given that there may be 1000 or more parents, this is quite unnecessary
+      string tname = SuccessfulOffspringParameter.TranslatedName;
+      double tmpSelPress = selectionPressure.Value, tmpSelPressInc = 1.0 / populationSize;
+      for (int i = 0; i < offspring.SubScopes.Count; i++) {
+        // fetch value
+        IVariable tmpVar;
+        if (!offspring.SubScopes[i].Variables.TryGetValue(tname, out tmpVar)) throw new InvalidOperationException(Name + ": Could not determine if an offspring was successful or not.");
+        BoolValue tmp = (tmpVar.Value as BoolValue);
+        if (tmp == null) throw new InvalidOperationException(Name + ": The variable that indicates whether an offspring is successful or not must contain a BoolValue.");
+
+        // add to population
+        if (tmp.Value) {
+          IScope currentOffspring = offspring.SubScopes[i];
+          offspring.SubScopes.Remove(currentOffspring);
+          i--;
+          population.Add(currentOffspring);
+          successfulOffspringAdded++;
+        } else if (worseOffspringNeeded > 0 || tmpSelPress >= maxSelPress) {
+          IScope currentOffspring;
+          if (!fillPopulationWithParents || worseOffspringNeeded > 0) {
+            currentOffspring = offspring.SubScopes[i];
+            offspring.SubScopes.Remove(currentOffspring);
+            i--;
+            worseOffspringNeeded--;
+          } else {
+            currentOffspring = parents.SubScopes[i];
+          }
+          population.Add(currentOffspring);
+        }
+        tmpSelPress += tmpSelPressInc;
+        if (population.Count == populationSize) break;
+      }
+      successfulOffspring.Value += successfulOffspringAdded;
+
+      // calculate actual selection pressure and success ratio
+      selectionPressure.Value = tmpSelPress;
+      currentSuccessRatio.Value = successfulOffspring.Value / ((double)populationSize);
+
+      // check if enough children have been generated
+      if (((selectionPressure.Value < maxSelPress) && (currentSuccessRatio.Value < successRatio)) ||
+          (population.Count < populationSize)) {
+        // more children required -> reduce left and start children generation again
+        scope.SubScopes.Remove(parents);
+        scope.SubScopes.Remove(offspring);
+        while (parents.SubScopes.Count > 0) {
+          IScope parent = parents.SubScopes[0];
+          parents.SubScopes.RemoveAt(0);
+          scope.SubScopes.Add(parent);
+        }
+
+        IOperator moreOffspring = OffspringCreatorParameter.ActualValue as IOperator;
+        if (moreOffspring == null) throw new InvalidOperationException(Name + ": More offspring are required, but no operator specified for creating them.");
+        return ExecutionContext.CreateOperation(moreOffspring);
+      } else {
+        // enough children generated
+        offspring.SubScopes.Clear();
+        offspring.SubScopes.AddRange(population);
+
+        scope.Variables.Remove(OffspringPopulationParameter.TranslatedName);
+        scope.Variables.Remove(OffspringPopulationWinnersParameter.TranslatedName);
+        return base.Apply();
+      }
+    }
+  }
+}
Index: stable/HeuristicLab.Algorithms.ALPS/3.3/HeuristicLab.Algorithms.ALPS-3.3.csproj
===================================================================
--- stable/HeuristicLab.Algorithms.ALPS/3.3/HeuristicLab.Algorithms.ALPS-3.3.csproj	(revision 14172)
+++ stable/HeuristicLab.Algorithms.ALPS/3.3/HeuristicLab.Algorithms.ALPS-3.3.csproj	(revision 14173)
@@ -85,5 +85,9 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="AlpsOffspringSelectionGeneticAlgorithmMainLoop.cs" />
+    <Compile Include="AlpsOffspringSelectionGeneticAlgorithm.cs" />
     <Compile Include="AlpsGeneticAlgorithmMainOperator.cs" />
+    <Compile Include="AlpsOffspringSelectionGeneticAlgorithmMainOperator.cs" />
+    <Compile Include="AlpsOffspringSelector.cs" />
     <Compile Include="ReseedingController.cs" />
     <Compile Include="ResultsHistoryWiper.cs" />
