Index: /stable/HeuristicLab 3.3.sln
===================================================================
--- /stable/HeuristicLab 3.3.sln	(revision 13284)
+++ /stable/HeuristicLab 3.3.sln	(revision 13285)
@@ -26,4 +26,5 @@
 		{662B4B15-8F4D-4AE5-B3EB-D91C215F5AF2} = {662B4B15-8F4D-4AE5-B3EB-D91C215F5AF2}
 		{E2419315-B10A-4BC1-B517-A24DCF4C59AC} = {E2419315-B10A-4BC1-B517-A24DCF4C59AC}
+		{9372D115-D933-40D2-BD29-A2C1EAC35874} = {9372D115-D933-40D2-BD29-A2C1EAC35874}
 		{B7FA451C-26BF-4EE5-8E0E-BECAADA5B8E9} = {B7FA451C-26BF-4EE5-8E0E-BECAADA5B8E9}
 		{E226881D-315F-423D-B419-A766FE0D8685} = {E226881D-315F-423D-B419-A766FE0D8685}
@@ -93,4 +94,5 @@
 		{5B9B9E8C-2706-43C2-80B8-A08341E431F7} = {5B9B9E8C-2706-43C2-80B8-A08341E431F7}
 		{997F018D-AEA2-4F21-9301-82FAF6A5612D} = {997F018D-AEA2-4F21-9301-82FAF6A5612D}
+		{26349C8D-72A1-4BAE-95A3-14E96A3B4AE8} = {26349C8D-72A1-4BAE-95A3-14E96A3B4AE8}
 		{D767C38D-8014-46B0-9A32-03A3AECCE34A} = {D767C38D-8014-46B0-9A32-03A3AECCE34A}
 		{B1BA398F-953F-4C3A-B07B-1E5E17A27DD9} = {B1BA398F-953F-4C3A-B07B-1E5E17A27DD9}
@@ -128,4 +130,5 @@
 		{79271BC8-4446-40E2-BB89-9BE4E17174FE} = {79271BC8-4446-40E2-BB89-9BE4E17174FE}
 		{BBF2CCC8-4D87-4297-8E18-8241FF93F966} = {BBF2CCC8-4D87-4297-8E18-8241FF93F966}
+		{59F354CB-FE13-4253-AED2-AD86372BEC27} = {59F354CB-FE13-4253-AED2-AD86372BEC27}
 		{D1EFA4CC-909F-41D5-9C1F-C3AF1957A372} = {D1EFA4CC-909F-41D5-9C1F-C3AF1957A372}
 		{7A2531CE-3F7C-4F13-BCCA-ED6DC27A7086} = {7A2531CE-3F7C-4F13-BCCA-ED6DC27A7086}
@@ -143,4 +146,5 @@
 		{FC627BE5-0F93-47D8-BD2E-530EA2B8AA5F} = {FC627BE5-0F93-47D8-BD2E-530EA2B8AA5F}
 		{C3AD50E6-E717-490E-ABC7-32EF7FB03C97} = {C3AD50E6-E717-490E-ABC7-32EF7FB03C97}
+		{1D41EAE6-CC79-41D4-858C-589C4DB5E50D} = {1D41EAE6-CC79-41D4-858C-589C4DB5E50D}
 		{C9CF6AE8-4637-4A75-9141-042F479B5D50} = {C9CF6AE8-4637-4A75-9141-042F479B5D50}
 		{BF1E4DF4-A4CC-451F-9D50-303F405E265E} = {BF1E4DF4-A4CC-451F-9D50-303F405E265E}
@@ -148,4 +152,5 @@
 		{494F87F4-0F25-4D33-A382-10CDB2174D48} = {494F87F4-0F25-4D33-A382-10CDB2174D48}
 		{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937} = {BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}
+		{02CDDBF5-42A7-4C40-AE6C-E5D29AC9CCEC} = {02CDDBF5-42A7-4C40-AE6C-E5D29AC9CCEC}
 		{6AE0E1F5-D3FF-43A3-90E1-2435E7493FB5} = {6AE0E1F5-D3FF-43A3-90E1-2435E7493FB5}
 		{EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9} = {EE07BFF8-B23D-41F5-8AD7-AC9598D7A2C9}
@@ -437,4 +442,6 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.GeneticProgramming.Views-3.3", "HeuristicLab.Problems.GeneticProgramming.Views\3.3\HeuristicLab.Problems.GeneticProgramming.Views-3.3.csproj", "{26349C8D-72A1-4BAE-95A3-14E96A3B4AE8}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.ALPS-3.3", "HeuristicLab.Algorithms.ALPS\3.3\HeuristicLab.Algorithms.ALPS-3.3.csproj", "{59F354CB-FE13-4253-AED2-AD86372BEC27}"
 EndProject
 Global
@@ -2140,4 +2147,16 @@
 		{26349C8D-72A1-4BAE-95A3-14E96A3B4AE8}.Release|x86.ActiveCfg = Release|x86
 		{26349C8D-72A1-4BAE-95A3-14E96A3B4AE8}.Release|x86.Build.0 = Release|x86
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Debug|x64.ActiveCfg = Debug|x64
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Debug|x64.Build.0 = Debug|x64
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Debug|x86.ActiveCfg = Debug|x86
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Debug|x86.Build.0 = Debug|x86
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Release|Any CPU.Build.0 = Release|Any CPU
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Release|x64.ActiveCfg = Release|x64
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Release|x64.Build.0 = Release|x64
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Release|x86.ActiveCfg = Release|x86
+		{59F354CB-FE13-4253-AED2-AD86372BEC27}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
@@ -2145,4 +2164,5 @@
 	EndGlobalSection
 	GlobalSection(NestedProjects) = preSolution
