Changeset 3231 for trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests

Timestamp:

03/29/10 17:53:12 (15 years ago)

Author:

abeham

Message:

Added a permutation type property specifying whether it's a relative (directed or undirected) or absolute permutation #889

Location:

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests

Files:

• CosaCrossoverTest.cs (modified) (5 diffs)
• CyclicCrossover2Test.cs (modified) (3 diffs)
• CyclicCrossoverTest.cs (modified) (3 diffs)
• EdgeRecombinationCrossoverTest.cs (modified) (3 diffs)
• InsertionManipulatorTest.cs (modified) (1 diff)
• InversionManipulatorTest.cs (modified) (1 diff)
• MaximalPreservativeCrossoverTest.cs (modified) (3 diffs)
• OrderBasedCrossoverTest.cs (modified) (3 diffs)
• OrderCrossover2Test.cs (modified) (3 diffs)
• OrderCrossoverTest.cs (modified) (8 diffs)
• PartiallyMatchedCrossoverTest.cs (modified) (4 diffs)
• PositionBasedCrossoverTest.cs (modified) (3 diffs)
• ScrambleManipulatorTest.cs (modified) (1 diff)
• Swap2ManipulatorTest.cs (modified) (1 diff)
• Swap3ManipulatorTest.cs (modified) (1 diff)
• TranslocationInversionManipulatorTest.cs (modified) (1 diff)
• TranslocationManipulatorTest.cs (modified) (1 diff)

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CosaCrossoverTest.cs ¶

@@ -93 +93 @@
       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 +110 @@
       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 +122 @@
       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 +134 @@
       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 +148 @@
       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;

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CyclicCrossover2Test.cs ¶

@@ -71 +71 @@
       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 +88 @@
       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 +102 @@
       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;

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/CyclicCrossoverTest.cs ¶

@@ -93 +93 @@
       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 +111 @@
       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 +125 @@
       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) {

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/EdgeRecombinationCrossoverTest.cs ¶

@@ -93 +93 @@
       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 +112 @@
       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 +126 @@
       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) {

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/InsertionManipulatorTest.cs ¶

@@ -88 +88 @@
       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);

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/InversionManipulatorTest.cs ¶

@@ -88 +88 @@
       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);

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/MaximalPreservativeCrossoverTest.cs ¶

@@ -93 +93 @@
       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 +111 @@
       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 +125 @@
       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) {

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderBasedCrossoverTest.cs ¶

@@ -93 +93 @@
       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 +110 @@
       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 +122 @@
       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;

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderCrossover2Test.cs ¶

@@ -70 +70 @@
       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 +87 @@
       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 +101 @@
       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;

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/OrderCrossoverTest.cs ¶

@@ -93 +93 @@
       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 +110 @@
       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 +122 @@
       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 +133 @@
       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 +145 @@
       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 +157 @@
       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 +165 @@
       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 +175 @@
       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;

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/PartiallyMatchedCrossoverTest.cs ¶

@@ -93 +93 @@
       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 +111 @@
       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 +123 @@
       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 +137 @@
       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) {

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/PositionBasedCrossoverTest.cs ¶

@@ -94 +94 @@
       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 +114 @@
       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 +129 @@
       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;

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/ScrambleManipulatorTest.cs ¶

@@ -88 +88 @@
       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);

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/Swap2ManipulatorTest.cs ¶

@@ -88 +88 @@
       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);

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/Swap3ManipulatorTest.cs ¶

@@ -89 +89 @@
       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);

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/TranslocationInversionManipulatorTest.cs ¶

@@ -88 +88 @@
       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);

trunk/sources/HeuristicLab.Encodings.PermutationEncoding/3.3/Tests/TranslocationManipulatorTest.cs ¶

@@ -88 +88 @@
       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);