Index: trunk/sources/HeuristicLab.Permutation/3.3/AbsolutePositionTopologicalCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/AbsolutePositionTopologicalCrossover.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/AbsolutePositionTopologicalCrossover.cs	(revision 1685)
@@ -0,0 +1,89 @@
+#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.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;
+      int[] result = new int[length];
+      bool[] numberCopied = new bool[length];
+      int index;
+
+      index = 0;
+      for (int i = 0; i < length; i++) {  // copy numbers from both parent permutations
+        if (!numberCopied[parent1[i]]) {
+          result[index] = parent1[i];
+          numberCopied[parent1[i]] = true;
+          index++;
+        }
+        if (!numberCopied[parent2[i]]) {
+          result[index] = parent2[i];
+          numberCopied[parent2[i]] = true;
+          index++;
+        }
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs an absolute position topological crossover operation for two given parent permutations.
+    /// </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="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in AbsolutePositionTopologicalCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/CosaCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/CosaCrossover.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/CosaCrossover.cs	(revision 1685)
@@ -0,0 +1,100 @@
+#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.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;
+      int[] result = new int[length];
+      int crossPoint, startIndex, endIndex;
+
+      crossPoint = random.Next(length);
+      startIndex = (crossPoint + 1) % length;
+
+      int i = 0;
+      while ((i < parent2.Length) && (parent2[i] != parent1[startIndex])) {  // find index of start value in second permutation
+        i++;
+      }
+      i = (i + 1) % length;
+      int j = 0;
+      while ((j < parent1.Length) && (parent1[j] != parent2[i])) {  // find index of parent2[i] in first permutation
+        j++;
+      }
+      endIndex = (j - 1 + length) % length;
+
+      i = endIndex;
+      j = 0;
+      do {  // permutation from end to crosspoint (backwards)
+        result[j] = parent1[i];
+        i = (i - 1 + length) % length;
+        j++;
+      } while (i != crossPoint);
+
+      i = (endIndex + 1) % length;
+      while (i != crossPoint) {  // permutation from end to crosspoint (forwards)
+        result[j] = parent1[i];
+        i = (i + 1) % length;
+        j++;
+      }
+      result[j] = parent1[crossPoint];  // last station: crosspoint
+      return result;
+    }
+
+    /// <summary>
+    /// Performs a COSA crossover operation for two given parent permutations.
+    /// </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="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in CosaCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/CyclicCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/CyclicCrossover.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/CyclicCrossover.cs	(revision 1685)
@@ -0,0 +1,94 @@
+#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.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;
+      int[] result = new int[length];
+      bool[] indexCopied = new bool[length];
+      int j, number;
+
+      j = random.Next(length);  // get number to start cycle
+      while (!indexCopied[j]) {  // copy whole cycle to new permutation
+        result[j] = parent1[j];
+        number = parent2[j];
+        indexCopied[j] = true;
+
+        j = 0;
+        while ((j < length) && (parent1[j] != number)) {  // search copied number in second permutation
+          j++;
+        }
+      }
+
+      for (int i = 0; i < length; i++) {  // copy rest of secound permutation to new permutation
+        if (!indexCopied[i]) {
+          result[i] = parent2[i];
+        }
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs a cyclic crossover operation for two given parent permutations.
+    /// </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="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in CyclicCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/EdgeRecombinationCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/EdgeRecombinationCrossover.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/EdgeRecombinationCrossover.cs	(revision 1685)
@@ -0,0 +1,153 @@
+#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.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;
+      int[] result = new int[length];
+      int[,] edgeList = new int[length, 4];
+      bool[] remainingNumbers = new bool[length];
+      int index, currentEdge, currentNumber, nextNumber, currentEdgeCount, minEdgeCount;
+
+      for (int i = 0; i < length; i++) {  // generate edge list for every number
+        remainingNumbers[i] = true;
+
+        index = 0;
+        while ((index < length) && (parent1[index] != i)) {  // search edges in parent1
+          index++;
+        }
+        if (index == length) {
+          throw (new InvalidOperationException("Permutation doesn't contain number " + i + "."));
+        } else {
+          edgeList[i, 0] = parent1[(index - 1 + length) % length];
+          edgeList[i, 1] = parent1[(index + 1) % length];
+        }
+        index = 0;
+        while ((index < length) && (parent2[index] != i)) {  // search edges in parent2
+          index++;
+        }
+        if (index == length) {
+          throw (new InvalidOperationException("Permutation doesn't contain number " + i + "."));
+        } else {
+          currentEdge = parent2[(index - 1 + length) % length];
+          if ((edgeList[i, 0] != currentEdge) && (edgeList[i, 1] != currentEdge)) {  // new edge found ?
+            edgeList[i, 2] = currentEdge;
+          } else {
+            edgeList[i, 2] = -1;
+          }
+          currentEdge = parent2[(index + 1) % length];
+          if ((edgeList[i, 0] != currentEdge) && (edgeList[i, 1] != currentEdge)) {  // new edge found ?
+            edgeList[i, 3] = currentEdge;
+          } else {
+            edgeList[i, 3] = -1;
+          }
+        }
+      }
+
+      currentNumber = random.Next(length);  // get number to start
+      for (int i = 0; i < length; i++) {
+        result[i] = currentNumber;
+        remainingNumbers[currentNumber] = false;
+
+        for (int j = 0; j < 4; j++) {  // remove all edges to / from currentNumber
+          if (edgeList[currentNumber, j] != -1) {
+            for (int k = 0; k < 4; k++) {
+              if (edgeList[edgeList[currentNumber, j], k] == currentNumber) {
+                edgeList[edgeList[currentNumber, j], k] = -1;
+              }
+            }
+          }
+        }
+
+        minEdgeCount = 5;  // every number hasn't more than 4 edges
+        nextNumber = -1;
+        for (int j = 0; j < 4; j++) {  // find next number with least edges
+          if (edgeList[currentNumber, j] != -1) {  // next number found
+            currentEdgeCount = 0;
+            for (int k = 0; k < 4; k++) {  // count edges of next number
+              if (edgeList[edgeList[currentNumber, j], k] != -1) {
+                currentEdgeCount++;
+              }
+            }
+            if ((currentEdgeCount < minEdgeCount) ||
+              ((currentEdgeCount == minEdgeCount) && (random.NextDouble() < 0.5))) {
+              nextNumber = edgeList[currentNumber, j];
+              minEdgeCount = currentEdgeCount;
+            }
+          }
+        }
+        currentNumber = nextNumber;
+        if (currentNumber == -1) {  // current number has no more edge
+          index = 0;
+          while ((index < length) && (!remainingNumbers[index])) {  // choose next remaining number
+            index++;
+          }
+          if (index < length) {
+            currentNumber = index;
+          }
+        }
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs an edge recombination crossover operation for two given parent permutations.
+    /// </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="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in EdgeRecombinationCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/HeuristicLab.Permutation-3.2.csproj
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/HeuristicLab.Permutation-3.2.csproj	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/HeuristicLab.Permutation-3.2.csproj	(revision 1685)
@@ -0,0 +1,160 @@
+﻿<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="3.5">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{55FDCFB3-3E8C-4FB0-837C-0CF06BEDED39}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Permutation</RootNamespace>
+    <AssemblyName>HeuristicLab.Permutation-3.2</AssemblyName>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>2.0</OldToolsVersion>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
+    <DocumentationFile>bin\Release\HeuristicLab.Permutation-3.2.XML</DocumentationFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>bin\Release\HeuristicLab.Permutation-3.2.XML</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>bin\Release\HeuristicLab.Permutation-3.2.XML</DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="AbsolutePositionTopologicalCrossover.cs" />
+    <Compile Include="CosaCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="CyclicCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="EdgeRecombinationCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="InsertionManipulator.cs" />
+    <Compile Include="InversionManipulator.cs" />
+    <Compile Include="MaximalPreservativeCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="OrderBasedCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="OrderCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="PartiallyMatchedCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="PermutationCrossoverBase.cs" />
+    <Compile Include="HeuristicLabPermutationPlugin.cs" />
+    <Compile Include="Permutation.cs" />
+    <Compile Include="PermutationManipulatorBase.cs" />
+    <Compile Include="PositionBasedCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RandomPermutationGenerator.cs" />
+    <Compile Include="ScrambleManipulator.cs" />
+    <Compile Include="Swap2Manipulator.cs" />
+    <Compile Include="Swap3Manipulator.cs" />
+    <Compile Include="TranslocationInversionManipulator.cs" />
+    <Compile Include="TranslocationManipulator.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Properties\AssemblyInfo.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.2\HeuristicLab.Core-3.2.csproj">
+      <Project>{F43B59AB-2B8C-4570-BC1E-15592086517C}</Project>
+      <Name>HeuristicLab.Core-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.2\HeuristicLab.Data-3.2.csproj">
+      <Project>{F473D9AF-3F09-4296-9F28-3C65118DAFFA}</Project>
+      <Name>HeuristicLab.Data-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Evolutionary\3.2\HeuristicLab.Evolutionary-3.2.csproj">
+      <Project>{F5614C53-153C-4A37-A608-121E1C087F07}</Project>
+      <Name>HeuristicLab.Evolutionary-3.2</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\HeuristicLab.PluginInfrastructure.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.2\HeuristicLab.Random-3.2.csproj">
+      <Project>{47019A74-F7F7-482E-83AA-D3F4F777E879}</Project>
+      <Name>HeuristicLab.Random-3.2</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd</PreBuildEvent>
+  </PropertyGroup>
+</Project>
Index: trunk/sources/HeuristicLab.Permutation/3.3/HeuristicLabPermutationPlugin.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/HeuristicLabPermutationPlugin.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/HeuristicLabPermutationPlugin.cs	(revision 1685)
@@ -0,0 +1,38 @@
+#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.PluginInfrastructure;
+
+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)]
+  [Dependency(Dependency = "HeuristicLab.Core-3.2")]
+  [Dependency(Dependency = "HeuristicLab.Data-3.2")]
+  [Dependency(Dependency = "HeuristicLab.Evolutionary-3.2")]
+  public class HeuristicLabRandomPlugin : PluginBase {
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/InsertionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/InsertionManipulator.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/InsertionManipulator.cs	(revision 1685)
@@ -0,0 +1,84 @@
+#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;
+
+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();
+      int cutIndex, insertIndex, number;
+
+      cutIndex = random.Next(permutation.Length);
+      insertIndex = random.Next(permutation.Length);
+      number = permutation[cutIndex];
+
+      int i = 0;  // index in new permutation
+      int j = 0;  // index in old permutation
+      while (i < permutation.Length) {
+        if (j == cutIndex) {
+          j++;
+        }
+        if (i == insertIndex) {
+          result[i] = number;
+          i++;
+        }
+        if ((i < permutation.Length) && (j < permutation.Length)) {
+          result[i] = permutation[j];
+          i++;
+          j++;
+        }
+      }
+      return result;
+    }
+
+    /// <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/3.3/InversionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/InversionManipulator.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/InversionManipulator.cs	(revision 1685)
@@ -0,0 +1,71 @@
+#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;
+
+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();
+      int breakPoint1, breakPoint2;
+
+      breakPoint1 = random.Next(result.Length - 1);
+      do {
+        breakPoint2 = random.Next(result.Length - 1);
+      } while (breakPoint2 == breakPoint1);
+      if (breakPoint2 < breakPoint1) { int h = breakPoint1; breakPoint1 = breakPoint2; breakPoint2 = h; }
+
+      for (int i = 0; i <= (breakPoint2 - breakPoint1); i++) {  // reverse permutation between breakpoints
+        result[breakPoint1 + i] = permutation[breakPoint2 - i];
+      }
+      return result;
+    }
+
+    /// <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/3.3/MaximalPreservativeCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/MaximalPreservativeCrossover.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/MaximalPreservativeCrossover.cs	(revision 1685)
@@ -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.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;
+      int[] result = new int[length];
+      bool[] numberCopied = new bool[length];
+      int breakPoint1, breakPoint2, subsegmentLength, index;
+
+      if (length >= 20) {  // length of subsegment must be >= 10 and <= length / 2
+        breakPoint1 = random.Next(length - 9);
+        subsegmentLength = random.Next(10, Math.Min((int)(length / 2), length - breakPoint1) + 1);
+        breakPoint2 = breakPoint1 + subsegmentLength - 1;
+      } else {
+        breakPoint1 = random.Next(length - 1);
+        breakPoint2 = random.Next(breakPoint1 + 1, length);
+      }
+
+      index = 0;
+      for (int i = breakPoint1; i <= breakPoint2; i++) {  // copy part of first permutation
+        result[index] = parent1[i];
+        numberCopied[result[index]] = true;
+        index++;
+      }
+
+      for (int i = 0; i < parent2.Length; i++) {  // copy remaining part of second permutation
+        if (!numberCopied[parent2[i]]) {
+          result[index] = parent2[i];
+          index++;
+        }
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs a maximal preservative crossover operation for two given parent permutations.
+    /// </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="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in MaximalPreservativeCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/OrderBasedCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/OrderBasedCrossover.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/OrderBasedCrossover.cs	(revision 1685)
@@ -0,0 +1,106 @@
+#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.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;
+      int[] result = new int[length];
+      int[] selectedNumbers = new int[random.Next(length + 1)];
+      bool[] numberSelected = new bool[length];
+      int index, selectedIndex, currentIndex;
+
+      for (int i = 0; i < selectedNumbers.Length; i++) {  // select numbers for array
+        index = 0;
+        while (numberSelected[parent1[index]]) {  // find first valid index
+          index++;
+        }
+
+        selectedIndex = random.Next(length - i);
+        currentIndex = 0;
+        while ((index < parent1.Length) && (currentIndex != selectedIndex)) {  // find selected number
+          index++;
+          if (!numberSelected[parent1[index]]) {
+            currentIndex++;
+          }
+        }
+        numberSelected[parent1[index]] = true;
+      }
+
+      index = 0;
+      for (int i = 0; i < parent1.Length; i++) {  // copy selected numbers in array
+        if (numberSelected[parent1[i]]) {
+          selectedNumbers[index] = parent1[i];
+          index++;
+        }
+      }
+
+      index = 0;
+      for (int i = 0; i < result.Length; i++) {  // copy rest of second permutation and selected numbers in order of first permutation
+        if (numberSelected[parent2[i]]) {
+          result[i] = selectedNumbers[index];
+          index++;
+        } else {
+          result[i] = parent2[i];
+        }
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs an order-based crossover operation for two given parent permutations.
+    /// </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="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in OrderBasedCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/OrderCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/OrderCrossover.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/OrderCrossover.cs	(revision 1685)
@@ -0,0 +1,88 @@
+#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.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];
+      bool[] copied = new bool[result.Length];
+
+      int breakPoint1 = random.Next(result.Length - 1);
+      int breakPoint2 = random.Next(breakPoint1 + 1, result.Length);
+
+      for (int i = breakPoint1; i <= breakPoint2; i++) {  // copy part of first permutation
+        result[i] = parent1[i];
+        copied[parent1[i]] = 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;
+        }
+        if (!copied[parent2[i]]) {
+          result[index] = parent2[i];
+          index++;
+        }
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs an order crossover operation for two given parent permutations.
+    /// </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="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in OrderCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/PartiallyMatchedCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/PartiallyMatchedCrossover.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/PartiallyMatchedCrossover.cs	(revision 1685)
@@ -0,0 +1,101 @@
+#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.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;
+      int[] result = new int[length];
+      bool[] numbersCopied = new bool[length];
+
+      int breakPoint1 = random.Next(length - 1);
+      int breakPoint2 = random.Next(breakPoint1 + 1, length);
+
+      for (int j = breakPoint1; j <= breakPoint2; j++) {  // copy part of first permutation
+        result[j] = parent1[j];
+        numbersCopied[result[j]] = true;
+      }
+
+      int index = breakPoint1;
+      int i = (breakPoint1 == 0 ? (breakPoint2 + 1) : 0);
+      while (i < length) {  // copy rest from second permutation
+        if (!numbersCopied[parent2[i]]) {  // copy directly
+          result[i] = parent2[i];
+        } else {  // copy from area between breakpoints
+          while (numbersCopied[parent2[index]]) {  // find next valid index
+            index++;
+          }
+          result[i] = parent2[index];
+          index++;
+        }
+
+        i++;
+        if (i == breakPoint1) {  // skip area between breakpoints
+          i = breakPoint2 + 1;
+        }
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs a partially matched crossover operation for two given parent permutations.
+    /// </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="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in PartiallyMatchedCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Permutation.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Permutation.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Permutation.cs	(revision 1685)
@@ -0,0 +1,60 @@
+#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 System.Xml;
+using HeuristicLab.Data;
+
+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());
+      clonedObjects.Add(Guid, clone);
+      return clone;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/PermutationCrossoverBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/PermutationCrossoverBase.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/PermutationCrossoverBase.cs	(revision 1685)
@@ -0,0 +1,71 @@
+#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.Evolutionary;
+
+namespace HeuristicLab.Permutation {
+  /// <summary>
+  /// Base class for all permutation crossover operators.
+  /// </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() {
+      AddVariableInfo(new VariableInfo("Permutation", "Parent and child permutations", typeof(Permutation), VariableKind.In | VariableKind.New));
+    }
+
+    /// <summary>
+    /// Performs a crossover by calling <see cref="Cross(HeuristicLab.Core.IScope, HeuristicLab.Core.IRandom, int[][]"/>
+    /// and adds the created permutation to the current scope.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown if the parents have different lengths.</exception>
+    /// <param name="scope">The current scope which represents a new child.</param>
+    /// <param name="random">A random number generator.</param>
+    protected sealed override void Cross(IScope scope, IRandom random) {
+      int[][] parents = new int[scope.SubScopes.Count][];
+      int length = -1;
+      for (int i = 0; i < scope.SubScopes.Count; i++) {
+        parents[i] = scope.SubScopes[i].GetVariableValue<Permutation>("Permutation", false).Data;
+        if (i == 0) length = parents[i].Length;
+        else if (parents[i].Length != length) throw new InvalidOperationException("ERROR in PermutationCrossoverBase: Cannot apply crossover to permutations of different length");
+      }
+
+      int[] result = Cross(scope, random, parents);
+      scope.AddVariable(new Variable(scope.TranslateName("Permutation"), new Permutation(result)));
+    }
+
+    /// <summary>
+    /// Performs a crossover of multiple permutations.
+    /// </summary>
+    /// <param name="scope">The current scope.</param>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing all parent permutations.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected abstract int[] Cross(IScope scope, IRandom random, int[][] parents);
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/PermutationManipulatorBase.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/PermutationManipulatorBase.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/PermutationManipulatorBase.cs	(revision 1685)
@@ -0,0 +1,66 @@
+#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;
+
+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() {
+      AddVariableInfo(new VariableInfo("Random", "Pseudo random number generator", typeof(IRandom), VariableKind.In));
+      AddVariableInfo(new VariableInfo("Permutation", "Permutation to manipulate", typeof(Permutation), VariableKind.In | VariableKind.Out));
+    }
+
+    /// <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);
+      Permutation perm = GetVariableValue<Permutation>("Permutation", scope, false);
+      perm.Data = Manipulate(scope, random, perm.Data);
+      return null;
+    }
+
+    /// <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/3.3/PositionBasedCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/PositionBasedCrossover.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/PositionBasedCrossover.cs	(revision 1685)
@@ -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.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;
+      int[] result = new int[length];
+      bool[] randomPosition = new bool[length];
+      bool[] numberCopied = new bool[length];
+      int randomPosNumber = random.Next(length);
+
+      for (int i = 0; i < randomPosNumber; i++) {  // generate random bit mask
+        randomPosition[random.Next(length)] = true;
+      }
+
+      for (int i = 0; i < length; i++) {  // copy numbers masked as true from second permutation
+        if (randomPosition[i]) {
+          result[i] = parent2[i];
+          numberCopied[parent2[i]] = true;
+        }
+      }
+
+      int index = 0;
+      for (int i = 0; i < length; i++) {  // copy numbers masked as false from first permutation
+        if (!numberCopied[parent1[i]]) {
+          if (randomPosition[index]) {
+            while (randomPosition[index]) {
+              index++;
+            }
+          }
+          result[index] = parent1[i];
+          index++;
+        }
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs a position-based crossover operation for two given parent permutations.
+    /// </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="parents">An array containing the two permutations that should be crossed.</param>
+    /// <returns>The newly created permutation, resulting from the crossover operation.</returns>
+    protected override int[] Cross(IScope scope, IRandom random, int[][] parents) {
+      if (parents.Length != 2) throw new InvalidOperationException("ERROR in PositionBasedCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1]);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/Properties/AssemblyInfo.frame
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Properties/AssemblyInfo.frame	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Properties/AssemblyInfo.frame	(revision 1685)
@@ -0,0 +1,58 @@
+#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.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using HeuristicLab.PluginInfrastructure;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Permutation")]
+[assembly: AssemblyDescription("HeuristicLab permutation operators")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2008 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("8819e533-c557-42e0-8cee-09dda7686cd2")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("3.2.0.$WCREV$")]
+[assembly: AssemblyFileVersion("3.2.0.$WCREV$")]
+[assembly: AssemblyBuildDate("$WCNOW$")]
Index: trunk/sources/HeuristicLab.Permutation/3.3/RandomPermutationGenerator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/RandomPermutationGenerator.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/RandomPermutationGenerator.cs	(revision 1685)
@@ -0,0 +1,88 @@
+#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.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() {
+      AddVariableInfo(new VariableInfo("Length", "Permutation length", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("Random", "Pseudo random number generator", typeof(IRandom), VariableKind.In));
+      AddVariableInfo(new VariableInfo("Permutation", "Created random permutation", typeof(Permutation), VariableKind.New));
+    }
+
+    /// <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];
+
+      for (int i = 0; i < length; i++)
+        perm[i] = i;
+
+      // Knuth shuffle
+      int index, tmp;
+      for (int i = 0; i < length - 1; i++) {
+        index = random.Next(i, length);
+        tmp = perm[i];
+        perm[i] = perm[index];
+        perm[index] = tmp;
+      }
+      return perm;
+    }
+
+    /// <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);
+      IntData length = GetVariableValue<IntData>("Length", scope, true);
+
+      int[] perm = Apply(random, length.Data);
+      scope.AddVariable(new Variable(scope.TranslateName("Permutation"), new Permutation(perm)));
+
+      return null;
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Permutation/3.3/ScrambleManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/ScrambleManipulator.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/ScrambleManipulator.cs	(revision 1685)
@@ -0,0 +1,93 @@
+#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;
+
+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();
+      int breakPoint1, breakPoint2;
+      int[] scrambledIndices, remainingIndices, temp;
+      int selectedIndex, index;
+
+      breakPoint1 = random.Next(permutation.Length - 1);
+      breakPoint2 = random.Next(breakPoint1 + 1, permutation.Length);
+
+      scrambledIndices = new int[breakPoint2 - breakPoint1 + 1];
+      remainingIndices = new int[breakPoint2 - breakPoint1 + 1];
+      for (int i = 0; i < remainingIndices.Length; i++) {  // initialise indices
+        remainingIndices[i] = i;
+      }
+      for (int i = 0; i < scrambledIndices.Length; i++) {  // generate permutation of indices
+        selectedIndex = random.Next(remainingIndices.Length);
+        scrambledIndices[i] = remainingIndices[selectedIndex];
+
+        temp = remainingIndices;
+        remainingIndices = new int[temp.Length - 1];
+        index = 0;
+        for (int j = 0; j < remainingIndices.Length; j++) {
+          if (index == selectedIndex) {
+            index++;
+          }
+          remainingIndices[j] = temp[index];
+          index++;
+        }
+      }
+
+      for (int i = 0; i <= (breakPoint2 - breakPoint1); i++) {  // scramble permutation between breakpoints
+        result[breakPoint1 + i] = permutation[breakPoint1 + scrambledIndices[i]];
+      }
+      return result;
+    }
+
+    /// <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/3.3/Swap2Manipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Swap2Manipulator.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Swap2Manipulator.cs	(revision 1685)
@@ -0,0 +1,69 @@
+#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;
+
+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();
+      int index1, index2, temp;
+
+      index1 = random.Next(result.Length);
+      index2 = random.Next(result.Length);
+
+      temp = result[index1];
+      result[index1] = result[index2];
+      result[index2] = temp;
+
+      return result;
+    }
+
+    /// <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/3.3/Swap3Manipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/Swap3Manipulator.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/Swap3Manipulator.cs	(revision 1685)
@@ -0,0 +1,85 @@
+#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;
+
+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();
+      int index1, index2, index3, temp;
+
+      index1 = random.Next(result.Length);
+      index2 = random.Next(result.Length);
+      index3 = random.Next(result.Length);
+
+      if (random.NextDouble() < 0.5) {
+        // swap edges 1 and 2
+        temp = result[index1];
+        result[index1] = result[index2];
+        result[index2] = temp;
+        // swap edges 2 and 3
+        temp = result[index2];
+        result[index2] = result[index3];
+        result[index3] = temp;
+      } else {
+        // swap edges 1 and 3
+        temp = result[index1];
+        result[index1] = result[index3];
+        result[index3] = temp;
+        // swap edges 2 and 3
+        temp = result[index2];
+        result[index2] = result[index3];
+        result[index3] = temp;
+      }
+      return result;
+    }
+
+    /// <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/3.3/TranslocationInversionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/TranslocationInversionManipulator.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/TranslocationInversionManipulator.cs	(revision 1685)
@@ -0,0 +1,91 @@
+#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;
+
+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();
+      int breakPoint1, breakPoint2, insertPoint, insertPointLimit;
+
+      breakPoint1 = random.Next(permutation.Length - 1);
+      breakPoint2 = random.Next(breakPoint1 + 1, permutation.Length);
+      insertPointLimit = permutation.Length - breakPoint2 + breakPoint1 - 1;  // get insertion point in remaining part
+      if (insertPointLimit > 0)
+        insertPoint = random.Next(insertPointLimit);
+      else
+        insertPoint = 0;
+
+      int i = 0;  // index in new permutation
+      int j = 0;  // index in old permutation
+      while (i < permutation.Length) {
+        if (i == insertPoint) {  // copy translocated area
+          for (int k = breakPoint2; k >= breakPoint1; k--) {
+            result[i] = permutation[k];
+            i++;
+          }
+        }
+        if (j == breakPoint1) {  // skip area between breakpoints
+          j = breakPoint2 + 1;
+        }
+        if ((i < permutation.Length) && (j < permutation.Length)) {
+          result[i] = permutation[j];
+          i++;
+          j++;
+        }
+      }
+      return result;
+    }
+
+    /// <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/3.3/TranslocationManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Permutation/3.3/TranslocationManipulator.cs	(revision 1685)
+++ trunk/sources/HeuristicLab.Permutation/3.3/TranslocationManipulator.cs	(revision 1685)
@@ -0,0 +1,91 @@
+#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;
+
+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();
+      int breakPoint1, breakPoint2, insertPoint, insertPointLimit;
+
+      breakPoint1 = random.Next(permutation.Length - 1);
+      breakPoint2 = random.Next(breakPoint1 + 1, permutation.Length);
+      insertPointLimit = permutation.Length - breakPoint2 + breakPoint1 - 1;  // get insertion point in remaining part
+      if (insertPointLimit > 0)
+        insertPoint = random.Next(insertPointLimit);
+      else
+        insertPoint = 0;
+
+      int i = 0;  // index in new permutation
+      int j = 0;  // index in old permutation
+      while (i < permutation.Length) {
+        if (i == insertPoint) {  // copy translocated area
+          for (int k = breakPoint1; k <= breakPoint2; k++) {
+            result[i] = permutation[k];
+            i++;
+          }
+        }
+        if (j == breakPoint1) {  // skip area between breakpoints
+          j = breakPoint2 + 1;
+        }
+        if ((i < permutation.Length) && (j < permutation.Length)) {
+          result[i] = permutation[j];
+          i++;
+          j++;
+        }
+      }
+      return result;
+    }
+
+    /// <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);
+    }
+  }
+}