+		{0C67A033-F6D9-4237-B3CA-C033A44706BE} = {D1B1DE45-F9C7-4FBF-B73C-E759BC4223D5}
 		{3083C7AA-5AF4-4C75-BA19-B69B86E2F66A} = {D1B1DE45-F9C7-4FBF-B73C-E759BC4223D5}
 		{9A04599C-D608-4240-8DA6-D41F51C515A3} = {D1B1DE45-F9C7-4FBF-B73C-E759BC4223D5}
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/AgingScheme.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/AgingScheme.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/AgingScheme.cs	(revision 13285)
@@ -0,0 +1,80 @@
+﻿#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.Data;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  /// <summary>
+  /// Defines the growth of age limits for the layers.
+  /// </summary>
+  public enum AgingScheme {
+    Linear,
+    Fibonacci,
+    Polynomial,
+    Exponential
+  }
+
+  /// <summary>
+  /// Helper for calculating the age limits for a AgingScheme and a given AgeGap.
+  /// </summary>
+  public static class AgingSchemeCalculator {
+    public static IntArray CalculateAgeLimits(this AgingScheme scheme, int ageGap, int numberOfLayers) {
+      IEnumerable<int> schemeGenerator;
+      switch (scheme) {
+        case AgingScheme.Linear: schemeGenerator = LinearAgingScheme(); break;
+        case AgingScheme.Fibonacci: schemeGenerator = FibonacciAgingScheme(); break;
+        case AgingScheme.Polynomial: schemeGenerator = PolynomialAgingScheme(2); break;
+        case AgingScheme.Exponential: schemeGenerator = ExponentialAgingScheme(2); break;
+        default: throw new NotSupportedException("Aging Scheme " + scheme + " is not supported.");
+      }
+
+      return new IntArray(schemeGenerator.Select(a => a * ageGap).Take(numberOfLayers).ToArray());
+    }
+
+    #region Scheme definitions
+    // 1 2 3 4 5 6 7 ...
+    private static IEnumerable<int> LinearAgingScheme() {
+      for (int i = 0; ; i++)
+        yield return i + 1;
+    }
+    // 1 2 3 5 8 13 21 ...
+    private static IEnumerable<int> FibonacciAgingScheme() {
+      for (int i = 1, next = 2, temp; ; temp = next, next = i + next, i = temp)
+        yield return i;
+    }
+    // (n^2): 1 2 4 9 16 25 36 ...
+    private static IEnumerable<int> PolynomialAgingScheme(double exp) {
+      yield return 1;
+      yield return 2;
+      for (int i = 2; ; i++)
+        yield return (int)Math.Pow(i, exp);
+    }
+    // 1 2 4 8 16 32 64 ...
+    private static IEnumerable<int> ExponentialAgingScheme(double @base) {
+      for (int i = 0; ; i++)
+        yield return (int)Math.Pow(@base, i);
+    }
+    #endregion
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs	(revision 13285)
@@ -0,0 +1,720 @@
+﻿#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 Genetic Algorithm", "A genetic algorithm within an age-layered population structure as described in Gregory S. Hornby. 2006. ALPS: the age-layered population structure for reducing the problem of premature convergence. In Proceedings of the 8th annual conference on Genetic and evolutionary computation (GECCO '06). 815-822.")]
+  [Creatable(CreatableAttribute.Categories.PopulationBasedAlgorithms, Priority = 160)]
+  [StorableClass]
+  public sealed class AlpsGeneticAlgorithm : 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 IValueParameter<IntValue> SeedParameter {
+      get { return (IValueParameter<IntValue>)Parameters["Seed"]; }
+    }
+    private IValueParameter<BoolValue> SetSeedRandomlyParameter {
+      get { return (IValueParameter<BoolValue>)Parameters["SetSeedRandomly"]; }
+    }
+
+    private IFixedValueParameter<MultiAnalyzer> AnalyzerParameter {
+      get { return (IFixedValueParameter<MultiAnalyzer>)Parameters["Analyzer"]; }
+    }
+    private IFixedValueParameter<MultiAnalyzer> LayerAnalyzerParameter {
+      get { return (IFixedValueParameter<MultiAnalyzer>)Parameters["LayerAnalyzer"]; }
+    }
+
+    private IValueParameter<IntValue> NumberOfLayersParameter {
+      get { return (IValueParameter<IntValue>)Parameters["NumberOfLayers"]; }
+    }
+    private IValueParameter<IntValue> PopulationSizeParameter {
+      get { return (IValueParameter<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 IValueParameter<PercentValue> MutationProbabilityParameter {
+      get { return (IValueParameter<PercentValue>)Parameters["MutationProbability"]; }
+    }
+    private IValueParameter<IntValue> ElitesParameter {
+      get { return (IValueParameter<IntValue>)Parameters["Elites"]; }
+    }
+    private IFixedValueParameter<BoolValue> ReevaluateElitesParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters["ReevaluateElites"]; }
+    }
+    private IValueParameter<BoolValue> PlusSelectionParameter {
+      get { return (IValueParameter<BoolValue>)Parameters["PlusSelection"]; }
+    }
+
+    private IValueParameter<EnumValue<AgingScheme>> AgingSchemeParameter {
+      get { return (IValueParameter<EnumValue<AgingScheme>>)Parameters["AgingScheme"]; }
+    }
+    private IValueParameter<IntValue> AgeGapParameter {
+      get { return (IValueParameter<IntValue>)Parameters["AgeGap"]; }
+    }
+    private IValueParameter<DoubleValue> AgeInheritanceParameter {
+      get { return (IValueParameter<DoubleValue>)Parameters["AgeInheritance"]; }
+    }
+    private IValueParameter<IntArray> AgeLimitsParameter {
+      get { return (IValueParameter<IntArray>)Parameters["AgeLimits"]; }
+    }
+
+    private IValueParameter<IntValue> MatingPoolRangeParameter {
+      get { return (IValueParameter<IntValue>)Parameters["MatingPoolRange"]; }
+    }
+    private IValueParameter<BoolValue> ReduceToPopulationSizeParameter {
+      get { return (IValueParameter<BoolValue>)Parameters["ReduceToPopulationSize"]; }
+    }
+
+    private IValueParameter<MultiTerminator> TerminatorParameter {
+      get { return (IValueParameter<MultiTerminator>)Parameters["Terminator"]; }
+    }
+    #endregion
+
+    #region Properties
+    public IntValue Seed {
+      get { return SeedParameter.Value; }
+      set { SeedParameter.Value = value; }
+    }
+    public BoolValue SetSeedRandomly {
+      get { return SetSeedRandomlyParameter.Value; }
+      set { SetSeedRandomlyParameter.Value = value; }
+    }
+
+    public MultiAnalyzer Analyzer {
+      get { return AnalyzerParameter.Value; }
+    }
+    public MultiAnalyzer LayerAnalyzer {
+      get { return LayerAnalyzerParameter.Value; }
+    }
+
+    public IntValue NumberOfLayers {
+      get { return NumberOfLayersParameter.Value; }
+      set { NumberOfLayersParameter.Value = value; }
+    }
+    public IntValue PopulationSize {
+      get { return PopulationSizeParameter.Value; }
+      set { PopulationSizeParameter.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 PercentValue MutationProbability {
+      get { return MutationProbabilityParameter.Value; }
+      set { MutationProbabilityParameter.Value = value; }
+    }
+    public IntValue Elites {
+      get { return ElitesParameter.Value; }
+      set { ElitesParameter.Value = value; }
+    }
+    public bool ReevaluteElites {
+      get { return ReevaluateElitesParameter.Value.Value; }
+      set { ReevaluateElitesParameter.Value.Value = value; }
+    }
+    public bool PlusSelection {
+      get { return PlusSelectionParameter.Value.Value; }
+      set { PlusSelectionParameter.Value.Value = value; }
+    }
+
+    public EnumValue<AgingScheme> AgingScheme {
+      get { return AgingSchemeParameter.Value; }
+      set { AgingSchemeParameter.Value = value; }
+    }
+    public IntValue AgeGap {
+      get { return AgeGapParameter.Value; }
+      set { AgeGapParameter.Value = value; }
+    }
+    public DoubleValue AgeInheritance {
+      get { return AgeInheritanceParameter.Value; }
+      set { AgeInheritanceParameter.Value = value; }
+    }
+    public IntArray AgeLimits {
+      get { return AgeLimitsParameter.Value; }
+      set { AgeLimitsParameter.Value = value; }
+    }
+
+    public IntValue MatingPoolRange {
+      get { return MatingPoolRangeParameter.Value; }
+      set { MatingPoolRangeParameter.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 AlpsGeneticAlgorithmMainLoop MainLoop {
+      get { return OperatorGraph.Iterate().OfType<AlpsGeneticAlgorithmMainLoop>().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;
+    #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 AlpsGeneticAlgorithm(bool deserializing)
+      : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+    private AlpsGeneticAlgorithm(AlpsGeneticAlgorithm 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);
+      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 AlpsGeneticAlgorithm(this, cloner);
+    }
+    public AlpsGeneticAlgorithm()
+      : base() {
+      #region Add parameters
+      Parameters.Add(new ValueParameter<IntValue>("Seed", "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
+      Parameters.Add(new ValueParameter<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 ValueParameter<IntValue>("NumberOfLayers", "The number of layers.", new IntValue(10)));
+      Parameters.Add(new ValueParameter<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 ValueParameter<PercentValue>("MutationProbability", "The probability that the mutation operator is applied on a solution.", new PercentValue(0.05)));
+      Parameters.Add(new ValueParameter<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 ValueParameter<BoolValue>("PlusSelection", "Include the parents in the selection of the invividuals for the next generation.", new BoolValue(false)));
+
+      Parameters.Add(new ValueParameter<EnumValue<AgingScheme>>("AgingScheme", "The aging scheme for setting the age-limits for the layers.", new EnumValue<AgingScheme>(ALPS.AgingScheme.Polynomial)));
+      Parameters.Add(new ValueParameter<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 ValueParameter<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 ValueParameter<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 ValueParameter<IntValue>("MatingPoolRange", "The range of layers used for creating a mating pool. (1 = current + previous layer)", new IntValue(1)) { Hidden = true });
+      Parameters.Add(new ValueParameter<BoolValue>("ReduceToPopulationSize", "Reduce the CurrentPopulationSize after elder migration to PopulationSize", new BoolValue(true)) { Hidden = true });
+
+      Parameters.Add(new ValueParameter<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 AlpsGeneticAlgorithmMainLoop();
+      #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.PlusSelectionParameter.ActualName = PlusSelectionParameter.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 selectors
+      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();
+      #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 AgeGapParameter_ValueChanged(object sender, EventArgs e) {
+      AgeGap.ValueChanged += AgeGap_ValueChanged;
+      ParameterizeAgeLimits();
+    }
+    private void AgeGap_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeLimits();
+    }
+    private void AgingSchemeParameter_ValueChanged(object sender, EventArgs e) {
+      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
+      ParameterizeAgeLimits();
+    }
+    private void AgingScheme_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeLimits();
+    }
+    private void NumberOfLayersParameter_ValueChanged(object sender, EventArgs e) {
+      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
+      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.ValueChanged += NumberOfLayersParameter_ValueChanged;
+      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
+
+      Analyzer.Operators.ItemsAdded += AnalyzerOperators_ItemsAdded;
+      LayerAnalyzer.Operators.ItemsAdded += LayerAnalyzerOperators_ItemsAdded;
+
+      AgeGapParameter.ValueChanged += AgeGapParameter_ValueChanged;
+      AgeGap.ValueChanged += AgeGap_ValueChanged;
+      AgingSchemeParameter.ValueChanged += AgingSchemeParameter_ValueChanged;
+      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
+
+      qualityAnalyzer.CurrentBestQualityParameter.NameChanged += new EventHandler(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;
+      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;
+        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() {
+      var scheme = AgingScheme.Value;
+      int ageGap = AgeGap.Value;
+      int numberOfLayers = NumberOfLayers.Value;
+      AgeLimits = scheme.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);
+      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, false);
+      LayerAnalyzer.Operators.Add(layerAgeAnalyzer, false);
+      LayerAnalyzer.Operators.Add(layerAgeDistributionAnalyzer, false);
+
+      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/AlpsGeneticAlgorithmMainLoop.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainLoop.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainLoop.cs	(revision 13285)
@@ -0,0 +1,431 @@
+﻿#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("AlpsGeneticAlgorithmMainLoop", "An ALPS genetic algorithm main loop operator.")]
+  [StorableClass]
+  public sealed class AlpsGeneticAlgorithmMainLoop : 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<BoolValue> PlusSelectionParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["PlusSelection"]; }
+    }
+
+    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 AlpsGeneticAlgorithmMainLoop(bool deserializing)
+      : base(deserializing) { }
+    private AlpsGeneticAlgorithmMainLoop(AlpsGeneticAlgorithmMainLoop original, Cloner cloner)
+      : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AlpsGeneticAlgorithmMainLoop(this, cloner);
+    }
+    public AlpsGeneticAlgorithmMainLoop()
+      : 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<BoolValue>("PlusSelection", "Include the parents in the selection of the invividuals for the next generation."));
+
+      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 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 AlpsGeneticAlgorithmMainOperator();
+      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.Successor = initLayerAnalyzerPlaceholder;
+
+      initLayerAnalyzerPlaceholder.OperatorParameter.ActualName = LayerAnalyzerParameter.Name;
+      initLayerAnalyzerPlaceholder.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.PlusSelectionParameter.ActualName = PlusSelectionParameter.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 AlpsGeneticAlgorithmMainOperator();
+      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.Name;
+      createChildrenViaCrossover.MutationProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      createChildrenViaCrossover.ElitesParameter.ActualName = ElitesParameter.Name;
+      createChildrenViaCrossover.ReevaluateElitesParameter.ActualName = ReevaluateElitesParameter.Name;
+      createChildrenViaCrossover.PlusSelectionParameter.ActualName = PlusSelectionParameter.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/AlpsGeneticAlgorithmMainOperator.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainOperator.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainOperator.cs	(revision 13285)
@@ -0,0 +1,240 @@
+﻿#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 {
+  [Item("AlpsGeneticAlgorithmMainOperator", "An operator that represents the core of an ALPS genetic algorithm.")]
+  [StorableClass]
+  public sealed class AlpsGeneticAlgorithmMainOperator : 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 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 IValueLookupParameter<IntValue> PopulationSizeParameter {
+      get { return (IValueLookupParameter<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 IValueLookupParameter<BoolValue> PlusSelectionParameter {
+      get { return (IValueLookupParameter<BoolValue>)Parameters["PlusSelection"]; }
+    }
+
+    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 AlpsGeneticAlgorithmMainOperator(bool deserializing) : base(deserializing) { }
+    private AlpsGeneticAlgorithmMainOperator(AlpsGeneticAlgorithmMainOperator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AlpsGeneticAlgorithmMainOperator(this, cloner);
+    }
+    public AlpsGeneticAlgorithmMainOperator()
+      : base() {
+      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 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<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 ValueLookupParameter<BoolValue>("PlusSelection", "Include the parents in the selection of the invividuals for the next generation."));
+
+      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 numberOfSelectedParentsCalculator = new ExpressionCalculator() { Name = "NumberOfSelectedParents = 2 * (PopulationSize - (PlusSelection ? 0 : Elites))" };
+      var selector = new Placeholder() { Name = "Selector (Placeholder)" };
+      var subScopesProcessor1 = new SubScopesProcessor();
+      var childrenCreator = new ChildrenCreator();
+      var uniformSubScopesProcessor1 = new UniformSubScopesProcessor();
+      var crossover = new Placeholder() { Name = "Crossover (Placeholder)" };
+      var stochasticBranch = new StochasticBranch() { Name = "MutationProbability" };
+      var mutator = new Placeholder() { Name = "Mutator (Placeholder)" };
+      var ageCalculator = new WeightingReducer() { Name = "Calculate Age" };
+      var subScopesRemover = new SubScopesRemover();
+      var uniformSubScopesProcessor2 = new UniformSubScopesProcessor();
+      var evaluator = new Placeholder() { Name = "Evaluator (Placeholder)" };
+      var subScopesCounter = new SubScopesCounter() { Name = "Increment EvaluatedSolutions" };
+      var replacementBranch = new ConditionalBranch() { Name = "PlusSelection?" };
+      var replacementMergingReducer = new MergingReducer();
+      var replacementBestSelector = new BestSelector();
+      var replacementRightReducer = new RightReducer();
+      var subScopesProcessor2 = new SubScopesProcessor();
+      var bestSelector = new BestSelector();
+      var rightReducer = new RightReducer();
+      var mergingReducer = new MergingReducer();
+      var reevaluateElitesBranch = new ConditionalBranch() { Name = "Reevaluate elites ?" };
+      var incrementAgeProcessor = new UniformSubScopesProcessor();
+      var ageIncrementor = new DoubleCounter() { Name = "Increment Age" };
+
+      OperatorGraph.InitialOperator = numberOfSelectedParentsCalculator;
+
+      numberOfSelectedParentsCalculator.CollectedValues.Add(new LookupParameter<IntValue>(PopulationSizeParameter.Name));
+      numberOfSelectedParentsCalculator.CollectedValues.Add(new LookupParameter<IntValue>(ElitesParameter.Name));
+      numberOfSelectedParentsCalculator.CollectedValues.Add(new LookupParameter<BoolValue>(PlusSelectionParameter.Name));
+      numberOfSelectedParentsCalculator.ExpressionResultParameter.ActualName = "NumberOfSelectedSubScopes";
+      numberOfSelectedParentsCalculator.ExpressionParameter.Value = new StringValue("PopulationSize 0 Elites PlusSelection if - 2 * toint");
+      numberOfSelectedParentsCalculator.Successor = selector;
+
+      selector.OperatorParameter.ActualName = SelectorParameter.Name;
+      selector.Successor = subScopesProcessor1;
+
+      subScopesProcessor1.Operators.Add(new EmptyOperator());
+      subScopesProcessor1.Operators.Add(childrenCreator);
+      subScopesProcessor1.Successor = replacementBranch;
+
+      childrenCreator.ParentsPerChild = new IntValue(2);
+      childrenCreator.Successor = uniformSubScopesProcessor1;
+
+      uniformSubScopesProcessor1.Operator = crossover;
+      uniformSubScopesProcessor1.Successor = uniformSubScopesProcessor2;
+
+      crossover.OperatorParameter.ActualName = CrossoverParameter.Name;
+      crossover.Successor = stochasticBranch;
+
+      stochasticBranch.ProbabilityParameter.ActualName = MutationProbabilityParameter.Name;
+      stochasticBranch.RandomParameter.ActualName = RandomParameter.Name;
+      stochasticBranch.FirstBranch = mutator;
+      stochasticBranch.SecondBranch = null;
+      stochasticBranch.Successor = ageCalculator;
+
+      mutator.OperatorParameter.ActualName = MutatorParameter.Name;
+      mutator.Successor = null;
+
+      ageCalculator.ParameterToReduce.ActualName = AgeParameter.Name;
+      ageCalculator.TargetParameter.ActualName = AgeParameter.Name;
+      ageCalculator.WeightParameter.ActualName = AgeInheritanceParameter.Name;
+      ageCalculator.Successor = subScopesRemover;
+
+      subScopesRemover.RemoveAllSubScopes = true;
+      subScopesRemover.Successor = null;
+
+      uniformSubScopesProcessor2.Parallel.Value = true;
+      uniformSubScopesProcessor2.Operator = evaluator;
+      uniformSubScopesProcessor2.Successor = subScopesCounter;
+
+      evaluator.OperatorParameter.ActualName = EvaluatorParameter.Name;
+      evaluator.Successor = null;
+
+      subScopesCounter.ValueParameter.ActualName = EvaluatedSolutionsParameter.Name;
+      subScopesCounter.AccumulateParameter.Value = new BoolValue(true);
+      subScopesCounter.Successor = null;
+
+      replacementBranch.ConditionParameter.ActualName = PlusSelectionParameter.Name;
+      replacementBranch.TrueBranch = replacementMergingReducer;
+      replacementBranch.FalseBranch = subScopesProcessor2;
+      replacementBranch.Successor = incrementAgeProcessor;
+
+      replacementMergingReducer.Successor = replacementBestSelector;
+
+      replacementBestSelector.NumberOfSelectedSubScopesParameter.ActualName = PopulationSizeParameter.Name;
+      replacementBestSelector.CopySelected = new BoolValue(false);
+      replacementBestSelector.Successor = replacementRightReducer;
+
+      replacementRightReducer.Successor = reevaluateElitesBranch;
+
+      subScopesProcessor2.Operators.Add(bestSelector);
+      subScopesProcessor2.Operators.Add(new EmptyOperator());
+      subScopesProcessor2.Successor = mergingReducer;
+
+      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;
+
+      mergingReducer.Successor = null;
+
+      reevaluateElitesBranch.ConditionParameter.ActualName = ReevaluateElitesParameter.Name;
+      reevaluateElitesBranch.TrueBranch = uniformSubScopesProcessor2;
+      reevaluateElitesBranch.FalseBranch = null;
+      reevaluateElitesBranch.Successor = null;
+
+
+      incrementAgeProcessor.Operator = ageIncrementor;
+      incrementAgeProcessor.Successor = null;
+
+      ageIncrementor.ValueParameter.ActualName = AgeParameter.Name;
+      ageIncrementor.IncrementParameter.Value = null;
+      ageIncrementor.IncrementParameter.ActualName = AgeIncrementParameter.Name;
+      ageIncrementor.Successor = null;
+    }
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/AgeDistributionAnalyzer.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/AgeDistributionAnalyzer.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/AgeDistributionAnalyzer.cs	(revision 13285)
@@ -0,0 +1,137 @@
+﻿#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.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  // Based on QualityDistributionAnalyzer
+  [Item("AgeDistributionAnalyzer", "Analyzes the distribution of the ages in that it adds a Histogram of them into the result collection.")]
+  [StorableClass]
+  public sealed class AgeDistributionAnalyzer : SingleSuccessorOperator, IAnalyzer, IIterationBasedOperator {
+
+    #region Parameter Properties
+    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Age"]; }
+    }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+    private IValueParameter<StringValue> HistogramNameParameter {
+      get { return (IValueParameter<StringValue>)Parameters["HistogramName"]; }
+    }
+    private IValueParameter<BoolValue> StoreHistoryParameter {
+      get { return (IValueParameter<BoolValue>)Parameters["StoreHistory"]; }
+    }
+    public ILookupParameter<IntValue> IterationsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Iterations"]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+    #endregion
+
+    public bool EnabledByDefault { get { return false; } }
+
+    public string HistogramName {
+      get { return HistogramNameParameter.Value.Value; }
+      set { HistogramNameParameter.Value.Value = value; }
+    }
+    public bool StoreHistory {
+      get { return StoreHistoryParameter.Value.Value; }
+      set { StoreHistoryParameter.Value.Value = value; }
+    }
+
+    [StorableConstructor]
+    private AgeDistributionAnalyzer(bool deserializing)
+      : base(deserializing) { }
+    private AgeDistributionAnalyzer(AgeDistributionAnalyzer original, Cloner cloner)
+      : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AgeDistributionAnalyzer(this, cloner);
+    }
+    public AgeDistributionAnalyzer()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The value which represents the age of a solution."));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection where the analysis values should be stored."));
+      Parameters.Add(new FixedValueParameter<StringValue>("HistogramName", "The name of the histogram that gets injected in to the results collection.", new StringValue("Age Distribution")));
+      Parameters.Add(new FixedValueParameter<BoolValue>("StoreHistory", "True if the history should be stored in addition to the current distribution", new BoolValue(false)));
+      Parameters.Add(new LookupParameter<IntValue>("Iterations", "Optional: A value indicating the current iteration."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "Unused", new IntValue(-1)));
+
+      AgeParameter.Hidden = true;
+      ResultsParameter.Hidden = true;
+      IterationsParameter.Hidden = true;
+      MaximumIterationsParameter.Hidden = true;
+    }
+
+    public override IOperation Apply() {
+      DataTable ageDistribution = null;
+      ResultCollection results = ResultsParameter.ActualValue;
+      string description = "Shows the age distributions in the current population.";
+      if (results.ContainsKey(HistogramName)) {
+        ageDistribution = results[HistogramName].Value as DataTable;
+      } else {
+        ageDistribution = new DataTable("Population Age Distribution", description);
+        ageDistribution.VisualProperties.XAxisTitle = AgeParameter.ActualName;
+        ageDistribution.VisualProperties.YAxisTitle = "Frequency";
+        results.Add(new Result(HistogramName, description, ageDistribution));
+      }
+      DataRow row;
+      if (!ageDistribution.Rows.TryGetValue("AgeDistribution", out row)) {
+        row = new DataRow("AgeDistribution");
+        row.VisualProperties.ChartType = DataRowVisualProperties.DataRowChartType.Histogram;
+        ageDistribution.Rows.Add(row);
+      }
+      var ages = AgeParameter.ActualValue;
+      row.Values.Replace(ages.Select(x => x.Value));
+
+      if (StoreHistory) {
+        string historyResultName = HistogramName + " History";
+        DataTableHistory adHistory = null;
+        if (results.ContainsKey(historyResultName)) {
+          adHistory = results[historyResultName].Value as DataTableHistory;
+        } else {
+          adHistory = new DataTableHistory();
+          results.Add(new Result(historyResultName, adHistory));
+        }
+        DataTable table = (DataTable)ageDistribution.Clone();
+        IntValue iteration = IterationsParameter.ActualValue;
+        if (iteration != null) {
+          string iterationName = IterationsParameter.ActualName;
+          if (iterationName.EndsWith("s")) iterationName = iterationName.Remove(iterationName.Length - 1);
+          string appendix = " at " + iterationName + " " + iteration.Value.ToString();
+          table.Name += appendix;
+          table.Rows["AgeDistribution"].VisualProperties.DisplayName += appendix;
+        }
+        adHistory.Add(table);
+      }
+      return base.Apply();
+    }
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeAnalyzer.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeAnalyzer.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeAnalyzer.cs	(revision 13285)
@@ -0,0 +1,137 @@
+﻿#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.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  [Item("OldestAverageYoungestAgeAnalyzer", "An operator which calculates the current oldest, average and youngest age in the scope tree.")]
+  [StorableClass]
+  public sealed class OldestAverageYoungestAgeAnalyzer : AlgorithmOperator, IAnalyzer {
+    #region Parameter properties
+    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Age"]; }
+    }
+    public IValueLookupParameter<DoubleValue> CurrentOldestAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["CurrentOldestAge"]; }
+    }
+    public IValueLookupParameter<DoubleValue> CurrentAverageAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["CurrentAverageAge"]; }
+    }
+    public IValueLookupParameter<DoubleValue> CurrentYoungestAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["CurrentYoungestAge"]; }
+    }
+    public IValueLookupParameter<DataTable> AgesParameter {
+      get { return (IValueLookupParameter<DataTable>)Parameters["Ages"]; }
+    }
+    public IValueLookupParameter<ResultCollection> ResultsParameter {
+      get { return (IValueLookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+    #endregion
+
+    #region Properties
+    public bool EnabledByDefault {
+      get { return false; }
+    }
+    private OldestAverageYoungestAgeCalculator OldestAverageYoungestAgeCalculator {
+      get { return (OldestAverageYoungestAgeCalculator)OperatorGraph.InitialOperator; }
+    }
+    #endregion
+
+    #region Storing & Cloning
+    [StorableConstructor]
+    private OldestAverageYoungestAgeAnalyzer(bool deserializing) : base(deserializing) { }
+    private OldestAverageYoungestAgeAnalyzer(OldestAverageYoungestAgeAnalyzer original, Cloner cloner)
+      : base(original, cloner) {
+      Initialize();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new OldestAverageYoungestAgeAnalyzer(this, cloner);
+    }
+    #endregion
+    public OldestAverageYoungestAgeAnalyzer()
+      : base() {
+      #region Create parameters
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The value which represents the age of a solution."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentOldestAge", "The oldest age value found in the current population."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentAverageAge", "The average age value of all solutions in the current population."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("CurrentYoungestAge", "The youngest age value found in the current population."));
+      Parameters.Add(new ValueLookupParameter<DataTable>("Ages", "The data table to store the current oldest, current average, current youngest age value."));
+      Parameters.Add(new ValueLookupParameter<ResultCollection>("Results", "The results collection where the analysis values should be stored."));
+
+      CurrentOldestAgeParameter.Hidden = true;
+      CurrentAverageAgeParameter.Hidden = true;
+      CurrentYoungestAgeParameter.Hidden = true;
+      AgesParameter.Hidden = true;
+      #endregion
+
+      #region Create operators
+      var oldestAverageYoungestAgeCalculator = new OldestAverageYoungestAgeCalculator();
+      var dataTableValuesCollector = new DataTableValuesCollector();
+      var resultsCollector = new ResultsCollector();
+
+      oldestAverageYoungestAgeCalculator.AverageAgeParameter.ActualName = CurrentAverageAgeParameter.Name;
+      oldestAverageYoungestAgeCalculator.OldestAgeParameter.ActualName = CurrentOldestAgeParameter.Name;
+      oldestAverageYoungestAgeCalculator.AgeParameter.ActualName = AgeParameter.Name;
+      oldestAverageYoungestAgeCalculator.AgeParameter.Depth = AgeParameter.Depth;
+      oldestAverageYoungestAgeCalculator.YoungestAgeParameter.ActualName = CurrentYoungestAgeParameter.Name;
+
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentOldestAge", null, CurrentOldestAgeParameter.Name));
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentAverageAge", null, CurrentAverageAgeParameter.Name));
+      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("CurrentYoungestAge", null, CurrentYoungestAgeParameter.Name));
+      dataTableValuesCollector.DataTableParameter.ActualName = AgesParameter.Name;
+
+      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(AgesParameter.Name));
+      resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
+      #endregion
+
+      #region Create operator graph
+      OperatorGraph.InitialOperator = oldestAverageYoungestAgeCalculator;
+      oldestAverageYoungestAgeCalculator.Successor = dataTableValuesCollector;
+      dataTableValuesCollector.Successor = resultsCollector;
+      resultsCollector.Successor = null;
+      #endregion
+
+      Initialize();
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+
+    private void Initialize() {
+      AgeParameter.DepthChanged += new EventHandler(AgeParameter_DepthChanged);
+    }
+
+    private void AgeParameter_DepthChanged(object sender, EventArgs e) {
+      OldestAverageYoungestAgeCalculator.AgeParameter.Depth = AgeParameter.Depth;
+    }
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeCalculator.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeCalculator.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeCalculator.cs	(revision 13285)
@@ -0,0 +1,91 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  [Item("OldestAverageYoungestAgeCalculator", "An operator which calculates the oldest, average and youngest age of solutions in the scope tree.")]
+  [StorableClass]
+  public sealed class OldestAverageYoungestAgeCalculator : SingleSuccessorOperator {
+    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Age"]; }
+    }
+    public IValueLookupParameter<DoubleValue> OldestAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["OldestAge"]; }
+    }
+    public IValueLookupParameter<DoubleValue> AverageAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["AverageAge"]; }
+    }
+    public IValueLookupParameter<DoubleValue> YoungestAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["YoungestAge"]; }
+    }
+
+    #region Storing & Cloning
+    [StorableConstructor]
+    private OldestAverageYoungestAgeCalculator(bool deserializing) : base(deserializing) { }
+    private OldestAverageYoungestAgeCalculator(OldestAverageYoungestAgeCalculator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new OldestAverageYoungestAgeCalculator(this, cloner);
+    }
+    #endregion
+
+    public OldestAverageYoungestAgeCalculator()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The value contained in the scope tree which represents the solution age."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("OldestAge", "The age value of the oldest solution."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("AverageAge", "The average age of all solutions."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("YoungestAge", "The age value of the youngest solution."));
+
+      OldestAgeParameter.Hidden = true;
+      AverageAgeParameter.Hidden = true;
+      YoungestAgeParameter.Hidden = true;
+    }
+
+    public override IOperation Apply() {
+      var ages = AgeParameter.ActualValue;
+
+      if (ages.Length > 0) {
+        double min = double.MaxValue, max = double.MinValue, sum = 0;
+        for (int i = 0; i < ages.Length; i++) {
+          if (ages[i].Value < min) min = ages[i].Value;
+          if (ages[i].Value > max) max = ages[i].Value;
+          sum += ages[i].Value;
+        }
+
+        var oldest = OldestAgeParameter.ActualValue;
+        if (oldest == null) OldestAgeParameter.ActualValue = new DoubleValue(max);
+        else oldest.Value = max;
+        var average = AverageAgeParameter.ActualValue;
+        if (average == null) AverageAgeParameter.ActualValue = new DoubleValue(sum / ages.Length);
+        else average.Value = sum / ages.Length;
+        var youngest = YoungestAgeParameter.ActualValue;
+        if (youngest == null) YoungestAgeParameter.ActualValue = new DoubleValue(min);
+        else youngest.Value = min;
+      }
+      return base.Apply();
+    }
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/EldersSelector.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/EldersSelector.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/EldersSelector.cs	(revision 13285)
@@ -0,0 +1,89 @@
+﻿#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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Selection;
+
+namespace HeuristicLab.Algorithms.ALPS {
+
+  [Item("EldersSelector", "Select all individuals which are too old for their current layer.")]
+  [StorableClass]
+  public sealed class EldersSelector : Selector {
+    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Age"]; }
+    }
+    public ILookupParameter<IntArray> AgeLimitsParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["AgeLimits"]; }
+    }
+    public ILookupParameter<IntValue> NumberOfLayersParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["NumberOfLayers"]; }
+    }
+    public ILookupParameter<IntValue> LayerParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Layer"]; }
+    }
+
+    [StorableConstructor]
+    private EldersSelector(bool deserializing)
+      : base(deserializing) { }
+    private EldersSelector(EldersSelector original, Cloner cloner)
+      : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EldersSelector(this, cloner);
+    }
+    public EldersSelector()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age", "The age of individuals."));
+      Parameters.Add(new LookupParameter<IntArray>("AgeLimits", "The maximum age an individual is allowed to reach in a certain layer."));
+      Parameters.Add(new LookupParameter<IntValue>("NumberOfLayers", "The number of layers."));
+      Parameters.Add(new LookupParameter<IntValue>("Layer", "The number of the current layer."));
+    }
+
+    protected override IScope[] Select(List<IScope> scopes) {
+      var ages = AgeParameter.ActualValue;
+      var ageLimits = AgeLimitsParameter.ActualValue;
+      int numberOfLayers = NumberOfLayersParameter.ActualValue.Value;
+      int layer = LayerParameter.ActualValue.Value;
+
+      if (layer >= numberOfLayers - 1) // is max layer?
+        return new IScope[0];
+
+      int limit = ageLimits[layer];
+      var elders = ages
+        .Select((x, index) => new { index, age = x.Value })
+        .Where(x => x.age > limit)
+        .ToList();
+
+      IScope[] selected = new IScope[elders.Count];
+      for (int i = 0; i < elders.Count; i++) {
+        selected[i] = scopes[elders[i].index];
+        scopes[elders[i].index] = null;
+      }
+      scopes.RemoveAll(x => x == null);
+      return selected;
+    }
+  }
+}
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 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/HeuristicLab.Algorithms.ALPS-3.3.csproj	(revision 13285)
@@ -0,0 +1,198 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProjectGuid>{59F354CB-FE13-4253-AED2-AD86372BEC27}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Algorithms.ALPS</RootNamespace>
+    <AssemblyName>HeuristicLab.Algorithms.ALPS-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <TargetFrameworkProfile />
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AlpsGeneticAlgorithmMainOperator.cs" />
+    <Compile Include="ReseedingController.cs" />
+    <Compile Include="ResultsHistoryWiper.cs" />
+    <Compile Include="WeightingReducer.cs" />
+    <Compile Include="Analyzers\OldestAverageYoungestAgeAnalyzer.cs" />
+    <Compile Include="Analyzers\AgeDistributionAnalyzer.cs" />
+    <Compile Include="AgingScheme.cs" />
+    <Compile Include="AlpsGeneticAlgorithm.cs" />
+    <Compile Include="AlpsGeneticAlgorithmMainLoop.cs" />
+    <Compile Include="Analyzers\OldestAverageYoungestAgeCalculator.cs" />
+    <Compile Include="EldersSelector.cs" />
+    <Compile Include="LastLayerCloner.cs" />
+    <Compile Include="MatingPoolCreator.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Analysis\3.3\HeuristicLab.Analysis-3.3.csproj">
+      <Project>{887425b4-4348-49ed-a457-b7d2c26ddbf9}</Project>
+      <Name>HeuristicLab.Analysis-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958b43bc-cc5c-4fa2-8628-2b3b01d890b6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
+      <Project>{a9ad58b9-3ef9-4cc1-97e5-8d909039ff5c}</Project>
+      <Name>HeuristicLab.Common-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{c36bd924-a541-4a00-afa8-41701378ddc5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{bbab9df5-5ef3-4ba8-ade9-b36e82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
+      <Project>{23da7ff4-d5b8-41b6-aa96-f0561d24f3ee}</Project>
+      <Name>HeuristicLab.Operators-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization.Operators\3.3\HeuristicLab.Optimization.Operators-3.3.csproj">
+      <Project>{25087811-f74c-4128-bc86-8324271da13e}</Project>
+      <Name>HeuristicLab.Optimization.Operators-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14ab8d24-25bc-400c-a846-4627aa945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
+      <Project>{56f9106a-079f-4c61-92f6-86a84c2d84b7}</Project>
+      <Name>HeuristicLab.Parameters-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102bc7d3-0ef9-439c-8f6d-96ff0fdb8e1b}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186a6a-5176-4402-ae83-886557b53cca}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.3\HeuristicLab.Random-3.3.csproj">
+      <Project>{f4539fb6-4708-40c9-be64-0a1390aea197}</Project>
+      <Name>HeuristicLab.Random-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Selection\3.3\HeuristicLab.Selection-3.3.csproj">
+      <Project>{2c36cd4f-e5f5-43a4-801a-201ea895fe17}</Project>
+      <Name>HeuristicLab.Selection-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+</PreBuildEvent>
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+export ProjectDir=$(ProjectDir)
+export SolutionDir=$(SolutionDir)
+
+$SolutionDir/PreBuildEvent.sh
+</PreBuildEvent>
+  </PropertyGroup>
+</Project>
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/LastLayerCloner.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/LastLayerCloner.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/LastLayerCloner.cs	(revision 13285)
@@ -0,0 +1,77 @@
+﻿#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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  [Item("LastLayerCloner", "An operator that creates a new layer by cloning the current last one.")]
+  [StorableClass]
+  public sealed class LastLayerCloner : SingleSuccessorOperator {
+    public OperatorParameter NewLayerOperatorParameter {
+      get { return (OperatorParameter)Parameters["NewLayerOperator"]; }
+    }
+
+    public IOperator NewLayerOperator {
+      get { return NewLayerOperatorParameter.Value; }
+      set { NewLayerOperatorParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    private LastLayerCloner(bool deserializing) : base(deserializing) { }
+
+    private LastLayerCloner(LastLayerCloner original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new LastLayerCloner(this, cloner);
+    }
+
+    public LastLayerCloner()
+      : base() {
+      Parameters.Add(new OperatorParameter("NewLayerOperator", "An operator that is performed on the new layer."));
+    }
+
+    public override IOperation Apply() {
+      var scopes = ExecutionContext.Scope.SubScopes;
+      if (scopes.Count < 1)
+        throw new ArgumentException("At least one layer must exist.");
+
+      var newScope = (IScope)scopes.Last().Clone();
+
+      int scopeNumber;
+      if (int.TryParse(newScope.Name, out scopeNumber))
+        newScope.Name = (scopeNumber + 1).ToString();
+
+      scopes.Add(newScope);
+
+      var next = new OperationCollection(base.Apply());
+      if (NewLayerOperator != null)
+        next.Insert(0, ExecutionContext.CreateOperation(NewLayerOperator, newScope));
+      return next;
+    }
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/MatingPoolCreator.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/MatingPoolCreator.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/MatingPoolCreator.cs	(revision 13285)
@@ -0,0 +1,80 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  [Item("MatingPoolCreator", "An operator which creates mating pools based on a set of sub-populations. For each sub-population, the individuals from the previous sub-population are copied into the current sub-population.")]
+  [StorableClass]
+  public sealed class MatingPoolCreator : SingleSuccessorOperator {
+    public IValueLookupParameter<IntValue> MatingPoolRangeParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MatingPoolRange"]; }
+    }
+
+    [StorableConstructor]
+    private MatingPoolCreator(bool deserializing)
+      : base(deserializing) { }
+    private MatingPoolCreator(MatingPoolCreator original, Cloner cloner)
+      : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MatingPoolCreator(this, cloner);
+    }
+    public MatingPoolCreator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntValue>("MatingPoolRange", "The range of sub-populations used for creating a mating pool. (1 = current + previous sub-population)", new IntValue(1)));
+    }
+
+    /// <summary>
+    /// Copies the subscopes of the n previous scopes into the current scope. (default n = 1)
+    /// <pre>
+    ///          __ scope __              __ scope __
+    ///         /     |     \            /     |     \
+    ///       Pop1   Pop2   Pop3  =>   Pop1   Pop2   Pop3
+    ///       /|\    /|\    /|\         /|\   /|\    /|\
+    ///       ABC    DEF    GHI         ABC   DEF    GHI
+    ///                                       ABC    DEF
+    /// </pre>
+    /// </summary>
+    /// <returns>The next operation.</returns>
+    public override IOperation Apply() {
+      var subScopes = ExecutionContext.Scope.SubScopes;
+      int range = MatingPoolRangeParameter.ActualValue.Value;
+
+      for (int targetIndex = subScopes.Count - 1; targetIndex > 0; targetIndex--) {
+        var targetScope = subScopes[targetIndex];
+        for (int n = 1; (n <= range) && (targetIndex - n >= 0); n++) {
+          var prevScope = subScopes[targetIndex - n];
+          var individuals = prevScope.SubScopes;
+          foreach (var individual in individuals) {
+            targetScope.SubScopes.Add((IScope)individual.Clone());
+          }
+        }
+      }
+
+      return base.Apply();
+    }
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/Plugin.cs.frame
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/Plugin.cs.frame	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/Plugin.cs.frame	(revision 13285)
@@ -0,0 +1,44 @@
+#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.PluginInfrastructure;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Algorithms.ALPS plugin.
+  /// </summary>
+  [Plugin("HeuristicLab.Algorithms.ALPS", "3.3.12.$WCREV$")]
+  [PluginFile("HeuristicLab.Algorithms.ALPS-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Analysis", "3.3")]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
+  [PluginDependency("HeuristicLab.Selection", "3.3")]
+  public class HeuristicLabAlgorithmsALPSPlugin : PluginBase {
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/Properties/AssemblyInfo.cs.frame	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/Properties/AssemblyInfo.cs.frame	(revision 13285)
@@ -0,0 +1,55 @@
+#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.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Algorithms.ALPS")]
+[assembly: AssemblyDescription("HeuristicLab ALPS")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2015 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("196f5964-865f-42aa-a584-f0d6f47aa5af")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.12.$WCREV$")]
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/ReseedingController.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/ReseedingController.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/ReseedingController.cs	(revision 13285)
@@ -0,0 +1,79 @@
+﻿#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.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  [Item("ReseedingController", "An operator that controls if reseeding is needed.")]
+  [StorableClass]
+  public sealed class ReseedingController : SingleSuccessorOperator {
+    public ILookupParameter<IntValue> GenerationsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["Generations"]; }
+    }
+    public ILookupParameter<IntValue> AgeGapParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["AgeGap"]; }
+    }
+    public OperatorParameter FirstLayerOperatorParameter {
+      get { return (OperatorParameter)Parameters["FirstLayerOperator"]; }
+    }
+
+    public IOperator FirstLayerOperator {
+      get { return FirstLayerOperatorParameter.Value; }
+      set { FirstLayerOperatorParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    private ReseedingController(bool deserializing)
+      : base(deserializing) { }
+
+    private ReseedingController(ReseedingController original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ReseedingController(this, cloner);
+    }
+
+    public ReseedingController()
+      : base() {
+      Parameters.Add(new LookupParameter<IntValue>("Generations", "The current number of generations."));
+      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 OperatorParameter("FirstLayerOperator", "The operator that is performed on the first layer if reseeding is required."));
+    }
+
+    public override IOperation Apply() {
+      int generations = GenerationsParameter.ActualValue.Value;
+      int ageGap = AgeGapParameter.ActualValue.Value;
+
+      var next = new OperationCollection(base.Apply());
+      if (generations % ageGap == 0) {
+        var layerZeroScope = ExecutionContext.Scope.SubScopes[0];
+        if (FirstLayerOperator != null)
+          next.Insert(0, ExecutionContext.CreateChildOperation(FirstLayerOperator, layerZeroScope));
+      }
+      return next;
+    }
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/ResultsHistoryWiper.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/ResultsHistoryWiper.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/ResultsHistoryWiper.cs	(revision 13285)
@@ -0,0 +1,77 @@
+﻿#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.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.ALPS {
+  [Item("ResultsHistoryWiper", "An operator that removes the history of a ResultsCollection by setting all values in all DataTables to NaN.")]
+  [StorableClass]
+  public sealed class ResultsHistoryWiper : SingleSuccessorOperator {
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    [StorableConstructor]
+    private ResultsHistoryWiper(bool deserializing) : base(deserializing) {
+    }
+
+    private ResultsHistoryWiper(ResultsHistoryWiper original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ResultsHistoryWiper(this, cloner);
+    }
+
+    public ResultsHistoryWiper()
+      : base() {
+      Parameters.Add(new LookupParameter<ResultCollection>("Results", "The ResultCollection the history is wiped from."));
+    }
+
+    public override IOperation Apply() {
+      var results = ResultsParameter.ActualValue;
+      ClearHistoryRecursively(results);
+      return base.Apply();
+    }
+
+    private void ClearHistoryRecursively(ResultCollection results) {
+      var values = results.Select(r => r.Value);
+
+      // Reset all values within results in results
+      foreach (var resultsCollection in values.OfType<ResultCollection>())
+        ClearHistoryRecursively(resultsCollection);
+
+      // Reset values
+      foreach (var dataTable in values.OfType<DataTable>()) {
+        foreach (var row in dataTable.Rows)
+          for (int i = 0; i < row.Values.Count; i++)
+            row.Values[i] = double.NaN;
+      }
+    }
+  }
+}
Index: /stable/HeuristicLab.Algorithms.ALPS/3.3/WeightingReducer.cs
===================================================================
--- /stable/HeuristicLab.Algorithms.ALPS/3.3/WeightingReducer.cs	(revision 13285)
+++ /stable/HeuristicLab.Algorithms.ALPS/3.3/WeightingReducer.cs	(revision 13285)
@@ -0,0 +1,79 @@
+﻿#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.Linq;
+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("WeightingReducer", "An operator that combines two values based on the weight of the lower (0.0) and higher (1.0) value.")]
+  [StorableClass]
+  public sealed class WeightingReducer : SingleSuccessorOperator {
+    public IScopeTreeLookupParameter<DoubleValue> ParameterToReduce {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["ParameterToReduce"]; }
+    }
+    public ILookupParameter<DoubleValue> TargetParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["TargetParameter"]; }
+    }
+    public IValueLookupParameter<DoubleValue> WeightParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Weight"]; }
+    }
+
+    [StorableConstructor]
+    private WeightingReducer(bool deserializing) : base(deserializing) { }
+    private WeightingReducer(WeightingReducer original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new WeightingReducer(this, cloner);
+    }
+    public WeightingReducer()
+      : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("ParameterToReduce", "The parameter on which the weighting should be applied."));
+      Parameters.Add(new LookupParameter<DoubleValue>("TargetParameter", "The target variable in which the weighted value should be stored."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Weight", "Weight of the two values (0.0 for the smaller, 1.0 for the larger)."));
+    }
+
+    public override IOperation Apply() {
+      var values = ParameterToReduce.ActualValue;
+      if (values.Length != 2)
+        throw new InvalidOperationException("Weighting between values can only done for two values.");
+
+      double weight = WeightParameter.ActualValue.Value;
+
+      double max = values.Max(v => v.Value);
+      double min = values.Min(v => v.Value);
+
+      double result = max * weight + min * (1 - weight);
+
+      if (TargetParameter.ActualValue == null)
+        TargetParameter.ActualValue = new DoubleValue(result);
+      else TargetParameter.ActualValue.Value = result;
+
+      return base.Apply();
+    }
+  }
+}
Index: /stable/HeuristicLab.Optimizer/3.3/HeuristicLab.Optimizer-3.3.csproj
===================================================================
--- /stable/HeuristicLab.Optimizer/3.3/HeuristicLab.Optimizer-3.3.csproj	(revision 13284)
+++ /stable/HeuristicLab.Optimizer/3.3/HeuristicLab.Optimizer-3.3.csproj	(revision 13285)
@@ -147,4 +147,6 @@
     <EmbeddedResource Include="Documents\VNS_OP.hl" />
     <EmbeddedResource Include="Documents\GA_Grouping.hl" />
