Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Creators/RandomPermutationCreator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Creators/RandomPermutationCreator.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Creators/RandomPermutationCreator.cs	(revision 3231)
@@ -47,4 +47,12 @@
       get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
     }
+    public IValueParameter<PermutationType> PermutationTypeParameter {
+      get { return (IValueParameter<PermutationType>)Parameters["PermutationType"]; }
+    }
+
+    public PermutationTypes PermutationType {
+      get { return PermutationTypeParameter.Value.Value; }
+      set { PermutationTypeParameter.Value.Value = value; }
+    }
 
     public RandomPermutationCreator()
@@ -53,8 +61,9 @@
       Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the new random permutation."));
       Parameters.Add(new LookupParameter<Permutation>("Permutation", "The new random permutation."));
+      Parameters.Add(new ValueParameter<PermutationType>("PermutationType", "The type of the permutation.", new PermutationType(PermutationTypes.RelativeUndirected)));
     }
 
     public override IOperation Apply() {
-      PermutationParameter.ActualValue = new Permutation(LengthParameter.ActualValue.Value, RandomParameter.ActualValue);
+      PermutationParameter.ActualValue = new Permutation(PermutationType, LengthParameter.ActualValue.Value, RandomParameter.ActualValue);
       return base.Apply();
     }
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CosaCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CosaCrossover.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CosaCrossover.cs	(revision 3231)
@@ -84,5 +84,5 @@
         }
       }
-      return new Permutation(result);
+      return new Permutation(parent1.PermutationType, result);
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CyclicCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CyclicCrossover.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CyclicCrossover.cs	(revision 3231)
@@ -90,5 +90,5 @@
       } while (j < length);
 
-      return new Permutation(result);
+      return new Permutation(parent1.PermutationType, result);
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CyclicCrossover2.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CyclicCrossover2.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/CyclicCrossover2.cs	(revision 3231)
@@ -77,5 +77,5 @@
         }
       }
-      return new Permutation(result);
+      return new Permutation(parent1.PermutationType, result);
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/EdgeRecombinationCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/EdgeRecombinationCrossover.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/EdgeRecombinationCrossover.cs	(revision 3231)
@@ -136,5 +136,5 @@
         }
       }
-      return new Permutation(result);
+      return new Permutation(parent1.PermutationType, result);
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/MaximalPreservativeCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/MaximalPreservativeCrossover.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/MaximalPreservativeCrossover.cs	(revision 3231)
@@ -117,5 +117,5 @@
       } while (index != breakPoint1);
 
-      return new Permutation(result);
+      return new Permutation(parent1.PermutationType, result);
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderBasedCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderBasedCrossover.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderBasedCrossover.cs	(revision 3231)
@@ -89,5 +89,5 @@
         }
       }
-      return new Permutation(result);
+      return new Permutation(parent1.PermutationType, result);
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderCrossover.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderCrossover.cs	(revision 3231)
@@ -80,5 +80,5 @@
         throw new InvalidOperationException("OrderCrossover: The permutation must consist of numbers in the interval [0;N) with N = length of the permutation.");
       }
-      return new Permutation(result);
+      return new Permutation(parent1.PermutationType, result);
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderCrossover2.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderCrossover2.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/OrderCrossover2.cs	(revision 3231)
@@ -72,5 +72,5 @@
         }
       }
-      return new Permutation(result);
+      return new Permutation(parent1.PermutationType, result);
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/PartiallyMatchedCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/PartiallyMatchedCrossover.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/PartiallyMatchedCrossover.cs	(revision 3231)
@@ -84,5 +84,5 @@
       }
 
-      return new Permutation(result);
+      return new Permutation(parent1.PermutationType, result);
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/PositionBasedCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/PositionBasedCrossover.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Crossovers/PositionBasedCrossover.cs	(revision 3231)
@@ -75,5 +75,5 @@
       }
 
