Index: /trunk/sources/HeuristicLab 3.3.sln
===================================================================
--- /trunk/sources/HeuristicLab 3.3.sln	(revision 3060)
+++ /trunk/sources/HeuristicLab 3.3.sln	(revision 3061)
@@ -55,8 +55,11 @@
 		{BB994448-2B21-4564-BB2E-38D8FFF8CF18} = {BB994448-2B21-4564-BB2E-38D8FFF8CF18}
 		{C49CB749-8B24-4628-8003-E86475749410} = {C49CB749-8B24-4628-8003-E86475749410}
+		{BB6D334A-4BB6-4674-9883-31A6EBB32CAB} = {BB6D334A-4BB6-4674-9883-31A6EBB32CAB}
 		{2C36CD4F-E5F5-43A4-801A-201EA895FE17} = {2C36CD4F-E5F5-43A4-801A-201EA895FE17}
 		{3BD61258-31DA-4B09-89C0-4F71FEF5F05A} = {3BD61258-31DA-4B09-89C0-4F71FEF5F05A}
 		{C664305E-497C-4533-A140-967DEDB05C19} = {C664305E-497C-4533-A140-967DEDB05C19}
+		{6F18ED66-2333-4B5C-B882-AC99FB3CDCE5} = {6F18ED66-2333-4B5C-B882-AC99FB3CDCE5}
 		{56F9106A-079F-4C61-92F6-86A84C2D84B7} = {56F9106A-079F-4C61-92F6-86A84C2D84B7}
+		{30D6606B-96E7-436C-B5D7-EA1455848E37} = {30D6606B-96E7-436C-B5D7-EA1455848E37}
 		{DC3D7072-7999-4719-B65D-3997744D5DC1} = {DC3D7072-7999-4719-B65D-3997744D5DC1}
 		{F42F3576-7233-4B28-90F7-36AE15F30F92} = {F42F3576-7233-4B28-90F7-36AE15F30F92}
@@ -64,4 +67,5 @@
 		{57F38579-409D-4DD8-AB19-3F2C4A665126} = {57F38579-409D-4DD8-AB19-3F2C4A665126}
 		{4ABA047D-46DD-4608-9E4A-41C5F92FDBB1} = {4ABA047D-46DD-4608-9E4A-41C5F92FDBB1}
+		{8FA6898D-E4B0-4E08-A6D6-F9F520E7959F} = {8FA6898D-E4B0-4E08-A6D6-F9F520E7959F}
 		{BF7D9494-A586-457B-8DF9-ED599F9E6A71} = {BF7D9494-A586-457B-8DF9-ED599F9E6A71}
 		{600287A3-8714-453E-B875-A05F3EB72315} = {600287A3-8714-453E-B875-A05F3EB72315}
@@ -71,4 +75,5 @@
 		{958B43BC-CC5C-4FA2-8628-2B3B01D890B6} = {958B43BC-CC5C-4FA2-8628-2B3B01D890B6}
 		{AB687BBE-1BFE-476B-906D-44237135431D} = {AB687BBE-1BFE-476B-906D-44237135431D}
+		{66D249C3-A01D-42A8-82A2-919BC8EC3D83} = {66D249C3-A01D-42A8-82A2-919BC8EC3D83}
 		{4C3305C4-E440-4EAD-B218-68D77AE51543} = {4C3305C4-E440-4EAD-B218-68D77AE51543}
 		{DF2E61C4-A76D-4315-9D0B-53A077B1AC2C} = {DF2E61C4-A76D-4315-9D0B-53A077B1AC2C}
@@ -77,4 +82,5 @@
 		{EE2034D9-6E27-48A1-B855-42D45F69A4FC} = {EE2034D9-6E27-48A1-B855-42D45F69A4FC}
 		{1B3063DB-D71C-4A6A-A359-883E8F53A140} = {1B3063DB-D71C-4A6A-A359-883E8F53A140}
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0} = {DDFB14DD-2A85-493C-A52D-E69729BBAEB0}
 		{35A42EE0-A896-4D7A-A99F-8ED9E925F320} = {35A42EE0-A896-4D7A-A99F-8ED9E925F320}
 		{AE5B1CE5-9862-4D6F-A700-D72CD9AEA295} = {AE5B1CE5-9862-4D6F-A700-D72CD9AEA295}
Index: /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCreator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCreator.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCreator.cs	(revision 3061)
@@ -47,5 +47,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<IntArray>("BinaryVector", "The vector which should be manipulated."));
+      Parameters.Add(new LookupParameter<BinaryVector>("BinaryVector", "The vector which should be manipulated."));
       Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the vector."));
     }
