Index: trunk/sources/HeuristicLab.Permutation/3.3/CyclicCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/CyclicCrossover.cs	(revision 2834)
+++ trunk/sources/HeuristicLab.Permutation/3.3/CyclicCrossover.cs	(revision 2835)
@@ -39,5 +39,5 @@
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when <paramref name="parent1"/> and <paramref name="parent2"/> are not of equal length.</exception>
-    /// <exception cref="InvalidOperationException">Thrown if the numbers in the permutation elements are not in the range [0,N) with N = length of the permutation.</exception>
+    /// <exception cref="InvalidOperationException">Thrown if the numbers in the permutation elements are not in the range [0;N) with N = length of the permutation.</exception>
     /// <remarks>
     /// First this method randomly determines from which parent to start with equal probability.
@@ -52,5 +52,5 @@
     /// <returns>The created cross over permutation as int array.</returns>
     public static Permutation Apply(IRandom random, Permutation parent1, Permutation parent2) {
-      if (parent1.Length != parent2.Length) throw new ArgumentException("CyclicCrossover: The parent permutations are of unequal length");
+      if (parent1.Length != parent2.Length) throw new ArgumentException("CyclicCrossover: The parent permutations are of unequal length.");
       int length = parent1.Length;
       int[] result = new int[length];
@@ -66,5 +66,5 @@
         }
       } catch (IndexOutOfRangeException) {
-        throw new InvalidOperationException("CyclicCrossover: The permutation must consist of consecutive numbers from 0 to N-1 with N = length of the permutation");
+        throw new InvalidOperationException("CyclicCrossover: The permutation must consist of numbers in the interval [0;N) with N = length of the permutation.");
       }
 
@@ -101,5 +101,5 @@
     /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
     protected override Permutation Cross(IRandom random, ItemArray<Permutation> parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("CyclicCrossover: The number of parents is not equal to 2");
+      if (parents.Length != 2) throw new InvalidOperationException("CyclicCrossover: The number of parents is not equal to 2.");
       return Apply(random, parents[0], parents[1]);
     }
Index: trunk/sources/HeuristicLab.Permutation/3.3/MaximalPreservativeCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/MaximalPreservativeCrossover.cs	(revision 2834)
+++ trunk/sources/HeuristicLab.Permutation/3.3/MaximalPreservativeCrossover.cs	(revision 2835)
@@ -29,7 +29,6 @@
   /// Performs a crossover between two permuation arrays by preserving a large number of edges in both parents.
   /// The operator also maintains the position in the arrays to some extent.
-  /// It is implemented as described in Mühlenbein, H. 1991. Evolution in time and space - the parallel genetic algorithm. FOUNDATIONS OF GENETIC ALGORITHMS, pp. 316-337. Morgan Kaufmann.
-  /// 
-  /// The length of the segment copied from the first parent to the offspring is uniformly distributed in the interval [3, N/3) with N = length of the permutation.
+  /// It is implemented as described in Mühlenbein, H. 1991. Evolution in time and space - the parallel genetic algorithm. FOUNDATIONS OF GENETIC ALGORITHMS, pp. 316-337. Morgan Kaufmann.<br /><br />
+  /// The length of the segment copied from the first parent to the offspring is uniformly distributed in the interval [3;N/3) with N = length of the permutation.
   /// This recommendation is mentioned in Pohlheim, H. 1999. Evolutionäre Algorithmen: Verfahren, Operatoren und Hinweise für die Praxis, p. 44, Springer.
   /// If the length of the permutation is smaller than 15, the size of the segment is always equal to 3.
@@ -44,5 +43,5 @@
     /// </summary>
     /// <exception cref="ArgumentException">Thrown when <paramref name="parent1"/> and <paramref name="parent2"/> are not of equal length or when the permutations are shorter than 4 elements.</exception>
-    /// <exception cref="InvalidOperationException">Thrown if the numbers in the permutation elements are not in the range [0,N) with N = length of the permutation.</exception>
+    /// <exception cref="InvalidOperationException">Thrown if the numbers in the permutation elements are not in the range [0;N) with N = length of the permutation.</exception>
     /// <remarks>
     /// First one segment is copied from the first parent to the offspring in the same position.
