Index: trunk/sources/HeuristicLab.Permutation/AbsolutePositionTopologicalCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/AbsolutePositionTopologicalCrossover.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/AbsolutePositionTopologicalCrossover.cs	(revision 850)
@@ -27,9 +27,29 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Performs a cross over permutation between two permutation arrays by taking
+  /// the entries with the same index (starting at position 0) from both parents 
+  /// (minding already inserted values).
+  /// </summary>
+  /// <example>First take the value at position 0 from parent1 then take the value at position 0
+  /// from parent2 if it has not already been inserted, afterwards take the value at position 1 from
+  /// parent1 if it has not already been inserted, then from parent2 and so on.</example>
   public class AbsolutePositionTopologicalCrossover : PermutationCrossoverBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <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 starting at position 0.
+    /// </summary>
+    /// <example>First take the value at position 0 from parent1 then take the value at position 0
+    /// from parent2 if it has not already been inserted, afterwards take the value at position 1 from
+    /// parent1 if it has not already been inserted, then from parent2 and so on.</example>
+    /// <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>
     public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
       int length = parent1.Length;
@@ -54,4 +74,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.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <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);
Index: trunk/sources/HeuristicLab.Permutation/CosaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/CosaCrossover.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/CosaCrossover.cs	(revision 850)
@@ -27,9 +27,25 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Performs a cross over permutation between two permutation arrays by taking randomly chosen 
+  /// reverse and forward intervals from the first permutation array inserting 
+  /// it in the child on different positions depending on the second permutation array.
+  /// </summary>
   public class CosaCrossover : PermutationCrossoverBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <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.
+    /// </summary>
+    /// <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>
     public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
       int length = parent1.Length;
@@ -69,4 +85,16 @@
     }
 
+    /// <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.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <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);
Index: trunk/sources/HeuristicLab.Permutation/CyclicCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/CyclicCrossover.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/CyclicCrossover.cs	(revision 850)
@@ -27,9 +27,30 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Performs a cross over permutation between two int arrays by taking first a whole cycle and then the
+  /// missing ones from the second parent.
+  /// </summary>
+  /// <remarks>A whole cycle means: <br/>
+  /// Start at a randomly chosen position x in parent1 and transfer it to the child at the same position.
+  /// Now this position x is no longer available for the node on position x in parent2, so
+  /// the value of the node at position x in parent2 is searched in parent1 and is then transferred
+  /// to the child preserving the position. Now this new position y is no longer available for the node in parent2 ....<br/>
+  /// This procedure is repeated till it is again at position x, then the cycle is over.
+  /// </remarks>
   public class CyclicCrossover : PermutationCrossoverBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <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.
+    /// </summary>
+    /// <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>
     public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
       int length = parent1.Length;
@@ -58,4 +79,15 @@
     }
 
+    /// <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.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <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);
Index: trunk/sources/HeuristicLab.Permutation/EdgeRecombinationCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/EdgeRecombinationCrossover.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/EdgeRecombinationCrossover.cs	(revision 850)
@@ -27,9 +27,27 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Performs a cross over permutation between two permutation arrays by calculating the edges (neighbours)
+  /// 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.
+  /// </summary>
   public class EdgeRecombinationCrossover : PermutationCrossoverBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <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.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when the permutation lacks a number.
+    /// </exception>
+    /// <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>
     public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
       int length = parent1.Length;
@@ -120,4 +138,18 @@
     }
 
+    /// <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.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when the permutation lacks a number.
+    /// </exception>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <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);
Index: trunk/sources/HeuristicLab.Permutation/HeuristicLabPermutationPlugin.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/HeuristicLabPermutationPlugin.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/HeuristicLabPermutationPlugin.cs	(revision 850)
@@ -26,4 +26,7 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Permutation plugin.
+  /// </summary>
   [ClassInfo(Name = "HeuristicLab.Permutation-3.2")]
   [PluginFile(Filename = "HeuristicLab.Permutation-3.2.dll", Filetype = PluginFileType.Assembly)]
Index: trunk/sources/HeuristicLab.Permutation/InsertionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/InsertionManipulator.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/InsertionManipulator.cs	(revision 850)
@@ -26,9 +26,20 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Manipulates a permutation array by moving randomly one element to another position in the array.
+  /// </summary>
   public class InsertionManipulator : PermutationManipulatorBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <summary>
+    /// Moves an randomly chosen element in the specified <paramref name="permutation"/> array 
+    /// to another randomly generated position.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     public static int[] Apply(IRandom random, int[] permutation) {
       int[] result = (int[])permutation.Clone();
@@ -58,4 +69,13 @@
     }
 
+    /// <summary>
+    /// Moves an randomly chosen element in the specified <paramref name="permutation"/> array 
+    /// to another randomly generated position.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="scope">The current scope.</param>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
       return Apply(random, permutation);
