Index: anches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/Alps.cs
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/Alps.cs	(revision 12992)
+++ 	(revision )
@@ -1,418 +1,0 @@
-﻿#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.Random;
-
-namespace HeuristicLab.Algorithms.ALPS {
-  [Item("ALPS", "Base class for all ALPS-based algorithms.")]
-  [StorableClass]
-  public abstract class Alps : 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<EnumValue<AgingScheme>> AgingSchemeParameter {
-      get { return (IValueParameter<EnumValue<AgingScheme>>)Parameters["AgingScheme"]; }
-    }
-    private IValueParameter<IntValue> AgeGapParameter {
-      get { return (IValueParameter<IntValue>)Parameters["AgeGap"]; }
-    }
-    private IValueParameter<IntArray> AgeLimitsParameter {
-      get { return (IValueParameter<IntArray>)Parameters["AgeLimits"]; }
-    }
-    private IValueParameter<EnumValue<AgeInheritance>> AgeInheritanceParameter {
-      get { return (IValueParameter<EnumValue<AgeInheritance>>)Parameters["AgeInheritance"]; }
-    }
-    private IValueParameter<ReductionOperation> AgeInheritanceReductionParameter {
-      get { return (IValueParameter<ReductionOperation>)Parameters["AgeInheritanceReduction"]; }
-    }
-    private IValueParameter<IntValue> MatingPoolRangeParameter {
-      get { return (IValueParameter<IntValue>)Parameters["MatingPoolRange"]; }
-    }
-    private IValueParameter<PercentValue> MatingPoolSelectionPercentageParameter {
-      get { return (IValueLookupParameter<PercentValue>)Parameters["MatingPoolSelectionPercentage"]; }
-    }
-    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 EnumValue<AgingScheme> AgingScheme {
-      get { return AgingSchemeParameter.Value; }
-      set { AgingSchemeParameter.Value = value; }
-    }
-    public IntValue AgeGap {
-      get { return AgeGapParameter.Value; }
-      set { AgeGapParameter.Value = value; }
-    }
-    public IntArray AgeLimits {
-      get { return AgeLimitsParameter.Value; }
-      set { AgeLimitsParameter.Value = value; }
-    }
-    public EnumValue<AgeInheritance> AgeInheritance {
-      get { return AgeInheritanceParameter.Value; }
-      set { AgeInheritanceParameter.Value = value; }
-    }
-    private ReductionOperation AgeInheritanceReduction {
-      get { return AgeInheritanceReductionParameter.Value; }
-      set { AgeInheritanceReductionParameter.Value = value; }
-    }
-    public IntValue MatingPoolRange {
-      get { return MatingPoolRangeParameter.Value; }
-      set { MatingPoolRangeParameter.Value = value; }
-    }
-    public PercentValue MatingPoolSelectionPercentage {
-      get { return MatingPoolSelectionPercentageParameter.Value; }
-      set { MatingPoolSelectionPercentageParameter.Value = value; }
-    }
-    public MultiTerminator Terminators {
-      get { return TerminatorParameter.Value; }
-    }
-    #endregion
-
-    #region Helper Properties
-    protected RandomCreator GlobalRandomCreator {
-      get { return (RandomCreator)OperatorGraph.InitialOperator; }
-    }
-    protected SolutionsCreator SolutionsCreator {
-      get { return OperatorGraph.Iterate().OfType<SolutionsCreator>().First(); }
-    }
-    #endregion
-
-    #region Preconfigured Analyzers
-    [Storable]
-    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
-    [Storable]
-    private BestAverageWorstQualityAnalyzer layerQualityAnalyzer;
-    #endregion
-    #region Preconfigured Terminators
-    [Storable]
-    protected ComparisonTerminator<IntValue> evaluationsTerminator;
-    [Storable]
-    protected SingleObjectiveQualityTerminator qualityTerminator;
-    [Storable]
-    protected ExecutionTimeTerminator executionTimeTerminator;
-    #endregion
-
-    [StorableConstructor]
-    protected Alps(bool deserializing)
-      : base(deserializing) { }
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      Initialize();
-    }
-    protected Alps(Alps original, Cloner cloner)
-      : base(original, cloner) {
-      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
-      layerQualityAnalyzer = cloner.Clone(original.layerQualityAnalyzer);
-      evaluationsTerminator = cloner.Clone(original.evaluationsTerminator);
-      qualityTerminator = cloner.Clone(original.qualityTerminator);
-      executionTimeTerminator = cloner.Clone(original.executionTimeTerminator);
-      Initialize();
-    }
-
-    protected Alps()
-      : base() {
-      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 the islands.", 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<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<IntArray>("AgeLimits", new IntArray(new int[0])) { Hidden = true });
-      Parameters.Add(new ValueParameter<EnumValue<AgeInheritance>>("AgeInheritance", "The operator for determining the age of an offspring based the parents' age.", new EnumValue<AgeInheritance>(ALPS.AgeInheritance.Older)));
-      Parameters.Add(new ValueParameter<ReductionOperation>("AgeInheritanceReduction") { 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<PercentValue>("MatingPoolSelectionPercentage", "Percentage of the previous layers used for creating a mating pool.", new PercentValue(1.0, restrictToUnitInterval: true)) { Hidden = true });
-      Parameters.Add(new ValueParameter<MultiTerminator>("Terminator", "The termination criteria which sould be checked.", new MultiTerminator()));
-
-      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
-      layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
-
-      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)));
-
-      ParameterizeAgeLimits();
-      ParameterizeAgeInheritanceReduction();
-
-      ParameterizeAnalyzers();
-      UpdateAnalyzers();
-
-      ParameterizeTerminators();
-
-      Initialize();
-    }
-
-
-    #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);
-      ParameterizeSolutionsCreator();
-      ParameterizeAnalyzers();
-      ParameterizeTerminators();
-      UpdateAnalyzers();
-      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
-    }
-    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);
-      ParameterizeSolutionsCreator();
-    }
-    protected override void Problem_EvaluatorChanged(object sender, EventArgs e) {
-      base.Problem_EvaluatorChanged(sender, e);
-      ParameterizeStochasticOperatorForLayer(Problem.Evaluator);
-      ParameterizeSolutionsCreator();
-      ParameterizeAnalyzers();
-      Problem.Evaluator.QualityParameter.ActualNameChanged += Evaluator_QualityParameter_ActualNameChanged;
-    }
-
-    protected override void Problem_OperatorsChanged(object sender, EventArgs e) {
-      foreach (var @operator in Problem.Operators.OfType<IOperator>())
-        ParameterizeStochasticOperator(@operator);
-      UpdateAnalyzers();
-      base.Problem_OperatorsChanged(sender, e);
-    }
-    protected virtual void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
-      ParameterizeAnalyzers();
-    }
-    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 AgeInheritanceParameter_ValueChanged(object sender, EventArgs e) {
-      AgeInheritance.ValueChanged += AgeInheritance_ValueChanged;
-      ParameterizeAgeInheritanceReduction();
-    }
-    private void AgeInheritance_ValueChanged(object sender, EventArgs e) {
-      ParameterizeAgeInheritanceReduction();
-    }
-    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;
-      AgeGapParameter.ValueChanged += AgeGapParameter_ValueChanged;
-      AgeGap.ValueChanged += AgeGap_ValueChanged;
-      AgingSchemeParameter.ValueChanged += AgingSchemeParameter_ValueChanged;
-      AgingScheme.ValueChanged += AgingScheme_ValueChanged;
-      NumberOfLayersParameter.ValueChanged += NumberOfLayersParameter_ValueChanged;
-      NumberOfLayers.ValueChanged += NumberOfLayers_ValueChanged;
-      AgeInheritanceParameter.ValueChanged += AgeInheritanceParameter_ValueChanged;
-      AgeInheritance.ValueChanged += AgeInheritance_ValueChanged;
-      Analyzer.Operators.ItemsAdded += AnalyzerOperators_ItemsAdded;
-      LayerAnalyzer.Operators.ItemsAdded += LayerAnalyzerOperators_ItemsAdded;
-      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 ParameterizeAnalyzers() {
-      qualityAnalyzer.ResultsParameter.ActualName = "Results";
-      qualityAnalyzer.ResultsParameter.Hidden = true;
-      qualityAnalyzer.QualityParameter.Depth = 2;
-      layerQualityAnalyzer.ResultsParameter.ActualName = "Results";
-      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 ParameterizeTerminators() {
-      qualityTerminator.Parameterize(qualityAnalyzer.CurrentBestQualityParameter, Problem);
-    }
-    private void ParameterizeAgeInheritanceReduction() {
-      AgeInheritanceReduction.Value = GetAgeInheritanceReduction(AgeInheritance.Value);
-    }
-    protected abstract ReductionOperations GetAgeInheritanceReduction(AgeInheritance ageInheritance);
-    private void ParameterizeAgeLimits() {
-      var scheme = AgingScheme.Value;
-      int ageGap = AgeGap.Value;
-      int numberOfLayers = NumberOfLayers.Value;
-      AgeLimits = scheme.CalculateAgeLimits(ageGap, numberOfLayers);
-    }
-    protected virtual void ParameterizeStochasticOperator(IOperator @operator) {
-      var stochasticOperator = @operator as IStochasticOperator;
-      if (stochasticOperator != null) {
-        stochasticOperator.RandomParameter.ActualName = "GlobalRandom";
-        stochasticOperator.RandomParameter.Hidden = true;
-      }
-    }
-    protected virtual 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);
-      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, layerQualityAnalyzer.EnabledByDefault);
-
-      if (Problem != null) {
-        foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
-          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
-        }
-      }
-    }
-    #endregion
-  }
-}
Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs	(revision 12992)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs	(revision 12993)
@@ -23,4 +23,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using HeuristicLab.Analysis;
+using HeuristicLab.Collections;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -39,9 +41,39 @@
   [Creatable("Algorithms")]
   [StorableClass]
