Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithm.cs
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithm.cs	(revision 12141)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithm.cs	(revision 12142)
@@ -40,6 +40,6 @@
   public class AlpsSsGeneticAlgorithm : Alps {
     #region Parameter Properties
-    private IValueParameter<IntArray> PopulationSizeParameter {
-      get { return (IValueParameter<IntArray>)Parameters["PopulationSize"]; }
+    private IValueParameter<IntValue> PopulationSizeParameter {
+      get { return (IValueParameter<IntValue>)Parameters["PopulationSize"]; }
     }
     private IValueParameter<IntValue> MaximumIterationsParameter {
@@ -67,5 +67,5 @@
 
     #region Properties
-    public IntArray PopulationSize {
+    public IntValue PopulationSize {
       get { return PopulationSizeParameter.Value; }
       set { PopulationSizeParameter.Value = value; }
@@ -119,5 +119,5 @@
     public AlpsSsGeneticAlgorithm()
       : base() {
-      Parameters.Add(new ValueParameter<IntArray>("PopulationSize", "The size of the population of solutions each layer.", new IntArray(new[] { 100 })));
+      Parameters.Add(new ValueParameter<IntValue>("PopulationSize", "The size of the population of solutions each layer.", new IntValue(100)));
       Parameters.Add(new ValueParameter<IntValue>("MaximumIterations", "The maximum number of iterations that should be processed.", new IntValue(1000)));
       Parameters.Add(new ConstrainedValueParameter<ISelector>("Selector", "The operator used to select solutions for reproduction."));
@@ -131,5 +131,5 @@
       var randomCreator = new RandomCreator();
       var layer0Creator = new SubScopesCreator() { Name = "Create Layer Zero" };
-      var layer0Processor = new LayerUniformSubScopesProcessor();
+      var layer0Processor = new /*Layer*/UniformSubScopesProcessor();
       var layer0VariableCreator = new VariableCreator();
       var layer0SolutionsCreator = new SolutionsCreator();
Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithmMainLoop.cs
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithmMainLoop.cs	(revision 12141)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsGeneticAlgorithmMainLoop.cs	(revision 12142)
@@ -71,5 +71,5 @@
 
       var variableCreator = new VariableCreator() { Name = "Initialize" };
-      var randomScopeProcessor = new RandomLayerProcessor() { Name = "Select a layer" }; // TODO LayerSubScopeProcessor for Array conversion
+      var randomScopeProcessor = new RandomLayerProcessor() { Name = "Select a layer" };
       var isLayerZeroComperator = new Comparator() { Name = "IsLayerZero = Layer == 0" };
       var isLayerZeroBranch = new ConditionalBranch() { Name = "IsLayerZero?" };
@@ -95,7 +95,9 @@
       var resetTargetIndex = new Assigner() { Name = "TargetIndex = 0" };
       var clearMatingPool = new SubScopesRemover() { Name = "Clear WorkingScope" };
-      var tryMoveUp = new EmptyOperator() { Name = "Try Move Up" }; // TODO
-      var setNewIndividual = new EmptyOperator() { Name = "Set New Individual" }; // TODO
+      var tryMoveUp = new AlpsSsMover() { Name = "Try Move Up" };
+      var removeWorkingScope = new LeftReducer() { Name = "Remove Working Scope" };
       var incrIterations = new IntCounter() { Name = "Incr. Iterations" };
+      var layerAnalyzerProcessor = new UniformSubScopesProcessor();
+      var layerAnalyzer = new Placeholder() { Name = "LayerAnalyzer (Placeholder)" };
       var analyzer = new Placeholder() { Name = "Analyzer (Placeholder)" };
       var iterationsComparator = new Comparator() { Name = "Iterations >= MaximumIterations" };
@@ -109,5 +111,7 @@
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("OpenLayers", new IntValue(1)));
       variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("TargetIndex", new IntValue(0)));
-      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations"));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("Iterations", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<IntValue>("MatingPoolSize", new IntValue(0)));
+      variableCreator.CollectedValues.Add(new ValueParameter<BoolValue>("ValidParents", new BoolValue(false)));
       variableCreator.Successor = randomScopeProcessor;
 
@@ -161,4 +165,5 @@
       selectRandomTargetIndex.MinimumParameter.Value = new IntValue(0);
       selectRandomTargetIndex.MaximumParameter.ActualName = "PopulationSize";
+      selectRandomTargetIndex.MaximumParameter.Value = null;
       selectRandomTargetIndex.Successor = copyLayer;
 
@@ -199,11 +204,16 @@
       clearMatingPool.Successor = createRandomIndividual;
 
-      tryMoveUp.Successor = setNewIndividual;
-
-      setNewIndividual.Successor = incrIterations;
+      tryMoveUp.Successor = removeWorkingScope;
+
+      removeWorkingScope.Successor = incrIterations;
 
       incrIterations.ValueParameter.ActualName = "Iterations";
       incrIterations.Increment = new IntValue(1);
-      incrIterations.Successor = analyzer;
+      incrIterations.Successor = layerAnalyzerProcessor;
+
+      layerAnalyzerProcessor.Operator = layerAnalyzer;
+      layerAnalyzerProcessor.Successor = analyzer;
+
+      layerAnalyzer.OperatorParameter.ActualName = "LayerAnalyzer";
 
       analyzer.OperatorParameter.ActualName = "Analyzer";
Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsMover.cs
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsMover.cs	(revision 12142)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/AlpsSsMover.cs	(revision 12142)
@@ -0,0 +1,113 @@
+﻿#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.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Algorithms.ALPS.SteadyState {
+  [Item("AlpsSsMover", "")]
+  [StorableClass]
+  public class AlpsSsMover : SingleSuccessorOperator, IStochasticOperator {
+    private ILookupParameter<IntValue> TargetIndexParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["TargetIndex"]; }
+    }
+    private ILookupParameter<IntValue> PopulationSizeParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["PopulationSize"]; }
+    }
+    private ILookupParameter<IntValue> NumberOfLayersParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["NumberOfLayers"]; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    [StorableConstructor]
+    private AlpsSsMover(bool deserializing)
+      : base(deserializing) { }
+    private AlpsSsMover(AlpsSsMover original, Cloner cloner)
+      : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AlpsSsMover(this, cloner);
+    }
+
+    public AlpsSsMover()
+      : base() {
+      Parameters.Add(new LookupParameter<IntValue>("TargetIndex"));
+      Parameters.Add(new LookupParameter<IntValue>("PopulationSize"));
+      Parameters.Add(new LookupParameter<IntValue>("NumberOfLayers"));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+    }
+
+    public override IOperation Apply() {
+      int i = ((IntValue)ExecutionContext.Scope.Variables["Layer"].Value).Value;
+      int j = TargetIndexParameter.ActualValue.Value;
+      int n = NumberOfLayersParameter.ActualValue.Value;
+      int m = PopulationSizeParameter.ActualValue.Value;
+      var random = RandomParameter.ActualValue;
+
+      var layer = ExecutionContext.Scope.SubScopes[0];
+      var newIndividual = ExecutionContext.Scope.SubScopes[1];
+      var gs = ExecutionContext.Scope.Parent;
+
+      if (i < n) {
+        TryMoveUp(gs, newIndividual, i, j, n, m, random);
+        layer.SubScopes[j] = newIndividual;
+        newIndividual.Name = j.ToString();
+      }
+
+      return base.Apply();
+    }
+
+    private void TryMoveUp(IScope gs, IScope individual, int i, int j, int n, int m, IRandom random) {
+      if (i < n) {
+        if (gs.SubScopes.Count <= i + 1) {
+          var newLayer = new Scope((i + 1).ToString());
+          newLayer.Variables.Add(new Variable("Layer", new IntValue(i + 1)));
+          gs.SubScopes.Add(newLayer);
+        }
+
+        var higherLayer = gs.SubScopes[i + 1];
+        var replaceIndex = FindReplaceable(higherLayer, individual, random, m);
+        if (replaceIndex.HasValue) {
+          TryMoveUp(gs, higherLayer.SubScopes[j], i + 1, replaceIndex.Value, n, m, random); // TODO higherlayer[j] does not exist
+          if (replaceIndex.Value >= higherLayer.SubScopes.Count)
+            higherLayer.SubScopes.Add(individual);
+          else
+            higherLayer.SubScopes[replaceIndex.Value] = individual;
+        }
+      }
+    }
+
+    private int? FindReplaceable(IScope layer, IScope individual, IRandom random, int m) {
+      if (layer.SubScopes.Count < m)
+        return layer.SubScopes.Count;
+      return Enumerable.Range(0, layer.SubScopes.Count).SampleRandom(random);
+    }
+  }
+}
Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/HeuristicLab.Algorithms.ALPS.SteadyState-3.3.csproj
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/HeuristicLab.Algorithms.ALPS.SteadyState-3.3.csproj	(revision 12141)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/HeuristicLab.Algorithms.ALPS.SteadyState-3.3.csproj	(revision 12142)
@@ -137,4 +137,5 @@
     <Compile Include="AlpsSsGeneticAlgorithmMainLoop.cs" />
     <Compile Include="AlpsSsGeneticAlgorithmMainOperator.cs" />
