Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs	(revision 13037)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithm.cs	(revision 13046)
@@ -344,5 +344,5 @@
       initializeLayerPopulationSize.Successor = initializeLocalEvaluatedSolutions;
 
-      initializeAge.CollectedValues.Add(new ValueParameter<IntValue>("Age", new IntValue(0)));
+      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
       initializeAge.Successor = null;
 
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainLoop.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainLoop.cs	(revision 13037)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/AlpsGeneticAlgorithmMainLoop.cs	(revision 13046)
@@ -216,11 +216,10 @@
       // Increment ages of all individuals after replacement
       var incrementAgeProcessor = new UniformSubScopesProcessor();
-      var ageIncrementor = new IntCounter() { Name = "Increment Age" };
+      var ageIncrementor = new DoubleCounter() { Name = "Increment Age" };
       replacementBranch.Successor = incrementAgeProcessor;
       incrementAgeProcessor.Operator = ageIncrementor;
       incrementAgeProcessor.Successor = null;
       ageIncrementor.ValueParameter.ActualName = "Age";
-      ageIncrementor.Increment = new IntValue(1);
-      //ageIncrementor.Successor = null;
+      ageIncrementor.Increment = new DoubleValue(1.0);
 
       // Insert AgeCalculator between crossover and its successor
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/AgeDistributionAnalyzer.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/AgeDistributionAnalyzer.cs	(revision 13037)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/AgeDistributionAnalyzer.cs	(revision 13046)
@@ -37,6 +37,6 @@
 
     #region Parameter Properties
-    public IScopeTreeLookupParameter<IntValue> AgeParameter {
-      get { return (IScopeTreeLookupParameter<IntValue>)Parameters["Age"]; }
+    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Age"]; }
     }
     public ValueLookupParameter<ResultCollection> ResultsParameter {
@@ -78,5 +78,5 @@
     public AgeDistributionAnalyzer()
       : base() {
-      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Age", "The value which represents the age of a solution."));
+      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")));
@@ -110,5 +110,5 @@
       }
       var ages = AgeParameter.ActualValue;
-      row.Values.Replace(ages.Select(x => (double)x.Value));
+      row.Values.Replace(ages.Select(x => x.Value));
 
       if (StoreHistory) {
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeAnalyzer.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeAnalyzer.cs	(revision 13037)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeAnalyzer.cs	(revision 13046)
@@ -36,15 +36,15 @@
   public sealed class OldestAverageYoungestAgeAnalyzer : AlgorithmOperator, IAnalyzer {
     #region Parameter properties
-    public IScopeTreeLookupParameter<IntValue> AgeParameter {
-      get { return (IScopeTreeLookupParameter<IntValue>)Parameters["Age"]; }
+    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Age"]; }
     }
-    public IValueLookupParameter<IntValue> CurrentOldestAgeParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["CurrentOldestAge"]; }
+    public IValueLookupParameter<DoubleValue> CurrentOldestAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["CurrentOldestAge"]; }
     }
-    public IValueLookupParameter<IntValue> CurrentAverageAgeParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["CurrentAverageAge"]; }
+    public IValueLookupParameter<DoubleValue> CurrentAverageAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["CurrentAverageAge"]; }
     }
-    public IValueLookupParameter<IntValue> CurrentYoungestAgeParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["CurrentYoungestAge"]; }
+    public IValueLookupParameter<DoubleValue> CurrentYoungestAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["CurrentYoungestAge"]; }
     }
     public IValueLookupParameter<DataTable> AgesParameter {
@@ -79,8 +79,8 @@
       : base() {
       #region Create parameters
-      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Age", "The value which represents the age of a solution."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("CurrentOldestAge", "The oldest age value found in the current population."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("CurrentAverageAge", "The average age value of all solutions in the current population."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("CurrentYoungestAge", "The youngest age value found in the current population."));
+      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."));
@@ -103,12 +103,9 @@
       oldestAverageYoungestAgeCalculator.YoungestAgeParameter.ActualName = CurrentYoungestAgeParameter.Name;
 
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<IntValue>("CurrentOldestAge", null, CurrentOldestAgeParameter.Name));
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<IntValue>("CurrentAverageAge", null, CurrentAverageAgeParameter.Name));
-      dataTableValuesCollector.CollectedValues.Add(new LookupParameter<IntValue>("CurrentYoungestAge", null, 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<IntValue>("CurrentOldestAge", null, CurrentOldestAgeParameter.Name));
-      //resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("CurrentAverageAge", null, CurrentAverageAgeParameter.Name));
-      //resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("CurrentYoungestAge", null, CurrentYoungestAgeParameter.Name));
       resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(AgesParameter.Name));
       resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeCalculator.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeCalculator.cs	(revision 13037)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/Analyzers/OldestAverageYoungestAgeCalculator.cs	(revision 13046)