-  public sealed class AlpsGeneticAlgorithm : Alps {
+  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"]; }
@@ -50,10 +82,10 @@
       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"]; }
     }
-    public IConstrainedValueParameter<IManipulator> MutatorParameter {
-      get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
-    }
     private IValueParameter<IntValue> ElitesParameter {
       get { return (IValueParameter<IntValue>)Parameters["Elites"]; }
@@ -65,44 +97,135 @@
       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<EnumValue<AgeInheritance>> AgeInheritanceParameter {
+      get { return (IValueParameter<EnumValue<AgeInheritance>>)Parameters["AgeInheritance"]; }
+    }
+    private IValueParameter<ReductionOperation> AgeInheritanceReductionParameter {
+      get { return (IValueParameter<ReductionOperation>)Parameters["AgeInheritanceReduction"]; }
+    }
+    private IValueParameter<IntArray> AgeLimitsParameter {
+      get { return (IValueParameter<IntArray>)Parameters["AgeLimits"]; }
+    }
+
+    private IValueParameter<IntValue> MatingPoolRangeParameter {
+      get { return (IValueParameter<IntValue>)Parameters["MatingPoolRange"]; }
+    }
+    private IValueParameter<PercentValue> MatingPoolSelectionPercentageParameter {
+      get { return (IValueLookupParameter<PercentValue>)Parameters["MatingPoolSelectionPercentage"]; }
+    }
+
+    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 EnumValue<AgeInheritance> AgeInheritance {
+      get { return AgeInheritanceParameter.Value; }
+      set { AgeInheritanceParameter.Value = value; }
+    }
+    private ReductionOperation AgeInheritanceReduction {
+      get { return AgeInheritanceReductionParameter.Value; }
+      set { AgeInheritanceReductionParameter.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 PercentValue MatingPoolSelectionPercentage {
+      get { return MatingPoolSelectionPercentageParameter.Value; }
+      set { MatingPoolSelectionPercentageParameter.Value = value; }
+    }
+
+    public MultiTerminator Terminators {
+      get { return TerminatorParameter.Value; }
+    }
+
     public int MaximumGenerations {
       get { return generationsTerminator.Threshold.Value; }
       set { generationsTerminator.Threshold.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 PercentValue MutationProbability {
-      get { return MutationProbabilityParameter.Value; }
-      set { MutationProbabilityParameter.Value = value; }
-    }
-    public IManipulator Mutator {
-      get { return MutatorParameter.Value; }
-      set { MutatorParameter.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; }
-    }
-
+    #endregion
+
+    #region Helper Properties
+    private RandomCreator GlobalRandomCreator {
+      get { return (RandomCreator)OperatorGraph.InitialOperator; }
+    }
+    private SolutionsCreator SolutionsCreator {
+      get { return OperatorGraph.Iterate().OfType<SolutionsCreator>().First(); }
+    }
     private AlpsGeneticAlgorithmMainLoop MainLoop {
       get { return OperatorGraph.Iterate().OfType<AlpsGeneticAlgorithmMainLoop>().First(); }
@@ -110,6 +233,21 @@
     #endregion
 
+    #region Preconfigured Analyzers
+    [Storable]
+    private BestAverageWorstQualityAnalyzer qualityAnalyzer;
+    [Storable]
+    private BestAverageWorstQualityAnalyzer layerQualityAnalyzer;
+    #endregion
+
+    #region Preconfigured Terminators
     [Storable]
     private ComparisonTerminator<IntValue> generationsTerminator;
+    [Storable]
+    private ComparisonTerminator<IntValue> evaluationsTerminator;
+    [Storable]
+    private SingleObjectiveQualityTerminator qualityTerminator;
+    [Storable]
+    private ExecutionTimeTerminator executionTimeTerminator;
+    #endregion
 
     [StorableConstructor]
@@ -122,5 +260,10 @@
     private AlpsGeneticAlgorithm(AlpsGeneticAlgorithm original, Cloner cloner)
       : base(original, cloner) {
+      qualityAnalyzer = cloner.Clone(original.qualityAnalyzer);
+      layerQualityAnalyzer = cloner.Clone(original.layerQualityAnalyzer);
       generationsTerminator = cloner.Clone(original.generationsTerminator);
+      evaluationsTerminator = cloner.Clone(original.evaluationsTerminator);
+      qualityTerminator = cloner.Clone(original.qualityTerminator);
+      executionTimeTerminator = cloner.Clone(original.executionTimeTerminator);
       Initialize();
     }
@@ -130,13 +273,35 @@
     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 the islands.", 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 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 OptionalConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
       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)) { Hidden = true });
 
+      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<EnumValue<AgeInheritance>>("AgeInheritance", "The operator for determining the age of an offspring based the parents' age.", new EnumValue<AgeInheritance>(ALPS.AgeInheritance.Older)));
+      Parameters.Add(new ValueParameter<ReductionOperation>("AgeInheritanceReduction") { Hidden = true });
+      Parameters.Add(new ValueParameter<IntArray>("AgeLimits", 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<PercentValue>("MatingPoolSelectionPercentage", "Percentage of the previous layers used for creating a mating pool.", new PercentValue(1.0, restrictToUnitInterval: true)) { Hidden = true });
+
+      Parameters.Add(new ValueParameter<MultiTerminator>("Terminator", "The termination criteria which sould be checked.", new MultiTerminator()));
+      #endregion
+
+      #region Create operators
       var globalRandomCreator = new RandomCreator();
       var layer0Creator = new SubScopesCreator() { Name = "Create Layer Zero" };
@@ -152,5 +317,7 @@
       var resultsCollector = new ResultsCollector();
       var mainLoop = new AlpsGeneticAlgorithmMainLoop();
-
+      #endregion
+
+      #region Create and parameterize operator graph
       OperatorGraph.InitialOperator = globalRandomCreator;
 
@@ -195,14 +362,31 @@
       resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Evaluated Solutions", null, "EvaluatedSolutions"));
       resultsCollector.Successor = mainLoop;
-
+      #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 tournamentSelector = SelectorParameter.ValidValues.OfType<TournamentSelector>().FirstOrDefault();
-      if (tournamentSelector != null) {
-        tournamentSelector.GroupSizeParameter.Value = new IntValue(4);
-        SelectorParameter.Value = tournamentSelector;
-      }
-
+      var defaultSelector = SelectorParameter.ValidValues.OfType<GeneralizedRankSelector>().FirstOrDefault();
+      if (defaultSelector != null) {
+        defaultSelector.PressureParameter.Value = new DoubleValue(4);
+        SelectorParameter.Value = defaultSelector;
+      }
+      #endregion
+
+      #region Create analyzers
+      qualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      layerQualityAnalyzer = new BestAverageWorstQualityAnalyzer();
+      #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
+      ParameterizeAnalyzers();
+      UpdateAnalyzers();
 
       ParameterizeSelectors();
@@ -210,24 +394,67 @@
       UpdateTerminators();
 
+      ParameterizeAgeLimits();
+      ParameterizeAgeInheritanceReduction();
+      #endregion
+
       Initialize();
     }
 
     #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();
-      ParameterizeIterationBasedOperators();
+      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();
@@ -241,8 +468,64 @@
       UpdateTerminators();
     }
-    protected override void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
-      base.Evaluator_QualityParameter_ActualNameChanged(sender, e);
+    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 AgeInheritanceParameter_ValueChanged(object sender, EventArgs e) {
+      AgeInheritance.ValueChanged += AgeInheritance_ValueChanged;
+      ParameterizeAgeInheritanceReduction();
+    }
+    private void AgeInheritance_ValueChanged(object sender, EventArgs e) {
+      ParameterizeAgeInheritanceReduction();
+    }
+
+    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
@@ -250,6 +533,25 @@
     #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;
+      AgeInheritanceParameter.ValueChanged += AgeInheritanceParameter_ValueChanged;
+      AgeInheritance.ValueChanged += AgeInheritance_ValueChanged;
+
+      qualityAnalyzer.CurrentBestQualityParameter.NameChanged += new EventHandler(QualityAnalyzer_CurrentBestQualityParameter_NameChanged);
     }
     private void ParameterizeSolutionsCreator() {
+      SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
+      SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
       MainLoop.LayerUpdator.SolutionsCreator.EvaluatorParameter.ActualName = Problem.EvaluatorParameter.Name;
       MainLoop.LayerUpdator.SolutionsCreator.SolutionCreatorParameter.ActualName = Problem.SolutionCreatorParameter.Name;
@@ -263,4 +565,26 @@
       MainLoop.LayerUpdator.SolutionsCreator.NumberOfSolutionsParameter.ActualName = PopulationSizeParameter.Name;
     }
