Index: /trunk/sources/HeuristicLab.BitVector/BitVectorCrossoverBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.BitVector/BitVectorCrossoverBase.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.BitVector/BitVectorCrossoverBase.cs	(revision 1218)
@@ -42,32 +42,31 @@
 
     /// <summary>
-    /// Performs a crossover of two given parents.
+    /// Performs a crossover by calling <see cref="Cross(HeuristicLab.Core.IScope, HeuristicLab.Core.IRandom, bool[][]"/>
+    /// and adds the created bit vector to the current scope.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown when the parents have different lengths.</exception>
-    /// <param name="scope">The current scope.</param>
+    /// <exception cref="InvalidOperationException">Thrown if the parents have different lengths.</exception>
+    /// <param name="scope">The current scope which represents a new child.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for crossover.</param>
-    /// <param name="parent2">The second parent for crossover.</param>
-    /// <param name="child">The resulting child scope.</param>
-    protected sealed override void Cross(IScope scope, IRandom random, IScope parent1, IScope parent2, IScope child) {
-      IVariableInfo bitVectorInfo = GetVariableInfo("BitVector");
-      BoolArrayData vector1 = parent1.GetVariableValue<BoolArrayData>(bitVectorInfo.FormalName, false);
-      BoolArrayData vector2 = parent2.GetVariableValue<BoolArrayData>(bitVectorInfo.FormalName, false);
+    protected sealed override void Cross(IScope scope, IRandom random) {
+      bool[][] parents = new bool[scope.SubScopes.Count][];
+      int length = -1;
+      for (int i = 0; i < scope.SubScopes.Count; i++) {
+        parents[i] = scope.SubScopes[i].GetVariableValue<BoolArrayData>("BitVector", false).Data;
+        if (i == 0) length = parents[i].Length;
+        else if (parents[i].Length != length) throw new InvalidOperationException("ERROR in BitVectorCrossoverBase: Cannot apply crossover to bit vectors of different length");
+      }
 
-      if (vector1.Data.Length != vector2.Data.Length) throw new InvalidOperationException("Cannot apply crossover to bit vectors of different length.");
-
-      bool[] result = Cross(scope, random, vector1.Data, vector2.Data);
-      child.AddVariable(new Variable(child.TranslateName(bitVectorInfo.FormalName), new BoolArrayData(result)));
+      bool[] result = Cross(scope, random, parents);
+      scope.AddVariable(new Variable(scope.TranslateName("BitVector"), new BoolArrayData(result)));
     }
 
     /// <summary>
-    /// Performs a crossover of two given parents.
+    /// Performs a crossover of multiple bit vectors.
     /// </summary>
     /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for crossover.</param>
-    /// <param name="parent2">The second parent for crossover.</param>
+    /// <param name="parents">An array containing all parent bit vectors.</param>
     /// <returns>The newly created bit vector, resulting from the crossover operation.</returns>
-    protected abstract bool[] Cross(IScope scope, IRandom random, bool[] parent1, bool[] parent2);
+    protected abstract bool[] Cross(IScope scope, IRandom random, bool[][] parents);
   }
 }
Index: /trunk/sources/HeuristicLab.BitVector/SinglePointCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.BitVector/SinglePointCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.BitVector/SinglePointCrossover.cs	(revision 1218)
@@ -57,14 +57,15 @@
 
     /// <summary>
-    /// Performs a single point crossover at a randomly chosen position of the two 
+    /// Performs a single point crossover at a randomly chosen position of two 
     /// given parent bit vectors.
     /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for crossover.</param>
-    /// <param name="parent2">The second parent for crossover.</param>
+    /// <param name="parents">An array containing the two bit vectors that should be crossed.</param>
     /// <returns>The newly created bit vector, resulting from the single point crossover.</returns>