@@ -56,6 +55,6 @@
     /// <returns>The new permutation resulting from the crossover.</returns>
     public static Permutation Apply(IRandom random, Permutation parent1, Permutation parent2) {
-      if (parent1.Length != parent2.Length) throw new ArgumentException("MaximalPreservativeCrossover: The parent permutations are of unequal length");
-      if (parent1.Length < 4) throw new ArgumentException("MaximalPreservativeCrossover: The parent permutation must be at least of size 4");
+      if (parent1.Length != parent2.Length) throw new ArgumentException("MaximalPreservativeCrossover: The parent permutations are of unequal length.");
+      if (parent1.Length < 4) throw new ArgumentException("MaximalPreservativeCrossover: The parent permutation must be at least of size 4.");
       int length = parent1.Length;
       int[] result = new int[length];
@@ -86,5 +85,5 @@
         }
       } catch (IndexOutOfRangeException) {
-        throw new InvalidOperationException("MaximalPreservativeCrossover: The permutation must consist of consecutive numbers from 0 to N-1 with N = length of the permutation");
+        throw new InvalidOperationException("MaximalPreservativeCrossover: The permutation must consist of numbers in the interval [0;N) with N = length of the permutation.");
       }
 
Index: trunk/sources/HeuristicLab.Permutation/3.3/OrderCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/OrderCrossover.cs	(revision 2834)
+++ trunk/sources/HeuristicLab.Permutation/3.3/OrderCrossover.cs	(revision 2835)
@@ -26,12 +26,13 @@
 namespace HeuristicLab.Permutation {
   /// <summary>
-  /// An operator which performs an order crossover of two permutations.
+  /// An operator which performs the order crossover on two permutations.
   /// </summary>
   /// <remarks>
-  /// Crosses two permutations by taking a randomly chosen interval from the frist permutation, preserving
-  /// the positions, and then the missing values from the second permutation in the order they occur in the
-  /// second permutation.
+  /// It is implemented as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg.<br />
+  /// Crosses two permutations by copying a randomly chosen interval from the first permutation, preserving
+  /// the positions. Then, starting from the end of the copied interval, copies the missing values from the second permutation
+  /// in the order they occur.
   /// </remarks>
-  [Item("OrderCrossover", "An operator which performs an order crossover of two permutations.")]
+  [Item("OrderCrossover", "An operator which performs an order crossover of two permutations as described in Eiben, A.E. and Smith, J.E. 2003. Introduction to Evolutionary Computation. Natural Computing Series, Springer-Verlag Berlin Heidelberg.")]
   [EmptyStorableClass]
   [Creatable("Test")]
@@ -40,4 +41,11 @@
     /// Performs an order crossover of two permutations.
     /// </summary>
+    /// <exception cref="ArgumentException">Thrown when <paramref name="parent1"/> and <paramref name="parent2"/> are not of equal length.</exception>
+    /// <exception cref="InvalidOperationException">Thrown if the numbers in the permutation elements are not in the range [0,N) with N = length of the permutation.</exception>
+    /// <remarks>
+    /// Crosses two permutations by copying a randomly chosen interval from the first permutation, preserving
+    /// the positions. Then, starting from the end of the copied interval, copies the missing values from the second permutation
+    /// in the order they occur.
+    /// </remarks>
     /// <param name="random">A random number generator.</param>
     /// <param name="parent1">The first parent permutation to cross.</param>
@@ -45,24 +53,31 @@
     /// <returns>The new permutation resulting from the crossover.</returns>
     public static Permutation Apply(IRandom random, Permutation parent1, Permutation parent2) {
-      int[] result = new int[parent1.Length];
-      bool[] copied = new bool[result.Length];
+      if (parent1.Length != parent2.Length) throw new ArgumentException("OrderCrossover: The parent permutations are of unequal length.");
+      int length = parent1.Length;
+      int[] result = new int[length];
+      bool[] copied = new bool[length];
 
-      int breakPoint1 = random.Next(result.Length - 1);
-      int breakPoint2 = random.Next(breakPoint1 + 1, result.Length);
+      int breakPoint1 = random.Next(length - 1);
+      int breakPoint2 = random.Next(breakPoint1 + 1, length);
 
-      for (int i = breakPoint1; i <= breakPoint2; i++) {  // copy part of first permutation
-        result[i] = parent1[i];
-        copied[parent1[i]] = true;
-      }
+      try {
+        for (int j = breakPoint1; j <= breakPoint2; j++) {  // copy part of first permutation
+          result[j] = parent1[j];
+          copied[parent1[j]] = true;
+        }
 
-      int index = 0;
-      for (int i = 0; i < parent2.Length; i++) {  // copy remaining part of second permutation
-        if (index == breakPoint1) {  // skip already copied part
-          index = breakPoint2 + 1;
+        int index = ((breakPoint2 + 1 >= length) ? (0) : (breakPoint2 + 1));
+        int i = index; // for moving in parent2
+        while (index != breakPoint1) {
+          if (!copied[parent2[i]]) {
+            result[index] = parent2[i];
+            index++;
+            if (index >= length) index = 0;
+          }
+          i++;
+          if (i >= length) i = 0;
         }
-        if (!copied[parent2[i]]) {
-          result[index] = parent2[i];
-          index++;
-        }
+      } catch (IndexOutOfRangeException) {
+        throw new InvalidOperationException("OrderCrossover: The permutation must consist of numbers in the interval [0;N) with N = length of the permutation.");
       }
       return new Permutation(result);
@@ -77,5 +92,5 @@
     /// <returns>The new permutation resulting from the crossover.</returns>
     protected override Permutation Cross(IRandom random, ItemArray<Permutation> parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("Number of parents is not equal to 2.");
+      if (parents.Length != 2) throw new InvalidOperationException("OrderCrossover: Number of parents is not equal to 2.");
       return Apply(random, parents[0], parents[1]);
     }
Index: trunk/sources/HeuristicLab.Permutation/3.3/PartiallyMatchedCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/PartiallyMatchedCrossover.cs	(revision 2834)
+++ trunk/sources/HeuristicLab.Permutation/3.3/PartiallyMatchedCrossover.cs	(revision 2835)
@@ -54,6 +54,6 @@
     /// <returns>The new permutation resulting from the crossover.</returns>
     public static Permutation Apply(IRandom random, Permutation parent1, Permutation parent2) {
-      if (parent1.Length != parent2.Length) throw new ArgumentException("PartiallyMatchedCrossover: The parent permutations are of unequal length");
-      if (parent1.Length < 4) throw new ArgumentException("PartiallyMatchedCrossover: The parent permutation must be at least of size 4");
+      if (parent1.Length != parent2.Length) throw new ArgumentException("PartiallyMatchedCrossover: The parent permutations are of unequal length.");
+      if (parent1.Length < 4) throw new ArgumentException("PartiallyMatchedCrossover: The parent permutation must be at least of size 4.");
       int length = parent1.Length;
       int[] result = new int[length];
@@ -73,5 +73,5 @@
         }
       } catch (IndexOutOfRangeException) {
-        throw new InvalidOperationException("PartiallyMatchedCrossover: The permutation must consist of consecutive numbers from 0 to N-1 with N = length of the permutation");
+        throw new InvalidOperationException("PartiallyMatchedCrossover: The permutation must consist of consecutive numbers from 0 to N-1 with N = length of the permutation.");
       }
 
@@ -97,5 +97,5 @@
     /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
     protected override Permutation Cross(IRandom random, ItemArray<Permutation> parents) {
-      if (parents.Length != 2) throw new InvalidOperationException("PartiallyMatchedCrossover: The number of parents is not equal to 2");
+      if (parents.Length != 2) throw new InvalidOperationException("PartiallyMatchedCrossover: The number of parents is not equal to 2.");
       return Apply(random, parents[0], parents[1]);
     }
