Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Creators/UniformRandomIntVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Creators/UniformRandomIntVectorCreator.cs	(revision 3054)
+++ 	(revision )
@@ -1,64 +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 System.Collections.Generic;
-using System.Text;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Encodings.IntegerVectorEncoding {
-  /// <summary>
-  /// Generates a new random integer vector with each element uniformly distributed in a specified range.
-  /// </summary>
-  [Item("UniformRandomIntVectorCreator", "An operator which creates a new random int vector with each element uniformly distributed in a specified range.")]
-  [StorableClass]
-  [Creatable("Test")]
-  public class UniformRandomIntVectorCreator : IntVectorCreator {
-    /// <summary>
-    /// Generates a new random integer vector with the given <paramref name="length"/>.
-    /// </summary>
-    /// <param name="random">The random number generator.</param>
-    /// <param name="length">The length of the int vector.</param>
-    /// <param name="min">The minimum value of the sampling range for each vector element (inclusive).</param>
-    /// <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 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 IntArray(result);
-    }
-
-    /// <summary>
-    /// Forwards the call to <see cref="Apply(IRandom, int, int, int)"/>.
-    /// </summary>
-    /// <param name="random">The pseudo random number generator to use.</param>
-    /// <param name="length">The length of the int vector.</param>
-    /// <param name="minimum">The minimum value of the sampling range for each vector element (inclusive).</param>
-    /// <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 IntArray Create(IRandom random, IntValue length, IntValue minimum, IntValue maximum) {
-      return Apply(random, length.Value, minimum.Value, maximum.Value);
-    }
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Creators/UniformRandomIntegerVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Creators/UniformRandomIntegerVectorCreator.cs	(revision 3059)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Creators/UniformRandomIntegerVectorCreator.cs	(revision 3059)
@@ -0,0 +1,64 @@
+#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 System.Collections.Generic;
+using System.Text;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Generates a new random integer vector with each element uniformly distributed in a specified range.
+  /// </summary>
+  [Item("UniformRandomIntegerVectorCreator", "An operator which creates a new random int vector with each element uniformly distributed in a specified range.")]
+  [StorableClass]
+  [Creatable("Test")]
+  public class UniformRandomIntegerVectorCreator : IntegerVectorCreator {
+    /// <summary>
+    /// Generates a new random integer vector with the given <paramref name="length"/>.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="length">The length of the int vector.</param>
+    /// <param name="min">The minimum value of the sampling range for each vector element (inclusive).</param>
+    /// <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 IntegerVector 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 IntegerVector(result);
+    }
+
+    /// <summary>
+    /// Forwards the call to <see cref="Apply(IRandom, int, int, int)"/>.
+    /// </summary>
+    /// <param name="random">The pseudo random number generator to use.</param>
+    /// <param name="length">The length of the int vector.</param>
+    /// <param name="minimum">The minimum value of the sampling range for each vector element (inclusive).</param>
+    /// <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 IntegerVector Create(IRandom random, IntValue length, IntValue minimum, IntValue maximum) {
+      return Apply(random, length.Value, minimum.Value, maximum.Value);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs	(revision 3054)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs	(revision 3059)
@@ -36,5 +36,5 @@
   [Item("DiscreteCrossover", "Discrete crossover for integer vectors. It is implemented as described in Gwiazda, T.D. 2006. Genetic algorithms reference Volume I Crossover for single-objective numerical optimization problems, p.17.")]
   [StorableClass]