-      return new Permutation(result);
+      return new Permutation(parent1.PermutationType, result);
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/HeuristicLab.Encodings.PermutationEncoding-3.3.csproj
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/HeuristicLab.Encodings.PermutationEncoding-3.3.csproj	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/HeuristicLab.Encodings.PermutationEncoding-3.3.csproj	(revision 3231)
@@ -108,14 +108,22 @@
     <Compile Include="Manipulators\TranslocationManipulator.cs" />
     <Compile Include="Moves\ThreeIndexMove.cs" />
-    <Compile Include="Moves\ThreeOpt\PreventDeleteThreeOptTabuMoveEvaluator.cs" />
-    <Compile Include="Moves\ThreeOpt\PreventReaddThreeOptTabuMoveEvaluator.cs" />
-    <Compile Include="Moves\ThreeOpt\PreventReaddDeleteThreeOptTabuMoveEvaluator.cs" />
-    <Compile Include="Moves\ThreeOpt\StochasticThreeOptSingleMoveGenerator.cs" />
     <Compile Include="Moves\ThreeOpt\Insertion\ExhaustiveInsertionMoveGenerator.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Moves\ThreeOpt\PreventDeleteThreeOptTabuMoveEvaluator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Moves\ThreeOpt\PreventReaddDeleteThreeOptTabuMoveEvaluator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Moves\ThreeOpt\PreventReaddThreeOptTabuMoveEvaluator.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Moves\ThreeOpt\StochasticThreeOptMultiMoveGenerator.cs">
       <SubType>Code</SubType>
     </Compile>
+    <Compile Include="Moves\ThreeOpt\StochasticThreeOptSingleMoveGenerator.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Moves\ThreeOpt\ThreeOptMove.cs">
       <SubType>Code</SubType>
@@ -127,29 +135,51 @@
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="Moves\ThreeOpt\ThreeOptTabuMoveAttribute.cs" />
-    <Compile Include="Moves\ThreeOpt\ThreeOptTabuMoveMaker.cs" />
-    <Compile Include="Moves\TwoOpt\PreventDeleteTwoOptTabuMoveEvaluator.cs" />
-    <Compile Include="Moves\TwoOpt\PreventReaddTwoOptTabuMoveEvaluator.cs" />
-    <Compile Include="Moves\TwoOpt\StochasticTwoOptSingleMoveGenerator.cs" />
+    <Compile Include="Moves\ThreeOpt\ThreeOptTabuMoveAttribute.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Moves\ThreeOpt\ThreeOptTabuMoveMaker.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Moves\TwoIndexMove.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Moves\TwoOpt\ExhaustiveTwoOptMoveGenerator.cs">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="Moves\TwoIndexMove.cs">
-      <SubType>Code</SubType>
-    </Compile>
-    <Compile Include="Moves\TwoOpt\StochasticTwoOptMultiMoveGenerator.cs" />
+    <Compile Include="Moves\TwoOpt\PreventDeleteTwoOptTabuMoveEvaluator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Moves\TwoOpt\PreventReaddDeleteTwoOptTabuMoveEvaluator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Moves\TwoOpt\PreventReaddTwoOptTabuMoveEvaluator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Moves\TwoOpt\StochasticTwoOptMultiMoveGenerator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Moves\TwoOpt\StochasticTwoOptSingleMoveGenerator.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Moves\TwoOpt\TwoOptMove.cs">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="Moves\TwoOpt\TwoOptMoveGenerator.cs" />
+    <Compile Include="Moves\TwoOpt\TwoOptMoveGenerator.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="Moves\TwoOpt\TwoOptMoveMaker.cs">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="Moves\TwoOpt\TwoOptTabuMoveAttribute.cs" />
-    <Compile Include="Moves\TwoOpt\PreventReaddDeleteTwoOptTabuMoveEvaluator.cs" />
-    <Compile Include="Moves\TwoOpt\TwoOptTabuMoveMaker.cs" />
+    <Compile Include="Moves\TwoOpt\TwoOptTabuMoveAttribute.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Moves\TwoOpt\TwoOptTabuMoveMaker.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="PermutationManipulator.cs" />
     <Compile Include="PermutationCrossover.cs" />
     <Compile Include="Permutation.cs" />
