Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Creators/UniformRandomIntVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Creators/UniformRandomIntVectorCreator.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Creators/UniformRandomIntVectorCreator.cs	(revision 3048)
@@ -43,9 +43,9 @@
     /// <param name="max">The maximum value of the sampling range for each vector element (exclusive).</param>
     /// <returns>The newly created integer vector.</returns>
-    public static IntArrayData Apply(IRandom random, int length, int min, int max) {
+    public static IntArray Apply(IRandom random, int length, int min, int max) {
       int[] result = new int[length];
       for (int i = 0; i < length; i++)
         result[i] = random.Next(min, max);
-      return new IntArrayData(result);
+      return new IntArray(result);
     }
 
@@ -58,5 +58,5 @@
     /// <param name="maximum">The maximum value of the sampling range for each vector element (exclusive).</param>
     /// <returns>The newly created int vector.</returns>
-    protected override IntArrayData Create(IRandom random, IntData length, IntData minimum, IntData maximum) {
+    protected override IntArray Create(IRandom random, IntValue length, IntValue minimum, IntValue maximum) {
       return Apply(random, length.Value, minimum.Value, maximum.Value);
     }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/DiscreteCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/DiscreteCrossover.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/DiscreteCrossover.cs	(revision 3048)
@@ -45,5 +45,5 @@
     /// <param name="parent2">The second parent for the crossover operation.</param>
     /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
-    public static IntArrayData Apply(IRandom random, IntArrayData parent1, IntArrayData parent2) {
+    public static IntArray Apply(IRandom random, IntArray parent1, IntArray parent2) {
       if(parent1.Length != parent2.Length)
         throw new ArgumentException("DiscreteCrossover: The parents are of different length.");
@@ -58,5 +58,5 @@
           result[i] = parent2[i];
       }
-      return new IntArrayData(result);
+      return new IntArray(result);
     }
 
@@ -68,5 +68,5 @@
     /// <param name="parents">An array containing the two integer vectors that should be crossed.</param>
     /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
-    protected override IntArrayData Cross(IRandom random, ItemArray<IntArrayData> parents) {
+    protected override IntArray Cross(IRandom random, ItemArray<IntArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("ERROR in DiscreteCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/SinglePointCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/SinglePointCrossover.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Crossovers/SinglePointCrossover.cs	(revision 3048)
@@ -45,5 +45,5 @@
     /// <param name="parent2">The second parent for crossover.</param>
     /// <returns>The newly created integer vector, resulting from the single point crossover.</returns>
-    public static IntArrayData Apply(IRandom random, IntArrayData parent1, IntArrayData parent2) {
+    public static IntArray Apply(IRandom random, IntArray parent1, IntArray parent2) {
       if (parent1.Length != parent2.Length)
         throw new ArgumentException("DiscreteCrossover: The parents are of different length.");
@@ -58,5 +58,5 @@
         result[i] = parent2[i];
 
-      return new IntArrayData(result);
+      return new IntArray(result);
     }
 
@@ -69,5 +69,5 @@
     /// <param name="parents">An array containing the two integer vectors that should be crossed.</param>
     /// <returns>The newly created integer vector, resulting from the single point crossover.</returns>
-    protected override IntArrayData Cross(IRandom random, ItemArray<IntArrayData> parents) {
+    protected override IntArray Cross(IRandom random, ItemArray<IntArray> parents) {
       if (parents.Length != 2) throw new ArgumentException("ERROR in SinglePointCrossover: The number of parents is not equal to 2");
       return Apply(random, parents[0], parents[1]);
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/HeuristicLab.Encodings.IntVector-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/HeuristicLab.Encodings.IntVector-3.3.csproj	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/HeuristicLab.Encodings.IntVector-3.3.csproj	(revision 3048)
@@ -32,4 +32,36 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
   </PropertyGroup>
   <ItemGroup>
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCreator.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCreator.cs	(revision 3048)
@@ -37,15 +37,15 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<IntArrayData> IntVectorParameter {
-      get { return (ILookupParameter<IntArrayData>)Parameters["IntVector"]; }
+    public ILookupParameter<IntArray> IntVectorParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["IntVector"]; }
     }
-    public IValueLookupParameter<IntData> LengthParameter {
-      get { return (IValueLookupParameter<IntData>)Parameters["Length"]; }
+    public IValueLookupParameter<IntValue> LengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
     }
-    public IValueLookupParameter<IntData> MinimumParameter {
-      get { return (IValueLookupParameter<IntData>)Parameters["Minimum"]; }
+    public IValueLookupParameter<IntValue> MinimumParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Minimum"]; }
     }
-    public IValueLookupParameter<IntData> MaximumParameter {
-      get { return (IValueLookupParameter<IntData>)Parameters["Maximum"]; }
+    public IValueLookupParameter<IntValue> MaximumParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Maximum"]; }
     }
 
@@ -53,8 +53,8 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new LookupParameter<IntArrayData>("IntVector", "The vector which should be manipulated."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Length", "The length of the vector."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Minimum", "The lower bound for each element in the vector."));
-      Parameters.Add(new ValueLookupParameter<IntData>("Maximum", "The upper bound for each element in the vector."));
+      Parameters.Add(new LookupParameter<IntArray>("IntVector", "The vector which should be manipulated."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the vector."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Minimum", "The lower bound for each element in the vector."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Maximum", "The upper bound for each element in the vector."));
     }
 
@@ -64,5 +64,5 @@
     }
 
-    protected abstract IntArrayData Create(IRandom random, IntData length, IntData minimum, IntData maximum);
+    protected abstract IntArray Create(IRandom random, IntValue length, IntValue minimum, IntValue maximum);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCrossover.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorCrossover.cs	(revision 3048)
@@ -37,9 +37,9 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<ItemArray<IntArrayData>> ParentsParameter {
-      get { return (SubScopesLookupParameter<IntArrayData>)Parameters["Parents"]; }
+    public ILookupParameter<ItemArray<IntArray>> ParentsParameter {
+      get { return (SubScopesLookupParameter<IntArray>)Parameters["Parents"]; }
     }
-    public ILookupParameter<IntArrayData> ChildParameter {
-      get { return (ILookupParameter<IntArrayData>)Parameters["Child"]; }
+    public ILookupParameter<IntArray> ChildParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["Child"]; }
     }
 
@@ -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<IntArrayData>("Parents", "The parent vectors which should be crossed."));
-      Parameters.Add(new LookupParameter<IntArrayData>("Child", "The child vector resulting from the crossover."));
+      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."));
     }
 
@@ -56,5 +56,5 @@
     }
 
-    protected abstract IntArrayData Cross(IRandom random, ItemArray<IntArrayData> parents);
+    protected abstract IntArray Cross(IRandom random, ItemArray<IntArray> parents);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorManipulator.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/IntVectorManipulator.cs	(revision 3048)
@@ -37,6 +37,6 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public ILookupParameter<IntArrayData> IntVectorParameter {
-      get { return (ILookupParameter<IntArrayData>)Parameters["IntVector"]; }
+    public ILookupParameter<IntArray> IntVectorParameter {
+      get { return (ILookupParameter<IntArray>)Parameters["IntVector"]; }
     }
 
@@ -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<IntArrayData>("IntVector", "The vector which should be manipulated."));
+      Parameters.Add(new LookupParameter<IntArray>("IntVector", "The vector which should be manipulated."));
     }
 
@@ -52,5 +52,5 @@
     }
 
-    protected abstract void Manipulate(IRandom random, IntArrayData intVector);
+    protected abstract void Manipulate(IRandom random, IntArray intVector);
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCreator.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCreator.cs	(revision 3048)
@@ -29,8 +29,8 @@
   /// </summary>
   public interface IIntVectorCreator : IIntVectorOperator, ISolutionCreator {
-    IValueLookupParameter<IntData> LengthParameter { get; }
-    IValueLookupParameter<IntData> MinimumParameter { get; }
-    IValueLookupParameter<IntData> MaximumParameter { get; }
-    ILookupParameter<IntArrayData> IntVectorParameter { get; }
+    IValueLookupParameter<IntValue> LengthParameter { get; }
+    IValueLookupParameter<IntValue> MinimumParameter { get; }
+    IValueLookupParameter<IntValue> MaximumParameter { get; }
+    ILookupParameter<IntArray> IntVectorParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCrossover.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorCrossover.cs	(revision 3048)
@@ -29,6 +29,6 @@
   /// </summary>
   public interface IIntVectorCrossover : IIntVectorOperator, ICrossover {
-    ILookupParameter<ItemArray<IntArrayData>> ParentsParameter { get; }
-    ILookupParameter<IntArrayData> ChildParameter { get; }
+    ILookupParameter<ItemArray<IntArray>> ParentsParameter { get; }
+    ILookupParameter<IntArray> ChildParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorManipulator.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Interfaces/IIntVectorManipulator.cs	(revision 3048)
@@ -29,5 +29,5 @@
   /// </summary>
   public interface IIntVectorManipulator : IIntVectorOperator, IManipulator {
-    ILookupParameter<IntArrayData> IntVectorParameter { get; }
+    ILookupParameter<IntArray> IntVectorParameter { get; }
   }
 }
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Manipulators/UniformOnePositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 3048)
@@ -42,12 +42,12 @@
     /// The lower bound of the values in the int vector.
     /// </summary>
-    public ValueLookupParameter<IntData> MinimumParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["Minimum"]; }
+    public ValueLookupParameter<IntValue> MinimumParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Minimum"]; }
     }
     /// <summary>
     /// The upper bound of the values in the int vector.
     /// </summary>