Index: trunk/sources/HeuristicLab.Permutation/InversionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/InversionManipulator.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/InversionManipulator.cs	(revision 850)
@@ -26,9 +26,19 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Manipulates a permutation array by reversing a randomly chosen interval.
+  /// </summary>
   public class InversionManipulator : PermutationManipulatorBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <summary>
+    /// Reverses the specified <paramref name="permutation"/> between two randomly generated positions.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     public static int[] Apply(IRandom random, int[] permutation) {
       int[] result = (int[])permutation.Clone();
@@ -47,4 +57,12 @@
     }
 
+    /// <summary>
+    /// Reverses the specified <paramref name="permutation"/> between two randomly generated positions.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="scope">The current scope.</param>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
       return Apply(random, permutation);
Index: trunk/sources/HeuristicLab.Permutation/MaximalPreservativeCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/MaximalPreservativeCrossover.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/MaximalPreservativeCrossover.cs	(revision 850)
@@ -27,9 +27,23 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Performs a cross over permutation between two permuation arrays by preserving a preferably big
+  /// region from one permutation array.
+  /// </summary>
   public class MaximalPreservativeCrossover : PermutationCrossoverBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <summary>
+    /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/>
+    /// by preserving a preferably big randomly chosen region of one permutation and taking 
+    /// the missing ones from the other permuation array.
+    /// </summary>
+    /// <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>
     public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
       int length = parent1.Length;
@@ -63,4 +77,15 @@
     }
 
+    /// <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.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <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);
Index: trunk/sources/HeuristicLab.Permutation/OrderBasedCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/OrderBasedCrossover.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/OrderBasedCrossover.cs	(revision 850)
@@ -27,9 +27,24 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Performs a cross over permutation of two permutation arrays by taking randomly a selection of values 
+  /// (not an interval!) from the first permutation keeping the correct order and filling 
+  /// the missing entries with the elements from the second permutation, also in the right order.
+  /// </summary>
   public class OrderBasedCrossover : PermutationCrossoverBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <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.
+    /// </summary>
+    /// <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>
     public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
       int length = parent1.Length;
@@ -76,4 +91,15 @@
     }
 
+    /// <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.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <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);
Index: trunk/sources/HeuristicLab.Permutation/OrderCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/OrderCrossover.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/OrderCrossover.cs	(revision 850)
@@ -27,9 +27,25 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Performs a cross over permutation between two permuation arrays
+  /// by taking a randomly chosen interval from the frist, preserving the positions,
+  /// then the missing values from the second array in the order they occur in the second array.
+  /// </summary>
   public class OrderCrossover : PermutationCrossoverBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <summary>
+    /// Performs a cross over permutation of <paramref name="parent1"/> and 
+    /// <paramref name="parent2"/> by taking a randomly chosen interval from <paramref name="parent1"/>,
+    /// preserving the positions and then the missing values from <paramref name="parent2"/> in the 
+    /// order they occur in <paramref name="parent2"/>.
+    /// </summary>
+    /// <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>
     public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
       int[] result = new int[parent1.Length];
@@ -57,4 +73,15 @@
     }
 
+    /// <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"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <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);
Index: trunk/sources/HeuristicLab.Permutation/PartiallyMatchedCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/PartiallyMatchedCrossover.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/PartiallyMatchedCrossover.cs	(revision 850)
@@ -27,9 +27,29 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Performs a cross over permutation between two permuation arrays
+  /// by taking a randomly chosen interval from the first, keeping the position, 
+  /// then all positions from the second permutation which are still free in the child 
+  /// (the position is free and the value is "free")
+  /// and then missing ones from the second array in the order they occur in the second array.
+  /// </summary>
   public class PartiallyMatchedCrossover : PermutationCrossoverBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <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"/>.
+    /// </summary>
+    /// <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>
     public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
       int length = parent1.Length;
@@ -66,4 +86,18 @@
     }
 