-    protected override bool[] Cross(IScope scope, IRandom random, bool[] parent1, bool[] parent2) {
-      return Apply(random, parent1, parent2);
+    protected override bool[] Cross(IScope scope, IRandom random, bool[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in SinglePointCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.Evolutionary/CrossoverBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Evolutionary/CrossoverBase.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.Evolutionary/CrossoverBase.cs	(revision 1218)
@@ -28,5 +28,5 @@
 namespace HeuristicLab.Evolutionary {
   /// <summary>
-  /// Base class for crossing over operators.
+  /// Base class for crossover operators.
   /// </summary>
   public abstract class CrossoverBase : OperatorBase {
@@ -40,35 +40,21 @@
 
     /// <summary>
-    /// Replaces the parents (the sub scopes of the current <paramref name="scope"/>) with created children
-    /// by crossing over of two adjacent sub scopes.
+    /// Retrieves the random number generator and calls <see cref="Cross(HeuristicLab.Core.IScope, HeuristicLab.Core.IRandom)"/>.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown when the size of the mating pool 
-    /// is not even.</exception>
-    /// <param name="scope">The current scope whose sub scopes shall be parents.</param>
+    /// <param name="scope">The current scope which represents a new child.</param>
     /// <returns><c>null</c>.</returns>
     public override IOperation Apply(IScope scope) {
       IRandom random = GetVariableValue<IRandom>("Random", scope, true);
-
-      if (scope.SubScopes.Count != 2)
-        throw new InvalidOperationException("ERROR: Number of parents is != 2");
-
-      IScope parent1 = scope.SubScopes[0];
-      IScope parent2 = scope.SubScopes[1];
-      IScope child = scope;
-      Cross(scope, random, parent1, parent2, child);
-
+      Cross(scope, random);
       return null;
     }
 
     /// <summary>
-    /// Performs a cross over of <paramref name="parent1"/> and <paramref name="parent2"/>
-    /// to create a new <paramref name="child"/>.
+    /// Performs a crossover of all parents (sub-scopes) of <paramref name="scope"/> to create a new child.
+    /// Note that all children have to be prepared using the <see cref="HeuristicLab.Evolutionary.ChildrenInitializer"/>.
     /// </summary>
-    /// <param name="scope">The current scope.</param>
+    /// <param name="scope">The current scope which represents a new child.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The parent scope 1 to cross over.</param>
-    /// <param name="parent2">The parent scope 2 to cross over.</param>
-    /// <param name="child">The resulting child of the cross over.</param>
-    protected abstract void Cross(IScope scope, IRandom random, IScope parent1, IScope parent2, IScope child);
+    protected abstract void Cross(IScope scope, IRandom random);
   }
 }
Index: /trunk/sources/HeuristicLab.Evolutionary/HeuristicLab.Evolutionary.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Evolutionary/HeuristicLab.Evolutionary.csproj	(revision 1217)
+++ /trunk/sources/HeuristicLab.Evolutionary/HeuristicLab.Evolutionary.csproj	(revision 1218)
@@ -61,5 +61,4 @@
   <ItemGroup>
     <Compile Include="ChildrenInitializer.cs" />
-    <Compile Include="MultiCrossoverBase.cs" />
     <Compile Include="SASEGASAReunificator.cs" />
     <Compile Include="CrossoverBase.cs" />
Index: unk/sources/HeuristicLab.Evolutionary/MultiCrossoverBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Evolutionary/MultiCrossoverBase.cs	(revision 1217)
+++ 	(revision )
@@ -1,77 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-
-namespace HeuristicLab.Evolutionary {
-  /// <summary>
-  /// Base class for cross over operators that use more than two parents.
-  /// </summary>
-  public abstract class MultiCrossoverBase : OperatorBase {
-    /// <summary>
-    /// Initializes a new instance of <see cref="MultiCrossoverBase"/> with two variable infos
-    /// (<c>Parents</c> and <c>Random</c>).
-    /// </summary>
-    public MultiCrossoverBase()
-      : base() {
-      AddVariableInfo(new VariableInfo("Random", "Pseudo random number generator", typeof(IRandom), VariableKind.In));
-    }
-
-    /// <summary>
-    /// Replaces the parents (sub scopes of the given <paramref name="scope"/>) with created children
-    /// by crossing over a specified number of parents.
-    /// </summary>
-    /// <remarks>Adds the children to the given <paramref name="scope"/> and removes the parents.</remarks>
-    /// <exception cref="InvalidOperationException">Thrown when the size of the mating pool and the 
-    /// number of parents don't match.</exception>
-    /// <param name="scope">The scope whose sub scopes shall be crossed over.</param>
-    /// <returns><c>null</c>.</returns>
-    public override IOperation Apply(IScope scope) {
-      IRandom random = GetVariableValue<IRandom>("Random", scope, true);
-      int parents = scope.SubScopes.Count;
-
-      if (parents < 2)
-        throw new InvalidOperationException("ERROR: Number of parents is < 2");
-
-      IScope[] parentScopes = new IScope[parents];
-      for (int i = 0; i < parents; i++)
-        parentScopes[i] = scope.SubScopes[i];
-      IScope child = scope;
-      Cross(scope, random, parentScopes, child);
-
-      return null;
-    }
-    /// <summary>
-    /// Performs a cross over of a number of <paramref name="parents"/>
-    /// to create a new <paramref name="child"/>.
-    /// </summary>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">A random number generator.</param>
-    /// <param name="parents">The scopes to cross over.</param>
-    /// <param name="child">The result of the cross over.</param>
-    protected abstract void Cross(IScope scope, IRandom random, IScope[] parents, IScope child);
-  }
-}
Index: /trunk/sources/HeuristicLab.IntVector/DiscreteCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.IntVector/DiscreteCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.IntVector/DiscreteCrossover.cs	(revision 1218)
@@ -56,13 +56,14 @@
 
     /// <summary>
-    /// Performs a discrete crossover operation of the two given parents.
+    /// Performs a discrete crossover operation for two given parent integer vectors.
     /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for the crossover operation.</param>
-    /// <param name="parent2">The second parent for the crossover operation.</param>
+    /// <param name="parents">An array containing the two integer vectors that should be crossed.</param>
     /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2) {
-      return Apply(random, parent1, parent2);
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in DiscreteCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.IntVector/IntVectorCrossoverBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.IntVector/IntVectorCrossoverBase.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.IntVector/IntVectorCrossoverBase.cs	(revision 1218)
@@ -42,31 +42,31 @@
 
     /// <summary>
-    /// Performs a crossover of two given parents.
+    /// Performs a crossover by calling <see cref="Cross(HeuristicLab.Core.IScope, HeuristicLab.Core.IRandom, int[][]"/>
+    /// and adds the created integer vector to the current scope.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if the parents have different lengths.</exception>
+    /// <param name="scope">The current scope which represents a new child.</param>
+    /// <param name="random">A random number generator.</param>
+    protected sealed override void Cross(IScope scope, IRandom random) {
+      int[][] parents = new int[scope.SubScopes.Count][];
+      int length = -1;
+      for (int i = 0; i < scope.SubScopes.Count; i++) {
+        parents[i] = scope.SubScopes[i].GetVariableValue<IntArrayData>("IntVector", false).Data;
+        if (i == 0) length = parents[i].Length;
+        else if (parents[i].Length != length) throw new InvalidOperationException("ERROR in IntVectorCrossoverBase: Cannot apply crossover to integer vectors of different length");
+      }
+
+      int[] result = Cross(scope, random, parents);
+      scope.AddVariable(new Variable(scope.TranslateName("IntVector"), new IntArrayData(result)));
+    }
+
+    /// <summary>
+    /// Performs a crossover of multiple integer vectors.
     /// </summary>
     /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for crossover.</param>
-    /// <param name="parent2">The second parent for crossover.</param>
-    /// <param name="child">The resulting child scope.</param>
-    protected sealed override void Cross(IScope scope, IRandom random, IScope parent1, IScope parent2, IScope child) {
-      IVariableInfo intVectorInfo = GetVariableInfo("IntVector");
-      IntArrayData vector1 = parent1.GetVariableValue<IntArrayData>(intVectorInfo.FormalName, false);
-      IntArrayData vector2 = parent2.GetVariableValue<IntArrayData>(intVectorInfo.FormalName, false);
-
-      if (vector1.Data.Length != vector2.Data.Length) throw new InvalidOperationException("Cannot apply crossover to integer vectors of different length.");
-
-      int[] result = Cross(scope, random, vector1.Data, vector2.Data);
-      child.AddVariable(new Variable(child.TranslateName(intVectorInfo.FormalName), new IntArrayData(result)));
-    }
-
-    /// <summary>
-    /// Performs a crossover of two given parents.
-    /// </summary>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for crossover.</param>
-    /// <param name="parent2">The second parent for crossover.</param>
+    /// <param name="parents">An array containing all parent integer vectors.</param>
     /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
-    protected abstract int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2);
+    protected abstract int[] Cross(IScope scope, IRandom random, int[][] parents);
   }
 }
Index: /trunk/sources/HeuristicLab.IntVector/SinglePointCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.IntVector/SinglePointCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.IntVector/SinglePointCrossover.cs	(revision 1218)
@@ -57,14 +57,15 @@
 
     /// <summary>
-    /// Performs a single point crossover at a randomly chosen position of the two 
+    /// Performs a single point crossover at a randomly chosen position of two 
     /// given parent integer vectors.
     /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for crossover.</param>
-    /// <param name="parent2">The second parent for crossover.</param>
+    /// <param name="parents">An array containing the two integer vectors that should be crossed.</param>
     /// <returns>The newly created integer vector, resulting from the single point crossover.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2) {
-      return Apply(random, parent1, parent2);
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in SinglePointCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.Permutation/AbsolutePositionTopologicalCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Permutation/AbsolutePositionTopologicalCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.Permutation/AbsolutePositionTopologicalCrossover.cs	(revision 1218)
@@ -75,15 +75,14 @@
 
     /// <summary>
-    /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/>
-    /// by taking the values from both parents one by one with the same index.
+    /// Performs an absolute position topological crossover operation for two given parent permutations.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The parent scope 1 to cross over.</param>
-    /// <param name="parent2">The parent scope 2 to cross over.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in AbsolutePositionTopologicalCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.Permutation/CosaCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Permutation/CosaCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.Permutation/CosaCrossover.cs	(revision 1218)
@@ -86,17 +86,14 @@
 
     /// <summary>
-    /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/>
-    /// by taking first the reverse elements of a randomly chosen interval of parent1 
-    /// and inserting it in the result at a position specified by the permutation of parent2. 
-    /// The remaining elements to be inserted are taken again from parent1 in the forward direction.
+    /// Performs a COSA crossover operation for two given parent permutations.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The parent scope 1 to cross over.</param>
-    /// <param name="parent2">The parent scope 2 to cross over.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in CosaCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.Permutation/CyclicCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Permutation/CyclicCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.Permutation/CyclicCrossover.cs	(revision 1218)
@@ -80,16 +80,14 @@
 
     /// <summary>
-    /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/>
-    /// by copying a whole cycle starting at a randomly chosen position in parent1 and taking the rest
-    /// from parent2.
+    /// Performs a cyclic crossover operation for two given parent permutations.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The parent scope 1 to cross over.</param>
-    /// <param name="parent2">The parent scope 2 to cross over.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in CyclicCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.Permutation/EdgeRecombinationCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Permutation/EdgeRecombinationCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.Permutation/EdgeRecombinationCrossover.cs	(revision 1218)
@@ -139,19 +139,14 @@
 
     /// <summary>