+    <Compile Include="PermutationType.cs" />
+    <Compile Include="PermutationTypes.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationCreator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationCreator.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Interfaces/IPermutationCreator.cs	(revision 3231)
@@ -31,4 +31,5 @@
     IValueLookupParameter<IntValue> LengthParameter { get; }
     ILookupParameter<Permutation> PermutationParameter { get; }
+    IValueParameter<PermutationType> PermutationTypeParameter { get; }
   }
 }
Index: unk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/ExhaustiveThreeOptMoveGenerator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Moves/ThreeOpt/ExhaustiveThreeOptMoveGenerator.cs	(revision 3230)
+++ 	(revision )
@@ -1,55 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 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 HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Encodings.PermutationEncoding {
-  [Item("ExhaustiveThreeOptMoveGenerator", "Generates all possible 3-opt moves from a given permutation.")]
-  [StorableClass]
-  public class ExhaustiveThreeOptMoveGenerator : ThreeOptMoveGenerator, IExhaustiveMoveGenerator {
-    public static ThreeOptMove[] Apply(Permutation permutation) {
-      int length = permutation.Length;
-      ThreeOptMove[] moves = new ThreeOptMove[sampleSize];
-      for (int i = 0; i < sampleSize; i++) {
-        int index1, index2, index3;
-        index1 = random.Next(length - 1);
-        do {
-          index2 = random.Next(index1 + 1, length);
-        } while (index2 - index1 >= length - 2);
-        do {
-          index3 = random.Next(length - index2 + index1 - 1);
-        } while (index3 == index1);
-        
-        moves[i] = new ThreeOptMove(index1, index2, index3);
-      }
-      return moves;
-    }
-
-    protected override ThreeOptMove[] GenerateMoves(Permutation permutation) {
-      return Apply(permutation);
-    }
-  }
-}
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Permutation.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Permutation.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Permutation.cs	(revision 3231)
@@ -25,20 +25,37 @@
 
 namespace HeuristicLab.Encodings.PermutationEncoding {
+  [Item("Permutation", "Represents a permutation of integer values.")]
   [StorableClass]
-  [Item("Permutation", "Represents a permutation of integer values.")]
   public class Permutation : IntArray {
-    public Permutation() : base() { }
-    public Permutation(int length)
+    [Storable]
+    private PermutationTypes permutationType;
+    /// <summary>
+    /// Gets the type of the permutation (see <see cref="PermutationType"/>).
+    /// </summary>
+    public PermutationTypes PermutationType {
+      get { return permutationType; }
+    }
+
+    public Permutation() : base() {
+      permutationType = PermutationTypes.RelativeUndirected;
+    }
+    public Permutation(PermutationTypes type) : base() {
+      permutationType = type;
+    }
+
+    public Permutation(PermutationTypes type, int length)
       : base(length) {
       for (int i = 0; i < length; i++)
         this[i] = i;
+      permutationType = type;
     }
-    public Permutation(int length, IRandom random)
-      : this(length) {
+    public Permutation(PermutationTypes type, int length, IRandom random)
+      : this(type, length) {
       Randomize(random);
     }
-    public Permutation(int[] elements) : base(elements) { }
-    public Permutation(IntArray elements)
-      : this(elements.Length) {
+    public Permutation(PermutationTypes type, int[] elements) : base(elements) {
+      permutationType = type;
+    }
+    public Permutation(PermutationTypes type, IntArray elements) : this(type, elements.Length) {
       for (int i = 0; i < array.Length; i++)
         array[i] = elements[i];
@@ -46,5 +63,5 @@
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      Permutation clone = new Permutation(array);
+      Permutation clone = new Permutation(permutationType, array);
       cloner.RegisterClonedObject(this, clone);
       return clone;
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationType.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationType.cs	(revision 3231)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationType.cs	(revision 3231)
@@ -0,0 +1,39 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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 HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.PermutationEncoding {
+  [Item("PermutationType", "Represents a certain type of permutation.")]
+  [StorableClass]
+  public class PermutationType : ValueTypeValue<PermutationTypes> {
+    public PermutationType() : base() { }
+    public PermutationType(PermutationTypes type) : base(type) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      PermutationType clone = new PermutationType(value);
+      cloner.RegisterClonedObject(this, clone);
+      return clone;
+    }
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationTypes.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationTypes.cs	(revision 3231)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/PermutationTypes.cs	(revision 3231)
@@ -0,0 +1,28 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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
+
+namespace HeuristicLab.Encodings.PermutationEncoding {
+  public enum PermutationTypes {
+    RelativeDirected,
+    RelativeUndirected,
+    Absolute
+  }
+}
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CosaCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CosaCrossoverTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CosaCrossoverTest.cs	(revision 3231)
@@ -93,5 +93,5 @@
       try {
         target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
-          new Permutation(4), new Permutation(4), new Permutation(4)}));
+          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
       } catch (System.InvalidOperationException) {
         exceptionFired = true;
@@ -110,9 +110,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 1 };
-      parent1 = new Permutation(new int[] { 0, 1, 5, 2, 4, 3 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 5, 2, 4, 3 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 3, 0, 2, 1, 4, 5 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 3, 0, 2, 1, 4, 5 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 0, 1, 4, 2, 5, 3 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 4, 2, 5, 3 });
       Assert.IsTrue(expected.Validate());
       actual = CosaCrossover.Apply(random, parent1, parent2);
@@ -122,9 +122,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 4 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 7, 6, 5, 3, 4, 2, 1, 0 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 5, 3, 4, 2, 1, 0 });
       Assert.IsTrue(expected.Validate());
       actual = CosaCrossover.Apply(random, parent1, parent2);
@@ -134,9 +134,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 5 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 4, 3, 5, 1, 0, 9, 7, 2, 8, 6 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 4, 3, 5, 1, 0, 9, 7, 2, 8, 6 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 7, 6, 2, 3, 4, 5, 1, 0, 9, 8 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 2, 3, 4, 5, 1, 0, 9, 8 });
       Assert.IsTrue(expected.Validate());
       actual = CosaCrossover.Apply(random, parent1, parent2);