Index: /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCrossover.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCrossover.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorCrossover.cs	(revision 3061)
@@ -47,6 +47,6 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
-      Parameters.Add(new SubScopesLookupParameter<IntArray>("Parents", "The parent vectors which should be crossed."));
-      Parameters.Add(new LookupParameter<IntArray>("Child", "The child vector resulting from the crossover."));
+      Parameters.Add(new SubScopesLookupParameter<BinaryVector>("Parents", "The parent vectors which should be crossed."));
+      Parameters.Add(new LookupParameter<BinaryVector>("Child", "The child vector resulting from the crossover."));
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorManipulator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorManipulator.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/BinaryVectorManipulator.cs	(revision 3061)
@@ -44,5 +44,5 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<IntArray>("BinaryVector", "The vector which should be manipulated."));
+      Parameters.Add(new LookupParameter<BinaryVector>("BinaryVector", "The vector which should be manipulated."));
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Tests/Auxiliary.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Tests/Auxiliary.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.BinaryVectorEncoding/3.3/Tests/Auxiliary.cs	(revision 3061)
@@ -20,10 +20,10 @@
 #endregion
 
-using HeuristicLab.Data;
 using HeuristicLab.Common;
+using HeuristicLab.Encodings.BinaryVectorEncoding;
 
 namespace HeuristicLab.Encodings.BinaryVectorEncoding_33.Tests {
   public static class Auxiliary {
-    public static bool BoolVectorIsEqualByPosition(BoolArray p1, BoolArray p2) {
+    public static bool BinaryVectorIsEqualByPosition(BinaryVector p1, BinaryVector p2) {
       bool equal = (p1.Length == p2.Length);
       if (equal) {
Index: /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/Auxiliary.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/Auxiliary.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/Auxiliary.cs	(revision 3061)
@@ -20,10 +20,10 @@
 #endregion
 
-using HeuristicLab.Data;
 using HeuristicLab.Common;
+using HeuristicLab.Encodings.IntegerVectorEncoding;
 
 namespace HeuristicLab.Encodings.IntegerVectorEncoding_33.Tests {
   public static class Auxiliary {
-    public static bool IntVectorIsEqualByPosition(IntArray p1, IntArray p2) {
+    public static bool IntegerVectorIsEqualByPosition(IntegerVector p1, IntegerVector p2) {
       bool equal = (p1.Length == p2.Length);
       if (equal) {
Index: /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3061)
@@ -76,5 +76,5 @@
       exceptionFired = false;
       try {
-        IntArray actual;
+        IntegerVector actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -99,5 +99,5 @@
       expected = new IntegerVector(new int[] { 2, 2, 3, 5, 8 });
       actual = DiscreteCrossover.Apply(random, parent1, parent2);
-      Assert.IsTrue(Auxiliary.IntVectorIsEqualByPosition(actual, expected));
+      Assert.IsTrue(Auxiliary.IntegerVectorIsEqualByPosition(actual, expected));
 
       // The following test is not based on published examples
Index: /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3061)
@@ -111,5 +111,5 @@
       expected = new IntegerVector(new int[] { 2, 2, 3, 2, 8 });
       actual = SinglePointCrossover.Apply(random, parent1, parent2);
-      Assert.IsTrue(Auxiliary.IntVectorIsEqualByPosition(actual, expected));
+      Assert.IsTrue(Auxiliary.IntegerVectorIsEqualByPosition(actual, expected));
       // The following test is not based on published examples
       random.Reset();
Index: /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3061)
@@ -95,5 +95,5 @@
       max = new IntValue(7);
       UniformOnePositionManipulator.Apply(random, parent, min, max);
-      Assert.IsTrue(Auxiliary.IntVectorIsEqualByPosition(expected, parent));
+      Assert.IsTrue(Auxiliary.IntegerVectorIsEqualByPosition(expected, parent));
     }
 
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Auxiliary.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Auxiliary.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/Auxiliary.cs	(revision 3061)
@@ -20,10 +20,10 @@
 #endregion
 
-using HeuristicLab.Data;
 using HeuristicLab.Common;
+using HeuristicLab.Encodings.RealVectorEncoding;
 
 namespace HeuristicLab.Encodings.RealVectorEncoding_33.Tests {
   public static class Auxiliary {
-    public static bool DoubleArrayIsAlmostEqualByPosition(DoubleArray p1, DoubleArray p2) {
+    public static bool RealVectorIsAlmostEqualByPosition(RealVector p1, RealVector p2) {
       bool equal = (p1.Length == p2.Length);
       if (equal) {
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaBetaCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaBetaCrossoverTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaBetaCrossoverTest.cs	(revision 3061)
@@ -114,5 +114,5 @@
       expected = new RealVector(new double[] { 0.3, 0.15, 0.3, 0.35, 0.45 });
       actual = BlendAlphaBetaCrossover.Apply(random, parent1, parent2, alpha, beta);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(actual, expected));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
       // The following test is not based on published examples
       random.Reset();
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaCrossoverTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/BlendAlphaCrossoverTest.cs	(revision 3061)
@@ -112,5 +112,5 @@
       expected = new RealVector(new double[] { 0.3, 0.15, 0.3, 0.35, 0.45 });
       actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(actual, expected));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
       // The following test is not based on published examples
       random.Reset();
@@ -121,5 +121,5 @@
       expected = new RealVector(new double[] { 0.225, 0.1875, 0.3, 0.4625, 0.1875 });
       actual = BlendAlphaCrossover.Apply(random, parent1, parent2, alpha);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(actual, expected));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
       // The following test is not based on published examples
       random.Reset();
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3061)
@@ -101,5 +101,5 @@
       expected = new RealVector(new double[] { 0.2, 0.2, 0.3, 0.5, 0.8 });
       actual = DiscreteCrossover.Apply(random, parents);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(actual, expected));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
       // The following test is not based on published examples
       random.Reset();
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/HeuristicCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/HeuristicCrossoverTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/HeuristicCrossoverTest.cs	(revision 3061)
@@ -111,5 +111,5 @@
       expected = new RealVector(new double[] { 0.14, 0.23, 0.3, 0.59, -0.11 });
       actual = HeuristicCrossover.Apply(random, parent1, parent2);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(actual, expected));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
       // The following test is not based on published examples
       random.Reset();
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/LocalCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/LocalCrossoverTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/LocalCrossoverTest.cs	(revision 3061)
@@ -111,5 +111,5 @@
       expected = new RealVector(new double[] { 0.34, 0.11, 0.3, 0.32, 0.639 });
       actual = LocalCrossover.Apply(random, parent1, parent2);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(actual, expected));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
       // The following test is not based on published examples
       random.Reset();
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformAllPositionsManipulatorTest.cs	(revision 3061)
@@ -100,5 +100,5 @@
       maximumGenerations = new IntValue(4);
       MichalewiczNonUniformAllPositionsManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(expected, parent));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
       // The following test is not based on published examples
       exceptionFired = false;
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/MichalewiczNonUniformOnePositionManipulatorTest.cs	(revision 3061)
@@ -101,5 +101,5 @@
       maximumGenerations = new IntValue(4);
       MichalewiczNonUniformOnePositionManipulator.Apply(random, parent, min, max, currentGeneration, maximumGenerations, generationsDependency);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(expected, parent));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
       // The following test is not based on published examples
       exceptionFired = false;
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialAllPositionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialAllPositionManipulatorTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialAllPositionManipulatorTest.cs	(revision 3061)
@@ -96,5 +96,5 @@
       maxManipulation = new DoubleValue(0.2);
       PolynomialAllPositionManipulator.Apply(random, parent, contiguity, maxManipulation);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(expected, parent));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
       // The following test is not based on published examples
       exceptionFired = false;
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialOnePositionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialOnePositionManipulatorTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/PolynomialOnePositionManipulatorTest.cs	(revision 3061)
@@ -97,5 +97,5 @@
       maxManipulation = new DoubleValue(0.7);
       PolynomialOnePositionManipulator.Apply(random, parent, contiguity, maxManipulation);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(expected, parent));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
       // The following test is not based on published examples
       exceptionFired = false;
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/RandomConvexCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/RandomConvexCrossoverTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/RandomConvexCrossoverTest.cs	(revision 3061)
@@ -111,5 +111,5 @@
       expected = new RealVector(new double[] { 0.34, 0.13, 0.3, 0.29, 0.59 });
       actual = RandomConvexCrossover.Apply(random, parent1, parent2);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(actual, expected));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
       // The following test is not based on published examples
       random.Reset();
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SimulatedBinaryCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SimulatedBinaryCrossoverTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SimulatedBinaryCrossoverTest.cs	(revision 3061)
@@ -113,5 +113,5 @@
       expected = new RealVector(new double[] { 1.11032829834638, -0.0145477755417797, 0.3, 0.5, 0.1 });
       actual = SimulatedBinaryCrossover.Apply(random, parent1, parent2, contiguity);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(actual, expected));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
       // The following test is not based on published examples
       random.Reset();
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3061)
@@ -111,5 +111,5 @@
       expected = new RealVector(new double[] { 0.2, 0.2, 0.3, 0.2, 0.8 });
       actual = SinglePointCrossover.Apply(random, parent1, parent2);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(actual, expected));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(actual, expected));
       // The following test is not based on published examples
       random.Reset();
Index: /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs
===================================================================
--- /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3060)
+++ /trunk/sources/HeuristicLab.Encodings.RealVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3061)
@@ -96,5 +96,5 @@
       max = new DoubleValue(0.7);
       UniformOnePositionManipulator.Apply(random, parent, min, max);
-      Assert.IsTrue(Auxiliary.DoubleArrayIsAlmostEqualByPosition(expected, parent));
+      Assert.IsTrue(Auxiliary.RealVectorIsAlmostEqualByPosition(expected, parent));
     }
 