+    private void ParameterizeAnalyzers() {
+      qualityAnalyzer.ResultsParameter.ActualName = "Results";
+      qualityAnalyzer.ResultsParameter.Hidden = true;
+      qualityAnalyzer.QualityParameter.Depth = 2;
+      layerQualityAnalyzer.ResultsParameter.ActualName = "Results";
+      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) {
@@ -279,4 +603,7 @@
         }
       }
+    }
+    private void ParameterizeTerminators() {
+      qualityTerminator.Parameterize(qualityAnalyzer.CurrentBestQualityParameter, Problem);
     }
     private void ParameterizeIterationBasedOperators() {
@@ -290,6 +617,31 @@
       }
     }
-
-    protected override ReductionOperations GetAgeInheritanceReduction(AgeInheritance ageInheritance) {
+    private void ParameterizeAgeInheritanceReduction() {
+      AgeInheritanceReduction.Value = GetAgeInheritanceReduction(AgeInheritance.Value);
+    }
+    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;
+      }
+    }
+
+    private ReductionOperations GetAgeInheritanceReduction(AgeInheritance ageInheritance) {
       switch (ageInheritance) {
         case ALPS.AgeInheritance.Older: return ReductionOperations.Max;
@@ -302,4 +654,48 @@
 
     #region Updates
+    private void UpdateAnalyzers() {
+      Analyzer.Operators.Clear();
+      LayerAnalyzer.Operators.Clear();
+
+      Analyzer.Operators.Add(qualityAnalyzer, qualityAnalyzer.EnabledByDefault);
+      LayerAnalyzer.Operators.Add(layerQualityAnalyzer, layerQualityAnalyzer.EnabledByDefault);
+
+      if (Problem != null) {
+        foreach (var analyzer in Problem.Operators.OfType<IAnalyzer>()) {
+          Analyzer.Operators.Add(analyzer, analyzer.EnabledByDefault);
+        }
+      }
+    }
+    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> {
@@ -319,35 +715,4 @@
         Terminators.Operators.Add(newTerminator.Key, newTerminator.Value);
     }
-    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;
-      }
-    }
     #endregion
   }
Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/HeuristicLab.Algorithms.ALPS-3.3.csproj
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/HeuristicLab.Algorithms.ALPS-3.3.csproj	(revision 12992)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/HeuristicLab.Algorithms.ALPS-3.3.csproj	(revision 12993)
@@ -133,5 +133,4 @@
   <ItemGroup>
     <Compile Include="AgeInheritance.cs" />
-    <Compile Include="Alps.cs" />
     <Compile Include="Analyzers\EvaluatedSolutionsHistoryAnalyzer.cs" />
     <Compile Include="Analyzers\OldestAverageYoungestAgeAnalyzer.cs" />