@@ -148,5 +148,5 @@
       bool exceptionFired = false;
       try {
-        CosaCrossover.Apply(random, new Permutation(8), new Permutation(6));
+        CosaCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
       } catch (System.ArgumentException) {
         exceptionFired = true;
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CyclicCrossover2Test.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CyclicCrossover2Test.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CyclicCrossover2Test.cs	(revision 3231)
@@ -71,5 +71,5 @@
       try {
         target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
-          new Permutation(4), new Permutation(4), new Permutation(4)}));
+          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
       } catch (System.InvalidOperationException) {
         exceptionFired = true;
@@ -88,9 +88,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 0 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 2, 5, 6, 0, 7, 1, 3, 8, 4, 9 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 5, 6, 0, 7, 1, 3, 8, 4, 9 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 0, 5, 2, 3, 7, 1, 6, 8, 4, 9 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 5, 2, 3, 7, 1, 6, 8, 4, 9 });
       Assert.IsTrue(expected.Validate());
       actual = CyclicCrossover2.Apply(random, parent1, parent2);
@@ -102,5 +102,5 @@
       bool exceptionFired = false;
       try {
-        CyclicCrossover.Apply(random, new Permutation(8), new Permutation(6));
+        CyclicCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
       } catch (System.ArgumentException) {
         exceptionFired = true;
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CyclicCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CyclicCrossoverTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CyclicCrossoverTest.cs	(revision 3231)
@@ -93,5 +93,5 @@
       try {
         target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
-          new Permutation(4), new Permutation(4), new Permutation(4)}));
+          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
       }
       catch (System.InvalidOperationException) {
@@ -111,9 +111,9 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0.9 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 0, 1, 5, 3, 6, 4, 2, 7 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 5, 3, 6, 4, 2, 7 });
       Assert.IsTrue(expected.Validate());
       actual = CyclicCrossover.Apply(random, parent1, parent2);