-    public ValueLookupParameter<IntData> MaximumParameter {
-      get { return (ValueLookupParameter<IntData>)Parameters["Maximum"]; }
+    public ValueLookupParameter<IntValue> MaximumParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["Maximum"]; }
     }
 
@@ -57,6 +57,6 @@
     /// </summary>
     public UniformOnePositionManipulator() {
-      Parameters.Add(new ValueLookupParameter<IntData>("Minimum", "Minimum of the sampling range for the vector element (included)"));
-      Parameters.Add(new ValueLookupParameter<IntData>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Minimum", "Minimum of the sampling range for the vector element (included)"));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Maximum", "Maximum of the sampling range for the vector element (excluded)"));
     }
 
@@ -70,5 +70,5 @@
     /// <param name="max">The maximum value of the sampling range for
     /// the vector element to change (exclusive).</param>
-    public static void Apply(IRandom random, IntArrayData vector, IntData min, IntData max) {
+    public static void Apply(IRandom random, IntArray vector, IntValue min, IntValue max) {
       int index = random.Next(vector.Length);
       vector[index] = random.Next(min.Value, max.Value);
@@ -81,5 +81,5 @@
     /// <param name="random">A random number generator.</param>
     /// <param name="vector">The integer vector to manipulate.</param>
-    protected override void Manipulate(IRandom random, IntArrayData vector) {
+    protected override void Manipulate(IRandom random, IntArray vector) {
       if (MinimumParameter.ActualValue == null) throw new InvalidOperationException("UniformOnePositionManipulator: Parameter " + MinimumParameter.ActualName + " could not be found.");
       if (MaximumParameter.ActualValue == null) throw new InvalidOperationException("UniformOnePositionManipulator: Parameter " + MaximumParameter.ActualName + " could not be found.");
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/Auxiliary.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/Auxiliary.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/Auxiliary.cs	(revision 3048)
@@ -25,5 +25,5 @@
 namespace HeuristicLab.Encodings.IntVector_33.Tests {
   public static class Auxiliary {
-    public static bool IntVectorIsEqualByPosition(IntArrayData p1, IntArrayData p2) {
+    public static bool IntVectorIsEqualByPosition(IntArray p1, IntArray p2) {
       bool equal = (p1.Length == p2.Length);
       if (equal) {
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/DiscreteCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void DiscreteCrossoverCrossTest() {
       DiscreteCrossover_Accessor target = new DiscreteCrossover_Accessor(new PrivateObject(typeof(DiscreteCrossover)));
-      ItemArray<IntArrayData> parents;
+      ItemArray<IntArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<IntArrayData>(new IntArrayData[] { new IntArrayData(4) });
+      parents = new ItemArray<IntArray>(new IntArray[] { new IntArray(4) });
       exceptionFired = false;
       try {
-        IntArrayData actual;
+        IntArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -90,12 +90,12 @@
     public void DiscreteCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      IntArrayData parent1, parent2, expected, actual;
+      IntArray parent1, parent2, expected, actual;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.DoubleNumbers = new double[] { 0, 0, 0.9, 0, 0.9 };
-      parent1 = new IntArrayData(new int[] { 2, 2, 3, 5, 1 });
-      parent2 = new IntArrayData(new int[] { 4, 1, 3, 2, 8 });
-      expected = new IntArrayData(new int[] { 2, 2, 3, 5, 8 });
+      parent1 = new IntArray(new int[] { 2, 2, 3, 5, 1 });
+      parent2 = new IntArray(new int[] { 4, 1, 3, 2, 8 });
+      expected = new IntArray(new int[] { 2, 2, 3, 5, 8 });
       actual = DiscreteCrossover.Apply(random, parent1, parent2);
       Assert.IsTrue(Auxiliary.IntVectorIsEqualByPosition(actual, expected));
@@ -104,6 +104,6 @@
       random.Reset();
       random.DoubleNumbers = new double[] { 0, 0, 0.9, 0, 0.9 };
-      parent1 = new IntArrayData(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
-      parent2 = new IntArrayData(new int[] { 4, 1, 3, 2, 8 });
+      parent1 = new IntArray(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
+      parent2 = new IntArray(new int[] { 4, 1, 3, 2, 8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/HeuristicLab.Encodings.IntVector-3.3.Tests.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/HeuristicLab.Encodings.IntVector-3.3.Tests.csproj	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/HeuristicLab.Encodings.IntVector-3.3.Tests.csproj	(revision 3048)
@@ -30,4 +30,36 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x64\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>bin\x64\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>bin\x86\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>bin\x86\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
   </PropertyGroup>
   <ItemGroup>
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/SinglePointCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3048)
@@ -68,13 +68,13 @@
     public void SinglePointCrossoverCrossTest() {
       SinglePointCrossover_Accessor target = new SinglePointCrossover_Accessor(new PrivateObject(typeof(SinglePointCrossover)));
-      ItemArray<IntArrayData> parents;
+      ItemArray<IntArray> parents;
       TestRandom random = new TestRandom();
       bool exceptionFired;
       // The following test checks if there is an exception when there are more than 2 parents
       random.Reset();
-      parents = new ItemArray<IntArrayData>(new IntArrayData[] { new IntArrayData(5), new IntArrayData(6), new IntArrayData(4) });
+      parents = new ItemArray<IntArray>(new IntArray[] { new IntArray(5), new IntArray(6), new IntArray(4) });
       exceptionFired = false;
       try {
-        IntArrayData actual;
+        IntArray actual;
         actual = target.Cross(random, parents);
       }
@@ -85,8 +85,8 @@
       // The following test checks if there is an exception when there are less than 2 parents
       random.Reset();
-      parents = new ItemArray<IntArrayData>(new IntArrayData[] { new IntArrayData(4) });
+      parents = new ItemArray<IntArray>(new IntArray[] { new IntArray(4) });
       exceptionFired = false;
       try {
-        IntArrayData actual;
+        IntArray actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -102,12 +102,12 @@
     public void SinglePointCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      IntArrayData parent1, parent2, expected, actual;
+      IntArray parent1, parent2, expected, actual;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.IntNumbers = new int[] { 3 };
-      parent1 = new IntArrayData(new int[] { 2, 2, 3, 5, 1 });
-      parent2 = new IntArrayData(new int[] { 4, 1, 3, 2, 8 });
-      expected = new IntArrayData(new int[] { 2, 2, 3, 2, 8 });
+      parent1 = new IntArray(new int[] { 2, 2, 3, 5, 1 });
+      parent2 = new IntArray(new int[] { 4, 1, 3, 2, 8 });
+      expected = new IntArray(new int[] { 2, 2, 3, 2, 8 });
       actual = SinglePointCrossover.Apply(random, parent1, parent2);
       Assert.IsTrue(Auxiliary.IntVectorIsEqualByPosition(actual, expected));
@@ -115,6 +115,6 @@
       random.Reset();
       random.IntNumbers = new int[] { 2 };
-      parent1 = new IntArrayData(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
-      parent2 = new IntArrayData(new int[] { 4, 1, 3, 2, 8 });
+      parent1 = new IntArray(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
+      parent2 = new IntArray(new int[] { 4, 1, 3, 2, 8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/UniformOnePositionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3035)
+++ trunk/sources/HeuristicLab.Encodings.IntVector/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3048)
@@ -85,13 +85,13 @@
     public void UniformOnePositionManipulatorApplyTest() {
       TestRandom random = new TestRandom();
-      IntArrayData parent, expected;
-      IntData min, max;
+      IntArray parent, expected;
+      IntValue min, max;
       // The following test is not based on published examples
       random.Reset();
       random.IntNumbers = new int[] { 3, 3 };
-      parent = new IntArrayData(new int[] { 2, 2, 3, 5, 1 });
-      expected = new IntArrayData(new int[] { 2, 2, 3, 3, 1 });
-      min = new IntData(2);
-      max = new IntData(7);
+      parent = new IntArray(new int[] { 2, 2, 3, 5, 1 });
+      expected = new IntArray(new int[] { 2, 2, 3, 3, 1 });
+      min = new IntValue(2);
+      max = new IntValue(7);
       UniformOnePositionManipulator.Apply(random, parent, min, max);
       Assert.IsTrue(Auxiliary.IntVectorIsEqualByPosition(expected, parent));