+    <EmbeddedResource Include="Documents\ALPSGP_SymReg.hl" />
+    <EmbeddedResource Include="Documents\ALPSGA_TSP.hl" />
     <None Include="Plugin.cs.frame" />
     <Compile Include="OptimizerSingleDocumentMainForm.cs">
Index: /stable/HeuristicLab.Optimizer/3.3/StartPage.cs
===================================================================
--- /stable/HeuristicLab.Optimizer/3.3/StartPage.cs	(revision 13284)
+++ /stable/HeuristicLab.Optimizer/3.3/StartPage.cs	(revision 13285)
@@ -133,12 +133,12 @@
 
     private void FillGroupLookup() {
-      var standardProblems = new List<string> { "ES_Griewank", "GA_Grouping", "GA_TSP", "GA_VRP", "GE_ArtificialAnt",
+      var standardProblems = new List<string> { "ALPSGA_TSP", "ES_Griewank", "GA_Grouping", "GA_TSP", "GA_VRP", "GE_ArtificialAnt",
                 "IslandGA_TSP", "LS_Knapsack", "PSO_Schwefel", "RAPGA_JSSP",
-                "SA_Rastrigin", "SGP_SantaFe","GP_Multiplexer", "SS_VRP", "TS_TSP", "TS_VRP", "VNS_OP" ,"VNS_TSP"
+                "SA_Rastrigin", "SGP_SantaFe","GP_Multiplexer", "SS_VRP", "TS_TSP", "TS_VRP", "VNS_OP", "VNS_TSP"
         };
       groupLookup[standardProblemsGroup] = standardProblems;
-      var dataAnalysisProblems = new List<string> { "SGP_SymbClass", "SGP_SymbReg", "OSGP_TimeSeries", "GE_SymbReg", "GPR" };
+      var dataAnalysisProblems = new List<string> { "ALPSGP_SymReg", "SGP_SymbClass", "SGP_SymbReg", "OSGP_TimeSeries", "GE_SymbReg", "GPR" };
       groupLookup[dataAnalysisGroup] = dataAnalysisProblems;
-      var scripts = new List<string> { "GA_QAP_Script", "GUI_Automation_Script", "OSGA_Rastrigin_Script", 
+      var scripts = new List<string> { "GA_QAP_Script", "GUI_Automation_Script", "OSGA_Rastrigin_Script",
                                        "GridSearch_RF_Classification_Script", "GridSearch_RF_Regression_Script",
                                        "GridSearch_SVM_Classification_Script", "GridSearch_SVM_Regression_Script" };
Index: /stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/AlpsSampleTest.cs
===================================================================
--- /stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/AlpsSampleTest.cs	(revision 13285)
+++ /stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/AlpsSampleTest.cs	(revision 13285)
@@ -0,0 +1,149 @@
+﻿#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.IO;
+using System.Linq;
+using HeuristicLab.Algorithms.ALPS;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.Xml;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
+using HeuristicLab.Problems.Instances.DataAnalysis;
+using HeuristicLab.Problems.Instances.TSPLIB;
+using HeuristicLab.Problems.TravelingSalesman;
+using HeuristicLab.Selection;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace HeuristicLab.Tests {
+  [TestClass]
+  public class AlpsTspSampleTest {
+    private const string TspSampleFileName = "ALPSGA_TSP";
+    private const string SymRegSampleFileName = "ALPSGP_SymReg";
+
+    [TestMethod]
+    [TestCategory("Samples.Create")]
+    [TestProperty("Time", "medium")]
+    public void CreateAlpsGaTspSampleTest() {
+      var alpsGa = CreateAlpsGaTspSample();
+      string path = Path.Combine(SamplesUtils.SamplesDirectory, TspSampleFileName + SamplesUtils.SampleFileExtension);
+      XmlGenerator.Serialize(alpsGa, path);
+    }
+
+    [TestMethod]
+    [TestCategory("Samples.Create")]
+    [TestProperty("Time", "medium")]
+    public void CreateAlpsGaSymRegSampleTest() {
+      var alpsGa = CreateAlpsGaSymRegSample();
+      string path = Path.Combine(SamplesUtils.SamplesDirectory, SymRegSampleFileName + SamplesUtils.SampleFileExtension);
+      XmlGenerator.Serialize(alpsGa, path);
+    }
+
+    [TestMethod]
+    [TestCategory("Samples.Execute")]
+    [TestProperty("Time", "long")]
+    public void RunAlpsGaTspSampleTest() {
+      var alpsGa = CreateAlpsGaTspSample();
+      alpsGa.SetSeedRandomly.Value = false;
+      SamplesUtils.RunAlgorithm(alpsGa);
+      Assert.AreEqual(7967, SamplesUtils.GetDoubleResult(alpsGa, "BestQuality"));
+      Assert.AreEqual(17565.174444444445, SamplesUtils.GetDoubleResult(alpsGa, "CurrentAverageQuality"));
+      Assert.AreEqual(50295, SamplesUtils.GetDoubleResult(alpsGa, "CurrentWorstQuality"));
+      Assert.AreEqual(621900, SamplesUtils.GetIntResult(alpsGa, "EvaluatedSolutions"));
+    }
+
+    [TestMethod]
+    [TestCategory("Samples.Execute")]
+    [TestProperty("Time", "long")]
+    public void RunAlpsGaSymRegSampleTest() {
+      var alpsGa = CreateAlpsGaSymRegSample();
+      alpsGa.SetSeedRandomly.Value = false;
+      SamplesUtils.RunAlgorithm(alpsGa);
+      Assert.AreEqual(265855, SamplesUtils.GetIntResult(alpsGa, "EvaluatedSolutions"));
+    }
+
+    private AlpsGeneticAlgorithm CreateAlpsGaTspSample() {
+      AlpsGeneticAlgorithm alpsGa = new AlpsGeneticAlgorithm();
+      #region Problem Configuration
+      var provider = new TSPLIBTSPInstanceProvider();
+      var instance = provider.GetDataDescriptors().Single(x => x.Name == "ch130");
+      TravelingSalesmanProblem tspProblem = new TravelingSalesmanProblem();
+      tspProblem.Load(provider.LoadData(instance));
+      tspProblem.UseDistanceMatrix.Value = true;
+      #endregion
+      #region Algorithm Configuration
+      alpsGa.Name = "ALPS Genetic Algorithm - TSP";
+      alpsGa.Description = "An age-layered population structure genetic algorithm which solves the \"ch130\" traveling salesman problem (imported from TSPLIB)";
+      alpsGa.Problem = tspProblem;
+      SamplesUtils.ConfigureAlpsGeneticAlgorithmParameters<GeneralizedRankSelector, MultiPermutationCrossover, InversionManipulator>(alpsGa,
+        numberOfLayers: 1000,
+        popSize: 100,
+        mutationRate: 0.05,
+        elites: 1,
+        plusSelection: true,
+        agingScheme: AgingScheme.Polynomial,
+        ageGap: 20,
+        ageInheritance: 1.0,
+        maxGens: 1000);
+      var checkedCrossovers = new[] { typeof(EdgeRecombinationCrossover), typeof(MaximalPreservativeCrossover), typeof(OrderCrossover2) };
+      var multiCrossover = (MultiPermutationCrossover)alpsGa.Crossover;
+      var crossovers = multiCrossover.Operators.Where(c => checkedCrossovers.Any(cc => cc.IsInstanceOfType(c))).ToList();
+      foreach (var c in multiCrossover.Operators)
+        multiCrossover.Operators.SetItemCheckedState(c, crossovers.Contains(c));
+      #endregion
+      return alpsGa;
+    }
+
+    private AlpsGeneticAlgorithm CreateAlpsGaSymRegSample() {
+      AlpsGeneticAlgorithm alpsGa = new AlpsGeneticAlgorithm();
+      #region Problem Configuration
+      var provider = new VladislavlevaInstanceProvider();
+      var instance = provider.GetDataDescriptors().Single(x => x.Name.StartsWith("Vladislavleva-5 F5"));
+      var symbRegProblem = new SymbolicRegressionSingleObjectiveProblem();
+      symbRegProblem.Load(provider.LoadData(instance));
+
+      symbRegProblem.MaximumSymbolicExpressionTreeDepth.Value = 35;
+      symbRegProblem.MaximumSymbolicExpressionTreeLength.Value = 35;
+
+      var grammar = (TypeCoherentExpressionGrammar)symbRegProblem.SymbolicExpressionTreeGrammar;
+      grammar.Symbols.OfType<Exponential>().Single().Enabled = false;
+      grammar.Symbols.OfType<Logarithm>().Single().Enabled = false;
+
+      #endregion
+      #region Algorithm Configuration
+      alpsGa.Name = "ALPS Genetic Programming - Symbolic Regression";
+      alpsGa.Description = "An ALPS-GP to solve a symbolic regression problem (Vladislavleva-5 dataset)";
+      alpsGa.Problem = symbRegProblem;
+      SamplesUtils.ConfigureAlpsGeneticAlgorithmParameters<GeneralizedRankSelector, SubtreeCrossover, MultiSymbolicExpressionTreeManipulator>(alpsGa,
+        numberOfLayers: 1000,
+        popSize: 100,
+        mutationRate: 0.25,
+        elites: 1,
+        plusSelection: false,
+        agingScheme: AgingScheme.Polynomial,
+        ageGap: 15,
+        ageInheritance: 1.0,
+        maxGens: 500);
+      #endregion
+      return alpsGa;
+    }
+  }
+}
Index: /stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/SamplesUtils.cs
===================================================================
--- /stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/SamplesUtils.cs	(revision 13284)
+++ /stable/HeuristicLab.Tests/HeuristicLab-3.3/Samples/SamplesUtils.cs	(revision 13285)
@@ -2,4 +2,5 @@
 using System.Linq;
 using System.Threading;
+using HeuristicLab.Algorithms.ALPS;
 using HeuristicLab.Algorithms.EvolutionStrategy;
 using HeuristicLab.Algorithms.GeneticAlgorithm;
@@ -170,4 +171,30 @@
       ga.Engine = new ParallelEngine.ParallelEngine();
     }
+
+    public static void ConfigureAlpsGeneticAlgorithmParameters<S, C, M>(AlpsGeneticAlgorithm ga, int numberOfLayers, int popSize, double mutationRate, int elites, bool plusSelection, AgingScheme agingScheme, int ageGap, double ageInheritance, int maxGens)
+      where S : ISelector
+      where C : ICrossover
+      where M : IManipulator {
+      ga.Seed.Value = 0;
+      ga.SetSeedRandomly.Value = true;
+
+      ga.NumberOfLayers.Value = numberOfLayers;
+      ga.PopulationSize.Value = popSize;
+
+      ga.Selector = ga.SelectorParameter.ValidValues.OfType<S>().Single();
+      ga.Crossover = ga.CrossoverParameter.ValidValues.OfType<C>().Single();
+      ga.Mutator = ga.MutatorParameter.ValidValues.OfType<M>().Single();
+      ga.MutationProbability.Value = mutationRate;
+      ga.Elites.Value = elites;
+      ga.PlusSelection = plusSelection;
+
+      ga.AgingScheme = new EnumValue<AgingScheme>(agingScheme);
+      ga.AgeGap.Value = ageGap;
+      ga.AgeInheritance.Value = ageInheritance;
+
+      ga.MaximumGenerations = maxGens;
+      
+      ga.Engine = new ParallelEngine.ParallelEngine();
+    }
   }
 }
Index: /stable/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- /stable/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 13284)
+++ /stable/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 13285)
@@ -111,4 +111,8 @@
     <Reference Include="ALGLIB-3.7.0">
       <HintPath>..\bin\ALGLIB-3.7.0.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Algorithms.ALPS-3.3">
+      <HintPath>..\bin\HeuristicLab.Algorithms.ALPS-3.3.dll</HintPath>
       <Private>False</Private>
     </Reference>
@@ -431,4 +435,5 @@
     <Compile Include="HeuristicLab-3.3\PluginDependenciesTest.cs" />
     <Compile Include="HeuristicLab-3.3\PluginLoader.cs" />
+    <Compile Include="HeuristicLab-3.3\Samples\AlpsSampleTest.cs" />
     <Compile Include="HeuristicLab-3.3\Samples\GAGroupingProblemSampleTest.cs" />
     <Compile Include="HeuristicLab-3.3\Samples\VnsOpSampleTest.cs" />