-  public class DiscreteCrossover : IntVectorCrossover {
+  public class DiscreteCrossover : IntegerVectorCrossover {
     /// <summary>
     /// Performs a discrete crossover operation of the two given parents.
@@ -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 IntArray Apply(IRandom random, IntArray parent1, IntArray parent2) {
+    public static IntegerVector Apply(IRandom random, IntegerVector parent1, IntegerVector 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 IntArray(result);
+      return new IntegerVector(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 IntArray Cross(IRandom random, ItemArray<IntArray> parents) {
+    protected override IntegerVector Cross(IRandom random, ItemArray<IntegerVector> 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.IntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 3054)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 3059)
@@ -36,5 +36,5 @@
   [Item("SinglePointCrossover", "Single point crossover for integer vectors. It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.")]
   [StorableClass]
-  public class SinglePointCrossover : IntVectorCrossover {
+  public class SinglePointCrossover : IntegerVectorCrossover {
     /// <summary>
     /// Performs a single point crossover at a randomly chosen position of the two 
@@ -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 IntArray Apply(IRandom random, IntArray parent1, IntArray parent2) {
+    public static IntegerVector Apply(IRandom random, IntegerVector parent1, IntegerVector 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 IntArray(result);
+      return new IntegerVector(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 IntArray Cross(IRandom random, ItemArray<IntArray> parents) {
+    protected override IntegerVector Cross(IRandom random, ItemArray<IntegerVector> 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.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj	(revision 3054)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj	(revision 3059)
@@ -79,5 +79,5 @@
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Creators\UniformRandomIntVectorCreator.cs" />
+    <Compile Include="Creators\UniformRandomIntegerVectorCreator.cs" />
     <Compile Include="Crossovers\DiscreteCrossover.cs">
       <SubType>Code</SubType>
@@ -87,10 +87,10 @@
     </Compile>
     <Compile Include="HeuristicLabEncodingsIntegerVectorEncodingPlugin.cs" />
-    <Compile Include="Interfaces\IIntVectorCreator.cs" />
-    <Compile Include="Interfaces\IIntVectorCrossover.cs" />
-    <Compile Include="Interfaces\IIntVectorManipulator.cs" />
-    <Compile Include="Interfaces\IIntVectorOperator.cs" />
-    <Compile Include="IntVectorCrossover.cs" />
-    <Compile Include="IntVectorManipulator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorCreator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorCrossover.cs" />
+    <Compile Include="Interfaces\IIntegerVectorManipulator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorOperator.cs" />
+    <Compile Include="IntegerVectorCrossover.cs" />
+    <Compile Include="IntegerVectorManipulator.cs" />
     <Compile Include="Manipulators\UniformOnePositionManipulator.cs">
       <SubType>Code</SubType>
@@ -98,5 +98,5 @@
     <Compile Include="IntegerVector.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="IntVectorCreator.cs" />
+    <Compile Include="IntegerVectorCreator.cs" />
   </ItemGroup>
   <ItemGroup>
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntVectorCreator.cs	(revision 3054)
+++ 	(revision )
@@ -1,68 +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 HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Encodings.IntegerVectorEncoding {
-  /// <summary>
-  /// A base class for operators creating int-valued vectors.
-  /// </summary>
-  [Item("IntVectorCreator", "A base class for operators creating int-valued vectors.")]
-  [StorableClass]
-  public abstract class IntVectorCreator : SingleSuccessorOperator, IIntVectorCreator, IStochasticOperator {
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ILookupParameter<IntArray> IntVectorParameter {
-      get { return (ILookupParameter<IntArray>)Parameters["IntVector"]; }
-    }
-    public IValueLookupParameter<IntValue> LengthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
-    }
-    public IValueLookupParameter<IntValue> MinimumParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Minimum"]; }
-    }
-    public IValueLookupParameter<IntValue> MaximumParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Maximum"]; }
-    }
-
-    protected IntVectorCreator()
-      : 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>("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."));
-    }
-
-    public sealed override IOperation Apply() {
-      IntVectorParameter.ActualValue = Create(RandomParameter.ActualValue, LengthParameter.ActualValue, MinimumParameter.ActualValue, MaximumParameter.ActualValue);
-      return base.Apply();
-    }
-
-    protected abstract IntArray Create(IRandom random, IntValue length, IntValue minimum, IntValue maximum);
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntVectorCrossover.cs	(revision 3054)
+++ 	(revision )
@@ -1,60 +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 HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Encodings.IntegerVectorEncoding {
-  /// <summary>
-  /// A base class for operators that perform a crossover of int-valued vectors.
-  /// </summary>
-  [Item("IntVectorCrossover", "A base class for operators that perform a crossover of int-valued vectors.")]
-  [StorableClass]
-  public abstract class IntVectorCrossover : SingleSuccessorOperator, IIntVectorCrossover, IStochasticOperator {
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ILookupParameter<ItemArray<IntArray>> ParentsParameter {
-      get { return (SubScopesLookupParameter<IntArray>)Parameters["Parents"]; }
-    }
-    public ILookupParameter<IntArray> ChildParameter {
-      get { return (ILookupParameter<IntArray>)Parameters["Child"]; }
-    }
-
-    protected IntVectorCrossover()
-      : 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."));
-    }
-
-    public sealed override IOperation Apply() {
-      ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
-      return base.Apply();
-    }
-
-    protected abstract IntArray Cross(IRandom random, ItemArray<IntArray> parents);
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntVectorManipulator.cs	(revision 3054)
+++ 	(revision )
@@ -1,56 +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 HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Operators;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Encodings.IntegerVectorEncoding {
-  /// <summary>
-  /// A base class for operators that manipulate int-valued vectors.
-  /// </summary>
-  [Item("IntVectorManipulator", "A base class for operators that manipulate int-valued vectors.")]
-  [StorableClass]
-  public abstract class IntVectorManipulator : SingleSuccessorOperator, IIntVectorManipulator, IStochasticOperator {
-    public ILookupParameter<IRandom> RandomParameter {
-      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
-    }
-    public ILookupParameter<IntArray> IntVectorParameter {
-      get { return (ILookupParameter<IntArray>)Parameters["IntVector"]; }
-    }
-
-    protected IntVectorManipulator()
-      : 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>("IntVector", "The vector which should be manipulated."));
-    }
-
-    public sealed override IOperation Apply() {
-      Manipulate(RandomParameter.ActualValue, IntVectorParameter.ActualValue);
-      return base.Apply();
-    }
-
-    protected abstract void Manipulate(IRandom random, IntArray intVector);
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs	(revision 3059)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs	(revision 3059)
@@ -0,0 +1,68 @@
+﻿#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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// A base class for operators creating int-valued vectors.
+  /// </summary>
+  [Item("IntegerVectorCreator", "A base class for operators creating int-valued vectors.")]
+  [StorableClass]
+  public abstract class IntegerVectorCreator : SingleSuccessorOperator, IIntegerVectorCreator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<IntegerVector> IntegerVectorParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["IntegerVector"]; }
+    }
+    public IValueLookupParameter<IntValue> LengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
+    }
+    public IValueLookupParameter<IntValue> MinimumParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Minimum"]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Maximum"]; }
+    }
+
+    protected IntegerVectorCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<IntegerVector>("IntegerVector", "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."));
+    }
+
+    public sealed override IOperation Apply() {
+      IntegerVectorParameter.ActualValue = Create(RandomParameter.ActualValue, LengthParameter.ActualValue, MinimumParameter.ActualValue, MaximumParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract IntegerVector Create(IRandom random, IntValue length, IntValue minimum, IntValue maximum);
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCrossover.cs	(revision 3059)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCrossover.cs	(revision 3059)
@@ -0,0 +1,60 @@
+#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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// A base class for operators that perform a crossover of int-valued vectors.
+  /// </summary>
+  [Item("IntegerVectorCrossover", "A base class for operators that perform a crossover of int-valued vectors.")]
+  [StorableClass]
+  public abstract class IntegerVectorCrossover : SingleSuccessorOperator, IIntegerVectorCrossover, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemArray<IntegerVector>> ParentsParameter {
+      get { return (SubScopesLookupParameter<IntegerVector>)Parameters["Parents"]; }
+    }
+    public ILookupParameter<IntegerVector> ChildParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["Child"]; }
+    }
+
+    protected IntegerVectorCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic crossover operators."));
+      Parameters.Add(new SubScopesLookupParameter<IntegerVector>("Parents", "The parent vectors which should be crossed."));
+      Parameters.Add(new LookupParameter<IntegerVector>("Child", "The child vector resulting from the crossover."));
+    }
+
+    public sealed override IOperation Apply() {
+      ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract IntegerVector Cross(IRandom random, ItemArray<IntegerVector> parents);
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorManipulator.cs	(revision 3059)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorManipulator.cs	(revision 3059)
@@ -0,0 +1,56 @@
+#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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// A base class for operators that manipulate int-valued vectors.
+  /// </summary>
+  [Item("IntegerVectorManipulator", "A base class for operators that manipulate int-valued vectors.")]
+  [StorableClass]
+  public abstract class IntegerVectorManipulator : SingleSuccessorOperator, IIntegerVectorManipulator, IStochasticOperator {
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<IntegerVector> IntegerVectorParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["IntegerVector"]; }
+    }
+
+    protected IntegerVectorManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
+      Parameters.Add(new LookupParameter<IntegerVector>("IntegerVector", "The vector which should be manipulated."));
+    }
+
+    public sealed override IOperation Apply() {
+      Manipulate(RandomParameter.ActualValue, IntegerVectorParameter.ActualValue);
+      return base.Apply();
+    }
+
+    protected abstract void Manipulate(IRandom random, IntegerVector integerVector);
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntVectorCreator.cs	(revision 3054)
+++ 	(revision )
@@ -1,36 +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 HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Encodings.IntegerVectorEncoding {
-  /// <summary>
-  /// An interface which represents an operator for creating vectors of int-valued data.
-  /// </summary>
-  public interface IIntVectorCreator : IIntVectorOperator, ISolutionCreator {
-    IValueLookupParameter<IntValue> LengthParameter { get; }
-    IValueLookupParameter<IntValue> MinimumParameter { get; }
-    IValueLookupParameter<IntValue> MaximumParameter { get; }
-    ILookupParameter<IntArray> IntVectorParameter { get; }
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntVectorCrossover.cs	(revision 3054)
+++ 	(revision )
@@ -1,34 +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 HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Encodings.IntegerVectorEncoding {
-  /// <summary>
-  /// An interface which represents an operator for crossing vectors of int-valued data.
-  /// </summary>
-  public interface IIntVectorCrossover : IIntVectorOperator, ICrossover {
-    ILookupParameter<ItemArray<IntArray>> ParentsParameter { get; }
-    ILookupParameter<IntArray> ChildParameter { get; }
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntVectorManipulator.cs	(revision 3054)
+++ 	(revision )
@@ -1,33 +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 HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Optimization;
-
-namespace HeuristicLab.Encodings.IntegerVectorEncoding {
-  /// <summary>
-  /// An interface which represents an operator for manipulating vectors of int-valued data.
-  /// </summary>
-  public interface IIntVectorManipulator : IIntVectorOperator, IManipulator {
-    ILookupParameter<IntArray> IntVectorParameter { get; }
-  }
-}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntVectorOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntVectorOperator.cs	(revision 3054)
+++ 	(revision )
@@ -1,29 +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 HeuristicLab.Core;
-
-namespace HeuristicLab.Encodings.IntegerVectorEncoding {
-  /// <summary>
-  /// An interface which represents an operator dealing with vectors of int-valued data.
-  /// </summary>
-  public interface IIntVectorOperator : IOperator { }
-}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCreator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCreator.cs	(revision 3059)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCreator.cs	(revision 3059)
@@ -0,0 +1,36 @@
+﻿#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.Optimization;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// An interface which represents an operator for creating vectors of int-valued data.
+  /// </summary>
+  public interface IIntegerVectorCreator : IIntegerVectorOperator, ISolutionCreator {
+    IValueLookupParameter<IntValue> LengthParameter { get; }
+    IValueLookupParameter<IntValue> MinimumParameter { get; }
+    IValueLookupParameter<IntValue> MaximumParameter { get; }
+    ILookupParameter<IntegerVector> IntegerVectorParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCrossover.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCrossover.cs	(revision 3059)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCrossover.cs	(revision 3059)
@@ -0,0 +1,34 @@
+﻿#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.Optimization;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// An interface which represents an operator for crossing vectors of int-valued data.
+  /// </summary>
+  public interface IIntegerVectorCrossover : IIntegerVectorOperator, ICrossover {
+    ILookupParameter<ItemArray<IntegerVector>> ParentsParameter { get; }
+    ILookupParameter<IntegerVector> ChildParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorManipulator.cs	(revision 3059)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorManipulator.cs	(revision 3059)
@@ -0,0 +1,33 @@
+﻿#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.Optimization;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// An interface which represents an operator for manipulating vectors of int-valued data.
+  /// </summary>
+  public interface IIntegerVectorManipulator : IIntegerVectorOperator, IManipulator {
+    ILookupParameter<IntegerVector> IntegerVectorParameter { get; }
+  }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorOperator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorOperator.cs	(revision 3059)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorOperator.cs	(revision 3059)
@@ -0,0 +1,29 @@
+﻿#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;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// An interface which represents an operator dealing with vectors of int-valued data.
+  /// </summary>
+  public interface IIntegerVectorOperator : IOperator { }
+}
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 3054)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 3059)
@@ -32,5 +32,4 @@
   /// Uniformly distributed change of a single position of an integer vector.
   /// </summary>
-  /// It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.
   /// <remarks>
   /// It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.
@@ -38,5 +37,5 @@
   [Item("UniformOnePositionManipulator", " Uniformly distributed change of a single position of an integer vector. It is implemented as described in Michalewicz, Z. 1999. Genetic Algorithms + Data Structures = Evolution Programs. Third, Revised and Extended Edition, Spring-Verlag Berlin Heidelberg.")]
   [StorableClass]
-  public class UniformOnePositionManipulator : IntVectorManipulator {
+  public class UniformOnePositionManipulator : IntegerVectorManipulator {
     /// <summary>
     /// The lower bound of the values in the int vector.
@@ -70,5 +69,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, IntArray vector, IntValue min, IntValue max) {
+    public static void Apply(IRandom random, IntegerVector vector, IntValue min, IntValue max) {
       int index = random.Next(vector.Length);
       vector[index] = random.Next(min.Value, max.Value);
@@ -81,5 +80,5 @@
     /// <param name="random">A random number generator.</param>
     /// <param name="vector">The integer vector to manipulate.</param>
-    protected override void Manipulate(IRandom random, IntArray vector) {
+    protected override void Manipulate(IRandom random, IntegerVector 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.IntegerVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3054)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/DiscreteCrossoverTest.cs	(revision 3059)
@@ -68,10 +68,10 @@
     public void DiscreteCrossoverCrossTest() {
       DiscreteCrossover_Accessor target = new DiscreteCrossover_Accessor(new PrivateObject(typeof(DiscreteCrossover)));
-      ItemArray<IntArray> parents;
+      ItemArray<IntegerVector> 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<IntArray>(new IntArray[] { new IntArray(4) });
+      parents = new ItemArray<IntegerVector>(new IntegerVector[] { new IntegerVector(4) });
       exceptionFired = false;
       try {
@@ -90,12 +90,12 @@
     public void DiscreteCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      IntArray parent1, parent2, expected, actual;
+      IntegerVector 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 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 });
+      parent1 = new IntegerVector(new int[] { 2, 2, 3, 5, 1 });
+      parent2 = new IntegerVector(new int[] { 4, 1, 3, 2, 8 });
+      expected = new IntegerVector(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 IntArray(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
-      parent2 = new IntArray(new int[] { 4, 1, 3, 2, 8 });
+      parent1 = new IntegerVector(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
+      parent2 = new IntegerVector(new int[] { 4, 1, 3, 2, 8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3054)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/SinglePointCrossoverTest.cs	(revision 3059)
@@ -68,13 +68,13 @@
     public void SinglePointCrossoverCrossTest() {
       SinglePointCrossover_Accessor target = new SinglePointCrossover_Accessor(new PrivateObject(typeof(SinglePointCrossover)));
-      ItemArray<IntArray> parents;
+      ItemArray<IntegerVector> 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<IntArray>(new IntArray[] { new IntArray(5), new IntArray(6), new IntArray(4) });
+      parents = new ItemArray<IntegerVector>(new IntegerVector[] { new IntegerVector(5), new IntegerVector(6), new IntegerVector(4) });
       exceptionFired = false;
       try {
-        IntArray actual;
+        IntegerVector 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<IntArray>(new IntArray[] { new IntArray(4) });
+      parents = new ItemArray<IntegerVector>(new IntegerVector[] { new IntegerVector(4) });
       exceptionFired = false;
       try {
-        IntArray actual;
+        IntegerVector actual;
         actual = target.Cross(random, parents);
       } catch (System.ArgumentException) {
@@ -102,12 +102,12 @@
     public void SinglePointCrossoverApplyTest() {
       TestRandom random = new TestRandom();
-      IntArray parent1, parent2, expected, actual;
+      IntegerVector parent1, parent2, expected, actual;
       bool exceptionFired;
       // The following test is not based on published examples
       random.Reset();
       random.IntNumbers = new int[] { 3 };
-      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 });
+      parent1 = new IntegerVector(new int[] { 2, 2, 3, 5, 1 });
+      parent2 = new IntegerVector(new int[] { 4, 1, 3, 2, 8 });
+      expected = new IntegerVector(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 IntArray(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
-      parent2 = new IntArray(new int[] { 4, 1, 3, 2, 8 });
+      parent1 = new IntegerVector(new int[] { 2, 2, 3, 5, 1, 9 }); // this parent is longer
+      parent2 = new IntegerVector(new int[] { 4, 1, 3, 2, 8 });
       exceptionFired = false;
       try {
Index: trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs
===================================================================
--- trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3054)
+++ trunk/sources/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Tests/UniformOnePositionManipulatorTest.cs	(revision 3059)
@@ -85,11 +85,11 @@
     public void UniformOnePositionManipulatorApplyTest() {
       TestRandom random = new TestRandom();
-      IntArray parent, expected;
+      IntegerVector parent, expected;
       IntValue min, max;
       // The following test is not based on published examples
       random.Reset();
       random.IntNumbers = new int[] { 3, 3 };
-      parent = new IntArray(new int[] { 2, 2, 3, 5, 1 });
-      expected = new IntArray(new int[] { 2, 2, 3, 3, 1 });
+      parent = new IntegerVector(new int[] { 2, 2, 3, 5, 1 });
+      expected = new IntegerVector(new int[] { 2, 2, 3, 3, 1 });
       min = new IntValue(2);
       max = new IntValue(7);