+    /// <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"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <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);
Index: trunk/sources/HeuristicLab.Permutation/Permutation.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/Permutation.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/Permutation.cs	(revision 850)
@@ -27,12 +27,29 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// The base class for a permutation, which is an ordered combination. 
+  /// </summary>
   public class Permutation : IntArrayData {
+    /// <summary>
+    /// Initializes a new instance of <see cref="Permutation"/>.
+    /// </summary>
     public Permutation()
       : base() {
     }
+    /// <summary>
+    /// Initializes a new instance of <see cref="Permutation"/> with the given 
+    /// <paramref name="permutation"/> array.
+    /// </summary>
+    /// <param name="permutation">The permutation array to assign.</param>
     public Permutation(int[] permutation)
       : base(permutation) {
     }
 
+    /// <summary>
+    /// Clones the current instance.
+    /// </summary>
+    /// <param name="clonedObjects">A dictionary of all already cloned objects. (Needed to 
+    /// avoid cycles.)</param>
+    /// <returns>The cloned object as <see cref="Permutation"/>.</returns>
     public override object Clone(IDictionary<Guid, object> clonedObjects) {
       Permutation clone = new Permutation((int[])Data.Clone());
Index: trunk/sources/HeuristicLab.Permutation/PermutationCrossoverBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/PermutationCrossoverBase.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/PermutationCrossoverBase.cs	(revision 850)
@@ -27,5 +27,12 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Base class for cross over permutations.
+  /// </summary>
   public abstract class PermutationCrossoverBase : CrossoverBase {
+    /// <summary>
+    /// Initializes a new instance of <see cref="PermutationCrossoverBase"/> with one variable info
+    /// (<c>Permutation</c>).
+    /// </summary>
     public PermutationCrossoverBase()
       : base() {
@@ -33,4 +40,17 @@
     }
 
+    /// <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"/>.
+    /// </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);
@@ -43,4 +63,13 @@
     }
 
+    /// <summary>
+    /// Performs a cross over permutation of <paramref name="parent1"/> and <paramref name="parent2"/> with
+    /// the given random number generator (<paramref name="random"/>) .
+    /// </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);
   }
Index: trunk/sources/HeuristicLab.Permutation/PermutationManipulatorBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/PermutationManipulatorBase.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/PermutationManipulatorBase.cs	(revision 850)
@@ -26,5 +26,12 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Base class for manipulation permutation.
+  /// </summary>
   public abstract class PermutationManipulatorBase : OperatorBase {
+    /// <summary>
+    /// Initializes a new instance of <see cref="PermutationManipulatorBase"/> with two variable infos
+    /// (<c>Random</c> and <c>Permutation</c>).
+    /// </summary>
     public PermutationManipulatorBase()
       : base() {
@@ -33,4 +40,11 @@
     }
 
+    /// <summary>
+    /// Manipulates the permutation data of the given <paramref name="scope"/> according to a
+    /// specified random number generator.
+    /// </summary>
+    /// <remarks>Calls <see cref="Manipulate"/>.</remarks>
+    /// <param name="scope">The scope of the permutation data and the random number generator.</param>
+    /// <returns><c>null</c>.</returns>
     public override IOperation Apply(IScope scope) {
       IRandom random = GetVariableValue<IRandom>("Random", scope, true);
@@ -40,4 +54,12 @@
     }
 
+    /// <summary>
+    /// Manipulates the given <paramref name="permutation"/> with the specified <paramref name="random"/> 
+    /// number generator.
+    /// </summary>
+    /// <param name="scope">The scope of the variables.</param>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation to manipulate.</param>
+    /// <returns>The manipulated permutation as int array.</returns>
     protected abstract int[] Manipulate(IScope scope, IRandom random, int[] permutation);
   }
Index: trunk/sources/HeuristicLab.Permutation/PositionBasedCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/PositionBasedCrossover.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/PositionBasedCrossover.cs	(revision 850)
@@ -27,9 +27,21 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Performs a cross over permutation between two permutation arrays based on randomly chosen positions.
+  /// </summary>
   public class PositionBasedCrossover : PermutationCrossoverBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <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.
+    /// </summary>
+    /// <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>
     public static int[] Apply(IRandom random, int[] parent1, int[] parent2) {
       int length = parent1.Length;
@@ -65,4 +77,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.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <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);
Index: trunk/sources/HeuristicLab.Permutation/RandomPermutationGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/RandomPermutationGenerator.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/RandomPermutationGenerator.cs	(revision 850)
@@ -27,9 +27,17 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Generates a randomly shuffled permuation.
+  /// </summary>
   public class RandomPermutationGenerator : OperatorBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <summary>
+    /// Initializes a new instance of <see cref="RandomPermutationGenerator"/> with three variable infos
+    /// (<c>Length</c>, <c>Random</c> and <c>Permutation</c>).
+    /// </summary>
     public RandomPermutationGenerator()
       : base() {
@@ -39,4 +47,10 @@
     }
 
+    /// <summary>
+    /// Generates a randomly shuffled permutation.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="length">The length of the permutation to create.</param>
+    /// <returns>The generated permuation as int array.</returns>
     public static int[] Apply(IRandom random, int length) {
       int[] perm = new int[length];
@@ -56,4 +70,10 @@
     }
 
+    /// <summary>
+    /// Generates a randomly shuffled permutation.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply(HeuristicLab.Core.IRandom, int)"/>.</remarks>
+    /// <param name="scope">The current scope with the variables.</param>
+    /// <returns><c>null</c>.</returns>
     public override IOperation Apply(IScope scope) {
       IRandom random = GetVariableValue<IRandom>("Random", scope, true);
Index: trunk/sources/HeuristicLab.Permutation/ScrambleManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/ScrambleManipulator.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/ScrambleManipulator.cs	(revision 850)
@@ -26,9 +26,20 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Manipulates a permutation array by randomly scrambling the elements in a randomly chosen interval.
+  /// </summary>
   public class ScrambleManipulator : PermutationManipulatorBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <summary>
+    /// Mixes the elements of the given <paramref name="permutation"/> randomly 
+    /// in a randomly chosen interval.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     public static int[] Apply(IRandom random, int[] permutation) {
       int[] result = (int[])permutation.Clone();
@@ -67,4 +78,13 @@
     }
 
+    /// <summary>
+    /// Mixes the elements of the given <paramref name="permutation"/> randomly 
+    /// in a randomly chosen interval.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="scope">The current scope.</param>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
       return Apply(random, permutation);
Index: trunk/sources/HeuristicLab.Permutation/Swap2Manipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/Swap2Manipulator.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/Swap2Manipulator.cs	(revision 850)
@@ -26,9 +26,19 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Manipulates a permutation array by swapping to randomly chosen elements.
+  /// </summary>
   public class Swap2Manipulator : PermutationManipulatorBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <summary>
+    /// Swaps two randomly chosen elements in the given <paramref name="permutation"/> array.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     public static int[] Apply(IRandom random, int[] permutation) {
       int[] result = (int[])permutation.Clone();
@@ -45,4 +55,12 @@
     }
 