-    /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="2"/>
-    /// by calculating the edges of each element. Starts at a randomly chosen position, 
-    /// the next element is a neighbour with the least 
-    /// number of neighbours, the next again a neighbour and so on.
+    /// Performs an edge recombination crossover operation for two given parent permutations.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown when the permutation lacks a number.
-    /// </exception>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The parent scope 1 to cross over.</param>
-    /// <param name="parent2">The parent scope 2 to cross over.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in EdgeRecombinationCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.Permutation/MaximalPreservativeCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Permutation/MaximalPreservativeCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.Permutation/MaximalPreservativeCrossover.cs	(revision 1218)
@@ -78,16 +78,14 @@
 
     /// <summary>
-    /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/>
-    /// by preserving a big randomly chosen region of one permutation and taking the missing ones from the other 
-    /// permuation array.
+    /// Performs a maximal preservative crossover operation for two given parent permutations.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The permutation array of parent 1.</param>
-    /// <param name="parent2">The permutation array of parent 2.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in MaximalPreservativeCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.Permutation/OrderBasedCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Permutation/OrderBasedCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.Permutation/OrderBasedCrossover.cs	(revision 1218)
@@ -92,16 +92,14 @@
 
     /// <summary>
-    /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/> by
-    /// randomly selecting some values from the first permutation that will be inserted one after each 
-    /// other; the missing ones are picked in the correct order from the second permutation.
+    /// Performs an order-based crossover operation for two given parent permutations.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The parent scope 1 to cross over.</param>
-    /// <param name="parent2">The parent scope 2 to cross over.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in OrderBasedCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.Permutation/OrderCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Permutation/OrderCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.Permutation/OrderCrossover.cs	(revision 1218)
@@ -74,16 +74,14 @@
 
     /// <summary>
-    /// Performs a cross over permuation of <paramref name="parent1"/> and <paramref name="parent2"/>
-    /// by taking a randomly chosen interval from <paramref name="parent1"/> and the rest from 
-    /// <paramref name="parent2"/>.
+    /// Performs an order crossover operation for two given parent permutations.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The parent scope 1 to cross over.</param>
-    /// <param name="parent2">The parent scope 2 to cross over.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in OrderCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.Permutation/PartiallyMatchedCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Permutation/PartiallyMatchedCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.Permutation/PartiallyMatchedCrossover.cs	(revision 1218)
@@ -87,19 +87,14 @@
 
     /// <summary>