@@ -125,5 +125,5 @@
       bool exceptionFired = false;
       try {
-        CyclicCrossover.Apply(random, new Permutation(8), new Permutation(6));
+        CyclicCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
       }
       catch (System.ArgumentException) {
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/EdgeRecombinationCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/EdgeRecombinationCrossoverTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/EdgeRecombinationCrossoverTest.cs	(revision 3231)
@@ -93,5 +93,5 @@
       try {
         target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
-          new Permutation(4), new Permutation(4), new Permutation(4)}));
+          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
       }
       catch (System.InvalidOperationException) {
@@ -112,9 +112,9 @@
       random.IntNumbers = new int[] { 0 };
       random.DoubleNumbers = new double[] { 0.5, 0, 0, 0 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 0, 4, 5, 1, 7, 6, 2, 8, 3 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 4, 5, 1, 7, 6, 2, 8, 3 });
       Assert.IsTrue(expected.Validate());
       actual = EdgeRecombinationCrossover.Apply(random, parent1, parent2);
@@ -126,5 +126,5 @@
       bool exceptionFired = false;
       try {
-        EdgeRecombinationCrossover.Apply(random, new Permutation(8), new Permutation(6));
+        EdgeRecombinationCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
       }
       catch (System.ArgumentException) {
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/InsertionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/InsertionManipulatorTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/InsertionManipulatorTest.cs	(revision 3231)
@@ -88,8 +88,8 @@
       random.Reset();
       random.IntNumbers = new int[] { 3, 6 };
-      parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
       Assert.IsTrue(parent.Validate());
       
-      expected = new Permutation(new int[] { 0, 1, 2, 4, 5, 6, 3, 7 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 4, 5, 6, 3, 7 });
       Assert.IsTrue(expected.Validate());
       InsertionManipulator.Apply(random, parent);
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/InversionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/InversionManipulatorTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/InversionManipulatorTest.cs	(revision 3231)
@@ -88,8 +88,8 @@
       random.Reset();
       random.IntNumbers = new int[] { 1, 4 };
-      parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
+      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
       Assert.IsTrue(parent.Validate());
       
-      expected = new Permutation(new int[] { 0, 4, 3, 2, 1, 5, 6, 7, 8 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 4, 3, 2, 1, 5, 6, 7, 8 });
       Assert.IsTrue(expected.Validate());
       InversionManipulator.Apply(random, parent);
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/MaximalPreservativeCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/MaximalPreservativeCrossoverTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/MaximalPreservativeCrossoverTest.cs	(revision 3231)
@@ -93,5 +93,5 @@
       try {
         target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
-          new Permutation(4), new Permutation(4), new Permutation(4)}));
+          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
       }
       catch (System.InvalidOperationException) {
@@ -111,9 +111,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 3, 2 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 1, 0, 2, 3, 4, 5, 7, 6 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 0, 2, 3, 4, 5, 7, 6 });
       Assert.IsTrue(expected.Validate());
       actual = MaximalPreservativeCrossover.Apply(random, parent1, parent2);
@@ -125,5 +125,5 @@
       bool exceptionFired = false;
       try {
-        MaximalPreservativeCrossover.Apply(random, new Permutation(8), new Permutation(6));
+        MaximalPreservativeCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
       }
       catch (System.ArgumentException) {
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderBasedCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderBasedCrossoverTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderBasedCrossoverTest.cs	(revision 3231)
@@ -93,5 +93,5 @@
       try {
         target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
-          new Permutation(4), new Permutation(4), new Permutation(4)}));
+          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
       } catch (System.InvalidOperationException) {
         exceptionFired = true;
@@ -110,9 +110,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 3, 5, 2, 1 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 1, 3, 2, 7, 6, 4, 5, 0 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 2, 7, 6, 4, 5, 0 });
       actual = OrderBasedCrossover.Apply(random, parent1, parent2);
       Assert.IsTrue(actual.Validate());