+    /// <summary>
+    /// Swaps two randomly chosen elements in the given <paramref name="permutation"/> array.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="scope">The current scope.</param>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
       return Apply(random, permutation);
Index: trunk/sources/HeuristicLab.Permutation/Swap3Manipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/Swap3Manipulator.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/Swap3Manipulator.cs	(revision 850)
@@ -26,9 +26,19 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Manipulates a permutation array by swaping three randomly chosen elements.
+  /// </summary>
   public class Swap3Manipulator : PermutationManipulatorBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <summary>
+    /// Swaps three randomly chosen elements of the given <paramref name="permutation"/> array.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     public static int[] Apply(IRandom random, int[] permutation) {
       int[] result = (int[])permutation.Clone();
@@ -61,4 +71,12 @@
     }
 
+    /// <summary>
+    /// Swaps three randomly chosen elements of the given <paramref name="permutation"/> array.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="scope">The current scope.</param>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
       return Apply(random, permutation);
Index: trunk/sources/HeuristicLab.Permutation/TranslocationInversionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/TranslocationInversionManipulator.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/TranslocationInversionManipulator.cs	(revision 850)
@@ -26,9 +26,21 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Manipulates a permutation array by moving and reversing a randomly chosen interval of elements to another 
+  /// (randomly chosen) position in the array.
+  /// </summary>
   public class TranslocationInversionManipulator : PermutationManipulatorBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <summary>
+    /// Moves a randomly chosen interval of elements to another (randomly chosen) position in the given
+    /// <paramref name="permutation"/> array and reverses it.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     public static int[] Apply(IRandom random, int[] permutation) {
       int[] result = (int[])permutation.Clone();
@@ -64,4 +76,13 @@
     }
 
+    /// <summary>
+    /// Moves a randomly chosen interval of elements to another (randomly chosen) position in the given
+    /// <paramref name="permutation"/> array and reverses it.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="scope">The current scope.</param>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
       return Apply(random, permutation);
Index: trunk/sources/HeuristicLab.Permutation/TranslocationManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/TranslocationManipulator.cs	(revision 755)
+++ trunk/sources/HeuristicLab.Permutation/TranslocationManipulator.cs	(revision 850)
@@ -26,9 +26,21 @@
 
 namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Manipulates a permutation array by moving a randomly chosen interval of elements to another 
+  /// (randomly chosen) position in the array.
+  /// </summary>
   public class TranslocationManipulator : PermutationManipulatorBase {
+    /// <inheritdoc select="summary"/>
     public override string Description {
       get { return @"TODO\r\nOperator description still missing ..."; }
     }
 
+    /// <summary>
+    /// Moves a randomly chosen interval of elements to another (randomly chosen) position in the given
+    /// <paramref name="permutation"/> array.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     public static int[] Apply(IRandom random, int[] permutation) {
       int[] result = (int[])permutation.Clone();
@@ -64,4 +76,13 @@
     }
 
+    /// <summary>
+    /// Moves a randomly chosen interval of elements to another (randomly chosen) position in the given
+    /// <paramref name="permutation"/> array.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="scope">The current scope.</param>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="permutation">The permutation array to manipulate.</param>
+    /// <returns>The new permuation array with the manipulated data.</returns>
     protected override int[] Manipulate(IScope scope, IRandom random, int[] permutation) {
       return Apply(random, permutation);