-    /// Performs a cross over permuation of <paramref name="parent1"/> and <paramref name="parent2"/>
-    /// by taking a randomly chosen interval from <paramref name="parent1"/>, preserving the position, 
-    /// then all positions from <paramref name="parent2"/> which are still free in the child 
-    /// (the position is free and the value is "free")
-    /// and then missing ones from <paramref name="parent2"/> in the order they occur 
-    /// in <paramref name="parent2"/>.
+    /// Performs a partially matched crossover operation for two given parent permutations.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The parent scope 1 to cross over.</param>
-    /// <param name="parent2">The parent scope 2 to cross over.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in PartiallyMatchedCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.Permutation/PermutationCrossoverBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Permutation/PermutationCrossoverBase.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.Permutation/PermutationCrossoverBase.cs	(revision 1218)
@@ -28,5 +28,5 @@
 namespace HeuristicLab.Permutation {
   /// <summary>
-  /// Base class for cross over permutations.
+  /// Base class for all permutation crossover operators.
   /// </summary>
   public abstract class PermutationCrossoverBase : CrossoverBase {
@@ -41,36 +41,31 @@
 
     /// <summary>
-    /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/> with
-    /// the given random number generator (<paramref name="random"/>) to create a new 
-    /// <paramref name="child"/>.
+    /// Performs a crossover by calling <see cref="Cross(HeuristicLab.Core.IScope, HeuristicLab.Core.IRandom, int[][]"/>
+    /// and adds the created permutation to the current scope.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown when the two permutations have a different
-    /// length.</exception>
-    /// <remarks>Calls <see cref="Cross(HeuristicLab.Core.IScope, HeuristicLab.Core.IRandom, int[], int[])"/>.</remarks>
-    /// <param name="scope">The scope where to get the actual child variable name.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The parent scope 1 to cross over.</param>
-    /// <param name="parent2">The parent scope 2 to cross over.</param>
-    /// <param name="child">The child scope which to assign the permutated data.</param>
-    protected sealed override void Cross(IScope scope, IRandom random, IScope parent1, IScope parent2, IScope child) {
-      Permutation perm1 = parent1.GetVariableValue<Permutation>("Permutation", false);
-      Permutation perm2 = parent2.GetVariableValue<Permutation>("Permutation", false);
+    /// <exception cref="InvalidOperationException">Thrown if the parents have different lengths.</exception>
+    /// <param name="scope">The current scope which represents a new child.</param>
+    /// <param name="random">A random number generator.</param>
+    protected sealed override void Cross(IScope scope, IRandom random) {
+      int[][] parents = new int[scope.SubScopes.Count][];
+      int length = -1;
+      for (int i = 0; i < scope.SubScopes.Count; i++) {
+        parents[i] = scope.SubScopes[i].GetVariableValue<Permutation>("Permutation", false).Data;
+        if (i == 0) length = parents[i].Length;
+        else if (parents[i].Length != length) throw new InvalidOperationException("ERROR in PermutationCrossoverBase: Cannot apply crossover to permutations of different length");
+      }
 
-      if (perm1.Data.Length != perm2.Data.Length) throw new InvalidOperationException("Cannot apply crossover to permutations of different length.");
-
-      int[] result = Cross(scope, random, perm1.Data, perm2.Data);
-      child.AddVariable(new Variable(scope.TranslateName("Permutation"), new Permutation(result)));
+      int[] result = Cross(scope, random, parents);
+      scope.AddVariable(new Variable(scope.TranslateName("Permutation"), new Permutation(result)));
     }
 
     /// <summary>
-    /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/> with
-    /// the given random number generator (<paramref name="random"/>) .
+    /// Performs a crossover of multiple permutations.
     /// </summary>
-    /// <param name="scope">The scope of the variables.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The parent scope 1 to cross over.</param>
-    /// <param name="parent2">The parent scope 2 to cross over.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    protected abstract int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2);
+    /// <param name="scope">The current scope.</param>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing all parent permutations.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected abstract int[] Cross(IScope scope, IRandom random, int[][] parents);
   }
 }
Index: /trunk/sources/HeuristicLab.Permutation/PositionBasedCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Permutation/PositionBasedCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.Permutation/PositionBasedCrossover.cs	(revision 1218)
@@ -78,15 +78,14 @@
 
     /// <summary>
-    /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/>
-    /// based on randomly chosen positions to define which position to take from where.
+    /// Performs a position-based crossover operation for two given parent permutations.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The permutation array of parent 1.</param>
-    /// <param name="parent2">The permutation array of parent 2.</param>
-    /// <returns>The created cross over permutation as int array.</returns>
-    protected override int[] Cross(IScope scope, IRandom random, int[] parent1, int[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in PositionBasedCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.RealVector/BlendAlphaBetaCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/BlendAlphaBetaCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.RealVector/BlendAlphaBetaCrossover.cs	(revision 1218)
@@ -34,5 +34,5 @@
   /// solution by the factor alpha, into the direction of the 'worse' solution by the factor beta.
   /// </summary>
-  public class BlendAlphaBetaCrossover : CrossoverBase {
+  public class BlendAlphaBetaCrossover : RealVectorCrossoverBase {
     /// <inheritdoc select="summary"/>
     public override string Description {
@@ -45,5 +45,5 @@
     /// <summary>
     /// Initializes a new instance of <see cref="BlendAlphaBetaCrossover"/> with five variable infos
-    /// (<c>Maximization</c>, <c>Quality</c>, <c>RealVector</c>, <c>Alpha</c> and <c>Beta</c>).
+    /// (<c>Maximization</c>, <c>Quality</c>, <c>Alpha</c> and <c>Beta</c>).
     /// </summary>
     public BlendAlphaBetaCrossover()
@@ -51,5 +51,4 @@
       AddVariableInfo(new VariableInfo("Maximization", "Maximization problem", typeof(BoolData), VariableKind.In));
       AddVariableInfo(new VariableInfo("Quality", "Quality value", typeof(DoubleData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("RealVector", "Parent and child real vector", typeof(DoubleArrayData), VariableKind.In | VariableKind.New));
       VariableInfo alphaVarInfo = new VariableInfo("Alpha", "Value for alpha", typeof(DoubleData), VariableKind.In);
       alphaVarInfo.Local = true;
@@ -110,24 +109,20 @@
 
     /// <summary>
-    /// Performs a blend alpha beta crossover of two real vectors.
+    /// Performs a blend alpha beta crossover operation for two given parent real vectors.
     /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The first parent for the crossover.</param>
-    /// <param name="parent2">The second parent for the crossover.</param>
-    /// <param name="child">The created child generated through the blend alpha beta crossover.</param>
-    protected sealed override void Cross(IScope scope, IRandom random, IScope parent1, IScope parent2, IScope child) {
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
+    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
+    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in BlendAlphaBetaCrossover: The number of parents is not equal to 2");
       bool maximization = GetVariableValue<BoolData>("Maximization", scope, true).Data;
-      DoubleArrayData vector1 = parent1.GetVariableValue<DoubleArrayData>("RealVector", false);
-      DoubleData quality1 = parent1.GetVariableValue<DoubleData>("Quality", false);
-      DoubleArrayData vector2 = parent2.GetVariableValue<DoubleArrayData>("RealVector", false);
-      DoubleData quality2 = parent2.GetVariableValue<DoubleData>("Quality", false);
+      double quality1 = scope.SubScopes[0].GetVariableValue<DoubleData>("Quality", false).Data;
+      double quality2 = scope.SubScopes[1].GetVariableValue<DoubleData>("Quality", false).Data;
       double alpha = GetVariableValue<DoubleData>("Alpha", scope, true).Data;
       double beta = GetVariableValue<DoubleData>("Beta", scope, true).Data;
 
-      if (vector1.Data.Length != vector2.Data.Length) throw new InvalidOperationException("Cannot apply crossover to real vectors of different length.");
-
-      double[] result = Apply(random, maximization, vector1.Data, quality1.Data, vector2.Data, quality2.Data, alpha, beta);
-      child.AddVariable(new Variable(child.TranslateName("RealVector"), new DoubleArrayData(result)));
+      return Apply(random, maximization, parents[0], quality1, parents[1], quality2, alpha, beta);
     }
   }
Index: /trunk/sources/HeuristicLab.RealVector/BlendAlphaCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/BlendAlphaCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.RealVector/BlendAlphaCrossover.cs	(revision 1218)
@@ -78,15 +78,15 @@
 
     /// <summary>
-    /// Performs a blend alpha crossover of two real vectors.
+    /// Performs a blend alpha crossover operation for two given parent real vectors.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The first parent for the crossover operation.</param>
-    /// <param name="parent2">The second parent for the crossover operation.</param>
-    /// <returns>The newly created real vector, resulting from the blend alpha crossover.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, double[] parent1, double[] parent2) {
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
+    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
+    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in BlendAlphaCrossover: The number of parents is not equal to 2");
       double alpha = GetVariableValue<DoubleData>("Alpha", scope, true).Data;
-      return Apply(random, parent1, parent2, alpha);
+      return Apply(random, parents[0], parents[1], alpha);
     }
   }
Index: /trunk/sources/HeuristicLab.RealVector/CompleteContinuousCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/CompleteContinuousCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.RealVector/CompleteContinuousCrossover.cs	(revision 1218)
@@ -29,5 +29,5 @@
   /// <summary>
   /// Complete continuous crossover for real vectors: for each element of the new vector the average
-  /// of both parents is calculated.
+  /// of all parents is calculated.
   /// </summary>
   public class CompleteContinuousCrossover : RealVectorCrossoverBase {
@@ -38,30 +38,32 @@
 
     /// <summary>
-    /// Performs a complete continuous crossover of the two given real vectors.
+    /// Performs a complete continuous crossover of multiple given real vectors.
     /// </summary>
     /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The first parent for the crossover.</param>
-    /// <param name="parent2">The second parent for the crossover.</param>
+    /// <param name="parents">An array containing the parents that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the complete continuous crossover.</returns>
-    public static double[] Apply(IRandom random, double[] parent1, double[] parent2) {
-      int length = parent1.Length;
+    public static double[] Apply(IRandom random, double[][] parents) {
+      int length = parents[0].Length;
       double[] result = new double[length];
-
-      for (int i = 0; i < length; i++)
-        result[i] = (parent1[i] + parent2[i]) / 2;
+      for (int i = 0; i < length; i++) {
+        double sum = 0.0;
+        for (int j = 0; j < parents.Length; j++)
+          sum += parents[j][i];
+        result[i] = sum / parents.Length;
+      }
       return result;
     }
 
     /// <summary>
-    /// Performs a complete continuous crossover of the two given real vectors.
+    /// Performs a complete continuous crossover operation for multiple given parent real vectors.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are less than two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The first parent for the crossover.</param>
-    /// <param name="parent2">The second parent for the crossover.</param>
-    /// <returns>The newly created real vector, resulting from the complete continuous crossover.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, double[] parent1, double[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the real vectors that should be crossed.</param>
+    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
+    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
+      if (parents.Length < 2) throw new InvalidOperationException("ERROR in CompleteContinuousCrossover: The number of parents is less than 2");
+      return Apply(random, parents);
     }
   }
Index: /trunk/sources/HeuristicLab.RealVector/ContinuousCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/ContinuousCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.RealVector/ContinuousCrossover.cs	(revision 1218)
@@ -28,6 +28,6 @@
 namespace HeuristicLab.RealVector {
   /// <summary>
-  /// Continuous crossover for real vectors: for each element randomly either the element of the first
-  /// parent or the average of both parents is selected.
+  /// Continuous crossover for real vectors: for each element either the element of the first
+  /// parent or the average of all parents is selected randomly.
   /// </summary>
   public class ContinuousCrossover : RealVectorCrossoverBase {
@@ -38,19 +38,21 @@
 
     /// <summary>
-    /// Performs a continuous crossover of the two given real vectors.
+    /// Performs a continuous crossover of multiple given real vectors.
     /// </summary>
     /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The first parent for the crossover.</param>
-    /// <param name="parent2">The second parent for the crossover.</param>
+    /// <param name="parents">An array containing the parents that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the continuous crossover.</returns>
-    public static double[] Apply(IRandom random, double[] parent1, double[] parent2) {
-      int length = parent1.Length;
+    public static double[] Apply(IRandom random, double[][] parents) {
+      int length = parents[0].Length;
       double[] result = new double[length];
 
       for (int i = 0; i < length; i++) {
         if (random.NextDouble() < 0.5) {
-          result[i] = (parent1[i] + parent2[i]) / 2;
+          double sum = 0.0;
+          for (int j = 0; j < parents.Length; j++)
+            sum += parents[j][i];
+          result[i] = sum / parents.Length;
         } else {
-          result[i] = parent1[i];
+          result[i] = parents[0][i];
         }
       }
@@ -59,14 +61,14 @@
 
     /// <summary>
-    /// Performs a continuous crossover of the two given real vectors.
+    /// Performs a continuous crossover operation for multiple given parent real vectors.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are less than two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The first parent for the crossover.</param>
-    /// <param name="parent2">The second parent for the crossover.</param>
-    /// <returns>The newly created real vector, resulting from the continuous crossover.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, double[] parent1, double[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the real vectors that should be crossed.</param>
+    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
+    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
+      if (parents.Length < 2) throw new InvalidOperationException("ERROR in ContinuousCrossover: The number of parents is less than 2");
+      return Apply(random, parents);
     }
   }
Index: /trunk/sources/HeuristicLab.RealVector/DiscreteCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/DiscreteCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.RealVector/DiscreteCrossover.cs	(revision 1218)
@@ -27,29 +27,24 @@
 namespace HeuristicLab.RealVector {
   /// <summary>
-  /// Discrete crossover for real vectors: Selects randomly either the value of the first or the 
-  /// second parent.
+  /// Discrete crossover for real vectors: For each position in the new vector an allele
+  /// of one of the parents is randomly selected.
   /// </summary>
   public class DiscreteCrossover : RealVectorCrossoverBase {
     /// <inheritdoc select="summary"/>
     public override string Description {
-      get { return "Discrete crossover for real vectors."; }
+      get { return @"Discrete crossover for real vectors: creates a new offspring by combining the alleles in the parents such that each allele is randomly selected from one parent."; }
     }
 
     /// <summary>
-    /// Performs a discrete crossover operation of the two given parents.
+    /// Performs a discrete crossover operation on multiple given parents.
     /// </summary>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for the crossover operation.</param>
-    /// <param name="parent2">The second parent for the crossover operation.</param>
+    /// <param name="parents">An array containing the parents that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    public static double[] Apply(IRandom random, double[] parent1, double[] parent2) {
-      int length = parent1.Length;
+    public static double[] Apply(IRandom random, double[][] parents) {
+      int length = parents[0].Length;
       double[] result = new double[length];
-
       for (int i = 0; i < length; i++) {
-        if (random.NextDouble() < 0.5)
-          result[i] = parent1[i];
-        else
-          result[i] = parent2[i];
+        result[i] = parents[random.Next(parents.Length)][i];
       }
       return result;
@@ -57,13 +52,14 @@
 
     /// <summary>
-    /// Performs a discrete crossover operation of the two given parents.
+    /// Performs a discrete crossover operation for multiple given parent real vectors.
     /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if there are less than two parents.</exception>
     /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for the crossover operation.</param>
-    /// <param name="parent2">The second parent for the crossover operation.</param>
+    /// <param name="parents">An array containing the real vectors that should be crossed.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, double[] parent1, double[] parent2) {
-      return Apply(random, parent1, parent2);
+    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
+      if (parents.Length < 2) throw new InvalidOperationException("ERROR in DiscreteCrossover: The number of parents is less than 2");
+      return Apply(random, parents);
     }
   }
Index: unk/sources/HeuristicLab.RealVector/DiscreteMultiCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/DiscreteMultiCrossover.cs	(revision 1217)
+++ 	(revision )
@@ -1,73 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.RealVector {
-  /// <summary>
-  /// Discrete multiple crossover for real vectors: For each position in the new vector an allele
-  /// of one of the parents is randomly selected.
-  /// </summary>
-  public class DiscreteMultiCrossover : RealVectorMultiCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get {
-        return @"This creates a new offspring by combining the alleles in the parents such that each allele is randomly selected from one parent";
-      }
-    }
-
-    /// <summary>
-    /// Performs a discrete multiple crossover on the given <paramref name="parents"/>.     
-    /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown when the parents have different lengths.</exception>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parents">The list of parents for the multiple crossover.</param>
-    /// <returns>The newly created real vector, resulting from the discrete multiple crossover.</returns>
-    public static double[] Apply(IRandom random, IList<double[]> parents) {
-      int length = parents[0].Length;
-      double[] result = new double[length];
-      try {
-        for (int i = 0; i < length; i++) {
-          result[i] = parents[random.Next(parents.Count)][i];
-        }
-      } catch (IndexOutOfRangeException) {
-        throw new InvalidOperationException("Cannot apply multicrossover to real vectors of different length.");
-      }
-      return result;
-    }
-
-    /// <summary>
-    /// Performs a discrete multiple crossover on the given <paramref name="parents"/>.
-    /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parents">The list of parents for the multiple crossover.</param>
-    /// <returns>The newly created real vector, resulting from the discrete multiple crossover.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, IList<double[]> parents) {
-      return Apply(random, parents);
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.RealVector/HeuristicCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/HeuristicCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.RealVector/HeuristicCrossover.cs	(revision 1218)
@@ -32,8 +32,8 @@
   /// of the two parents times a randomly chosen factor.
   /// </summary>
-  public class HeuristicCrossover : CrossoverBase {
+  public class HeuristicCrossover : RealVectorCrossoverBase {
     /// <summary>
-    /// Initializes a new instance of <see cref="HeuristicCrossover"/> with three variable infos
-    /// (<c>Maximization</c>, <c>Quality</c> and <c>RealVector</c>).
+    /// Initializes a new instance of <see cref="HeuristicCrossover"/> with two variable infos
+    /// (<c>Maximization</c> and <c>Quality</c>).
     /// </summary>
     public HeuristicCrossover()
@@ -41,5 +41,4 @@
       AddVariableInfo(new VariableInfo("Maximization", "Maximization problem", typeof(BoolData), VariableKind.In));
       AddVariableInfo(new VariableInfo("Quality", "Quality value", typeof(DoubleData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("RealVector", "Parent and child real vector", typeof(DoubleArrayData), VariableKind.In | VariableKind.New));
     }
 
@@ -74,23 +73,18 @@
 
     /// <summary>
-    /// Perfomrs a heuristic crossover on the two given parents.
+    /// Performs a heuristic crossover operation for two given parent real vectors.
     /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown when the parent vectors have different lengths.</exception>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The first parent for the crossover operation.</param>
-    /// <param name="parent2">The second parent for the crossover operation.</param>
-    /// <param name="child">The newly created real vector, resulting from the heuristic crossover.</param>
-    protected sealed override void Cross(IScope scope, IRandom random, IScope parent1, IScope parent2, IScope child) {
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
+    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
+    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in HeuristicCrossover: The number of parents is not equal to 2");
       bool maximization = GetVariableValue<BoolData>("Maximization", scope, true).Data;
-      DoubleArrayData vector1 = parent1.GetVariableValue<DoubleArrayData>("RealVector", false);
-      DoubleData quality1 = parent1.GetVariableValue<DoubleData>("Quality", false);
-      DoubleArrayData vector2 = parent2.GetVariableValue<DoubleArrayData>("RealVector", false);
-      DoubleData quality2 = parent2.GetVariableValue<DoubleData>("Quality", false);
+      double quality1 = scope.SubScopes[0].GetVariableValue<DoubleData>("Quality", false).Data;
+      double quality2 = scope.SubScopes[1].GetVariableValue<DoubleData>("Quality", false).Data;
 
-      if (vector1.Data.Length != vector2.Data.Length) throw new InvalidOperationException("Cannot apply crossover to real vectors of different length.");
-
-      double[] result = Apply(random, maximization, vector1.Data, quality1.Data, vector2.Data, quality2.Data);
-      child.AddVariable(new Variable(child.TranslateName("RealVector"), new DoubleArrayData(result)));
+      return Apply(random, maximization, parents[0], quality1, parents[1], quality2);
     }
   }
Index: /trunk/sources/HeuristicLab.RealVector/HeuristicLab.RealVector.csproj
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/HeuristicLab.RealVector.csproj	(revision 1217)
+++ /trunk/sources/HeuristicLab.RealVector/HeuristicLab.RealVector.csproj	(revision 1218)
@@ -65,14 +65,10 @@
     <Compile Include="ContinuousManipulator.cs" />
     <Compile Include="DiscreteCrossover.cs" />
-    <Compile Include="DiscreteMultiCrossover.cs" />
     <Compile Include="HeuristicCrossover.cs" />
-    <Compile Include="IntermediateMultiCrossover.cs" />
     <Compile Include="MichalewiczNonUniformAllPositionsManipulator.cs" />
     <Compile Include="MichalewiczNonUniformOnePositionManipulator.cs" />
     <Compile Include="RandomConvexCrossover.cs" />
     <Compile Include="LocalCrossover.cs" />
-    <Compile Include="RealVectorMultiCrossoverBase.cs" />
-    <Compile Include="RealVectorSelfAdaptiveMultiCrossoverBase.cs" />
-    <Compile Include="SelfAdaptiveDiscreteMultiCrossover.cs" />
+    <Compile Include="SelfAdaptiveDiscreteCrossover.cs" />
     <Compile Include="SelfAdaptiveNormalAllPositionsManipulator.cs" />
     <Compile Include="UniformAllPositionsManipulator.cs" />
Index: unk/sources/HeuristicLab.RealVector/IntermediateMultiCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/IntermediateMultiCrossover.cs	(revision 1217)
+++ 	(revision )
@@ -1,70 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.RealVector {
-  /// <summary>
-  /// Intermediate multiple crossover: Creates a new offspring by computing the centroid of a list of
-  /// parents.
-  /// </summary>
-  public class IntermediateMultiCrossover : RealVectorMultiCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get {
-        return @"This creates a new offspring by computing the centroid of a number of parents";
-      }
-    }
-
-    /// <summary>
-    /// Performs an intermediate multiple crossover of the given list of <paramref name="parents"/>.
-    /// </summary>
-    /// <param name="parents">The list of parents of which to perform the crossover.</param>
-    /// <returns>The newly created real vector, resulting from the intermediate multiple crossover.</returns>
-    public static double[] Apply(IList<double[]> parents) {
-      int length = parents[0].Length;
-      double[] result = new double[length];
-      for (int i = 0; i < length; i++) {
-        double sum = 0.0;
-        for (int j = 0; j < parents.Count; j++)
-          sum += parents[j][i];
-        result[i] = sum / parents.Count;
-      }
-      return result;
-    }
-
-    /// <summary>
-    /// Performs an intermediate multiple crossover of the given list of <paramref name="parents"/>.
-    /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">A random number generator.</param>
-    /// <param name="parents">The list of parents of which to perform the crossover.</param>
-    /// <returns>The newly created real vector, resulting from the intermediate multiple crossover.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, IList<double[]> parents) {
-      return Apply(parents);
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.RealVector/LocalCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/LocalCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.RealVector/LocalCrossover.cs	(revision 1218)
@@ -57,14 +57,14 @@
 
     /// <summary>
-    /// Performs a local crossover on the two given parent vectors.
+    /// Performs a local crossover operation for two given parent real vectors.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The first parent for the crossover operation.</param>
-    /// <param name="parent2">The second parent for the crossover operation.</param>
-    /// <returns>The newly created real vector, resulting from the local crossover.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, double[] parent1, double[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
+    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
+    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in LocalCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.RealVector/RandomConvexCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/RandomConvexCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.RealVector/RandomConvexCrossover.cs	(revision 1218)
@@ -56,14 +56,14 @@
 
     /// <summary>
-    /// Performs a random convex crossover on the two given parents.
+    /// Performs a random convex crossover operation for two given parent real vectors.
     /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parent1">The first parent vector for the crossover.</param>
-    /// <param name="parent2">The second parent vector for the crossover.</param>
-    /// <returns>The newly created real vector, resulting from the random convex crossover.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, double[] parent1, double[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
+    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
+    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in RandomConvexCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.RealVector/RealVectorCrossoverBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/RealVectorCrossoverBase.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.RealVector/RealVectorCrossoverBase.cs	(revision 1218)
@@ -42,30 +42,31 @@
 
     /// <summary>
-    /// Performs a crossover of two given parents.
+    /// Performs a crossover by calling <see cref="Cross(HeuristicLab.Core.IScope, HeuristicLab.Core.IRandom, double[][]"/>
+    /// and adds the created real vector to the current scope.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if the parents have different lengths.</exception>
+    /// <param name="scope">The current scope which represents a new child.</param>
+    /// <param name="random">A random number generator.</param>
+    protected sealed override void Cross(IScope scope, IRandom random) {
+      double[][] parents = new double[scope.SubScopes.Count][];
+      int length = -1;
+      for (int i = 0; i < scope.SubScopes.Count; i++) {
+        parents[i] = scope.SubScopes[i].GetVariableValue<DoubleArrayData>("RealVector", false).Data;
+        if (i == 0) length = parents[i].Length;
+        else if (parents[i].Length != length) throw new InvalidOperationException("ERROR in RealVectorCrossoverBase: Cannot apply crossover to real vectors of different length");
+      }
+
+      double[] result = Cross(scope, random, parents);
+      scope.AddVariable(new Variable(scope.TranslateName("RealVector"), new DoubleArrayData(result)));
+    }
+
+    /// <summary>
+    /// Performs a crossover of multiple real vectors.
     /// </summary>
     /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for crossover.</param>
-    /// <param name="parent2">The second parent for crossover.</param>
-    /// <param name="child">The resulting child scope.</param>
-    protected sealed override void Cross(IScope scope, IRandom random, IScope parent1, IScope parent2, IScope child) {
-      DoubleArrayData vector1 = parent1.GetVariableValue<DoubleArrayData>("RealVector", false);
-      DoubleArrayData vector2 = parent2.GetVariableValue<DoubleArrayData>("RealVector", false);
-
-      if (vector1.Data.Length != vector2.Data.Length) throw new InvalidOperationException("Cannot apply crossover to real vectors of different length.");
-
-      double[] result = Cross(scope, random, vector1.Data, vector2.Data);
-      child.AddVariable(new Variable(child.TranslateName("RealVector"), new DoubleArrayData(result)));
-    }
-
-    /// <summary>
-    /// Performs a crossover of two given parents.
-    /// </summary>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for crossover.</param>
-    /// <param name="parent2">The second parent for crossover.</param>
+    /// <param name="parents">An array containing all parent real vectors.</param>
     /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected abstract double[] Cross(IScope scope, IRandom random, double[] parent1, double[] parent2);
+    protected abstract double[] Cross(IScope scope, IRandom random, double[][] parents);
   }
 }
Index: unk/sources/HeuristicLab.RealVector/RealVectorMultiCrossoverBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/RealVectorMultiCrossoverBase.cs	(revision 1217)
+++ 	(revision )
@@ -1,69 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Evolutionary;
-
-namespace HeuristicLab.RealVector {
-  /// <summary>
-  /// Base class for all real vector multiple crossover operators.
-  /// </summary>
-  public abstract class RealVectorMultiCrossoverBase : MultiCrossoverBase {
-    /// <summary>
-    /// Initializes a new instance of <see cref="RealVectorMultiCrossoverBase"/> with one variable info
-    /// (<c>RealVector</c>).
-    /// </summary>
-    public RealVectorMultiCrossoverBase()
-      : base() {
-      AddVariableInfo(new VariableInfo("RealVector", "Parent and child real vector", typeof(DoubleArrayData), VariableKind.In | VariableKind.New));
-    }
-
-    /// <summary>
-    /// Performs a crossover of a number of given parents.
-    /// </summary>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">A random number generator.</param>
-    /// <param name="parents">The parents for crossover.</param>
-    /// <param name="child">The resulting child scope.</param>
-    protected sealed override void Cross(IScope scope, IRandom random, IScope[] parents, IScope child) {
-      IList<double[]> parentsList = new List<double[]>(parents.Length);
-
-      for (int i = 0; i < parents.Length; i++)
-        parentsList.Add(parents[i].GetVariableValue<DoubleArrayData>("RealVector", false).Data);
-
-      double[] result = Cross(scope, random, parentsList);
-      child.AddVariable(new Variable(child.TranslateName("RealVector"), new DoubleArrayData(result)));
-    }
-
-    /// <summary>
-    /// Performs a crossover of a number of given parents.
-    /// </summary>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">A random number generator.</param>
-    /// <param name="parents">The parents for crossover.</param>
-    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
-    protected abstract double[] Cross(IScope scope, IRandom random, IList<double[]> parents);
-  }
-}
Index: unk/sources/HeuristicLab.RealVector/RealVectorSelfAdaptiveMultiCrossoverBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/RealVectorSelfAdaptiveMultiCrossoverBase.cs	(revision 1217)
+++ 	(revision )
@@ -1,78 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Evolutionary;
-
-namespace HeuristicLab.RealVector {
-  /// <summary>
-  /// Base class for self adaptive multiple crossovers for real vectors.
-  /// </summary>
-  public abstract class RealVectorSelfAdaptiveMultiCrossoverBase : MultiCrossoverBase {
-    /// <summary>
-    /// Initializes a new instance of <see cref="RealVectorSelfAdaptiveMultiCrossoverBase"/> with two
-    /// variable infos (<c>RealVector</c> and <c>StrategyVector</c>).
-    /// </summary>
-    public RealVectorSelfAdaptiveMultiCrossoverBase()
-      : base() {
-      AddVariableInfo(new VariableInfo("RealVector", "Parent and child real vector", typeof(DoubleArrayData), VariableKind.In | VariableKind.New));
-      AddVariableInfo(new VariableInfo("StrategyVector", "Endogenous strategy parameter vector", typeof(DoubleArrayData), VariableKind.In | VariableKind.New));
-    }
-
-    /// <summary>
-    /// Performs a self adaptive multiple crossover on the given list of <paramref name="parents"/>.
-    /// </summary>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parents">The list of parents of which to perform the crossover.</param>
-    /// <param name="child">The newly generated real vector, resulting from the self adaptive multiple
-    /// crossover.</param>
-    protected sealed override void Cross(IScope scope, IRandom random, IScope[] parents, IScope child) {
-      IList<double[]> parentsList = new List<double[]>(parents.Length);
-      IList<double[]> strategyParametersList = new List<double[]>(parents.Length);
-
-      for (int i = 0; i < parents.Length; i++) {
-        parentsList.Add(parents[i].GetVariableValue<DoubleArrayData>("RealVector", false).Data);
-        strategyParametersList.Add(parents[i].GetVariableValue<DoubleArrayData>("StrategyVector", false).Data);
-      }
-
-      double[] childIndividual, strategyParameters;
-      Cross(scope, random, parentsList, strategyParametersList, out childIndividual, out strategyParameters);
-      child.AddVariable(new Variable(child.TranslateName("RealVector"), new DoubleArrayData(childIndividual)));
-      child.AddVariable(new Variable(child.TranslateName("StrategyVector"), new DoubleArrayData(strategyParameters)));
-    }
-
-    /// <summary>
-    /// Performs a self adaptive multiple crossover on the given list of <paramref name="parents"/>.
-    /// </summary>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parents">The list of parents of which to perform the crossover.</param>
-    /// <param name="strategyParametersList">The strategy parameter list.</param>
-    /// <param name="childIndividual">Output parameter; the created child.</param>
-    /// <param name="strategyParameters">Output parameter; endogenous strategy parameters.</param>
-    protected abstract void Cross(IScope scope, IRandom random, IList<double[]> parents, IList<double[]> strategyParametersList, out double[] childIndividual, out double[] strategyParameters);
-  }
-}
Index: /trunk/sources/HeuristicLab.RealVector/SelfAdaptiveDiscreteCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/SelfAdaptiveDiscreteCrossover.cs	(revision 1218)
+++ /trunk/sources/HeuristicLab.RealVector/SelfAdaptiveDiscreteCrossover.cs	(revision 1218)
@@ -0,0 +1,92 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2008 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.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+
+namespace HeuristicLab.RealVector {
+  /// <summary>
+  /// Discrete crossover for real vectors: creates a new offspring by combining the alleles in the parents such that each allele is 
+  /// randomly selected from one parent. It will also use the same strategy to combine the endogenous 
+  /// strategy parameter vector.
+  /// </summary>
+  public class SelfAdaptiveDiscreteCrossover : RealVectorCrossoverBase {
+    /// <inheritdoc select="summary"/>
+    public override string Description {
+      get {
+        return @"Discrete crossover for real vectors: creates a new offspring by combining the alleles in the parents such that each allele is randomly selected from one parent. It will also use the same strategy to combine the endogenous strategy parameter vector.";
+      }
+    }
+
+    /// <summary>
+    /// Initializes a new instance of <see cref="SelfAdaptiveDiscreteCrossover"/> with one additional
+    /// variable infos (<c>StrategyVector</c>).
+    /// </summary>
+    public SelfAdaptiveDiscreteCrossover()
+      : base() {
+      AddVariableInfo(new VariableInfo("StrategyVector", "Endogenous strategy parameter vector", typeof(DoubleArrayData), VariableKind.In | VariableKind.New));
+    }
+
+    /// <summary>
+    /// Performs a discrete crossover operation for multiple given parent real vectors that combines the strategy vectors in the same way.
+    /// </summary>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the parents that should be crossed.</param>
+    /// <param name="strategies">An array containing the strategy vectors of the parents.</param>
+    /// <param name="child">The newly created real vector, resulting from the crossover operation (output parameter).</param>
+    /// <param name="strategy">The newly created strategy vector, resulting from the crossover operation (output parameter).</param>
+    public static void Apply(IRandom random, double[][] parents, double[][] strategies, out double[] child, out double[] strategy) {
+      child = new double[parents[0].Length];
+      strategy = new double[strategies[0].Length];
+      for (int i = 0; i < child.Length; i++) {
+        int nextParent = random.Next(parents.Length);
+        child[i] = parents[nextParent][i];
+        strategy[i] = strategies[nextParent][i];
+      }
+    }
+
+    /// <summary>
+    /// Performs a discrete crossover operation for multiple given parent real vectors that combines the strategy vectors in the same way.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if there are less than two parents or if the length of the strategy vectors is not the same as the length of the real vectors.</exception>
+    /// <param name="scope">The current scope.</param>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the real vectors that should be crossed.</param>
+    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
+    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
+      if (parents.Length < 2) throw new InvalidOperationException("ERROR in SelfAdaptiveDiscreteCrossover: The number of parents is less than 2");
+      double[][] strategies = new double[scope.SubScopes.Count][];
+      int length = parents[0].Length;
+      for (int i = 0; i < scope.SubScopes.Count; i++) {
+        strategies[i] = scope.SubScopes[i].GetVariableValue<DoubleArrayData>("StrategyVector", false).Data;
+        if (strategies[i].Length != length) throw new InvalidOperationException("ERROR in SelfAdaptiveDiscreteCrossover: Strategy vectors do not have the same length as the real vectors");
+      }
+
+      double[] child, strategy;
+      Apply(random, parents, strategies, out child, out strategy);
+      scope.AddVariable(new Variable(scope.TranslateName("StrategyVector"), new DoubleArrayData(strategy)));
+      return child;
+    }
+  }
+}
Index: unk/sources/HeuristicLab.RealVector/SelfAdaptiveDiscreteMultiCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/SelfAdaptiveDiscreteMultiCrossover.cs	(revision 1217)
+++ 	(revision )
@@ -1,79 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2008 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.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-
-namespace HeuristicLab.RealVector {
-  /// <summary>
-  /// Creates a new offspring by combining the alleles in the parents such that each allele is 
-  /// randomly selected from one parent. It will also use the same strategy to combine the endogenous 
-  /// strategy parameter vector. 
-  /// </summary>
-  public class SelfAdaptiveDiscreteMultiCrossover : RealVectorSelfAdaptiveMultiCrossoverBase {
-    /// <inheritdoc select="summary"/>
-    public override string Description {
-      get {
-        return @"This creates a new offspring by combining the alleles in the parents such that each allele is randomly selected from one parent. It will also use the same strategy to combine the endogenous strategy parameter vector.";
-      }
-    }
-
-    /// <summary>
-    /// Performs a self adaptive discrete multiple crossover on the given list of <paramref name="parents"/>.
-    /// </summary>
-    /// <exception cref="InvalidOperationException">Thrown when the parent vectors have different lengths.</exception>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parents">The list of parents to crossover.</param>
-    /// <param name="strategyParametersList">The strategy parameter list.</param>
-    /// <param name="childIndividual">Output parameter; the created child.</param>
-    /// <param name="strategyParameters">Output parameter; endogenous strategy parameters.</param>
-    public static void Apply(IRandom random, IList<double[]> parents, IList<double[]> strategyParametersList, out double[] childIndividual, out double[] strategyParameters) {
-      childIndividual = new double[parents[0].Length];
-      strategyParameters = new double[strategyParametersList[0].Length];
-      try {
-        for (int i = 0; i < childIndividual.Length; i++) {
-          int nextParent = random.Next(parents.Count);
-          childIndividual[i] = parents[nextParent][i];
-          strategyParameters[i] = strategyParametersList[nextParent][i];
-        }
-      } catch (IndexOutOfRangeException) {
-        throw new InvalidOperationException("Cannot apply self adaptive multicrossover to real vectors of different length.");
-      }
-    }
-
-    /// <summary>
-    /// Performs a self adaptive discrete multiple crossover on the given list of <paramref name="parents"/>.
-    /// </summary>
-    /// <remarks>Calls <see cref="Apply"/>.</remarks>
-    /// <param name="scope">The current scope.</param>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="parents">The list of parents to crossover.</param>
-    /// <param name="strategyParametersList">The strategy parameter list.</param>
-    /// <param name="childIndividual">Output parameter; the created child.</param>
-    /// <param name="strategyParameters">Output parameter; endogenous strategy parameters.</param>
-    protected override void Cross(IScope scope, IRandom random, IList<double[]> parents, IList<double[]> strategyParametersList, out double[] childIndividual, out double[] strategyParameters) {
-      Apply(random, parents, strategyParametersList, out childIndividual, out strategyParameters);
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.RealVector/SinglePointCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.RealVector/SinglePointCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.RealVector/SinglePointCrossover.cs	(revision 1218)
@@ -57,14 +57,14 @@
 
     /// <summary>
-    /// Performs a single point crossover at a randomly chosen position of the two 
-    /// given parent real vectors.
+    /// Performs a single point crossover operation for two given parent real vectors.
     /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if there are not exactly two parents.</exception>
     /// <param name="scope">The current scope.</param>
     /// <param name="random">A random number generator.</param>
-    /// <param name="parent1">The first parent for crossover.</param>
-    /// <param name="parent2">The second parent for crossover.</param>
-    /// <returns>The newly created real vector, resulting from the single point crossover.</returns>
-    protected override double[] Cross(IScope scope, IRandom random, double[] parent1, double[] parent2) {
-      return Apply(random, parent1, parent2);
+    /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
+    /// <returns>The newly created real vector, resulting from the crossover operation.</returns>
+    protected override double[] Cross(IScope scope, IRandom random, double[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in SinglePointCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
     }
   }
Index: /trunk/sources/HeuristicLab.SimOpt/SimOptDiscreteMultiCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.SimOpt/SimOptDiscreteMultiCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.SimOpt/SimOptDiscreteMultiCrossover.cs	(revision 1218)
@@ -29,5 +29,5 @@
 
 namespace HeuristicLab.SimOpt {
-  public class SimOptDiscreteMultiCrossover : MultiCrossoverBase {
+  public class SimOptDiscreteMultiCrossover : CrossoverBase {
 
     public override string Description {
@@ -40,10 +40,10 @@
     }
 
-    protected override void Cross(IScope scope, IRandom random, IScope[] parents, IScope child) {
+    protected override void Cross(IScope scope, IRandom random) {
       ICollection<IConstraint> violated;
 
-      ConstrainedItemList[] p = new ConstrainedItemList[parents.Length];
+      ConstrainedItemList[] p = new ConstrainedItemList[scope.SubScopes.Count];
       for (int i = 0; i < p.Length; i++) {
-        p[i] = parents[i].GetVariableValue<ConstrainedItemList>("Item", false);
+        p[i] = scope.SubScopes[i].GetVariableValue<ConstrainedItemList>("Item", false);
         if (i > 0 && p[i].Count != p[i-1].Count) throw new InvalidOperationException("ERROR: the lists do not contain the same number of items");
       }
@@ -55,10 +55,10 @@
           childList.BeginCombinedOperation();
           for (int i = 0; i < childList.Count; i++) {
-            int nextParent = random.Next(0, parents.Length);
+            int nextParent = random.Next(0, scope.SubScopes.Count);
             if (nextParent > 0) childList.TrySetAt(i, (IItem)p[nextParent].Clone(), out violated);
           }
         } while (!childList.EndCombinedOperation(out violated) && ++iter < 100);
         if (violated.Count == 0) {
-          child.AddVariable(new Variable(parents[0].TranslateName("Item"), childList));
+          scope.AddVariable(new Variable(scope.SubScopes[0].TranslateName("Item"), childList));
         }
       }
Index: /trunk/sources/HeuristicLab.SimOpt/SimOptSinglePointCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.SimOpt/SimOptSinglePointCrossover.cs	(revision 1217)
+++ /trunk/sources/HeuristicLab.SimOpt/SimOptSinglePointCrossover.cs	(revision 1218)
@@ -40,8 +40,8 @@
     }
 
-    protected override void Cross(IScope scope, IRandom random, IScope parent1, IScope parent2, IScope child) {
+    protected override void Cross(IScope scope, IRandom random) {
       ICollection<IConstraint> violated;
-      ConstrainedItemList p1 = parent1.GetVariableValue<ConstrainedItemList>("Item", false);
-      ConstrainedItemList p2 = parent2.GetVariableValue<ConstrainedItemList>("Item", false);
+      ConstrainedItemList p1 = scope.SubScopes[0].GetVariableValue<ConstrainedItemList>("Item", false);
+      ConstrainedItemList p2 = scope.SubScopes[1].GetVariableValue<ConstrainedItemList>("Item", false);
 
       if (p1.Count != p2.Count) throw new InvalidOperationException("ERROR: the lists do not contain the same number of items");
@@ -58,5 +58,5 @@
         } while (!childList.EndCombinedOperation(out violated) && ++iter < 100);
         if (violated.Count == 0) {
-          child.AddVariable(new Variable(parent1.TranslateName("Item"), childList));
+          scope.AddVariable(new Variable(scope.SubScopes[0].TranslateName("Item"), childList));
         }
       }