@@ -122,5 +122,5 @@
       bool exceptionFired = false;
       try {
-        OrderBasedCrossover.Apply(random, new Permutation(8), new Permutation(6));
+        OrderBasedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
       } catch (System.ArgumentException) {
         exceptionFired = true;
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderCrossover2Test.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderCrossover2Test.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderCrossover2Test.cs	(revision 3231)
@@ -70,5 +70,5 @@
       try {
         target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
-          new Permutation(4), new Permutation(4), new Permutation(4)}));
+          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
       } catch (System.InvalidOperationException) {
         exceptionFired = true;
@@ -87,9 +87,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 5, 7 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 2, 5, 6, 0, 9, 1, 3, 8, 4, 7 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 5, 6, 0, 9, 1, 3, 8, 4, 7 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 2, 0, 9, 1, 3, 5, 6, 7, 8, 4 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 0, 9, 1, 3, 5, 6, 7, 8, 4 });
       Assert.IsTrue(expected.Validate());
       actual = OrderCrossover2.Apply(random, parent1, parent2);
@@ -101,5 +101,5 @@
       bool exceptionFired = false;
       try {
-        OrderCrossover.Apply(random, new Permutation(8), new Permutation(6));
+        OrderCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
       } catch (System.ArgumentException) {
         exceptionFired = true;
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderCrossoverTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderCrossoverTest.cs	(revision 3231)
@@ -93,5 +93,5 @@
       try {
         target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
-          new Permutation(4), new Permutation(4), new Permutation(4)}));
+          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
       } catch (System.InvalidOperationException) {
         exceptionFired = true;
@@ -110,9 +110,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 3, 6 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 8, 2, 6, 7, 1, 5, 4, 0, 3 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 2, 7, 1, 3, 4, 5, 6, 0, 8 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 7, 1, 3, 4, 5, 6, 0, 8 });
       Assert.IsTrue(expected.Validate());
       actual = OrderCrossover.Apply(random, parent1, parent2);
@@ -122,9 +122,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 2, 4 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 7, 6, 2, 3, 4, 0, 1, 5 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 6, 2, 3, 4, 0, 1, 5 });
       actual = OrderCrossover.Apply(random, parent1, parent2);
       Assert.IsTrue(actual.Validate());
@@ -133,9 +133,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 2, 5 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 7, 3, 0, 4, 8, 2, 5, 1, 6 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 7, 3, 0, 4, 8, 2, 5, 1, 6 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 0, 8, 2, 3, 4, 5, 1, 6, 7 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 8, 2, 3, 4, 5, 1, 6, 7 });
       Assert.IsTrue(expected.Validate());
       actual = OrderCrossover.Apply(random, parent1, parent2);
@@ -145,9 +145,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 0, 5 };
-      parent1 = new Permutation(new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 5, 3, 4, 0, 9, 8, 2, 7, 1, 6 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 5, 3, 4, 0, 9, 8, 2, 7, 1, 6 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 2, 1, 4, 3, 7, 8, 6, 5, 0, 9 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 5, 0, 9 });
       Assert.IsTrue(expected.Validate());
       actual = OrderCrossover.Apply(random, parent1, parent2);
@@ -157,5 +157,5 @@
       random.Reset();
       random.IntNumbers = new int[] { 6, 9 };
-      expected = new Permutation(new int[] { 3, 4, 8, 2, 7, 1, 6, 0, 5, 9 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 3, 4, 8, 2, 7, 1, 6, 0, 5, 9 });
       Assert.IsTrue(expected.Validate());
       actual = OrderCrossover.Apply(random, parent1, parent2);
@@ -165,5 +165,5 @@
       random.Reset();
       random.IntNumbers = new int[] { 0, 9 };
-      expected = new Permutation(new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 4, 3, 7, 8, 6, 0, 5, 9 });
       Assert.IsTrue(expected.Validate());
       actual = OrderCrossover.Apply(random, parent1, parent2);
