Index: trunk/sources/HeuristicLab.RealVector/BlendAlphaBetaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.RealVector/BlendAlphaBetaCrossover.cs	(revision 1184)
+++ 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 1184)
+++ 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 1184)
+++ 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 1184)
+++ 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 1184)
+++ 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: trunk/sources/HeuristicLab.RealVector/DiscreteMultiCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.RealVector/DiscreteMultiCrossover.cs	(revision 1184)
+++ 	(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 1184)
+++ 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 1184)
+++ 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: trunk/sources/HeuristicLab.RealVector/IntermediateMultiCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.RealVector/IntermediateMultiCrossover.cs	(revision 1184)
+++ 	(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 1184)
+++ 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 1184)
+++ 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 1184)
+++ 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: trunk/sources/HeuristicLab.RealVector/RealVectorMultiCrossoverBase.cs
===================================================================
--- trunk/sources/HeuristicLab.RealVector/RealVectorMultiCrossoverBase.cs	(revision 1184)
+++ 	(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: trunk/sources/HeuristicLab.RealVector/RealVectorSelfAdaptiveMultiCrossoverBase.cs
===================================================================
--- trunk/sources/HeuristicLab.RealVector/RealVectorSelfAdaptiveMultiCrossoverBase.cs	(revision 1184)
+++ 	(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: trunk/sources/HeuristicLab.RealVector/SelfAdaptiveDiscreteMultiCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.RealVector/SelfAdaptiveDiscreteMultiCrossover.cs	(revision 1184)
+++ 	(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 1184)
+++ 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]);
     }
   }