+    <Compile Include="AlpsSsMover.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Plugin.cs" />
Index: /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/RandomLayerProcessor.cs
===================================================================
--- /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/RandomLayerProcessor.cs	(revision 12141)
+++ /branches/ALPS/HeuristicLab.Algorithms.ALPS.SteadyState/3.3/RandomLayerProcessor.cs	(revision 12142)
@@ -41,8 +41,4 @@
     }
 
-    private ILookupParameter<IntArray> PopulationSizeParameter {
-      get { return (ILookupParameter<IntArray>)Parameters["PopulationSize"]; }
-    }
-
     public IOperator Operator {
       get { return OperatorParameter.Value; }
@@ -59,6 +55,4 @@
       Parameters.Add(new OperatorParameter("Operator", "The operator which should be applied on a random sub-scopes of the current scope."));
       Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
-
-      Parameters.Add(new LookupParameter<IntArray>("PopulationSize"));
     }
 
@@ -74,11 +68,5 @@
         var subScopes = ExecutionContext.Scope.SubScopes;
         int index = random.Next(subScopes.Count);
-        var selectedLayer = subScopes[index];
-
-        var layerParameters = new LayerIntermediateParameter {
-            new ValueParameter<IntValue>(PopulationSizeParameter.ActualName, new IntValue(PopulationSizeParameter.ActualValue[Math.Min(index, PopulationSizeParameter.ActualValue.Length - 1)]))
-          };
-        var immediateContext = new ExecutionContext(ExecutionContext.Parent, layerParameters, selectedLayer);
-        next.Insert(0, immediateContext.CreateChildOperation(Operator, selectedLayer));
+        next.Insert(0, ExecutionContext.CreateOperation(Operator, subScopes[index]));
       }
       return next;