@@ -175,5 +175,5 @@
       bool exceptionFired = false;
       try {
-        OrderCrossover.Apply(random, new Permutation(8), new Permutation(6));
+        OrderCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
       } catch (System.ArgumentException) {
         exceptionFired = true;
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/PartiallyMatchedCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/PartiallyMatchedCrossoverTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/PartiallyMatchedCrossoverTest.cs	(revision 3231)
@@ -93,5 +93,5 @@
       try {
         target.Cross(random, new ItemArray<Permutation>(new Permutation[] { 
-          new Permutation(4), new Permutation(4), new Permutation(4)}));
+          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4)}));
       }
       catch (System.InvalidOperationException) {
@@ -111,9 +111,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 3, 5 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 2, 6, 4, 0, 5, 7, 1, 3 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 6, 4, 0, 5, 7, 1, 3 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 2, 6, 7, 3, 4, 5, 1, 0 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 6, 7, 3, 4, 5, 1, 0 });
       Assert.IsTrue(expected.Validate());
       actual = PartiallyMatchedCrossover.Apply(random, parent1, parent2);
@@ -123,9 +123,9 @@
       random.Reset();
       random.IntNumbers = new int[] { 5, 7 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 2, 5, 6, 0, 9, 1, 3, 8, 4, 7 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 5, 6, 0, 9, 1, 3, 8, 4, 7 });
       Assert.IsTrue(parent2.Validate());
-      expected = new Permutation(new int[] { 2, 1, 3, 0, 9, 5, 6, 7, 4, 8 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 2, 1, 3, 0, 9, 5, 6, 7, 4, 8 });
       Assert.IsTrue(expected.Validate());
       actual = PartiallyMatchedCrossover.Apply(random, parent1, parent2);
@@ -137,5 +137,5 @@
       bool exceptionFired = false;
       try {
-        PartiallyMatchedCrossover.Apply(random, new Permutation(8), new Permutation(6));
+        PartiallyMatchedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
       }
       catch (System.ArgumentException) {
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/PositionBasedCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/PositionBasedCrossoverTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/PositionBasedCrossoverTest.cs	(revision 3231)
@@ -94,5 +94,5 @@
       try {
         target.Cross(random, new ItemArray<Permutation>(new Permutation[] {
-          new Permutation(4), new Permutation(4), new Permutation(4) }));
+          new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4), new Permutation(PermutationTypes.RelativeUndirected, 4) }));
       }
       catch (System.InvalidOperationException) {
@@ -114,10 +114,10 @@
       random.Reset();
       random.IntNumbers = new int[] { 3, 1, 2, 5 };
-      parent1 = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      parent1 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
       Assert.IsTrue(parent1.Validate());
-      parent2 = new Permutation(new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
+      parent2 = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 1, 3, 5, 7, 6, 4, 2, 0 });
       Assert.IsTrue(parent2.Validate());
 
-      expected = new Permutation(new int[] { 0, 3, 5, 1, 2, 4, 6, 7 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 3, 5, 1, 2, 4, 6, 7 });
       Assert.IsTrue(expected.Validate());
       actual = PositionBasedCrossover.Apply(random, parent1, parent2);
