Index: /branches/GeneralizedQAP/GeneralizedQAP.sln
===================================================================
--- /branches/GeneralizedQAP/GeneralizedQAP.sln	(revision 15490)
+++ /branches/GeneralizedQAP/GeneralizedQAP.sln	(revision 15491)
@@ -17,4 +17,6 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Optimization-3.3", "HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj", "{14AB8D24-25BC-400C-A846-4627AA945192}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Encodings.IntegerVectorEncoding-3.3", "HeuristicLab.Encodings.IntegerVectorEncoding\3.3\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj", "{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}"
 EndProject
 Global
@@ -100,4 +102,16 @@
 		{14AB8D24-25BC-400C-A846-4627AA945192}.Release|x86.ActiveCfg = Release|x86
 		{14AB8D24-25BC-400C-A846-4627AA945192}.Release|x86.Build.0 = Release|x86
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Debug|x64.ActiveCfg = Debug|x64
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Debug|x64.Build.0 = Debug|x64
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Debug|x86.ActiveCfg = Debug|x86
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Debug|x86.Build.0 = Debug|x86
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Release|x64.ActiveCfg = Release|x64
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Release|x64.Build.0 = Release|x64
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Release|x86.ActiveCfg = Release|x86
+		{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorCrossover.cs	(revision 15491)
@@ -0,0 +1,53 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("BoundedIntegerVectorCrossover", "Base class for bounded crossovers.")]
+  [StorableClass]
+  public abstract class BoundedIntegerVectorCrossover : IntegerVectorCrossover, IBoundedIntegerVectorOperator {
+
+    public IValueLookupParameter<IntMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected BoundedIntegerVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected BoundedIntegerVectorCrossover(BoundedIntegerVectorCrossover original, Cloner cloner) : base(original, cloner) { }
+    public BoundedIntegerVectorCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
+    }
+
+    protected sealed override IntegerVector Cross(IRandom random, ItemArray<IntegerVector> parents) {
+      if (BoundsParameter.ActualValue == null) throw new InvalidOperationException(Name + ": Bounds are not defined!");
+      return CrossBounded(random, parents, BoundsParameter.ActualValue);
+    }
+
+    protected abstract IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds);
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorManipulator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorManipulator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/BoundedIntegerVectorManipulator.cs	(revision 15491)
@@ -0,0 +1,53 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("BoundedIntegerVectorManipulator", "Base class for bounded integer vector manipulators.")]
+  [StorableClass]
+  public abstract class BoundedIntegerVectorManipulator : IntegerVectorManipulator, IBoundedIntegerVectorOperator {
+
+    public IValueLookupParameter<IntMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected BoundedIntegerVectorManipulator(bool deserializing) : base(deserializing) { }
+    protected BoundedIntegerVectorManipulator(BoundedIntegerVectorManipulator original, Cloner cloner) : base(original, cloner) { }
+    public BoundedIntegerVectorManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
+    }
+
+    protected sealed override void Manipulate(IRandom random, IntegerVector integerVector) {
+      if (BoundsParameter.ActualValue == null) throw new InvalidOperationException("BoundedIntegerVectorManipulator: Parameter " + BoundsParameter.ActualName + " could not be found.");
+      ManipulateBounded(random, integerVector, BoundsParameter.ActualValue);
+    }
+
+    protected abstract void ManipulateBounded(IRandom random, IntegerVector integerVector, IntMatrix bounds);
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Creators/UniformRandomIntegerVectorCreator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Creators/UniformRandomIntegerVectorCreator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Creators/UniformRandomIntegerVectorCreator.cs	(revision 15491)
@@ -0,0 +1,68 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Common;
+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]
+  public class UniformRandomIntegerVectorCreator : IntegerVectorCreator {
+    [StorableConstructor]
+    protected UniformRandomIntegerVectorCreator(bool deserializing) : base(deserializing) { }
+    protected UniformRandomIntegerVectorCreator(UniformRandomIntegerVectorCreator original, Cloner cloner) : base(original, cloner) { }
+    public UniformRandomIntegerVectorCreator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformRandomIntegerVectorCreator(this, cloner);
+    }
+
+    /// <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="bounds">A matrix containing the inclusive lower and inclusive upper bound in the first and second column and a step size in the third column.
+    /// Each line represents the bounds for a certain dimension. If fewer lines are given, the lines are cycled.</param>
+    /// <returns>The newly created integer vector.</returns>
+    public static IntegerVector Apply(IRandom random, int length, IntMatrix bounds) {
+      var result = new IntegerVector(length);
+      result.Randomize(random, bounds);
+      return 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="bounds">Contains in each row for each dimension minimum (inclusive), maximum (inclusive), and step size.</param>
+    /// <returns>The newly created int vector.</returns>
+    protected override IntegerVector Create(IRandom random, IntValue length, IntMatrix bounds) {
+      return Apply(random, length.Value, bounds);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/DiscreteCrossover.cs	(revision 15491)
@@ -0,0 +1,80 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Discrete crossover for integer vectors.
+  /// </summary>
+  /// 
+  /// It is implemented as described in Gwiazda, T.D. 2006. Genetic algorithms reference Volume I Crossover for single-objective numerical optimization problems, p.17.
+  /// </remarks>
+  [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 : IntegerVectorCrossover {
+    [StorableConstructor]
+    protected DiscreteCrossover(bool deserializing) : base(deserializing) { }
+    protected DiscreteCrossover(DiscreteCrossover original, Cloner cloner) : base(original, cloner) { }
+    public DiscreteCrossover() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new DiscreteCrossover(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs a discrete crossover operation of any number of given parents.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when the vectors of the parents are of different length or when there are less than 2 parents.</exception>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">The list of parents for the crossover operation.</param>
+    /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
+    public static IntegerVector Apply(IRandom random, ItemArray<IntegerVector> parents) {
+      if (parents.Length < 2) throw new ArgumentException("DiscreteCrossover: There are less than two parents to cross.");
+      int length = parents[0].Length;
+
+      for (int i = 0; i < parents.Length; i++) {
+        if (parents[i].Length != length)
+          throw new ArgumentException("DiscreteCrossover: The parents' vectors are of different length.", "parents");
+      }
+
+      var result = new IntegerVector(length);
+      for (int i = 0; i < length; i++) {
+        result[i] = parents[random.Next(parents.Length)][i];
+      }
+
+      return result;
+    }
+
+    /// <summary>
+    /// Performs a discrete crossover operation for any number of given parent integer vectors.
+    /// </summary>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing integer vectors that should be crossed.</param>
+    /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
+    protected override IntegerVector Cross(IRandom random, ItemArray<IntegerVector> parents) {
+      return Apply(random, parents);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/MultiIntegerVectorCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/MultiIntegerVectorCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/MultiIntegerVectorCrossover.cs	(revision 15491)
@@ -0,0 +1,108 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Linq;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("MultiIntegerVectorCrossover", "Randomly selects and applies one of its crossovers every time it is called.")]
+  [StorableClass]
+  public class MultiIntegerVectorCrossover : StochasticMultiBranch<IIntegerVectorCrossover>, IIntegerVectorCrossover, IStochasticOperator, IBoundedIntegerVectorOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    protected override bool CreateChildOperation {
+      get { return true; }
+    }
+
+    public IValueLookupParameter<IntMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
+    }
+
+    public ILookupParameter<ItemArray<IntegerVector>> ParentsParameter {
+      get { return (ILookupParameter<ItemArray<IntegerVector>>)Parameters["Parents"]; }
+    }
+
+    public ILookupParameter<IntegerVector> ChildParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["Child"]; }
+    }
+
+    [StorableConstructor]
+    protected MultiIntegerVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected MultiIntegerVectorCrossover(MultiIntegerVectorCrossover original, Cloner cloner) : base(original, cloner) { }
+    public MultiIntegerVectorCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
+      Parameters.Add(new ScopeTreeLookupParameter<IntegerVector>("Parents", "The parent integer vector which should be crossed."));
+      ParentsParameter.ActualName = "IntegerVector";
+      Parameters.Add(new LookupParameter<IntegerVector>("Child", "The child integer vector resulting from the crossover."));
+      ChildParameter.ActualName = "IntegerVector";
+
+      foreach (Type type in ApplicationManager.Manager.GetTypes(typeof(IIntegerVectorCrossover))) {
+        if (!typeof(MultiOperator<IIntegerVectorCrossover>).IsAssignableFrom(type))
+          Operators.Add((IIntegerVectorCrossover)Activator.CreateInstance(type), true);
+      }
+
+      SelectedOperatorParameter.ActualName = "SelectedCrossoverOperator";
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MultiIntegerVectorCrossover(this, cloner);
+    }
+
+    protected override void Operators_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<IIntegerVectorCrossover>> e) {
+      base.Operators_ItemsReplaced(sender, e);
+      ParameterizeCrossovers();
+    }
+
+    protected override void Operators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IIntegerVectorCrossover>> e) {
+      base.Operators_ItemsAdded(sender, e);
+      ParameterizeCrossovers();
+    }
+
+    private void ParameterizeCrossovers() {
+      foreach (IIntegerVectorCrossover crossover in Operators.OfType<IIntegerVectorCrossover>()) {
+        crossover.ChildParameter.ActualName = ChildParameter.Name;
+        crossover.ParentsParameter.ActualName = ParentsParameter.Name;
+      }
+      foreach (IStochasticOperator crossover in Operators.OfType<IStochasticOperator>()) {
+        crossover.RandomParameter.ActualName = RandomParameter.Name;
+      }
+      foreach (IBoundedIntegerVectorOperator crossover in Operators.OfType<IBoundedIntegerVectorOperator>()) {
+        crossover.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+
+    public override IOperation InstrumentedApply() {
+      if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one integer vector crossover to choose from.");
+      return base.InstrumentedApply();
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedAverageCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedAverageCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedAverageCrossover.cs	(revision 15491)
@@ -0,0 +1,91 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Rounded average crossover for integer vectors.
+  /// </summary>
+  [Item("RoundedAverageCrossover", "Average crossover for integer vectors.")]
+  [StorableClass]
+  public class RoundedAverageCrossover : BoundedIntegerVectorCrossover, IBoundedIntegerVectorOperator {
+
+    [StorableConstructor]
+    protected RoundedAverageCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedAverageCrossover(RoundedAverageCrossover original, Cloner cloner) : base(original, cloner) { }
+    public RoundedAverageCrossover() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedAverageCrossover(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs an average crossover of the two given parent integer vectors.
+    /// The average is rounded and mapped to the nearest valid value (e.g. if step size is > 1)
+    /// </summary>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">The parents for crossover.</param>
+    /// <param name="bounds">The bounds matrix that contains for each dimension one row with minimum (inclusive), maximum (exclusive), and step size columns.
+    /// If the number of rows is smaller than the number of dimensions the matrix is cycled.</param>
+    /// <returns>The newly created integer vector, resulting from the single point crossover.</returns>
+    public static IntegerVector Apply(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      int length = parents[0].Length, parentsCount = parents.Length;
+      if (parents.Length < 2) throw new ArgumentException("RoundedAverageCrossover: The number of parents is less than 2.", "parents");
+      if (bounds == null || bounds.Rows < 1 || bounds.Columns < 2) throw new ArgumentException("AverageCrossover: Invalid bounds specified.", "bounds");
+
+      var result = new IntegerVector(length);
+      try {
+        double avg;
+        for (int i = 0; i < length; i++) {
+          avg = 0;
+          for (int j = 0; j < parentsCount; j++)
+            avg += parents[j][i];
+          avg /= parentsCount;
+          int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
+          if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+          max = FloorFeasible(min, max, step, max - 1);
+          result[i] = RoundFeasible(min, max, step, avg);
+        }
+      } catch (IndexOutOfRangeException) {
+        throw new ArgumentException("RoundedAverageCrossover: The parents' vectors are of different length.", "parents");
+      }
+
+      return result;
+    }
+
+    /// <summary>
+    /// Performs an average crossover between two parent integer vectors.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown if there are not exactly two parents.</exception>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two integer vectors that should be crossed.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The newly created integer vector, resulting from the average crossover.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      return Apply(random, parents, bounds);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaBetaCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaBetaCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaBetaCrossover.cs	(revision 15491)
@@ -0,0 +1,164 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Blend alpha-beta crossover for integer vectors (BLX-a-b). Creates a new offspring by selecting a 
+  /// random value from the interval between the two alleles of the parent solutions and rounds the
+  /// result to the nearest feasible value. The interval is increased in both directions as follows:
+  /// Into the direction of the 'better' solution by the factor alpha, into the direction of the
+  /// 'worse' solution by the factor beta.
+  /// </summary>
+  [Item("RoundedBlendAlphaBetaCrossover", "The rounded blend alpha beta crossover (BLX-a-b) for integer vectors is similar to the blend alpha crossover (BLX-a), but distinguishes between the better and worse of the parents. The interval from which to choose the new offspring can be extended beyond the better parent by specifying a higher alpha value, and beyond the worse parent by specifying a higher beta value. The new offspring is sampled uniformly in the extended range and rounded to the next feasible integer.")]
+  [StorableClass]
+  public class RoundedBlendAlphaBetaCrossover : BoundedIntegerVectorCrossover, ISingleObjectiveOperator {
+    /// <summary>
+    /// Whether the problem is a maximization or minimization problem.
+    /// </summary>
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    /// <summary>
+    /// The quality of the parents.
+    /// </summary>
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+    /// <summary>
+    /// The Alpha parameter controls the extension of the range beyond the better parent. The value must be >= 0 and does not depend on Beta.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+    /// <summary>
+    /// The Beta parameter controls the extension of the range beyond the worse parent. The value must be >= 0 and does not depend on Alpha.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> BetaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Beta"]; }
+    }
+
+    [StorableConstructor]
+    protected RoundedBlendAlphaBetaCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedBlendAlphaBetaCrossover(RoundedBlendAlphaBetaCrossover original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="RoundedBlendAlphaBetaCrossover"/> with four additional parameters
+    /// (<c>Maximization</c>, <c>Quality</c>, <c>Alpha</c> and <c>Beta</c>).
+    /// </summary>
+    public RoundedBlendAlphaBetaCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality values of the parents."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The Alpha parameter controls the extension of the range beyond the better parent. The value must be >= 0 and does not depend on Beta.", new DoubleValue(0.75)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Beta", "The Beta parameter controls the extension of the range beyond the worse parent. The value must be >= 0 and does not depend on Alpha.", new DoubleValue(0.25)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedBlendAlphaBetaCrossover(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs the rounded blend alpha beta crossover (BLX-a-b) on two parent vectors.
+    /// </summary>
+    /// <exception cref="ArgumentException">
+    /// Thrown when either:<br/>
+    /// <list type="bullet">
+    /// <item><description>The length of <paramref name="betterParent"/> and <paramref name="worseParent"/> is not equal.</description></item>
+    /// <item><description>The parameter <paramref name="alpha"/> is smaller than 0.</description></item>
+    /// <item><description>The parameter <paramref name="beta"/> is smaller than 0.</description></item>
+    /// </list>
+    /// </exception>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="betterParent">The better of the two parents with regard to their fitness.</param>
+    /// <param name="worseParent">The worse of the two parents with regard to their fitness.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <param name="alpha">The parameter alpha.</param>
+    /// <param name="beta">The parameter beta.</param>
+    /// <returns>The integer vector that results from the crossover.</returns>
+    public static IntegerVector Apply(IRandom random, IntegerVector betterParent, IntegerVector worseParent, IntMatrix bounds, DoubleValue alpha, DoubleValue beta) {
+      if (betterParent.Length != worseParent.Length) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: The parents' vectors are of different length.", "betterParent");
+      if (alpha.Value < 0) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: Parameter alpha must be greater or equal to 0.", "alpha");
+      if (beta.Value < 0) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: Parameter beta must be greater or equal to 0.", "beta");
+      if (bounds == null || bounds.Rows < 1 || bounds.Columns < 2) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: Invalid bounds specified.", "bounds");
+
+      int length = betterParent.Length;
+      double min, max, d;
+      var result = new IntegerVector(length);
+      int minBound, maxBound, step = 1;
+      for (int i = 0; i < length; i++) {
+        minBound = bounds[i % bounds.Rows, 0];
+        maxBound = bounds[i % bounds.Rows, 1];
+        if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+        maxBound = FloorFeasible(minBound, maxBound, step, maxBound - 1);
+
+        d = Math.Abs(betterParent[i] - worseParent[i]);
+        if (betterParent[i] <= worseParent[i]) {
+          min = FloorFeasible(minBound, maxBound, step, betterParent[i] - d * alpha.Value);
+          max = CeilingFeasible(minBound, maxBound, step, worseParent[i] + d * beta.Value);
+        } else {
+          min = FloorFeasible(minBound, maxBound, step, worseParent[i] - d * beta.Value);
+          max = CeilingFeasible(minBound, maxBound, step, betterParent[i] + d * alpha.Value);
+        }
+        result[i] = RoundFeasible(minBound, maxBound, step, min + random.NextDouble() * (max - min));
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Checks if the number of parents is equal to 2, if all parameters are available and forwards the call to <see cref="Apply(IRandom, IntegerVector, IntegerVector, IntMatrix, DoubleValue, DoubleValue)"/>.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when the number of parents is not equal to 2.</exception>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when either:<br/>
+    /// <list type="bullet">
+    /// <item><description>Maximization parameter could not be found.</description></item>
+    /// <item><description>Quality parameter could not be found or the number of quality values is not equal to the number of parents.</description></item>
+    /// <item><description>Alpha parameter could not be found.</description></item>
+    /// <item><description>Beta parameter could not be found.</description></item>
+    /// </list>
+    /// </exception>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="parents">The collection of parents (must be of size 2).</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The integer vector that results from the crossover.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      if (parents.Length != 2) throw new ArgumentException("RoundedBlendAlphaBetaCrossover: Number of parents is not equal to 2.", "parents");
+      if (MaximizationParameter.ActualValue == null) throw new InvalidOperationException("RoundedBlendAlphaBetaCrossover: Parameter " + MaximizationParameter.ActualName + " could not be found.");
+      if (QualityParameter.ActualValue == null || QualityParameter.ActualValue.Length != parents.Length) throw new InvalidOperationException("RoundedBlendAlphaBetaCrossover: Parameter " + QualityParameter.ActualName + " could not be found, or not in the same quantity as there are parents.");
+      if (AlphaParameter.ActualValue == null || BetaParameter.ActualValue == null) throw new InvalidOperationException("RoundedBlendAlphaBetaCrossover: Parameter " + AlphaParameter.ActualName + " or paramter " + BetaParameter.ActualName + " could not be found.");
+
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+      if (maximization && qualities[0].Value >= qualities[1].Value || !maximization && qualities[0].Value <= qualities[1].Value)
+        return Apply(random, parents[0], parents[1], bounds, AlphaParameter.ActualValue, BetaParameter.ActualValue);
+      else {
+        return Apply(random, parents[1], parents[0], bounds, AlphaParameter.ActualValue, BetaParameter.ActualValue);
+      }
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedBlendAlphaCrossover.cs	(revision 15491)
@@ -0,0 +1,121 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Rounded blend alpha crossover for integer vectors (BLX-a). Creates a new offspring by selecting a random value 
+  /// from the interval between the two alleles of the parent solutions and rounding the result to the next feasible
+  /// integer. The interval is increased in both directions by the factor alpha.
+  /// </summary>
+  [Item("RoundedBlendAlphaCrossover", "The rounded blend alpha crossover (BLX-a) for integer vectors creates new offspring by sampling a new value in the range [min_i - d * alpha, max_i + d * alpha) at each position i and rounding the result to the next feasible integer. Here min_i and max_i are the smaller and larger value of the two parents at position i and d is max_i - min_i.")]
+  [StorableClass]
+  public class RoundedBlendAlphaCrossover : BoundedIntegerVectorCrossover {
+    /// <summary>
+    /// The alpha parameter specifies how much the interval between the parents should be extended to the left and right.
+    /// The value of this parameter also determines the name of the operator: BLX-0.0 for example means alpha is set to 0.
+    /// When Alpha is 0, then the offspring will only be chosen in between the parents, the bigger alpha is the more it will be possible to choose
+    /// values left and right of the min and max value for each gene.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+
+    [StorableConstructor]
+    protected RoundedBlendAlphaCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedBlendAlphaCrossover(RoundedBlendAlphaCrossover original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="RoundedBlendAlphaCrossover"/> with one parameter (<c>Alpha</c>).
+    /// </summary>
+    public RoundedBlendAlphaCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The Alpha parameter controls the extension of the range beyond the two parents. It must be >= 0. A value of 0.5 means that half the range is added to both sides of the intervals.", new DoubleValue(0.5)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedBlendAlphaCrossover(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs the rounded blend alpha crossover (BLX-a) of two integer vectors.<br/>
+    /// It creates new offspring by sampling a new value in the range [min_i - d * alpha, max_i + d * alpha) at each position i
+    /// and rounding the result to the next integer.
+    /// Here min_i and max_i are the smaller and larger value of the two parents at position i and d is max_i - min_i.
+    /// </summary>
+    /// <exception cref="ArgumentException">
+    /// Thrown when <paramref name="parent1"/> and <paramref name="parent2"/> are of different length or<br/>
+    /// when <paramref name="alpha"/> is less than 0.
+    /// </exception>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="parent1">The first parent for the crossover operation.</param>
+    /// <param name="parent2">The second parent for the crossover operation.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <param name="alpha">The alpha value for the crossover.</param>
+    /// <returns>The newly created integer vector resulting from the crossover operation.</returns>
+    public static IntegerVector Apply(IRandom random, IntegerVector parent1, IntegerVector parent2, IntMatrix bounds, DoubleValue alpha) {
+      if (parent1.Length != parent2.Length) throw new ArgumentException("RoundedBlendAlphaCrossover: The parents' vectors are of different length.", "parent1");
+      if (alpha.Value < 0) throw new ArgumentException("RoundedBlendAlphaCrossover: Paramter alpha must be greater or equal than 0.", "alpha");
+      if (bounds == null || bounds.Rows < 1 || bounds.Columns < 2) throw new ArgumentException("RoundedBlendAlphaCrossover: Invalid bounds specified.", "bounds");
+
+      int length = parent1.Length;
+      var result = new IntegerVector(length);
+      double max = 0, min = 0, d = 0, resMin = 0, resMax = 0;
+      int minBound, maxBound, step = 1;
+
+      for (int i = 0; i < length; i++) {
+        minBound = bounds[i % bounds.Rows, 0];
+        maxBound = bounds[i % bounds.Rows, 1];
+        if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+        maxBound = FloorFeasible(minBound, maxBound, step, maxBound - 1);
+
+        max = Math.Max(parent1[i], parent2[i]);
+        min = Math.Min(parent1[i], parent2[i]);
+        d = Math.Abs(max - min);
+        resMin = FloorFeasible(minBound, maxBound, step, min - d * alpha.Value);
+        resMax = CeilingFeasible(minBound, maxBound, step, max + d * alpha.Value);
+
+        result[i] = RoundFeasible(minBound, maxBound, step, resMin + random.NextDouble() * Math.Abs(resMax - resMin));
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Checks that the number of parents is equal to 2 and forwards the call to <see cref="Apply(IRandom, RealVector, RealVector, DoubleValue)"/>.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when the number of parents is not equal to 2.</exception>
+    /// <exception cref="InvalidOperationException">Thrown when the parameter alpha could not be found.</exception>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="parents">The collection of parents (must be of size 2).</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The integer vector resulting from the crossover operation.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      if (parents.Length != 2) throw new ArgumentException("RoundedBlendAlphaCrossover: The number of parents is not equal to 2", "parents");
+      if (AlphaParameter.ActualValue == null) throw new InvalidOperationException("RoundedBlendAlphaCrossover: Parameter " + AlphaParameter.ActualName + " could not be found.");
+      return Apply(random, parents[0], parents[1], bounds, AlphaParameter.ActualValue);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedHeuristicCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedHeuristicCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedHeuristicCrossover.cs	(revision 15491)
@@ -0,0 +1,127 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Heuristic crossover for integer vectors: Calculates the vector from the worse to the better parent and adds that to the better parent weighted with a factor in the interval [0;1).
+  /// The result is then rounded to the next feasible integer.
+  /// The idea is that going further in direction from the worse to the better leads to even better solutions (naturally this depends on the fitness landscape).
+  /// </summary>
+  [Item("RoundedHeuristicCrossover", "The heuristic crossover produces offspring that extend the better parent in direction from the worse to the better parent.")]
+  [StorableClass]
+  public class RoundedHeuristicCrossover : BoundedIntegerVectorCrossover, ISingleObjectiveOperator {
+    /// <summary>
+    /// Whether the problem is a maximization or minimization problem.
+    /// </summary>
+    public ValueLookupParameter<BoolValue> MaximizationParameter {
+      get { return (ValueLookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+    /// <summary>
+    /// The quality of the parents.
+    /// </summary>
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    [StorableConstructor]
+    protected RoundedHeuristicCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedHeuristicCrossover(RoundedHeuristicCrossover original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="RoundedHeuristicCrossover"/> with two variable infos
+    /// (<c>Maximization</c> and <c>Quality</c>).
+    /// </summary>
+    public RoundedHeuristicCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<BoolValue>("Maximization", "Whether the problem is a maximization problem or not."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>("Quality", "The quality values of the parents."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedHeuristicCrossover(this, cloner);
+    }
+
+    /// <summary>
+    /// Perfomrs a heuristic crossover on the two given parents.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when two parents are not of the same length.</exception>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="betterParent">The first parent for the crossover operation.</param>
+    /// <param name="worseParent">The second parent for the crossover operation.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The newly created integer vector, resulting from the heuristic crossover.</returns>
+    public static IntegerVector Apply(IRandom random, IntegerVector betterParent, IntegerVector worseParent, IntMatrix bounds) {
+      if (betterParent.Length != worseParent.Length)
+        throw new ArgumentException("HeuristicCrossover: the two parents are not of the same length");
+
+      int length = betterParent.Length;
+      var result = new IntegerVector(length);
+      double factor = random.NextDouble();
+
+      int min, max, step = 1;
+      for (int i = 0; i < length; i++) {
+        min = bounds[i % bounds.Rows, 0];
+        max = bounds[i % bounds.Rows, 1];
+        if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+        max = FloorFeasible(min, max, step, max - 1);
+        result[i] = RoundFeasible(min, max, step, betterParent[i] + factor * (betterParent[i] - worseParent[i]));
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs a heuristic crossover operation for two given parent integer vectors.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when the number of parents is not equal to 2.</exception>
+    /// <exception cref="InvalidOperationException">
+    /// Thrown when either:<br/>
+    /// <list type="bullet">
+    /// <item><description>Maximization parameter could not be found.</description></item>
+    /// <item><description>Quality parameter could not be found or the number of quality values is not equal to the number of parents.</description></item>
+    /// </list>
+    /// </exception>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
+    /// /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      if (parents.Length != 2) throw new ArgumentException("RoundedHeuristicCrossover: The number of parents is not equal to 2");
+
+      if (MaximizationParameter.ActualValue == null) throw new InvalidOperationException("RoundedHeuristicCrossover: Parameter " + MaximizationParameter.ActualName + " could not be found.");
+      if (QualityParameter.ActualValue == null || QualityParameter.ActualValue.Length != parents.Length) throw new InvalidOperationException("RoundedHeuristicCrossover: Parameter " + QualityParameter.ActualName + " could not be found, or not in the same quantity as there are parents.");
+
+      ItemArray<DoubleValue> qualities = QualityParameter.ActualValue;
+      bool maximization = MaximizationParameter.ActualValue.Value;
+
+      if (maximization && qualities[0].Value >= qualities[1].Value || !maximization && qualities[0].Value <= qualities[1].Value)
+        return Apply(random, parents[0], parents[1], bounds);
+      else
+        return Apply(random, parents[1], parents[0], bounds);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedLocalCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedLocalCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedLocalCrossover.cs	(revision 15491)
@@ -0,0 +1,86 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// The rounded local crossover for integer vectors is similar to the <see cref="UniformArithmeticCrossover"/>, but where the factor alpha is chosen randomly in the interval [0;1) for each position.
+  /// </summary>cribed in Dumitrescu, D. et al. (2000), Evolutionary computation, CRC Press, Boca Raton, FL, p. 194.
+  /// </remarks>
+  [Item("RoundedLocalCrossover", @"The runded local crossover is similar to the arithmetic crossover, but uses a random alpha for each position x = alpha * p1 + (1-alpha) * p2.")]
+  [StorableClass]
+  public class RoundedLocalCrossover : BoundedIntegerVectorCrossover {
+    [StorableConstructor]
+    protected RoundedLocalCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedLocalCrossover(RoundedLocalCrossover original, Cloner cloner) : base(original, cloner) { }
+    public RoundedLocalCrossover() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedLocalCrossover(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs a local crossover on the two given parent vectors.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when two parents are not of the same length.</exception>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="parent1">The first parent for the crossover operation.</param>
+    /// <param name="parent2">The second parent for the crossover operation.</param>
+    /// <returns>The newly created integer vector, resulting from the local crossover.</returns>
+    public static IntegerVector Apply(IRandom random, IntegerVector parent1, IntegerVector parent2, IntMatrix bounds) {
+      if (parent1.Length != parent2.Length)
+        throw new ArgumentException("RoundedLocalCrossover: the two parents are not of the same length");
+
+      double factor;
+      int length = parent1.Length;
+      var result = new IntegerVector(length);
+
+      int min, max, step = 1;
+      for (int i = 0; i < length; i++) {
+        min = bounds[i % bounds.Rows, 0];
+        max = bounds[i % bounds.Rows, 1];
+        if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+        max = FloorFeasible(min, max, step, max - 1);
+        factor = random.NextDouble();
+        result[i] = RoundFeasible(min, max, step, (factor * parent1[i]) + ((1 - factor) * parent2[i]));
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Performs a local crossover operation for two given parent integer vectors.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown if there are not exactly two parents.</exception>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parents">An array containing the two real vectors that should be crossed.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The newly created integer vector, resulting from the crossover operation.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      if (parents.Length != 2) throw new ArgumentException("RoundedLocalCrossover: The number of parents is not equal to 2");
+      return Apply(random, parents[0], parents[1], bounds);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedUniformArithmeticCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedUniformArithmeticCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/RoundedUniformArithmeticCrossover.cs	(revision 15491)
@@ -0,0 +1,111 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// The rounded uniform arithmetic crossover (continuous recombination) constructs an offspring by calculating x = alpha * p1 + (1-alpha) * p2 for a position x in the vector with a given probability (otherwise p1 is taken at this position).
+  /// </summary>
+  [Item("RoundedUniformSomePositionsArithmeticCrossover", "The uniform some positions arithmetic crossover (continuous recombination) constructs an offspring by calculating x = alpha * p1 + (1-alpha) * p2 for a position x in the vector with a given probability (otherwise p1 is taken at this position).")]
+  [StorableClass]
+  public class RoundedUniformArithmeticCrossover : BoundedIntegerVectorCrossover, IBoundedIntegerVectorOperator {
+
+    /// <summary>
+    /// The alpha parameter needs to be in the interval (0;1) and specifies how close the resulting offspring should be either to parent1 (alpha -> 0) or parent2 (alpha -> 1).
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> AlphaParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Alpha"]; }
+    }
+    /// <summary>
+    /// The probability in the range (0;1] for each position in the vector to be crossed.
+    /// </summary>
+    public ValueLookupParameter<DoubleValue> ProbabilityParameter {
+      get { return (ValueLookupParameter<DoubleValue>)Parameters["Probability"]; }
+    }
+
+    [StorableConstructor]
+    protected RoundedUniformArithmeticCrossover(bool deserializing) : base(deserializing) { }
+    protected RoundedUniformArithmeticCrossover(RoundedUniformArithmeticCrossover original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance with two parameters (<c>Alpha</c> and <c>Probability</c>).
+    /// </summary>
+    public RoundedUniformArithmeticCrossover()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Alpha", "The alpha value in the range (0;1) that defines whether the point should be close to parent1 (->1) or parent2 (->0)", new DoubleValue(0.5)));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Probability", "The probability for crossing a position in the range (0;1]", new DoubleValue(1)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedUniformArithmeticCrossover(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs the arithmetic crossover on some positions by taking either x = alpha * p1 + (1 - alpha) * p2 or x = p1 depending on the probability for a gene to be crossed.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="parent1">The first parent vector.</param>
+    /// <param name="parent2">The second parent vector.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <param name="alpha">The alpha parameter (<see cref="AlphaParameter"/>).</param>
+    /// <param name="probability">The probability parameter (<see cref="ProbabilityParameter"/>).</param>
+    /// <returns>The vector resulting from the crossover.</returns>
+    public static IntegerVector Apply(IRandom random, IntegerVector parent1, IntegerVector parent2, IntMatrix bounds, DoubleValue alpha, DoubleValue probability) {
+      int length = parent1.Length;
+      if (length != parent2.Length) throw new ArgumentException("RoundedUniformArithmeticCrossover: The parent vectors are of different length.", "parent1");
+      if (alpha.Value < 0 || alpha.Value > 1) throw new ArgumentException("RoundedUniformArithmeticCrossover: Parameter alpha must be in the range [0;1]", "alpha");
+      if (probability.Value < 0 || probability.Value > 1) throw new ArgumentException("RoundedUniformArithmeticCrossover: Parameter probability must be in the range [0;1]", "probability");
+
+      var result = new IntegerVector(length);
+      for (int i = 0; i < length; i++) {
+        if (random.NextDouble() < probability.Value) {
+          int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
+          if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+          max = FloorFeasible(min, max, step, max - 1);
+          double value = alpha.Value * parent1[i] + (1 - alpha.Value) * parent2[i];
+          result[i] = RoundFeasible(min, max, step, value);
+        } else result[i] = parent1[i];
+      }
+      return result;
+    }
+
+    /// <summary>
+    /// Checks that there are exactly 2 parents, that the alpha and the probability parameter are not null and fowards the call to the static Apply method.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown when there are not exactly two parents.</exception>
+    /// <exception cref="InvalidOperationException">Thrown when either the alpha parmeter or the probability parameter could not be found.</exception>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="parents">The collection of parents (must be of size 2).</param>
+    /// /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The vector resulting from the crossover.</returns>
+    protected override IntegerVector CrossBounded(IRandom random, ItemArray<IntegerVector> parents, IntMatrix bounds) {
+      if (parents.Length != 2) throw new ArgumentException("RoundedUniformArithmeticCrossover: There must be exactly two parents.", "parents");
+      if (AlphaParameter.ActualValue == null) throw new InvalidOperationException("RoundedUniformArithmeticCrossover: Parameter " + AlphaParameter.ActualName + " could not be found.");
+      if (ProbabilityParameter.ActualValue == null) throw new InvalidOperationException("RoundedUniformArithmeticCrossover: Parameter " + ProbabilityParameter.ActualName + " could not be found.");
+      return Apply(random, parents[0], parents[1], bounds, AlphaParameter.ActualValue, ProbabilityParameter.ActualValue);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Crossovers/SinglePointCrossover.cs	(revision 15491)
@@ -0,0 +1,83 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Single point crossover for integer vectors.
+  /// </summary>
+  /// <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.
+  /// </remarks>
+  [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 : IntegerVectorCrossover {
+    [StorableConstructor]
+    protected SinglePointCrossover(bool deserializing) : base(deserializing) { }
+    protected SinglePointCrossover(SinglePointCrossover original, Cloner cloner) : base(original, cloner) { }
+    public SinglePointCrossover() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SinglePointCrossover(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs a single point crossover at a randomly chosen position of the two 
+    /// given parent integer vectors.
+    /// </summary>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="parent1">The first parent for crossover.</param>
+    /// <param name="parent2">The second parent for crossover.</param>
+    /// <returns>The newly created integer vector, resulting from the single point crossover.</returns>
+    public static IntegerVector Apply(IRandom random, IntegerVector parent1, IntegerVector parent2) {
+      if (parent1.Length != parent2.Length)
+        throw new ArgumentException("SinglePointCrossover: The parents are of different length.");
+
+      int length = parent1.Length;
+      int[] result = new int[length];
+      int breakPoint = random.Next(1, length);
+
+      for (int i = 0; i < breakPoint; i++)
+        result[i] = parent1[i];
+      for (int i = breakPoint; i < length; i++)
+        result[i] = parent2[i];
+
+      return new IntegerVector(result);
+    }
+
+    /// <summary>
+    /// Performs a single point crossover at a randomly chosen position of two 
+    /// given parent integer vectors.
+    /// </summary>
+    /// <exception cref="ArgumentException">Thrown if there are not exactly two parents.</exception>
+    /// <param name="random">A random number generator.</param>
+    /// <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 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: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj	(revision 15491)
@@ -0,0 +1,252 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{DDFB14DD-2A85-493C-A52D-E69729BBAEB0}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Encodings.IntegerVectorEncoding</RootNamespace>
+    <AssemblyName>HeuristicLab.Encodings.IntegerVectorEncoding-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkProfile>
+    </TargetFrameworkProfile>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <UpgradeBackupLocation />
+    <PublishUrl>publish\</PublishUrl>
+    <Install>true</Install>
+    <InstallFrom>Disk</InstallFrom>
+    <UpdateEnabled>false</UpdateEnabled>
+    <UpdateMode>Foreground</UpdateMode>
+    <UpdateInterval>7</UpdateInterval>
+    <UpdateIntervalUnits>Days</UpdateIntervalUnits>
+    <UpdatePeriodically>false</UpdatePeriodically>
+    <UpdateRequired>false</UpdateRequired>
+    <MapFileExtensions>true</MapFileExtensions>
+    <ApplicationRevision>0</ApplicationRevision>
+    <ApplicationVersion>1.0.0.%2a</ApplicationVersion>
+    <IsWebBootstrapper>false</IsWebBootstrapper>
+    <UseApplicationTrust>false</UseApplicationTrust>
+    <BootstrapperEnabled>true</BootstrapperEnabled>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+    <Prefer32Bit>false</Prefer32Bit>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="BoundedIntegerVectorCrossover.cs" />
+    <Compile Include="BoundedIntegerVectorManipulator.cs" />
+    <Compile Include="Creators\UniformRandomIntegerVectorCreator.cs" />
+    <Compile Include="Crossovers\RoundedAverageCrossover.cs" />
+    <Compile Include="Crossovers\DiscreteCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Crossovers\MultiIntegerVectorCrossover.cs" />
+    <Compile Include="Crossovers\RoundedBlendAlphaBetaCrossover.cs" />
+    <Compile Include="Crossovers\RoundedBlendAlphaCrossover.cs" />
+    <Compile Include="Crossovers\RoundedHeuristicCrossover.cs" />
+    <Compile Include="Crossovers\RoundedLocalCrossover.cs" />
+    <Compile Include="Crossovers\SinglePointCrossover.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="Crossovers\RoundedUniformArithmeticCrossover.cs" />
+    <Compile Include="IntegerVectorEncoding.cs" />
+    <Compile Include="IntegerVectorEqualityComparer.cs" />
+    <Compile Include="IntegerVectorOperator.cs" />
+    <Compile Include="Interfaces\IBoundedIntegerVectorOperator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorCreator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorCrossover.cs" />
+    <Compile Include="Interfaces\IIntegerVectorManipulator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorMultiNeighborhoodShakingOperator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorOperator.cs" />
+    <Compile Include="IntegerVectorCrossover.cs" />
+    <Compile Include="IntegerVectorManipulator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorStdDevStrategyParameterCreator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorStdDevStrategyParameterCrossover.cs" />
+    <Compile Include="Interfaces\IIntegerVectorStdDevStrategyParameterManipulator.cs" />
+    <Compile Include="Interfaces\IIntegerVectorStdDevStrategyParameterOperator.cs" />
+    <Compile Include="Manipulators\UniformSomePositionsManipulator.cs" />
+    <Compile Include="Manipulators\RoundedNormalAllPositionsManipulator.cs" />
+    <Compile Include="Manipulators\SelfAdaptiveRoundedNormalAllPositionsManipulator.cs" />
+    <Compile Include="SimilarityCalculators\EuclideanSimilarityCalculator.cs" />
+    <Compile Include="SimilarityCalculators\HammingSimilarityCalculator.cs" />
+    <Compile Include="StrategyParameters\StdDevStrategyVectorCreator.cs" />
+    <Compile Include="StrategyParameters\StdDevStrategyVectorCrossover.cs" />
+    <Compile Include="StrategyParameters\StdDevStrategyVectorManipulator.cs" />
+    <Compile Include="Manipulators\UniformOnePositionManipulator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="IntegerVector.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="IntegerVectorCreator.cs" />
+    <Compile Include="ShakingOperators\IntegerVectorShakingOperator.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <BootstrapperPackage Include="Microsoft.Net.Client.3.5">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName>
+      <Install>false</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1">
+      <Visible>False</Visible>
+      <ProductName>.NET Framework 3.5 SP1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+    <BootstrapperPackage Include="Microsoft.Windows.Installer.3.1">
+      <Visible>False</Visible>
+      <ProductName>Windows Installer 3.1</ProductName>
+      <Install>true</Install>
+    </BootstrapperPackage>
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization.Operators-3.3, Version=3.3.0.0">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3, Version=3.3.0.0">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3, Version=3.3.0.0">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14AB8D24-25BC-400C-A846-4627AA945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+  <PropertyGroup>
+    <PreBuildEvent Condition=" '$(OS)' == 'Windows_NT' ">set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+</PreBuildEvent>
+    <PreBuildEvent Condition=" '$(OS)' != 'Windows_NT' ">
+export ProjectDir=$(ProjectDir)
+export SolutionDir=$(SolutionDir)
+
+$SolutionDir/PreBuildEvent.sh
+</PreBuildEvent>
+  </PropertyGroup>
+</Project>
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVector.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVector.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVector.cs	(revision 15491)
@@ -0,0 +1,79 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [StorableClass]
+  [Item("IntegerVector", "Represents a vector of integer values.")]
+  public class IntegerVector : IntArray {
+    [StorableConstructor]
+    protected IntegerVector(bool deserializing) : base(deserializing) { }
+    protected IntegerVector(IntegerVector original, Cloner cloner) : base(original, cloner) { }
+    public IntegerVector() : base() { }
+    public IntegerVector(int length) : base(length) { }
+    public IntegerVector(int length, IRandom random, int min, int max)
+      : this(length) {
+      Randomize(random, min, max);
+    }
+    public IntegerVector(int[] elements) : base(elements) { }
+    public IntegerVector(IntArray elements)
+      : this(elements.Length) {
+      for (int i = 0; i < array.Length; i++)
+        array[i] = elements[i];
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntegerVector(this, cloner);
+    }
+
+    public virtual void Randomize(IRandom random, int startIndex, int length, int min, int max, int step = 1) {
+      if (length > 0) {
+        int numbers = (int)Math.Floor((max - min) / (double)step);
+        for (int i = startIndex; i < startIndex + length; i++) {
+          array[i] = random.Next(numbers) * step + min;
+        }
+        OnReset();
+      }
+    }
+    public virtual void Randomize(IRandom random, int startIndex, int length, IntMatrix bounds) {
+      if (length > 0) {
+        for (int i = startIndex; i < startIndex + length; i++) {
+          int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
+          if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+          int numbers = (int)Math.Floor((max - min) / (double)step);
+          array[i] = random.Next(numbers) * step + min;
+        }
+        OnReset();
+      }
+    }
+    public void Randomize(IRandom random, int min, int max, int step = 1) {
+      Randomize(random, 0, Length, min, max, step);
+    }
+    public void Randomize(IRandom random, IntMatrix bounds) {
+      Randomize(random, 0, Length, bounds);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCreator.cs	(revision 15491)
@@ -0,0 +1,88 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Common;
+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 : InstrumentedOperator, IIntegerVectorCreator, IStochasticOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    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<IntMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected IntegerVectorCreator(bool deserializing) : base(deserializing) { }
+    protected IntegerVectorCreator(IntegerVectorCreator original, Cloner cloner) : base(original, cloner) { }
+    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<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
+    }
+
+    // BackwardsCompatibility3.3
+    #region Backwards compatible code, remove with 3.4
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("Bounds")) {
+        var min = ((IValueLookupParameter<IntValue>)Parameters["Minimum"]).Value as IntValue;
+        var max = ((IValueLookupParameter<IntValue>)Parameters["Maximum"]).Value as IntValue;
+        Parameters.Remove("Minimum");
+        Parameters.Remove("Maximum");
+        Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
+        if (min != null && max != null) {
+          BoundsParameter.Value = new IntMatrix(new int[,] { { min.Value, max.Value, 1 } });
+        }
+      }
+    }
+    #endregion
+
+    public sealed override IOperation InstrumentedApply() {
+      IntegerVectorParameter.ActualValue = Create(RandomParameter.ActualValue, LengthParameter.ActualValue, BoundsParameter.ActualValue);
+      return base.InstrumentedApply();
+    }
+
+    protected abstract IntegerVector Create(IRandom random, IntValue length, IntMatrix bounds);
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorCrossover.cs	(revision 15491)
@@ -0,0 +1,67 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Common;
+using HeuristicLab.Core;
+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 : IntegerVectorOperator, IIntegerVectorCrossover, IStochasticOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemArray<IntegerVector>> ParentsParameter {
+      get { return (ScopeTreeLookupParameter<IntegerVector>)Parameters["Parents"]; }
+    }
+    public ILookupParameter<IntegerVector> ChildParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["Child"]; }
+    }
+
+    [StorableConstructor]
+    protected IntegerVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected IntegerVectorCrossover(IntegerVectorCrossover original, Cloner cloner) : base(original, cloner) { }
+    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 ScopeTreeLookupParameter<IntegerVector>("Parents", "The parent vectors which should be crossed."));
+      ParentsParameter.ActualName = "IntegerVector";
+      Parameters.Add(new LookupParameter<IntegerVector>("Child", "The child vector resulting from the crossover."));
+      ChildParameter.ActualName = "IntegerVector";
+    }
+
+    public sealed override IOperation InstrumentedApply() {
+      ChildParameter.ActualValue = Cross(RandomParameter.ActualValue, ParentsParameter.ActualValue);
+      return base.InstrumentedApply();
+    }
+
+    protected abstract IntegerVector Cross(IRandom random, ItemArray<IntegerVector> parents);
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEncoding.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEncoding.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEncoding.cs	(revision 15491)
@@ -0,0 +1,283 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("IntegerVectorEncoding", "Describes an integer vector encoding.")]
+  [StorableClass]
+  public sealed class IntegerVectorEncoding : Encoding<IIntegerVectorCreator> {
+    #region Encoding Parameters
+    [Storable]
+    private IFixedValueParameter<IntValue> lengthParameter;
+    public IFixedValueParameter<IntValue> LengthParameter {
+      get { return lengthParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Length parameter must not be null.");
+        if (value.Value == null) throw new ArgumentNullException("Length parameter value must not be null.");
+        if (lengthParameter == value) return;
+
+        if (lengthParameter != null) Parameters.Remove(lengthParameter);
+        lengthParameter = value;
+        Parameters.Add(lengthParameter);
+        OnLengthParameterChanged();
+      }
+    }
+
+    [Storable]
+    private IValueParameter<IntMatrix> boundsParameter;
+    public IValueParameter<IntMatrix> BoundsParameter {
+      get { return boundsParameter; }
+      set {
+        if (value == null) throw new ArgumentNullException("Bounds parameter must not be null.");
+        if (boundsParameter == value) return;
+
+        if (boundsParameter != null) Parameters.Remove(boundsParameter);
+        boundsParameter = value;
+        Parameters.Add(boundsParameter);
+        OnBoundsParameterChanged();
+      }
+    }
+    #endregion
+
+    public int Length {
+      get { return LengthParameter.Value.Value; }
+      set { LengthParameter.Value.Value = value; }
+    }
+    public IntMatrix Bounds {
+      get { return BoundsParameter.Value; }
+      set { BoundsParameter.Value = value; }
+    }
+
+    [StorableConstructor]
+    private IntegerVectorEncoding(bool deserializing) : base(deserializing) { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    private IntegerVectorEncoding(IntegerVectorEncoding original, Cloner cloner)
+      : base(original, cloner) {
+      lengthParameter = cloner.Clone(original.lengthParameter);
+      boundsParameter = cloner.Clone(original.boundsParameter);
+      RegisterParameterEvents();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) { return new IntegerVectorEncoding(this, cloner); }
+
+
+    public IntegerVectorEncoding() : this("IntegerVector", 10) { }
+    public IntegerVectorEncoding(string name) : this(name, 10) { }
+    public IntegerVectorEncoding(int length) : this("integerVector", length) { }
+    public IntegerVectorEncoding(string name, int length, int min = int.MinValue, int max = int.MaxValue, int? step = null)
+      : base(name) {
+      if (min >= max) throw new ArgumentException("min must be less than max", "min");
+      if (step.HasValue && step.Value <= 0) throw new ArgumentException("step must be greater than zero or null", "step");
+
+      var bounds = new IntMatrix(1, step.HasValue ? 3 : 2);
+      bounds[0, 0] = min;
+      bounds[0, 1] = max;
+      if (step.HasValue) bounds[0, 2] = step.Value;
+
+      lengthParameter = new FixedValueParameter<IntValue>(Name + ".Length", new IntValue(length));
+      boundsParameter = new ValueParameter<IntMatrix>(Name + ".Bounds", bounds);
+      Parameters.Add(lengthParameter);
+      Parameters.Add(boundsParameter);
+
+      SolutionCreator = new UniformRandomIntegerVectorCreator();
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+    public IntegerVectorEncoding(string name, int length, IList<int> min, IList<int> max, IList<int> step = null)
+      : base(name) {
+      if (min.Count == 0) throw new ArgumentException("Bounds must be given for the integer parameters.");
+      if (min.Count != max.Count) throw new ArgumentException("min must be of the same length as max", "min");
+      if (step != null && min.Count != step.Count) throw new ArgumentException("step must be of the same length as min or null", "step");
+      if (min.Zip(max, (mi, ma) => mi >= ma).Any(x => x)) throw new ArgumentException("min must be less than max in each dimension", "min");
+
+      var bounds = new IntMatrix(min.Count, step != null ? 3 : 2);
+      for (int i = 0; i < min.Count; i++) {
+        bounds[i, 0] = min[i];
+        bounds[i, 1] = max[i];
+        if (step != null) bounds[i, 2] = step[i];
+      }
+
+      lengthParameter = new FixedValueParameter<IntValue>(Name + ".Length", new IntValue(length));
+      boundsParameter = new ValueParameter<IntMatrix>(Name + ".Bounds", bounds);
+      Parameters.Add(lengthParameter);
+      Parameters.Add(boundsParameter);
+
+      SolutionCreator = new UniformRandomIntegerVectorCreator();
+      RegisterParameterEvents();
+      DiscoverOperators();
+    }
+
+    private void OnLengthParameterChanged() {
+      RegisterLengthParameterEvents();
+      ConfigureOperators(Operators);
+    }
+    private void OnBoundsParameterChanged() {
+      RegisterBoundsParameterEvents();
+      ConfigureOperators(Operators);
+    }
+
+    private void RegisterParameterEvents() {
+      RegisterLengthParameterEvents();
+      RegisterBoundsParameterEvents();
+    }
+    private void RegisterLengthParameterEvents() {
+      LengthParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      LengthParameter.Value.ValueChanged += (o, s) => ConfigureOperators(Operators);
+    }
+    private void RegisterBoundsParameterEvents() {
+      BoundsParameter.ValueChanged += (o, s) => ConfigureOperators(Operators);
+      boundsParameter.Value.ToStringChanged += (o, s) => ConfigureOperators(Operators);
+    }
+
+
+    #region Operator Discovery
+    private static readonly IEnumerable<Type> encodingSpecificOperatorTypes;
+    static IntegerVectorEncoding() {
+      encodingSpecificOperatorTypes = new List<Type>() {
+        typeof (IIntegerVectorOperator),
+        typeof (IIntegerVectorCreator),
+        typeof (IIntegerVectorCrossover),
+        typeof (IIntegerVectorManipulator),
+        typeof (IIntegerVectorStdDevStrategyParameterOperator),
+        typeof (IIntegerVectorMultiNeighborhoodShakingOperator),
+      };
+    }
+    private void DiscoverOperators() {
+      var assembly = typeof(IIntegerVectorOperator).Assembly;
+      var discoveredTypes = ApplicationManager.Manager.GetTypes(encodingSpecificOperatorTypes, assembly, true, false, false);
+      var operators = discoveredTypes.Select(t => (IOperator)Activator.CreateInstance(t));
+      var newOperators = operators.Except(Operators, new TypeEqualityComparer<IOperator>()).ToList();
+
+      ConfigureOperators(newOperators);
+      foreach (var @operator in newOperators)
+        AddOperator(@operator);
+    }
+    #endregion
+
+    public override void ConfigureOperators(IEnumerable<IOperator> operators) {
+      ConfigureBoundedOperators(operators.OfType<IBoundedIntegerVectorOperator>());
+      ConfigureCreators(operators.OfType<IIntegerVectorCreator>());
+      ConfigureCrossovers(operators.OfType<IIntegerVectorCrossover>());
+      ConfigureManipulators(operators.OfType<IIntegerVectorManipulator>());
+      ConfigureShakingOperators(operators.OfType<IIntegerVectorMultiNeighborhoodShakingOperator>());
+      ConfigureStrategyVectorOperator(operators.OfType<IIntegerVectorStdDevStrategyParameterOperator>());
+    }
+
+    #region Specific Operator Wiring
+    private void ConfigureBoundedOperators(IEnumerable<IBoundedIntegerVectorOperator> boundedOperators) {
+      foreach (var boundedOperator in boundedOperators) {
+        boundedOperator.BoundsParameter.ActualName = BoundsParameter.Name;
+      }
+    }
+
+    private void ConfigureCreators(IEnumerable<IIntegerVectorCreator> creators) {
+      foreach (var creator in creators) {
+        creator.IntegerVectorParameter.ActualName = Name;
+        creator.BoundsParameter.ActualName = BoundsParameter.Name;
+        creator.LengthParameter.ActualName = LengthParameter.Name;
+      }
+    }
+
+    private void ConfigureCrossovers(IEnumerable<IIntegerVectorCrossover> crossovers) {
+      foreach (var crossover in crossovers) {
+        crossover.ChildParameter.ActualName = Name;
+        crossover.ParentsParameter.ActualName = Name;
+      }
+    }
+
+    private void ConfigureManipulators(IEnumerable<IIntegerVectorManipulator> manipulators) {
+      foreach (var manipulator in manipulators) {
+        manipulator.IntegerVectorParameter.ActualName = Name;
+        manipulator.IntegerVectorParameter.Hidden = true;
+        var sm = manipulator as ISelfAdaptiveManipulator;
+        if (sm != null) {
+          var p = sm.StrategyParameterParameter as ILookupParameter;
+          if (p != null) {
+            p.ActualName = Name + "Strategy";
+          }
+        }
+      }
+    }
+
+    private void ConfigureShakingOperators(IEnumerable<IIntegerVectorMultiNeighborhoodShakingOperator> shakingOperators) {
+      foreach (var shakingOperator in shakingOperators) {
+        shakingOperator.IntegerVectorParameter.ActualName = Name;
+      }
+    }
+
+    private void ConfigureStrategyVectorOperator(IEnumerable<IIntegerVectorStdDevStrategyParameterOperator> strategyVectorOperators) {
+      var bounds = new DoubleMatrix(Bounds.Rows, Bounds.Columns);
+      for (var i = 0; i < bounds.Rows; i++) {
+        bounds[i, 1] = (int)Math.Ceiling(0.33 * (Bounds[i, 1] - Bounds[i, 0]));
+        bounds[i, 0] = 0;
+        if (bounds.Columns > 2) bounds[i, 2] = Bounds[i, 2];
+      }
+      foreach (var s in strategyVectorOperators) {
+        var c = s as IIntegerVectorStdDevStrategyParameterCreator;
+        if (c != null) {
+          c.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+          c.LengthParameter.ActualName = Name;
+          c.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+        var m = s as IIntegerVectorStdDevStrategyParameterManipulator;
+        if (m != null) {
+          m.BoundsParameter.Value = (DoubleMatrix)bounds.Clone();
+          m.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+        var mm = s as StdDevStrategyVectorManipulator;
+        if (mm != null) {
+          mm.GeneralLearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Length));
+          mm.LearningRateParameter.Value = new DoubleValue(1.0 / Math.Sqrt(2 * Math.Sqrt(Length)));
+        }
+        var x = s as IIntegerVectorStdDevStrategyParameterCrossover;
+        if (x != null) {
+          x.ParentsParameter.ActualName = Name + "Strategy";
+          x.StrategyParameterParameter.ActualName = Name + "Strategy";
+        }
+      }
+    }
+    #endregion
+  }
+
+  public static class IndividualExtensionMethods {
+    public static IntegerVector IntegerVector(this Individual individual) {
+      var encoding = individual.GetEncoding<IntegerVectorEncoding>();
+      return individual.IntegerVector(encoding.Name);
+    }
+    public static IntegerVector IntegerVector(this Individual individual, string name) {
+      return (IntegerVector)individual[name];
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEqualityComparer.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEqualityComparer.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorEqualityComparer.cs	(revision 15491)
@@ -0,0 +1,48 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2017 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 HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [NonDiscoverableType]
+  public class IntegerVectorEqualityComparer : EqualityComparer<IntegerVector> {
+    public override bool Equals(IntegerVector x, IntegerVector y) {
+      if (ReferenceEquals(x, y)) return true;
+      if (x == null || y == null) return false;
+      if (x.Length != y.Length) return false;
+      for (var i = 0; i < x.Length; i++)
+        if (x[i] != y[i]) return false;
+      return true;
+    }
+
+    public override int GetHashCode(IntegerVector obj) {
+      if (obj == null) throw new ArgumentNullException("obj", "IntegerVectorEqualityComparer: Cannot compute hash value of null.");
+      unchecked {
+        int hash = 17;
+        foreach (var o in obj)
+          hash = hash * 31 + o.GetHashCode();
+        return hash;
+      }
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorManipulator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorManipulator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorManipulator.cs	(revision 15491)
@@ -0,0 +1,61 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Common;
+using HeuristicLab.Core;
+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 : IntegerVectorOperator, IIntegerVectorManipulator, IStochasticOperator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<IntegerVector> IntegerVectorParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["IntegerVector"]; }
+    }
+
+    [StorableConstructor]
+    protected IntegerVectorManipulator(bool deserializing) : base(deserializing) { }
+    protected IntegerVectorManipulator(IntegerVectorManipulator original, Cloner cloner) : base(original, cloner) { }
+    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 InstrumentedApply() {
+      Manipulate(RandomParameter.ActualValue, IntegerVectorParameter.ActualValue);
+      return base.InstrumentedApply();
+    }
+
+    protected abstract void Manipulate(IRandom random, IntegerVector integerVector);
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorOperator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorOperator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/IntegerVectorOperator.cs	(revision 15491)
@@ -0,0 +1,48 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("IntegerVectorOperator", "Base class for integer vectoro operators.")]
+  [StorableClass]
+  public abstract class IntegerVectorOperator : InstrumentedOperator, IIntegerVectorOperator {
+
+    [StorableConstructor]
+    protected IntegerVectorOperator(bool deserializing) : base(deserializing) { }
+    protected IntegerVectorOperator(IntegerVectorOperator original, Cloner cloner) : base(original, cloner) { }
+    public IntegerVectorOperator() : base() { }
+
+    public static int RoundFeasible(int min, int max, int step, double value) {
+      return Math.Max(min, Math.Min(max, (int)Math.Round((value - min) / (double)step) * step + min));
+    }
+    public static int FloorFeasible(int min, int max, int step, double value) {
+      return Math.Max(min, Math.Min(max, (int)Math.Floor((value - min) / (double)step) * step + min));
+    }
+    public static int CeilingFeasible(int min, int max, int step, double value) {
+      return Math.Max(min, Math.Min(max, (int)Math.Ceiling((value - min) / (double)step) * step + min));
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IBoundedIntegerVectorOperator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IBoundedIntegerVectorOperator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IBoundedIntegerVectorOperator.cs	(revision 15491)
@@ -0,0 +1,32 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  public interface IBoundedIntegerVectorOperator : IIntegerVectorOperator {
+    /// <summary>
+    /// The bounds parameter must contain at least one row and at least two columns. The first two columns specify min and max values, the last column specifies the step size, but is optional (1 is assumed if omitted).
+    /// </summary>
+    IValueLookupParameter<IntMatrix> BoundsParameter { get; }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCreator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCreator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCreator.cs	(revision 15491)
@@ -0,0 +1,34 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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 : ISolutionCreator, IBoundedIntegerVectorOperator {
+    IValueLookupParameter<IntValue> LengthParameter { get; }
+    ILookupParameter<IntegerVector> IntegerVectorParameter { get; }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorCrossover.cs	(revision 15491)
@@ -0,0 +1,33 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.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: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorManipulator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorManipulator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorManipulator.cs	(revision 15491)
@@ -0,0 +1,32 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.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: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorMultiNeighborhoodShakingOperator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorMultiNeighborhoodShakingOperator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorMultiNeighborhoodShakingOperator.cs	(revision 15491)
@@ -0,0 +1,28 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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 {
+  public interface IIntegerVectorMultiNeighborhoodShakingOperator : IIntegerVectorOperator {
+    ILookupParameter<IntegerVector> IntegerVectorParameter { get; }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorOperator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorOperator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorOperator.cs	(revision 15491)
@@ -0,0 +1,29 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCreator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCreator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCreator.cs	(revision 15491)
@@ -0,0 +1,32 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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 {
+  public interface IIntegerVectorStdDevStrategyParameterCreator : IIntegerVectorStdDevStrategyParameterOperator, IStrategyParameterCreator {
+    ILookupParameter<DoubleArray> StrategyParameterParameter { get; }
+    IValueLookupParameter<IntValue> LengthParameter { get; }
+    IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterCrossover.cs	(revision 15491)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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 {
+  public interface IIntegerVectorStdDevStrategyParameterCrossover : IIntegerVectorStdDevStrategyParameterOperator, IStrategyParameterCrossover {
+    ILookupParameter<DoubleArray> StrategyParameterParameter { get; }
+    ILookupParameter<ItemArray<DoubleArray>> ParentsParameter { get; }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterManipulator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterManipulator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterManipulator.cs	(revision 15491)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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 {
+  public interface IIntegerVectorStdDevStrategyParameterManipulator : IIntegerVectorStdDevStrategyParameterOperator, IStrategyParameterManipulator {
+    ILookupParameter<DoubleArray> StrategyParameterParameter { get; }
+    IValueLookupParameter<DoubleMatrix> BoundsParameter { get; }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterOperator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterOperator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Interfaces/IIntegerVectorStdDevStrategyParameterOperator.cs	(revision 15491)
@@ -0,0 +1,27 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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 {
+  public interface IIntegerVectorStdDevStrategyParameterOperator : IOperator {
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/RoundedNormalAllPositionsManipulator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/RoundedNormalAllPositionsManipulator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/RoundedNormalAllPositionsManipulator.cs	(revision 15491)
@@ -0,0 +1,93 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Manipulates each dimension in the integer vector with the mutation strength given 
+  /// in the sigma parameter vector and rounds the result to the next feasible value.
+  /// </summary>
+  [Item("RoundedNormalAllPositionsManipulator", "This manipulation operator adds a value sigma_i * N_i(0,1) to the current value in each position i given the values for sigma_i in the parameter. The result is rounded to the next feasible value. If there are less elements in Sigma than positions, then Sigma is cycled.")]
+  [StorableClass]
+  public class RoundedNormalAllPositionsManipulator : BoundedIntegerVectorManipulator {
+
+    public IValueParameter<DoubleArray> SigmaParameter {
+      get { return (IValueParameter<DoubleArray>)Parameters["Sigma"]; }
+    }
+
+    [StorableConstructor]
+    protected RoundedNormalAllPositionsManipulator(bool deserializing) : base(deserializing) { }
+    protected RoundedNormalAllPositionsManipulator(RoundedNormalAllPositionsManipulator original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="RoundedNormalAllPositionsManipulator"/> with one
+    /// parameter (<c>Sigma</c>).
+    /// </summary>
+    public RoundedNormalAllPositionsManipulator()
+      : base() {
+      Parameters.Add(new ValueParameter<DoubleArray>("Sigma", "The vector containing the standard deviations used for manipulating each dimension. If it is only of length one the same sigma will be used for every dimension.", new DoubleArray(new double[] { 1 })));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RoundedNormalAllPositionsManipulator(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs a normally distributed all position manipulation on the given 
+    /// <paramref name="vector"/> and rounds the result to the next feasible value.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when the sigma vector is null or of length 0.</exception>
+    /// <param name="sigma">The sigma vector determining the strength of the mutation.</param>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The integer vector to manipulate.</param>#
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    /// <returns>The manipulated integer vector.</returns>
+    public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds, DoubleArray sigma) {
+      if (sigma == null || sigma.Length == 0) throw new ArgumentException("RoundedNormalAllPositionsManipulator: Vector containing the standard deviations is not defined.", "sigma");
+      if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("RoundedNormalAllPositionsManipulator: Invalid bounds specified.", "bounds");
+      var N = new NormalDistributedRandom(random, 0.0, 1.0);
+      for (int i = 0; i < vector.Length; i++) {
+        int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
+        if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+
+        int value = (vector[i] + (int)Math.Round((N.NextDouble() * sigma[i % sigma.Length])) - min) / step;
+        max = FloorFeasible(min, max, step, max - 1);
+        vector[i] = RoundFeasible(min, max, step, value);
+      }
+    }
+
+    /// <summary>
+    /// Retrieves the bounds and forwards the call to the static Apply method.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="vector">The vector of integer values that is manipulated.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Apply(random, vector, bounds, SigmaParameter.Value);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/SelfAdaptiveRoundedNormalAllPositionsManipulator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/SelfAdaptiveRoundedNormalAllPositionsManipulator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/SelfAdaptiveRoundedNormalAllPositionsManipulator.cs	(revision 15491)
@@ -0,0 +1,104 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Manipulates each dimension in the integer vector with the mutation strength given 
+  /// in the strategy parameter vector.
+  /// </summary>
+  [Item("SelfAdaptiveRoundedNormalAllPositionsManipulator", "This manipulation operator adds a value sigma_i * N(0,1) to the current value in each position i. The resulting value is rounded to the next feasible value. The values for sigma_i are looked up dynamically. If there are less elements in the strategy vector than positions, then the strategy vector is cycled.")]
+  [StorableClass]
+  public class SelfAdaptiveRoundedNormalAllPositionsManipulator : BoundedIntegerVectorManipulator, ISelfAdaptiveManipulator {
+    public Type StrategyParameterType {
+      get { return typeof(IIntegerVectorStdDevStrategyParameterOperator); }
+    }
+    /// <summary>
+    /// Parameter for the strategy vector.
+    /// </summary>
+    public ILookupParameter<DoubleArray> StrategyParameterParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["StrategyParameter"]; }
+    }
+
+    IParameter ISelfAdaptiveManipulator.StrategyParameterParameter {
+      get { return StrategyParameterParameter; }
+    }
+
+    [StorableConstructor]
+    protected SelfAdaptiveRoundedNormalAllPositionsManipulator(bool deserializing) : base(deserializing) { }
+    protected SelfAdaptiveRoundedNormalAllPositionsManipulator(SelfAdaptiveRoundedNormalAllPositionsManipulator original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="SelfAdaptiveRoundedNormalAllPositionsManipulator"/> with one.
+    /// </summary>
+    public SelfAdaptiveRoundedNormalAllPositionsManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<DoubleArray>("StrategyParameter", "The vector containing the endogenous strategy parameters."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SelfAdaptiveRoundedNormalAllPositionsManipulator(this, cloner);
+    }
+
+    /// <summary>
+    /// Performs an adaptive normally distributed all position manipulation on the given 
+    /// <paramref name="vector"/> and rounding the results to the next feasible value.
+    /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when the strategy vector is not
+    /// as long as the vector to get manipulated.</exception>
+    /// <param name="strategyParameters">The strategy vector determining the strength of the mutation.</param>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The integer vector to manipulate.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds, DoubleArray strategyParameters) {
+      if (strategyParameters == null || strategyParameters.Length == 0) throw new ArgumentException("SelfAdaptiveRoundedNormalAllPositionsManipulator: Vector containing the standard deviations is not defined.", "sigma");
+      if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("SelfAdaptiveRoundedNormalAllPositionsManipulator: Invalid bounds specified.", "bounds");
+      var N = new NormalDistributedRandom(random, 0.0, 1.0);
+      if (strategyParameters != null) {
+        for (int i = 0; i < vector.Length; i++) {
+          int min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1], step = 1;
+          if (bounds.Columns > 2) step = bounds[i % bounds.Rows, 2];
+
+          int value = (vector[i] + (int)Math.Round((N.NextDouble() * strategyParameters[i % strategyParameters.Length])) - min) / step;
+          max = FloorFeasible(min, max, step, max - 1);
+          vector[i] = RoundFeasible(min, max, step, value);
+        }
+      }
+    }
+
+    /// <summary>
+    /// Checks that the strategy vector is not null and forwards the call to the static Apply method.
+    /// </summary>
+    /// <param name="random">The random number generator.</param>
+    /// <param name="vector">The vector of integer values that is manipulated.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Apply(random, vector, bounds, StrategyParameterParameter.ActualValue);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformOnePositionManipulator.cs	(revision 15491)
@@ -0,0 +1,111 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Uniformly distributed change of a single position of an integer vector.
+  /// </summary>
+  /// <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.
+  /// </remarks>
+  [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 : BoundedIntegerVectorManipulator {
+
+    [StorableConstructor]
+    protected UniformOnePositionManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformOnePositionManipulator(UniformOnePositionManipulator original, Cloner cloner) : base(original, cloner) { }
+    /// <summary>
+    /// Initializes a new instance of <see cref="UniformOnePositionManipulator"/> with two parameters
+    /// (<c>Minimum</c> and <c>Maximum</c>).
+    /// </summary>
+    public UniformOnePositionManipulator() : base() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformOnePositionManipulator(this, cloner);
+    }
+
+    // BackwardsCompatibility3.3
+    #region Backwards compatible code, remove with 3.4
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey("Bounds")) {
+        var min = ((IValueLookupParameter<IntValue>)Parameters["Minimum"]).Value as IntValue;
+        var max = ((IValueLookupParameter<IntValue>)Parameters["Maximum"]).Value as IntValue;
+        Parameters.Remove("Minimum");
+        Parameters.Remove("Maximum");
+        Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
+        if (min != null && max != null) {
+          BoundsParameter.Value = new IntMatrix(new int[,] { { min.Value, max.Value, 1 } });
+        }
+      }
+    }
+    #endregion
+
+    /// <summary>
+    /// Changes randomly a single position in the given integer <paramref name="vector"/>.
+    /// </summary>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The integer vector to manipulate.</param>
+    /// <param name="min">The minimum value of the sampling range for 
+    /// the vector element to change (inclusive).</param>
+    /// <param name="max">The maximum value of the sampling range for
+    /// the vector element to change (exclusive).</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Manipulate(random, vector, bounds, random.Next(vector.Length));
+    }
+
+    public static void Manipulate(IRandom random, IntegerVector vector, IntMatrix bounds, int index) {
+      if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("UniformOnePositionManipulator: Invalid bounds specified", "bounds");
+      int min = bounds[index % bounds.Rows, 0], max = bounds[index % bounds.Rows, 1], step = 1;
+      if (min == max) {
+        vector[index] = min;
+      } else {
+        if (bounds.Columns > 2) step = bounds[index % bounds.Rows, 2];
+        // max has to be rounded to the lower feasible value
+        // e.g. min...max / step = 0...100 / 5, max is exclusive so it would be 0..99
+        // but 99 is not a feasible value, so max needs to be adjusted => min = 0, max = 95
+        max = FloorFeasible(min, max, step, max - 1);
+        vector[index] = RoundFeasible(min, max, step, random.Next(min, max));
+      }
+    }
+
+    /// <summary>
+    /// Changes randomly a single position in the given integer <paramref name="vector"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The integer vector to manipulate.</param>
+    /// <param name="bounds">The bounds and step size for each dimension (will be cycled in case there are less rows than elements in the parent vectors).</param>
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      if (BoundsParameter.ActualValue == null) throw new InvalidOperationException("UniformOnePositionManipulator: Parameter " + BoundsParameter.ActualName + " could not be found.");
+      Apply(random, vector, bounds);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformSomePositionsManipulator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformSomePositionsManipulator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Manipulators/UniformSomePositionsManipulator.cs	(revision 15491)
@@ -0,0 +1,89 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Uniformly distributed change of several, but at least one, positions of an integer vector.
+  /// </summary>
+  /// <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.
+  /// </remarks>
+  [Item("UniformSomePositionsManipulator", "Uniformly distributed change of several, but at least one, positions 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 UniformSomePositionsManipulator : BoundedIntegerVectorManipulator {
+
+    public IValueLookupParameter<DoubleValue> ProbabilityParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["Probability"]; }
+    }
+
+    [StorableConstructor]
+    protected UniformSomePositionsManipulator(bool deserializing) : base(deserializing) { }
+    protected UniformSomePositionsManipulator(UniformSomePositionsManipulator original, Cloner cloner) : base(original, cloner) { }
+    public UniformSomePositionsManipulator()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("Probability", "The probability for each dimension to be manipulated.", new DoubleValue(0.5)));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new UniformSomePositionsManipulator(this, cloner);
+    }
+
+    /// <summary>
+    /// Changes randomly several, but at least one, positions in the given integer <paramref name="vector"/>, according to the given probabilities.
+    /// </summary>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The integer vector to manipulate.</param>
+    /// <param name="bounds"> Contains the minimum value (inclusive), maximum value (exclusive), and step size of the sampling range for 
+    /// the vector element to change.</param>
+    /// <param name="probability">The probability for each dimension to be manipulated..</param>
+    public static void Apply(IRandom random, IntegerVector vector, IntMatrix bounds, double probability) {
+      if (bounds == null || bounds.Rows == 0 || bounds.Columns < 2) throw new ArgumentException("UniformSomePositionsManipulator: Invalid bounds specified", "bounds");
+      bool atLeastOneManipulated = false;
+      for (int index = 0; index < vector.Length; index++) {
+        if (random.NextDouble() < probability) {
+          atLeastOneManipulated = true;
+          UniformOnePositionManipulator.Manipulate(random, vector, bounds, index);
+        }
+      }
+
+      if (!atLeastOneManipulated) {
+        UniformOnePositionManipulator.Manipulate(random, vector, bounds, random.Next(vector.Length));
+      }
+    }
+
+    /// <summary>
+    /// Changes randomly several, but at least one, positions in the given integer <paramref name="vector"/>.
+    /// </summary>
+    /// <remarks>Calls <see cref="Apply"/>.</remarks>
+    /// <param name="random">A random number generator.</param>
+    /// <param name="vector">The integer vector to manipulate.</param>
+    protected override void ManipulateBounded(IRandom random, IntegerVector vector, IntMatrix bounds) {
+      Apply(random, vector, bounds, ProbabilityParameter.ActualValue.Value);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Plugin.cs.frame
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Plugin.cs.frame	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Plugin.cs.frame	(revision 15491)
@@ -0,0 +1,42 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Encodings.IntegerVectorEncoding plugin.
+  /// </summary>
+  [Plugin("HeuristicLab.Encodings.IntegerVectorEncoding", "3.3.14.$WCREV$")]
+  [PluginFile("HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Operators", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")]
+  [PluginDependency("HeuristicLab.Random", "3.3")]
+  public class HeuristicLabEncodingsIntegerVectorEncodingPlugin : PluginBase {
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Properties/AssemblyInfo.cs.frame	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/Properties/AssemblyInfo.cs.frame	(revision 15491)
@@ -0,0 +1,56 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Encodings.IntegerVectorEncoding")]
+[assembly: AssemblyDescription("HeuristicLab integer vector encoding and related operators")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2016 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("B0F88DF0-497D-4038-BCC4-065B278C5D2A")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.14.$WCREV$")]
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/ShakingOperators/IntegerVectorShakingOperator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/ShakingOperators/IntegerVectorShakingOperator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/ShakingOperators/IntegerVectorShakingOperator.cs	(revision 15491)
@@ -0,0 +1,99 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// A shaking operator for VNS.
+  /// </summary>
+  [Item("IntegerVectorShakingOperator", "A shaking operator for VNS which uses available manipulation operators to perform the shaking.")]
+  [StorableClass]
+  public class IntegerVectorShakingOperator : ShakingOperator<IIntegerVectorManipulator>, IIntegerVectorMultiNeighborhoodShakingOperator, IStochasticOperator, IBoundedIntegerVectorOperator {
+
+    public ILookupParameter<IntegerVector> IntegerVectorParameter {
+      get { return (ILookupParameter<IntegerVector>)Parameters["IntegerVector"]; }
+    }
+
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+
+    public IValueLookupParameter<IntMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected IntegerVectorShakingOperator(bool deserializing) : base(deserializing) { }
+    protected IntegerVectorShakingOperator(IntegerVectorShakingOperator original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntegerVectorShakingOperator(this, cloner);
+    }
+    public IntegerVectorShakingOperator()
+      : base() {
+      Parameters.Add(new LookupParameter<IntegerVector>("IntegerVector", "The integer vector to shake."));
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator that will be used for stochastic shaking operators."));
+      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "A 2 column matrix specifying the lower and upper bound for each dimension. If there are less rows than dimension the bounds vector is cycled."));
+
+      foreach (IIntegerVectorManipulator shaker in ApplicationManager.Manager.GetInstances<IIntegerVectorManipulator>().OrderBy(x => x.Name))
+        if (!(shaker is ISelfAdaptiveManipulator)) Operators.Add(shaker);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      #region Backwards compatible code, remove with 3.4
+      if (!Parameters.ContainsKey("Bounds"))
+        Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "A 2 column matrix specifying the lower and upper bound for each dimension. If there are less rows than dimension the bounds vector is cycled."));
+      #endregion
+    }
+
+    #region Wiring of some parameters
+    protected override void Operators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IIntegerVectorManipulator>> e) {
+      base.Operators_ItemsAdded(sender, e);
+      ParameterizeOperators(e.Items);
+    }
+
+    protected override void Operators_ItemsReplaced(object sender, CollectionItemsChangedEventArgs<IndexedItem<IIntegerVectorManipulator>> e) {
+      base.Operators_ItemsReplaced(sender, e);
+      ParameterizeOperators(e.Items);
+    }
+
+    private void ParameterizeOperators(IEnumerable<IndexedItem<IIntegerVectorManipulator>> items) {
+      if (items.Any()) {
+        foreach (IStochasticOperator op in items.Select(x => x.Value).OfType<IStochasticOperator>())
+          op.RandomParameter.ActualName = RandomParameter.Name;
+        foreach (IIntegerVectorManipulator op in items.Select(x => x.Value).OfType<IIntegerVectorManipulator>())
+          op.IntegerVectorParameter.ActualName = IntegerVectorParameter.Name;
+      }
+    }
+    #endregion
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/SimilarityCalculators/EuclideanSimilarityCalculator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/SimilarityCalculators/EuclideanSimilarityCalculator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/SimilarityCalculators/EuclideanSimilarityCalculator.cs	(revision 15491)
@@ -0,0 +1,87 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2017 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("Euclidean Similarity Calculator for IntegerVector", "Calculates the solution similarity based on the Euclidean distance and a transformation into (0;1] between two integer vectors.")]
+  [StorableClass]
+  public sealed class EuclideanSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
+    protected override bool IsCommutative {
+      get { return true; }
+    }
+
+    [Storable]
+    private double scaling;
+    /// <summary>
+    /// The higher the scaling, the higher the similarity score for solutions of larger Euclidean distance.
+    /// A value of 1 means no scaling is applied. The function for squashing the numbers into (0;1] is
+    /// 1 / (1 + x / scaling) where x is the Euclidean distance.
+    /// </summary>
+    public double Scaling {
+      get { return scaling; }
+      set { scaling = value; }
+    }
+
+    [StorableConstructor]
+    private EuclideanSimilarityCalculator(bool deserializing) : base(deserializing) { }
+    private EuclideanSimilarityCalculator(EuclideanSimilarityCalculator original, Cloner cloner)
+      : base(original, cloner) {
+      scaling = original.scaling;
+    }
+    public EuclideanSimilarityCalculator() {
+      scaling = 1;
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EuclideanSimilarityCalculator(this, cloner);
+    }
+
+    public static double CalculateSimilarity(IntegerVector left, IntegerVector right, double scaling = 1.0) {
+      if (left == null || right == null)
+        throw new ArgumentException("Cannot calculate similarity because one or both of the provided solutions is null.");
+      if (left.Length != right.Length)
+        throw new ArgumentException("Cannot calculate similarity because the provided solutions have different lengths.");
+      if (left.Length == 0)
+        throw new ArgumentException("Cannot calculate similarity because solutions are of length 0.");
+      if (scaling <= 0)
+        throw new ArgumentException("Cannot choose a 0 or negative scaling value.");
+      if (ReferenceEquals(left, right)) return 1.0;
+
+      var distance = 0.0;
+      for (int i = 0; i < left.Length; i++)
+        distance += (left[i] - right[i]) * (left[i] - right[i]);
+      return 1.0 / (1.0 + Math.Sqrt(distance) / scaling);
+
+    }
+
+    public override double CalculateSolutionSimilarity(IScope leftSolution, IScope rightSolution) {
+      var left = leftSolution.Variables[SolutionVariableName].Value as IntegerVector;
+      var right = rightSolution.Variables[SolutionVariableName].Value as IntegerVector;
+
+      return CalculateSimilarity(left, right, Scaling);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/SimilarityCalculators/HammingSimilarityCalculator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/SimilarityCalculators/HammingSimilarityCalculator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/SimilarityCalculators/HammingSimilarityCalculator.cs	(revision 15491)
@@ -0,0 +1,68 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2017 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization.Operators;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  [Item("Hamming Similarity Calculator for IntegerVector", "Calculates the solution similarity based on the Hamming distance between two integer vectors.")]
+  [StorableClass]
+  public sealed class HammingSimilarityCalculator : SingleObjectiveSolutionSimilarityCalculator {
+    protected override bool IsCommutative {
+      get { return true; }
+    }
+
+    [StorableConstructor]
+    private HammingSimilarityCalculator(bool deserializing) : base(deserializing) { }
+    private HammingSimilarityCalculator(HammingSimilarityCalculator original, Cloner cloner) : base(original, cloner) { }
+    public HammingSimilarityCalculator() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new HammingSimilarityCalculator(this, cloner);
+    }
+
+    public static double CalculateSimilarity(IntegerVector left, IntegerVector right) {
+      if (left == null || right == null)
+        throw new ArgumentException("Cannot calculate similarity because one or both of the provided solutions is null.");
+      if (left.Length != right.Length)
+        throw new ArgumentException("Cannot calculate similarity because the provided solutions have different lengths.");
+      if (left.Length == 0)
+        throw new ArgumentException("Cannot calculate similarity because solutions are of length 0.");
+      if (ReferenceEquals(left, right)) return 1.0;
+
+      double similarity = 0.0;
+      for (int i = 0; i < left.Length; i++)
+        if (left[i] == right[i]) similarity++;
+      return similarity / left.Length;
+
+    }
+
+    public override double CalculateSolutionSimilarity(IScope leftSolution, IScope rightSolution) {
+      var left = leftSolution.Variables[SolutionVariableName].Value as IntegerVector;
+      var right = rightSolution.Variables[SolutionVariableName].Value as IntegerVector;
+
+      return CalculateSimilarity(left, right);
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorCreator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorCreator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorCreator.cs	(revision 15491)
@@ -0,0 +1,78 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Common;
+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 {
+  [Item("StdDevStrategyVectorCreator", "Creates the endogeneous strategy parameters.")]
+  [StorableClass]
+  public class StdDevStrategyVectorCreator : SingleSuccessorOperator, IStochasticOperator, IIntegerVectorStdDevStrategyParameterCreator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<DoubleArray> StrategyParameterParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["StrategyParameter"]; }
+    }
+    public IValueLookupParameter<IntValue> LengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
+    }
+    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected StdDevStrategyVectorCreator(bool deserializing) : base(deserializing) { }
+    protected StdDevStrategyVectorCreator(StdDevStrategyVectorCreator original, Cloner cloner) : base(original, cloner) { }
+    public StdDevStrategyVectorCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<DoubleArray>("StrategyParameter", "The crossed strategy parameter."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the vector."));
+      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "A 2 column matrix specifying the lower and upper bound for each dimension. If there are less rows than dimension the bounds vector is cycled.", new DoubleMatrix(new double[,] { { 0, 5 } })));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StdDevStrategyVectorCreator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      StrategyParameterParameter.ActualValue = Randomize(RandomParameter.ActualValue, LengthParameter.ActualValue.Value, BoundsParameter.ActualValue);
+      return base.Apply();
+    }
+
+    private DoubleArray Randomize(IRandom random, int length, DoubleMatrix bounds) {
+      var result = new DoubleArray(length);
+      for (int i = 0; i < length; i++) {
+        result[i] = random.NextDouble() * bounds[i % bounds.Rows, 1] - bounds[i % bounds.Rows, 0];
+      }
+      return result;
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorCrossover.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorCrossover.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorCrossover.cs	(revision 15491)
@@ -0,0 +1,79 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 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.Common;
+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 {
+  [Item("StdDevStrategyVectorCrossover", "Crosses the strategy vector by using intermediate recombination (average crossover).")]
+  [StorableClass]
+  public class StdDevStrategyVectorCrossover : SingleSuccessorOperator, IStochasticOperator, IIntegerVectorStdDevStrategyParameterCrossover {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<ItemArray<DoubleArray>> ParentsParameter {
+      get { return (ILookupParameter<ItemArray<DoubleArray>>)Parameters["ParentStrategyParameter"]; }
+    }
+    public ILookupParameter<DoubleArray> StrategyParameterParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["StrategyParameter"]; }
+    }
+
+    [StorableConstructor]
+    protected StdDevStrategyVectorCrossover(bool deserializing) : base(deserializing) { }
+    protected StdDevStrategyVectorCrossover(StdDevStrategyVectorCrossover original, Cloner cloner) : base(original, cloner) { }
+    public StdDevStrategyVectorCrossover()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new ScopeTreeLookupParameter<DoubleArray>("ParentStrategyParameter", "The strategy parameters to cross."));
+      Parameters.Add(new LookupParameter<DoubleArray>("StrategyParameter", "The crossed strategy parameter."));
+      ParentsParameter.ActualName = "StrategyParameter";
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StdDevStrategyVectorCrossover(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      StrategyParameterParameter.ActualValue = Average(RandomParameter.ActualValue, ParentsParameter.ActualValue);
+      return base.Apply();
+    }
+
+    private DoubleArray Average(IRandom random, ItemArray<DoubleArray> parents) {
+      int length = parents[0].Length;
+      var result = new DoubleArray(length);
+      for (int i = 0; i < length; i++) {
+        for (int p = 0; p < parents.Length; p++) {
+          result[i] += parents[p][i];
+        }
+        result[i] /= parents.Length;
+      }
+      return result;
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorManipulator.cs
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorManipulator.cs	(revision 15491)
+++ /branches/GeneralizedQAP/HeuristicLab.Encodings.IntegerVectorEncoding/3.3/StrategyParameters/StdDevStrategyVectorManipulator.cs	(revision 15491)
@@ -0,0 +1,113 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Encodings.IntegerVectorEncoding {
+  /// <summary>
+  /// Mutates the endogenous strategy parameters.
+  /// </summary>
+  [Item("StdDevStrategyVectorManipulator", "Mutates the endogenous strategy parameters.")]
+  [StorableClass]
+  public class StdDevStrategyVectorManipulator : SingleSuccessorOperator, IStochasticOperator, IIntegerVectorStdDevStrategyParameterManipulator {
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public ILookupParameter<IRandom> RandomParameter {
+      get { return (ILookupParameter<IRandom>)Parameters["Random"]; }
+    }
+    public ILookupParameter<DoubleArray> StrategyParameterParameter {
+      get { return (ILookupParameter<DoubleArray>)Parameters["StrategyParameter"]; }
+    }
+    public IValueLookupParameter<DoubleValue> GeneralLearningRateParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["GeneralLearningRate"]; }
+    }
+    public IValueLookupParameter<DoubleValue> LearningRateParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters["LearningRate"]; }
+    }
+    public IValueLookupParameter<DoubleMatrix> BoundsParameter {
+      get { return (IValueLookupParameter<DoubleMatrix>)Parameters["Bounds"]; }
+    }
+
+    [StorableConstructor]
+    protected StdDevStrategyVectorManipulator(bool deserializing) : base(deserializing) { }
+    protected StdDevStrategyVectorManipulator(StdDevStrategyVectorManipulator original, Cloner cloner) : base(original, cloner) { }
+    public StdDevStrategyVectorManipulator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRandom>("Random", "The random number generator to use."));
+      Parameters.Add(new LookupParameter<DoubleArray>("StrategyParameter", "The strategy parameter to manipulate."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("GeneralLearningRate", "The general learning rate (tau0)."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>("LearningRate", "The learning rate (tau)."));
+      Parameters.Add(new ValueLookupParameter<DoubleMatrix>("Bounds", "A 2 column matrix specifying the lower and upper bound for each dimension. If there are less rows than dimension the bounds vector is cycled.", new DoubleMatrix(new double[,] { { 0, 5 } })));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StdDevStrategyVectorManipulator(this, cloner);
+    }
+
+    /// <summary>
+    /// Mutates the endogenous strategy parameters.
+    /// </summary>
+    /// <param name="random">The random number generator to use.</param>
+    /// <param name="vector">The strategy vector to manipulate.</param>
+    /// <param name="generalLearningRate">The general learning rate dampens the mutation over all dimensions.</param>
+    /// <param name="learningRate">The learning rate dampens the mutation in each dimension.</param>
+    /// <param name="bounds">The minimal and maximal value for each component, bounds are cycled if the length of bounds is smaller than the length of vector</param>
+    public static void Apply(IRandom random, DoubleArray vector, double generalLearningRate, double learningRate, DoubleMatrix bounds) {
+      NormalDistributedRandom N = new NormalDistributedRandom(random, 0.0, 1.0);
+      double generalMultiplier = Math.Exp(generalLearningRate * N.NextDouble());
+      for (int i = 0; i < vector.Length; i++) {
+        double change = vector[i] * generalMultiplier * Math.Exp(learningRate * N.NextDouble());
+        if (bounds != null) {
+          double min = bounds[i % bounds.Rows, 0], max = bounds[i % bounds.Rows, 1];
+          if (min == max) vector[i] = min;
+          else {
+            if (change < min || change > max) change = Math.Max(min, Math.Min(max, change));
+            vector[i] = change;
+          }
+        }
+      }
+    }
+    /// <summary>
+    /// Mutates the endogenous strategy parameters.
+    /// </summary>
+    /// <remarks>Calls <see cref="OperatorBase.Apply"/> of base class <see cref="OperatorBase"/>.</remarks>
+    /// <inheritdoc select="returns"/>
+    public override IOperation Apply() {
+      var strategyParams = StrategyParameterParameter.ActualValue;
+      if (strategyParams != null) { // only apply if there is a strategy vector
+        IRandom random = RandomParameter.ActualValue;
+        double tau0 = GeneralLearningRateParameter.ActualValue.Value;
+        double tau = LearningRateParameter.ActualValue.Value;
+        Apply(random, strategyParams, tau0, tau, BoundsParameter.ActualValue);
+      }
+      return base.Apply();
+    }
+  }
+}
Index: /branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common-3.3.csproj
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common-3.3.csproj	(revision 15490)
+++ /branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Common-3.3.csproj	(revision 15491)
@@ -61,8 +61,4 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3">
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <Reference Include="HeuristicLab.Operators-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
@@ -99,4 +95,9 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.IntegerVectorEncoding\3.3\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj">
+      <Project>{ddfb14dd-2a85-493c-a52d-e69729bbaeb0}</Project>
+      <Name>HeuristicLab.Encodings.IntegerVectorEncoding-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
       <Project>{14ab8d24-25bc-400c-a846-4627aa945192}</Project>
Index: /branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views-3.3.csproj
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views-3.3.csproj	(revision 15490)
+++ /branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment.Views-3.3.csproj	(revision 15491)
@@ -67,8 +67,4 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3">
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.IntegerVectorEncoding-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
     <Reference Include="HeuristicLab.MainForm-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.MainForm-3.3.dll</HintPath>
@@ -130,4 +126,9 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.IntegerVectorEncoding\3.3\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj">
+      <Project>{ddfb14dd-2a85-493c-a52d-e69729bbaeb0}</Project>
+      <Name>HeuristicLab.Encodings.IntegerVectorEncoding-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
       <Project>{14ab8d24-25bc-400c-a846-4627aa945192}</Project>
Index: /branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment-3.3.csproj
===================================================================
--- /branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment-3.3.csproj	(revision 15490)
+++ /branches/GeneralizedQAP/HeuristicLab.Problems.GeneralizedQuadraticAssignment/3.3/HeuristicLab.Problems.GeneralizedQuadraticAssignment-3.3.csproj	(revision 15491)
@@ -63,8 +63,4 @@
     <Reference Include="HeuristicLab.Data-3.3">
       <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.Encodings.IntegerVectorEncoding-3.3">
-      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.dll</HintPath>
       <Private>False</Private>
     </Reference>
@@ -180,4 +176,9 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.IntegerVectorEncoding\3.3\HeuristicLab.Encodings.IntegerVectorEncoding-3.3.csproj">
+      <Project>{ddfb14dd-2a85-493c-a52d-e69729bbaeb0}</Project>
+      <Name>HeuristicLab.Encodings.IntegerVectorEncoding-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
       <Project>{14ab8d24-25bc-400c-a846-4627aa945192}</Project>
