Index: branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPInversionMoveEvaluator.cs
===================================================================
--- branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPInversionMoveEvaluator.cs	(revision 5927)
+++ branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPInversionMoveEvaluator.cs	(revision 5930)
@@ -54,13 +54,17 @@
       int min = Math.Min(move.Index1, move.Index2);
       int max = Math.Max(move.Index1, move.Index2);
+
       for (int i = min; i <= max; i++) {
+        int locI = assignment[i];
+        int newlocI = assignment[max - i + min];
+
         for (int j = 0; j < assignment.Length; j++) {
-          moveQuality -= weights[i, j] * distances[assignment[i], assignment[j]];
-          if (j < min || j > max) {
-            moveQuality -= weights[j, i] * distances[assignment[j], assignment[i]];
-            moveQuality += weights[i, j] * distances[assignment[max - i + min], assignment[j]];
-            moveQuality += weights[j, i] * distances[assignment[j], assignment[max - i + min]];
+          int locJ = assignment[j];
+          if (j >= min && j <= max) {
+            int newlocJ = assignment[max - j + min];
+            moveQuality += weights[i, j] * (distances[newlocI, newlocJ] - distances[locI, locJ]);
           } else {
-            moveQuality += weights[i, j] * distances[assignment[max - i + min], assignment[max - j + min]];
+            moveQuality += weights[i, j] * (distances[newlocI, locJ] - distances[locI, locJ]);
+            moveQuality += weights[j, i] * (distances[locJ, newlocI] - distances[locJ, locI]);
           }
         }
Index: branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPSwap2MoveEvaluator.cs
===================================================================
--- branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPSwap2MoveEvaluator.cs	(revision 5930)
+++ branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPSwap2MoveEvaluator.cs	(revision 5930)
@@ -0,0 +1,88 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 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.Encodings.PermutationEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.QuadraticAssignment {
+  [Item("QAPSwap2MoveEvaluator", "Evaluated a swap-2 move on a QAP solution.")]
+  [StorableClass]
+  public class QAPSwap2MoveEvaluator : QAPMoveEvaluator, IPermutationSwap2MoveOperator {
+    public ILookupParameter<Swap2Move> Swap2MoveParameter {
+      get { return (ILookupParameter<Swap2Move>)Parameters["Swap2Move"]; }
+    }
+
+    [StorableConstructor]
+    protected QAPSwap2MoveEvaluator(bool deserializing) : base(deserializing) { }
+    protected QAPSwap2MoveEvaluator(QAPSwap2MoveEvaluator original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public QAPSwap2MoveEvaluator() {
+      Parameters.Add(new LookupParameter<Swap2Move>("Swap2Move", "The move to evaluate."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new QAPSwap2MoveEvaluator(this, cloner);
+    }
+
+    public static double Apply(Permutation assignment, Swap2Move move, DoubleMatrix weights, DoubleMatrix distances) {
+      if (move.Index1 == move.Index2) return 0;
+      double moveQuality = 0;
+      int fac1 = move.Index1, fac2 = move.Index2;
+      int loc1 = assignment[fac1], loc2 = assignment[fac2];
+
+      for (int j = 0; j < assignment.Length; j++) {
+        if (j == fac1) {
+          moveQuality += weights[fac1, fac1] * (distances[loc2, loc2] - distances[loc1, loc1]);
+          moveQuality += weights[fac1, fac2] * (distances[loc2, loc1] - distances[loc1, loc2]);
+        } else if (j == fac2) {
+          moveQuality += weights[fac2, fac2] * (distances[loc1, loc1] - distances[loc2, loc2]);
+          moveQuality += weights[fac2, fac1] * (distances[loc1, loc2] - distances[loc2, loc1]);
+        } else {
+          int locJ = assignment[j];
+          moveQuality += weights[fac1, j] * (distances[loc2, locJ] - distances[loc1, locJ]);
+          moveQuality += weights[j, fac1] * (distances[locJ, loc2] - distances[locJ, loc1]);
+          moveQuality += weights[fac2, j] * (distances[loc1, locJ] - distances[loc2, locJ]);
+          moveQuality += weights[j, fac2] * (distances[locJ, loc1] - distances[locJ, loc2]);
+        }
+      }
+      return moveQuality;
+    }
+
+    public override IOperation Apply() {
+      Swap2Move move = Swap2MoveParameter.ActualValue;
+      if (move == null) throw new InvalidOperationException("Swap-2 move is not found.");
+      Permutation assignment = PermutationParameter.ActualValue;
+      DoubleMatrix distances = DistancesParameter.ActualValue;
+      DoubleMatrix weights = WeightsParameter.ActualValue;
+
+      double moveQuality = QualityParameter.ActualValue.Value;
+      moveQuality += Apply(assignment, move, weights, distances);
+      MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);
+      return base.Apply();
+    }
+  }
+}
Index: branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPSwapMoveEvaluator.cs
===================================================================
--- branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/Evaluators/QAPSwapMoveEvaluator.cs	(revision 5927)
+++ 	(revision )
@@ -1,84 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 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.Encodings.PermutationEncoding;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.QuadraticAssignment {
-  [Item("QAPSwap2MoveEvaluator", "Evaluated a swap-2 move on a QAP solution.")]
-  [StorableClass]
-  public class QAPSwap2MoveEvaluator : QAPMoveEvaluator, IPermutationSwap2MoveOperator {
-    public ILookupParameter<Swap2Move> Swap2MoveParameter {
-      get { return (ILookupParameter<Swap2Move>)Parameters["Swap2Move"]; }
-    }
-
-    [StorableConstructor]
-    protected QAPSwap2MoveEvaluator(bool deserializing) : base(deserializing) { }
-    protected QAPSwap2MoveEvaluator(QAPSwap2MoveEvaluator original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public QAPSwap2MoveEvaluator() {
-      Parameters.Add(new LookupParameter<Swap2Move>("Swap2Move", "The move to evaluate."));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new QAPSwap2MoveEvaluator(this, cloner);
-    }
-
-    public static double Apply(Permutation assignment, Swap2Move move, DoubleMatrix weights, DoubleMatrix distances) {
-      if (move.Index1 == move.Index2) return 0;
-      double moveQuality = 0;
-      for (int j = 0; j < assignment.Length; j++) {
-        moveQuality -= weights[move.Index1, j] * distances[assignment[move.Index1], assignment[j]];
-        moveQuality -= weights[j, move.Index1] * distances[assignment[j], assignment[move.Index1]];
-        moveQuality -= weights[move.Index2, j] * distances[assignment[move.Index2], assignment[j]];
-        moveQuality -= weights[j, move.Index2] * distances[assignment[j], assignment[move.Index2]];
-
-        int facility1 = j == move.Index1 ? assignment[move.Index2] : assignment[j];
-        int facility2 = j == move.Index2 ? assignment[move.Index1] : assignment[j];
-
-        moveQuality += weights[move.Index1, j] * distances[assignment[move.Index2], facility2];
-        moveQuality += weights[j, move.Index1] * distances[facility2, assignment[move.Index2]];
-        moveQuality += weights[move.Index2, j] * distances[assignment[move.Index1], facility1];
-        moveQuality += weights[j, move.Index2] * distances[facility1, assignment[move.Index1]];
-      }
-      return moveQuality;
-    }
-
-    public override IOperation Apply() {
-      Swap2Move move = Swap2MoveParameter.ActualValue;
-      if (move == null) throw new InvalidOperationException("Swap-2 move is not found.");
-      Permutation assignment = PermutationParameter.ActualValue;
-      DoubleMatrix distances = DistancesParameter.ActualValue;
-      DoubleMatrix weights = WeightsParameter.ActualValue;
-
-      double moveQuality = QualityParameter.ActualValue.Value;
-      moveQuality += Apply(assignment, move, weights, distances);
-      MoveQualityParameter.ActualValue = new DoubleValue(moveQuality);
-      return base.Apply();
-    }
-  }
-}
Index: branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/HeuristicLab.Problems.QuadraticAssignment-3.3.csproj
===================================================================
--- branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/HeuristicLab.Problems.QuadraticAssignment-3.3.csproj	(revision 5927)
+++ branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/HeuristicLab.Problems.QuadraticAssignment-3.3.csproj	(revision 5930)
@@ -139,5 +139,5 @@
   <ItemGroup>
     <Compile Include="Analyzers\BestQAPSolutionAnalyzer.cs" />
-    <Compile Include="Evaluators\QAPSwapMoveEvaluator.cs" />
+    <Compile Include="Evaluators\QAPSwap2MoveEvaluator.cs" />
     <Compile Include="Evaluators\QAPEvaluator.cs" />
     <Compile Include="Evaluators\QAPInversionMoveEvaluator.cs" />
Index: branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/Tests/QAPMoveEvaluatorTest.cs
===================================================================
--- branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/Tests/QAPMoveEvaluatorTest.cs	(revision 5927)
+++ branches/QAP/HeuristicLab.Problems.QuadraticAssignment/3.3/Tests/QAPMoveEvaluatorTest.cs	(revision 5930)
@@ -34,4 +34,8 @@
   [TestClass()]
   public class QAPSwapMoveEvaluatorTest {
+    private const int ProblemSize = 10;
+    private static DoubleMatrix symmetricDistances, symmetricWeights, asymmetricDistances, asymmetricWeights, nonZeroDiagonalWeights, nonZeroDiagonalDistances;
+    private static Permutation assignment;
+    private static MersenneTwister random;
 
     private TestContext testContextInstance;
@@ -45,58 +49,68 @@
     }
 
-    #region Additional test attributes
-    // 
-    //You can use the following additional attributes as you write your tests:
-    //
-    //Use ClassInitialize to run code before running the first test in the class
-    //[ClassInitialize()]
-    //public static void MyClassInitialize(TestContext testContext)
-    //{
-    //}
-    //
-    //Use ClassCleanup to run code after all tests in a class have run
-    //[ClassCleanup()]
-    //public static void MyClassCleanup()
-    //{
-    //}
-    //
-    //Use TestInitialize to run code before running each test
-    //[TestInitialize()]
-    //public void MyTestInitialize()
-    //{
-    //}
-    //
-    //Use TestCleanup to run code after each test has run
-    //[TestCleanup()]
-    //public void MyTestCleanup()
-    //{
-    //}
-    //
-    #endregion
+    [ClassInitialize]
+    public static void MyClassInitialize(TestContext testContext) {
+      random = new MersenneTwister();
+      symmetricDistances = new DoubleMatrix(ProblemSize, ProblemSize);
+      symmetricWeights = new DoubleMatrix(ProblemSize, ProblemSize);
+      asymmetricDistances = new DoubleMatrix(ProblemSize, ProblemSize);
+      asymmetricWeights = new DoubleMatrix(ProblemSize, ProblemSize);
+      nonZeroDiagonalDistances = new DoubleMatrix(ProblemSize, ProblemSize);
+      nonZeroDiagonalWeights = new DoubleMatrix(ProblemSize, ProblemSize);
+      for (int i = 0; i < ProblemSize - 1; i++) {
+        for (int j = i + 1; j < ProblemSize; j++) {
+          symmetricDistances[i, j] = random.Next(ProblemSize);
+          symmetricDistances[j, i] = symmetricDistances[i, j];
+          symmetricWeights[i, j] = random.Next(ProblemSize);
+          symmetricWeights[j, i] = symmetricWeights[i, j];
+          asymmetricDistances[i, j] = random.Next(ProblemSize);
+          asymmetricDistances[j, i] = random.Next(ProblemSize);
+          asymmetricWeights[i, j] = random.Next(ProblemSize);
+          asymmetricWeights[j, i] = random.Next(ProblemSize);
+          nonZeroDiagonalDistances[i, j] = random.Next(ProblemSize);
+          nonZeroDiagonalDistances[j, i] = random.Next(ProblemSize);
+          nonZeroDiagonalWeights[i, j] = random.Next(ProblemSize);
+          nonZeroDiagonalWeights[j, i] = random.Next(ProblemSize);
+        }
+        nonZeroDiagonalDistances[i, i] = random.Next(ProblemSize);
+        nonZeroDiagonalWeights[i, i] = random.Next(ProblemSize);
+      }
+      int index = random.Next(ProblemSize);
+      if (nonZeroDiagonalDistances[index, index] == 0)
+        nonZeroDiagonalDistances[index, index] = random.Next(1, ProblemSize);
+      index = random.Next(ProblemSize);
+      if (nonZeroDiagonalWeights[index, index] == 0)
+        nonZeroDiagonalWeights[index, index] = random.Next(1, ProblemSize);
+      assignment = new Permutation(PermutationTypes.Absolute, ProblemSize, random);
+    }
 
     [TestMethod]
-    public void SwapMoveEvaluatorTest() {
-      DoubleMatrix distances = new DoubleMatrix(
-        new double[,] { { 0, 1, 2, 3 },
-                        { 1, 0, 3, 4 },
-                        { 2, 3, 0, 5 },
-                        { 3, 4, 5, 0 } });
-      DoubleMatrix weights = new DoubleMatrix(
-        new double[,] { { 0, 1, 0, 0 },
-                        { 1, 0, 2, 0 },
-                        { 0, 2, 0, 1 },
-                        { 0, 0, 1, 0 } });
-      Permutation assignment = new Permutation(PermutationTypes.Absolute,
-        new int[] { 0, 1, 2, 3 });
-      MersenneTwister random = new MersenneTwister();
+    public void Swap2MoveEvaluatorTest() {
       for (int i = 0; i < 500; i++) {
-        int index1 = random.Next(4);
-        int index2 = random.Next(4);
-        double before = QAPEvaluator.Apply(assignment, weights, distances);
+        int index1 = random.Next(ProblemSize);
+        int index2 = random.Next(ProblemSize);
+
+        // SYMMETRIC MATRICES
+        double before = QAPEvaluator.Apply(assignment, symmetricWeights, symmetricDistances);
         Swap2Manipulator.Apply(assignment, index1, index2);
-        double after = QAPEvaluator.Apply(assignment, weights, distances);
-        // evaluate swap back
-        double move = QAPSwap2MoveEvaluator.Apply(assignment, new Swap2Move(index1, index2, assignment), weights, distances);
-        Assert.IsTrue(move.IsAlmost(before - after));
+        double after = QAPEvaluator.Apply(assignment, symmetricWeights, symmetricDistances);
+        double move = QAPSwap2MoveEvaluator.Apply(assignment, new Swap2Move(index1, index2, assignment), symmetricWeights, symmetricDistances);
+        Assert.IsTrue(move.IsAlmost(before - after), "Failed on symmetric matrices");
+
+        // ASYMMETRIC MATRICES
+        before = QAPEvaluator.Apply(assignment, asymmetricWeights, asymmetricDistances);
+        Permutation clone = (Permutation)assignment.Clone();
+        Swap2Manipulator.Apply(assignment, index1, index2);
+        after = QAPEvaluator.Apply(assignment, asymmetricWeights, asymmetricDistances);
+        move = QAPSwap2MoveEvaluator.Apply(clone, new Swap2Move(index1, index2), asymmetricWeights, asymmetricDistances);
+        Assert.IsTrue(move.IsAlmost(after - before), "Failed on asymmetric matrices");
+
+        // NON-ZERO DIAGONAL ASSYMETRIC MATRICES
+        before = QAPEvaluator.Apply(assignment, nonZeroDiagonalWeights, nonZeroDiagonalDistances);
+        clone = (Permutation)assignment.Clone();
+        Swap2Manipulator.Apply(assignment, index1, index2);
+        after = QAPEvaluator.Apply(assignment, nonZeroDiagonalWeights, nonZeroDiagonalDistances);
+        move = QAPSwap2MoveEvaluator.Apply(clone, new Swap2Move(index1, index2), nonZeroDiagonalWeights, nonZeroDiagonalDistances);
+        Assert.IsTrue(move.IsAlmost(after - before), "Failed on non-zero diagonal matrices");
       }
     }
@@ -104,27 +118,31 @@
     [TestMethod]
     public void InversionMoveEvaluatorTest() {
-      DoubleMatrix distances = new DoubleMatrix(
-        new double[,] { { 0, 1, 2, 3 },
-                        { 1, 0, 3, 4 },
-                        { 2, 3, 0, 5 },
-                        { 3, 4, 5, 0 } });
-      DoubleMatrix weights = new DoubleMatrix(
-        new double[,] { { 0, 1, 0, 0 },
-                        { 1, 0, 2, 0 },
-                        { 0, 2, 0, 1 },
-                        { 0, 0, 1, 0 } });
-      Permutation assignment = new Permutation(PermutationTypes.Absolute,
-        new int[] { 0, 1, 2, 3 });
-      MersenneTwister random = new MersenneTwister();
       for (int i = 0; i < 500; i++) {
-        int index1 = random.Next(4);
-        int index2 = random.Next(4);
-        double before = QAPEvaluator.Apply(assignment, weights, distances);
-        // invert
+        int index1 = random.Next(ProblemSize);
+        int index2 = random.Next(ProblemSize);
+        if (index1 > index2) { int h = index1; index1 = index2; index2 = h; }
+
+        // SYMMETRIC MATRICES
+        double before = QAPEvaluator.Apply(assignment, symmetricWeights, symmetricDistances);
         InversionManipulator.Apply(assignment, Math.Min(index1, index2), Math.Max(index1, index2));
-        double after = QAPEvaluator.Apply(assignment, weights, distances);
-        // evaluate invert back
-        double move = QAPInversionMoveEvaluator.Apply(assignment, new InversionMove(index1, index2, assignment), weights, distances);
-        Assert.IsTrue(move.IsAlmost(before - after));
+        double after = QAPEvaluator.Apply(assignment, symmetricWeights, symmetricDistances);
+        double move = QAPInversionMoveEvaluator.Apply(assignment, new InversionMove(index1, index2, assignment), symmetricWeights, symmetricDistances);
+        Assert.IsTrue(move.IsAlmost(before - after), "Failed on symmetric matrices");
+
+        // ASYMMETRIC MATRICES
+        before = QAPEvaluator.Apply(assignment, asymmetricWeights, asymmetricDistances);
+        Permutation clone = (Permutation)assignment.Clone();
+        InversionManipulator.Apply(assignment, index1, index2);
+        after = QAPEvaluator.Apply(assignment, asymmetricWeights, asymmetricDistances);
+        move = QAPInversionMoveEvaluator.Apply(clone, new InversionMove(index1, index2), asymmetricWeights, asymmetricDistances);
+        Assert.IsTrue(move.IsAlmost(after - before), "Failed on asymmetric matrices");
+
+        // NON-ZERO DIAGONAL ASYMMETRIC MATRICES
+        before = QAPEvaluator.Apply(assignment, nonZeroDiagonalWeights, nonZeroDiagonalDistances);
+        clone = (Permutation)assignment.Clone();
+        InversionManipulator.Apply(assignment, index1, index2);
+        after = QAPEvaluator.Apply(assignment, nonZeroDiagonalWeights, nonZeroDiagonalDistances);
+        move = QAPInversionMoveEvaluator.Apply(clone, new InversionMove(index1, index2), nonZeroDiagonalWeights, nonZeroDiagonalDistances);
+        Assert.IsTrue(move.IsAlmost(after - before), "Failed on non-zero diagonal matrices");
       }
     }
@@ -132,17 +150,4 @@
     [TestMethod]
     public void TranslocationMoveEvaluatorTest() {
-      DoubleMatrix distances = new DoubleMatrix(
-        new double[,] { { 0, 1, 2, 3 },
-                        { 1, 0, 3, 4 },
-                        { 2, 3, 0, 5 },
-                        { 3, 4, 5, 0 } });
-      DoubleMatrix weights = new DoubleMatrix(
-        new double[,] { { 0, 1, 0, 0 },
-                        { 1, 0, 2, 0 },
-                        { 0, 2, 0, 1 },
-                        { 0, 0, 1, 0 } });
-      Permutation assignment = new Permutation(PermutationTypes.Absolute,
-        new int[] { 0, 1, 2, 3 });
-      MersenneTwister random = new MersenneTwister();
       for (int i = 0; i < 500; i++) {
         int index1 = random.Next(assignment.Length - 1);
@@ -154,12 +159,28 @@
         else
           insertPoint = 0;
-        double before = QAPEvaluator.Apply(assignment, weights, distances);
-        // translocate
+
+        // SYMMETRIC MATRICES
+        double before = QAPEvaluator.Apply(assignment, symmetricWeights, symmetricDistances);
         Permutation clone = new Cloner().Clone(assignment);
         TranslocationManipulator.Apply(assignment, index1, index2, insertPoint);
-        double after = QAPEvaluator.Apply(assignment, weights, distances);
-        // evaluate translocate move
-        double move = QAPTranslocationMoveEvaluator.Apply(clone, new TranslocationMove(index1, index2, insertPoint, assignment), weights, distances);
-        Assert.IsTrue(move.IsAlmost(after - before));
+        double after = QAPEvaluator.Apply(assignment, symmetricWeights, symmetricDistances);
+        double move = QAPTranslocationMoveEvaluator.Apply(clone, new TranslocationMove(index1, index2, insertPoint, assignment), symmetricWeights, symmetricDistances);
+        Assert.IsTrue(move.IsAlmost(after - before), "Failed on symmetric matrices");
+
+        // ASYMMETRIC MATRICES
+        before = QAPEvaluator.Apply(assignment, asymmetricWeights, asymmetricDistances);
+        clone = new Cloner().Clone(assignment);
+        TranslocationManipulator.Apply(assignment, index1, index2, insertPoint);
+        after = QAPEvaluator.Apply(assignment, asymmetricWeights, asymmetricDistances);
+        move = QAPTranslocationMoveEvaluator.Apply(clone, new TranslocationMove(index1, index2, insertPoint, assignment), asymmetricWeights, asymmetricDistances);
+        Assert.IsTrue(move.IsAlmost(after - before), "Failed on asymmetric matrices");
+
+        // NON-ZERO DIAGONAL ASYMMETRIC MATRICES
+        before = QAPEvaluator.Apply(assignment, nonZeroDiagonalWeights, nonZeroDiagonalDistances);
+        clone = new Cloner().Clone(assignment);
+        TranslocationManipulator.Apply(assignment, index1, index2, insertPoint);
+        after = QAPEvaluator.Apply(assignment, nonZeroDiagonalWeights, nonZeroDiagonalDistances);
+        move = QAPTranslocationMoveEvaluator.Apply(clone, new TranslocationMove(index1, index2, insertPoint, assignment), nonZeroDiagonalWeights, nonZeroDiagonalDistances);
+        Assert.IsTrue(move.IsAlmost(after - before), "Failed on non-zero diagonal matrices");
       }
     }