@@ -129,5 +129,5 @@
       bool exceptionFired = false;
       try {
-        PositionBasedCrossover.Apply(random, new Permutation(8), new Permutation(6));
+        PositionBasedCrossover.Apply(random, new Permutation(PermutationTypes.RelativeUndirected, 8), new Permutation(PermutationTypes.RelativeUndirected, 6));
       } catch (System.ArgumentException) {
         exceptionFired = true;
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/ScrambleManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/ScrambleManipulatorTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/ScrambleManipulatorTest.cs	(revision 3231)
@@ -88,8 +88,8 @@
       random.Reset();
       random.IntNumbers = new int[] { 3, 6, 1, 1, 1, 0 };
-      parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
       Assert.IsTrue(parent.Validate());
       
-      expected = new Permutation(new int[] { 0, 1, 2, 4, 5, 6, 3, 7 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 4, 5, 6, 3, 7 });
       Assert.IsTrue(expected.Validate());
       ScrambleManipulator.Apply(random, parent);
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/Swap2ManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/Swap2ManipulatorTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/Swap2ManipulatorTest.cs	(revision 3231)
@@ -88,8 +88,8 @@
       random.Reset();
       random.IntNumbers = new int[] { 1, 4 };
-      parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
+      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
       Assert.IsTrue(parent.Validate());
 
-      expected = new Permutation(new int[] { 0, 4, 2, 3, 1, 5, 6, 7, 8 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 4, 2, 3, 1, 5, 6, 7, 8 });
       Assert.IsTrue(expected.Validate());
       Swap2Manipulator.Apply(random, parent);
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/Swap3ManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/Swap3ManipulatorTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/Swap3ManipulatorTest.cs	(revision 3231)
@@ -89,8 +89,8 @@
       random.IntNumbers = new int[] { 1, 3, 6 };
       random.DoubleNumbers = new double[] { 0 };
-      parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
+      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });
       Assert.IsTrue(parent.Validate());
 
-      expected = new Permutation(new int[] { 0, 3, 2, 6, 4, 5, 1, 7, 8 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 3, 2, 6, 4, 5, 1, 7, 8 });
       Assert.IsTrue(expected.Validate());
       Swap3Manipulator.Apply(random, parent);
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/TranslocationInversionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/TranslocationInversionManipulatorTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/TranslocationInversionManipulatorTest.cs	(revision 3231)
@@ -88,8 +88,8 @@
       random.Reset();
       random.IntNumbers = new int[] { 2, 4, 4 };
-      parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
       Assert.IsTrue(parent.Validate());
       
-      expected = new Permutation(new int[] { 0, 1, 5, 6, 4, 3, 2, 7 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 5, 6, 4, 3, 2, 7 });
       Assert.IsTrue(expected.Validate());
       TranslocationInversionManipulator.Apply(random, parent);
Index: /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/TranslocationManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/TranslocationManipulatorTest.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/TranslocationManipulatorTest.cs	(revision 3231)
@@ -88,8 +88,8 @@
       random.Reset();
       random.IntNumbers = new int[] { 2, 4, 4 };
-      parent = new Permutation(new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
+      parent = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 2, 3, 4, 5, 6, 7 });
       Assert.IsTrue(parent.Validate());
       
-      expected = new Permutation(new int[] { 0, 1, 5, 6, 2, 3, 4, 7 });
+      expected = new Permutation(PermutationTypes.RelativeUndirected, new int[] { 0, 1, 5, 6, 2, 3, 4, 7 });
       Assert.IsTrue(expected.Validate());
       TranslocationManipulator.Apply(random, parent);
Index: /trunk/sources/HeuristicLab.Problems.TravelingSalesman/3.3/TravelingSalesmanProblem.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.TravelingSalesman/3.3/TravelingSalesmanProblem.cs	(revision 3230)
+++ /trunk/sources/HeuristicLab.Problems.TravelingSalesman/3.3/TravelingSalesmanProblem.cs	(revision 3231)
@@ -194,5 +194,5 @@
         tourParser.Parse();
         if (tourParser.Tour.Length != Coordinates.Rows) throw new InvalidDataException("Length of optimal tour is not equal to number of cities.");
-        BestKnownSolution = new Permutation(tourParser.Tour);
+        BestKnownSolution = new Permutation(PermutationTypes.RelativeUndirected, tourParser.Tour);
       }
     }
@@ -326,4 +326,5 @@
     private void ParameterizeSolutionCreator() {
       SolutionCreator.LengthParameter.Value = new IntValue(Coordinates.Rows);
+      SolutionCreator.PermutationTypeParameter.Value = new PermutationType(PermutationTypes.RelativeUndirected);
     }
     private void ParameterizeEvaluator() {