@@ -31,15 +31,15 @@
   [StorableClass]
   public sealed class OldestAverageYoungestAgeCalculator : SingleSuccessorOperator {
-    public IScopeTreeLookupParameter<IntValue> AgeParameter {
-      get { return (IScopeTreeLookupParameter<IntValue>)Parameters["Age"]; }
+    public IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Age"]; }
     }
-    public IValueLookupParameter<IntValue> OldestAgeParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["OldestAge"]; }
+    public IValueLookupParameter<DoubleValue> OldestAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["OldestAge"]; }
     }
-    public IValueLookupParameter<IntValue> AverageAgeParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["AverageAge"]; }
+    public IValueLookupParameter<DoubleValue> AverageAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["AverageAge"]; }
     }
-    public IValueLookupParameter<IntValue> YoungestAgeParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["YoungestAge"]; }
+    public IValueLookupParameter<DoubleValue> YoungestAgeParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["YoungestAge"]; }
     }
 
@@ -55,8 +55,8 @@
     public OldestAverageYoungestAgeCalculator()
       : base() {
-      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("Age", "The value contained in the scope tree which represents the solution age."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("OldestAge", "The age value of the oldest solution."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("AverageAge", "The average age of all solutions."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("YoungestAge", "The age value of the youngest solution."));
+      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;
@@ -69,5 +69,5 @@
 
       if (ages.Length > 0) {
-        int min = int.MaxValue, max = int.MinValue, sum = 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;
@@ -77,11 +77,11 @@
 
         var oldest = OldestAgeParameter.ActualValue;
-        if (oldest == null) OldestAgeParameter.ActualValue = new IntValue(max);
+        if (oldest == null) OldestAgeParameter.ActualValue = new DoubleValue(max);
         else oldest.Value = max;
         var average = AverageAgeParameter.ActualValue;
-        if (average == null) AverageAgeParameter.ActualValue = new IntValue(sum / ages.Length);
+        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 IntValue(min);
+        if (youngest == null) YoungestAgeParameter.ActualValue = new DoubleValue(min);
         else youngest.Value = min;
       }
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/EldersEmigrator.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/EldersEmigrator.cs	(revision 13037)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/EldersEmigrator.cs	(revision 13046)
@@ -59,5 +59,4 @@
       selectorProsessor.Successor = shiftToRightMigrator;
 
-      eldersSelector.CopySelected = new BoolValue(false);
       eldersSelector.Successor = null;
 
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/EldersSelector.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/EldersSelector.cs	(revision 13037)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/EldersSelector.cs	(revision 13046)
@@ -33,6 +33,8 @@
   [Item("EldersSelector", "Select all individuals which are to old for their current layer.")]
   [StorableClass]
-  public sealed class EldersSelector : SingleObjectiveSelector {
-
+  public sealed class EldersSelector : Selector {
+    private IScopeTreeLookupParameter<DoubleValue> AgeParameter {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["Age"]; }
+    }
     private ILookupParameter<IntArray> AgeLimitsParameter {
       get { return (ILookupParameter<IntArray>)Parameters["AgeLimits"]; }
@@ -55,4 +57,5 @@
     public EldersSelector()
       : base() {
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Age"));
       Parameters.Add(new LookupParameter<IntArray>("AgeLimits"));
       Parameters.Add(new LookupParameter<IntValue>("NumberOfLayers"));
@@ -61,4 +64,5 @@
 
     protected override IScope[] Select(List<IScope> scopes) {
+      var ages = AgeParameter.ActualValue;
       var ageLimits = AgeLimitsParameter.ActualValue;
       int numberOfLayers = NumberOfLayersParameter.ActualValue.Value;
@@ -69,17 +73,16 @@
 
       int limit = ageLimits[layer];
-      var eldersQuery =
-        from scope in scopes
-        let age = ((IntValue)scope.Variables["Age"].Value).Value
-        where age > limit
-        select scope;
+      var elders = ages
+        .Select((x, index) => new { index, age = x.Value })
+        .Where(x => x.age > limit)
+        .ToList();
 
-      var elders = eldersQuery.ToArray();
-
-      if (!CopySelected.Value)
-        foreach (var elder in elders)
-          scopes.Remove(elder);
-
-      return elders;
+      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: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerCreator.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerCreator.cs	(revision 13037)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerCreator.cs	(revision 13046)
@@ -35,9 +35,4 @@
   [StorableClass]
   public sealed class LayerCreator : SingleSuccessorOperator {
-
-    /*private static readonly ISet<string> SavedVariables = new HashSet<string>{
-      "LocalRandom", "Layer", "LayerEvaluatedSolutions", "NumSubScopes"
-    };*/
-
     private ILookupParameter<IntValue> OpenLayersParameter {
       get { return (ILookupParameter<IntValue>)Parameters["OpenLayers"]; }
@@ -78,5 +73,5 @@
       // Decrement ages, because MainOperator is goint to increment it
       foreach (var solution in clone.SubScopes)
-        ((IntValue)solution.Variables["Age"].Value).Value -= 1;
+        ((DoubleValue)solution.Variables["Age"].Value).Value -= 1;
 
       // Reset existing values in the results to NaN to symbolize that no layer existed during that duration
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerUpdator.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerUpdator.cs	(revision 13037)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/LayerUpdator.cs	(revision 13046)
@@ -64,7 +64,4 @@
       var newLayerLayerProcessor = new UniformSubScopesProcessor();
       var newLayerReducer = new MergingReducer();
-      var layerInitializer = new Assigner() { Name = "Init Layer" };
-      var correctAgeProcessor = new UniformSubScopesProcessor() { Name = "Hack: Decrement Age" };
-      var correctAgeDecrementor = new IntCounter() { Name = "Age = Age - 1" };
       var incrEvaluatedSolutionsForNewLayer = new SubScopesCounter() { Name = "Update EvaluatedSolutions" };
       var newResultCollectionAssigner = new Assigner() { Name = "Empty Results" };
@@ -131,14 +128,4 @@
       newLayerReducer.Successor = incrOpenLayers;
 
-      layerInitializer.LeftSideParameter.ActualName = "Layer";
-      layerInitializer.RightSideParameter.ActualName = "OpenLayers";
-      layerInitializer.Successor = correctAgeProcessor;
-
-      correctAgeProcessor.Operator = correctAgeDecrementor;
-      correctAgeProcessor.Successor = incrEvaluatedSolutionsForNewLayer;
-
-      correctAgeDecrementor.Increment = new IntValue(-1);
-      correctAgeDecrementor.ValueParameter.ActualName = "Age";
-
       incrEvaluatedSolutionsForNewLayer.ValueParameter.ActualName = "EvaluatedSolutions";
       incrEvaluatedSolutionsForNewLayer.AccumulateParameter.Value = new BoolValue(true);
@@ -179,5 +166,5 @@
       initializeAgeProsessor.Successor = incrEvaluatedSolutionsAfterReseeding;
 
-      initializeAge.CollectedValues.Add(new ValueParameter<IntValue>("Age", new IntValue(0)));
+      initializeAge.CollectedValues.Add(new ValueParameter<DoubleValue>("Age", new DoubleValue(0)));
       initializeAge.Successor = null;
 
Index: branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/WeightingReducer.cs
===================================================================
--- branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/WeightingReducer.cs	(revision 13037)
+++ branches/ALPS/HeuristicLab.Algorithms.ALPS/3.3/WeightingReducer.cs	(revision 13046)
@@ -34,9 +34,9 @@
   public sealed class WeightingReducer : SingleSuccessorOperator {
 
-    public ScopeTreeLookupParameter<IntValue> ParameterToReduce {
-      get { return (ScopeTreeLookupParameter<IntValue>)Parameters["ParameterToReduce"]; }
+    public IScopeTreeLookupParameter<DoubleValue> ParameterToReduce {
+      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters["ParameterToReduce"]; }
     }
-    public LookupParameter<IntValue> TargetParameter {
-      get { return (LookupParameter<IntValue>)Parameters["TargetParameter"]; }
+    public ILookupParameter<DoubleValue> TargetParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["TargetParameter"]; }
     }
     public IValueLookupParameter<DoubleValue> WeightParameter {
@@ -54,6 +54,6 @@
     public WeightingReducer()
       : base() {
-      Parameters.Add(new ScopeTreeLookupParameter<IntValue>("ParameterToReduce", "The parameter on which the weighting should be applied."));
-      Parameters.Add(new LookupParameter<IntValue>("TargetParameter", "The target variable in which the weighted value should be stored."));
+      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)."));
     }
@@ -64,13 +64,13 @@
         throw new InvalidOperationException("Weighting between values can only done for two values.");
 
-      var weight = WeightParameter.ActualValue.Value;
+      double weight = WeightParameter.ActualValue.Value;
 
-      var max = values.Max(v => v.Value);
-      var min = values.Min(v => v.Value);
+      double max = values.Max(v => v.Value);
+      double min = values.Min(v => v.Value);
 
-      int result = (int)(max * weight + min * (1 - weight));
+      double result = max * weight + min * (1 - weight);
 
       if (TargetParameter.ActualValue == null)
-        TargetParameter.ActualValue = new IntValue(result);
+        TargetParameter.ActualValue = new DoubleValue(result);
       else TargetParameter.ActualValue.Value = result;
 
