Index: branches/PTSP/HeuristicLab.Problems.PTSP/3.3/AnalyticalPTSP.cs
===================================================================
--- branches/PTSP/HeuristicLab.Problems.PTSP/3.3/AnalyticalPTSP.cs	(revision 12225)
+++ branches/PTSP/HeuristicLab.Problems.PTSP/3.3/AnalyticalPTSP.cs	(revision 12228)
@@ -66,7 +66,7 @@
       for (int i = 0; i < p.Length - 1; i++) {
         for (int j = i + 1; j < p.Length - 1; j++) {
-          double sum1 = DistanceMatrix[p[i], p[j]] * ProbabilityMatrix[p[i]].Value * ProbabilityMatrix[p[j]].Value;
+          double sum1 = DistanceMatrix[p[i], p[j]] * ProbabilityMatrix[p[i]] * ProbabilityMatrix[p[j]];
           for (int k = i + 1; k < j; k++) {
-            sum1 = sum1 * (1 - ProbabilityMatrix[p[k]].Value);
+            sum1 = sum1 * (1 - ProbabilityMatrix[p[k]]);
           }
           A[i, j - 1] = sum1;
@@ -77,10 +77,10 @@
       for (int j = 0; j < p.Length - 1; j++) {
         for (int i = 0; i < j; i++) {
-          double sum2 = DistanceMatrix[p[j], p[i]] * ProbabilityMatrix[p[i]].Value * ProbabilityMatrix[p[j]].Value;
+          double sum2 = DistanceMatrix[p[j], p[i]] * ProbabilityMatrix[p[i]] * ProbabilityMatrix[p[j]];
           for (int k = j + 1; k < p.Length - 1; k++) {
-            sum2 = sum2 * (1 - ProbabilityMatrix[p[k]].Value);
+            sum2 = sum2 * (1 - ProbabilityMatrix[p[k]]);
           }
           for (int k = 1; k < i; k++) {
-            sum2 = sum2 * (1 - ProbabilityMatrix[p[k]].Value);
+            sum2 = sum2 * (1 - ProbabilityMatrix[p[k]]);
           }
           B[i, j] = sum2;
Index: branches/PTSP/HeuristicLab.Problems.PTSP/3.3/EstimatedPTSP.cs
===================================================================
--- branches/PTSP/HeuristicLab.Problems.PTSP/3.3/EstimatedPTSP.cs	(revision 12225)
+++ branches/PTSP/HeuristicLab.Problems.PTSP/3.3/EstimatedPTSP.cs	(revision 12228)
@@ -56,4 +56,6 @@
       Operators.Add(new PTSPEstimatedInversionMovePathEvaluator());
       Operators.Add(new PTSPEstimatedInsertionEvaluator());
+      Operators.Add(new PTSPExhaustiveInversionLocalImprovement());
+      Operators.Add(new PTSPExhaustiveInsertionLocalImprovement());
       Encoding.ConfigureOperators(Operators.OfType<IOperator>());
     }
@@ -68,5 +70,5 @@
         realizations.Add(new ItemList<IntValue>());
         for (int j = 0; j < data.Dimension; j++) {
-          if (ProbabilityMatrix[j].Value > r.NextDouble()) {
+          if (ProbabilityMatrix[j] > r.NextDouble()) {
             realizations.ElementAt(i).Add(new IntValue(1));
           } else {
@@ -76,5 +78,9 @@
         
       }
+
       foreach (var op in Operators.OfType<PTSPPathMoveEvaluator>()) {
+        op.RealizationsParameter.Value = realizations;
+      }
+      foreach (var op in Operators.OfType<PTSPExhaustiveInversionLocalImprovement>()) {
         op.RealizationsParameter.Value = realizations;
       }
Index: branches/PTSP/HeuristicLab.Problems.PTSP/3.3/HeuristicLab.Problems.PTSP-3.3.csproj
===================================================================
--- branches/PTSP/HeuristicLab.Problems.PTSP/3.3/HeuristicLab.Problems.PTSP-3.3.csproj	(revision 12225)
+++ branches/PTSP/HeuristicLab.Problems.PTSP/3.3/HeuristicLab.Problems.PTSP-3.3.csproj	(revision 12228)
@@ -21,4 +21,5 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <PlatformTarget>AnyCPU</PlatformTarget>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
@@ -112,4 +113,6 @@
     <Compile Include="DistanceMatrix.cs" />
     <Compile Include="EstimatedPTSP.cs" />
+    <Compile Include="Improvers\PTSPExhaustiveInsertionLocalImprovement.cs" />
+    <Compile Include="Improvers\PTSPExhaustiveInversionLocalImprovement.cs" />
     <Compile Include="Interfaces\IPTSPPathMoveEvaluator.cs" />
     <Compile Include="Interfaces\IPTSPMoveEvaluator.cs" />
@@ -119,4 +122,5 @@
     <Compile Include="MoveEvaluators\TwoOpt\PTSPAnalyticalInversionMovePathEvaluator.cs" />
     <Compile Include="MoveEvaluators\TwoOpt\PTSPEstimatedInversionMovePathEvaluator.cs" />
+    <Compile Include="PathPTSPTour.cs" />
     <Compile Include="PTSP.cs" />
     <Compile Include="Plugin.cs" />
Index: branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPExhaustiveInsertionLocalImprovement.cs
===================================================================
--- branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPExhaustiveInsertionLocalImprovement.cs	(revision 12228)
+++ branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPExhaustiveInsertionLocalImprovement.cs	(revision 12228)
@@ -0,0 +1,150 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Threading;
+using HeuristicLab.Problems.PTSP.MoveEvaluators.OneShift;
+
+namespace HeuristicLab.Problems.PTSP {
+  /// <summary>
+  /// An operator that improves probabilistic traveling salesman solutions.
+  /// </summary>
+  /// <remarks>
+  /// The operator tries to improve the probabilistic traveling salesman solution by swapping two randomly chosen edges for a certain number of times.
+  /// </remarks>
+  [Item("PTSPExhaustiveInsertionLocalImprovement", "An operator that improves probabilistic traveling salesman solutions. The operator tries to improve the probabilistic traveling salesman solution by swapping two randomly chosen edges for a certain number of times.")]
+  [StorableClass]
+  public sealed class PTSPExhaustiveInsertionLocalImprovement : SingleSuccessorOperator, ILocalImprovementOperator {
+  
+    public ILookupParameter<IntValue> LocalIterationsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["LocalIterations"]; }
+    }
+
+    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+
+    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
+
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+
+    public ILookupParameter<DistanceMatrix> DistanceMatrixParameter {
+      get { return (ILookupParameter<DistanceMatrix>)Parameters["DistanceMatrix"]; }
+    }
+
+    public IValueParameter<ItemList<ItemList<IntValue>>> RealizationsParameter {
+      get { return (IValueParameter<ItemList<ItemList<IntValue>>>)Parameters["Realizations"]; }
+    }
+
+    [StorableConstructor]
+    protected PTSPExhaustiveInsertionLocalImprovement(bool deserializing) : base(deserializing) { }
+    protected PTSPExhaustiveInsertionLocalImprovement(PTSPExhaustiveInsertionLocalImprovement original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public PTSPExhaustiveInsertionLocalImprovement()
+      : base() {
+      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The solution as permutation."));
+      Parameters.Add(new LookupParameter<IntValue>("LocalIterations", "The number of iterations that have already been performed."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum amount of iterations that should be performed (note that this operator will abort earlier when a local optimum is reached).", new IntValue(10000)));
+      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The amount of evaluated solutions (here a move is counted only as 4/n evaluated solutions with n being the length of the permutation)."));
+      Parameters.Add(new LookupParameter<ResultCollection>("Results", "The collection where to store results."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value of the assignment."));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem should be maximized or minimized."));
+      Parameters.Add(new LookupParameter<DistanceMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
+      Parameters.Add(new ValueParameter<ItemList<ItemList<IntValue>>>("Realizations", "The concrete..."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPExhaustiveInsertionLocalImprovement(this, cloner);
+    }
+
+    public static void Improve(Permutation assignment, DoubleMatrix distances, DoubleValue quality, IntValue localIterations, IntValue evaluatedSolutions, bool maximization, int maxIterations, CancellationToken cancellation, ItemList<ItemList<IntValue>> realizations) {
+      DistanceMatrix distanceM = (DistanceMatrix)distances;
+      for (int i = localIterations.Value; i < maxIterations; i++) {
+        TranslocationMove bestMove = null;
+        double bestQuality = 0; // we have to make an improvement, so 0 is the baseline
+        double evaluations = 0.0;
+        foreach (var move in ExhaustiveInsertionMoveGenerator.Generate(assignment)) {
+          double moveQuality = PTSPEstimatedInsertionEvaluator.EvaluateByDistanceMatrix(assignment, move, distanceM, realizations);
+          int min = Math.Min(move.Index1, move.Index3);
+          int max = Math.Max(move.Index2, move.Index3 + (move.Index2 - move.Index1));
+          evaluations += 2.0 * (max - min + 1) / assignment.Length
+            + 4.0 * (assignment.Length - (max - min + 1)) / assignment.Length;
+          if (maximization && moveQuality > bestQuality
+            || !maximization && moveQuality < bestQuality) {
+            bestQuality = moveQuality;
+            bestMove = move;
+          }
+        }
+        evaluatedSolutions.Value += (int)Math.Ceiling(evaluations);
+        if (bestMove == null) break;
+        TranslocationManipulator.Apply(assignment, bestMove.Index1, bestMove.Index2, bestMove.Index3);
+        quality.Value += bestQuality;
+        localIterations.Value++;
+        cancellation.ThrowIfCancellationRequested();
+      }
+    }
+
+    public override IOperation Apply() {
+      var maxIterations = MaximumIterationsParameter.ActualValue.Value;
+      var assignment = PermutationParameter.ActualValue;
+      var maximization = MaximizationParameter.ActualValue.Value;
+      var distances = DistanceMatrixParameter.ActualValue;
+      var quality = QualityParameter.ActualValue;
+      var localIterations = LocalIterationsParameter.ActualValue;
+      var evaluations = EvaluatedSolutionsParameter.ActualValue;
+      var realizations = RealizationsParameter.Value;
+      if (localIterations == null) {
+        localIterations = new IntValue(0);
+        LocalIterationsParameter.ActualValue = localIterations;
+      }
+
+      Improve(assignment, distances, quality, localIterations, evaluations, maximization, maxIterations, CancellationToken, realizations);
+
+      localIterations.Value = 0;
+      return base.Apply();
+    }
+  }
+}
Index: branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPExhaustiveInversionLocalImprovement.cs
===================================================================
--- branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPExhaustiveInversionLocalImprovement.cs	(revision 12228)
+++ branches/PTSP/HeuristicLab.Problems.PTSP/3.3/Improvers/PTSPExhaustiveInversionLocalImprovement.cs	(revision 12228)
@@ -0,0 +1,146 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using System.Threading;
+
+namespace HeuristicLab.Problems.PTSP {
+  /// <summary>
+  /// An operator that improves probabilistic traveling salesman solutions.
+  /// </summary>
+  /// <remarks>
+  /// The operator tries to improve the probabilistic traveling salesman solution by swapping two randomly chosen edges for a certain number of times.
+  /// </remarks>
+  [Item("PTSPExhaustiveInversionLocalImprovement", "An operator that improves probabilistic traveling salesman solutions. The operator tries to improve the probabilistic traveling salesman solution by swapping two randomly chosen edges for a certain number of times.")]
+  [StorableClass]
+  public sealed class PTSPExhaustiveInversionLocalImprovement : SingleSuccessorOperator, ILocalImprovementOperator {
+  
+    public ILookupParameter<IntValue> LocalIterationsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["LocalIterations"]; }
+    }
+
+    public IValueLookupParameter<IntValue> MaximumIterationsParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters["MaximumIterations"]; }
+    }
+
+    public ILookupParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (ILookupParameter<IntValue>)Parameters["EvaluatedSolutions"]; }
+    }
+
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters["Results"]; }
+    }
+
+    public ILookupParameter<Permutation> PermutationParameter {
+      get { return (ILookupParameter<Permutation>)Parameters["Permutation"]; }
+    }
+
+    public ILookupParameter<DoubleValue> QualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
+
+    public ILookupParameter<BoolValue> MaximizationParameter {
+      get { return (ILookupParameter<BoolValue>)Parameters["Maximization"]; }
+    }
+
+    public ILookupParameter<DistanceMatrix> DistanceMatrixParameter {
+      get { return (ILookupParameter<DistanceMatrix>)Parameters["DistanceMatrix"]; }
+    }
+
+    public IValueParameter<ItemList<ItemList<IntValue>>> RealizationsParameter {
+      get { return (IValueParameter<ItemList<ItemList<IntValue>>>)Parameters["Realizations"]; }
+    }
+
+    [StorableConstructor]
+    protected PTSPExhaustiveInversionLocalImprovement(bool deserializing) : base(deserializing) { }
+    protected PTSPExhaustiveInversionLocalImprovement(PTSPExhaustiveInversionLocalImprovement original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public PTSPExhaustiveInversionLocalImprovement()
+      : base() {
+      Parameters.Add(new LookupParameter<Permutation>("Permutation", "The solution as permutation."));
+      Parameters.Add(new LookupParameter<IntValue>("LocalIterations", "The number of iterations that have already been performed."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("MaximumIterations", "The maximum amount of iterations that should be performed (note that this operator will abort earlier when a local optimum is reached).", new IntValue(10000)));
+      Parameters.Add(new LookupParameter<IntValue>("EvaluatedSolutions", "The amount of evaluated solutions (here a move is counted only as 4/n evaluated solutions with n being the length of the permutation)."));
+      Parameters.Add(new LookupParameter<ResultCollection>("Results", "The collection where to store results."));
+      Parameters.Add(new LookupParameter<DoubleValue>("Quality", "The quality value of the assignment."));
+      Parameters.Add(new LookupParameter<BoolValue>("Maximization", "True if the problem should be maximized or minimized."));
+      Parameters.Add(new LookupParameter<DistanceMatrix>("DistanceMatrix", "The matrix which contains the distances between the cities."));
+      Parameters.Add(new ValueParameter<ItemList<ItemList<IntValue>>>("Realizations", "The concrete..."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PTSPExhaustiveInversionLocalImprovement(this, cloner);
+    }
+
+    public static void Improve(Permutation assignment, DoubleMatrix distances, DoubleValue quality, IntValue localIterations, IntValue evaluatedSolutions, bool maximization, int maxIterations, CancellationToken cancellation, ItemList<ItemList<IntValue>> realizations) {
+      DistanceMatrix distanceM = (DistanceMatrix)distances;
+      for (int i = localIterations.Value; i < maxIterations; i++) {
+        InversionMove bestMove = null;
+        double bestQuality = 0; // we have to make an improvement, so 0 is the baseline
+        double evaluations = 0.0;
+        foreach (var move in ExhaustiveInversionMoveGenerator.Generate(assignment)) {
+          double moveQuality = PTSPEstimatedInversionMovePathEvaluator.EvaluateByDistanceMatrix(assignment, move, distanceM, realizations);
+          evaluations += 2 * (move.Index2 - move.Index1 + 1) / (double)assignment.Length;
+          if (maximization && moveQuality > bestQuality
+            || !maximization && moveQuality < bestQuality) {
+            bestQuality = moveQuality;
+            bestMove = move;
+          }
+        }
+        evaluatedSolutions.Value += (int)Math.Ceiling(evaluations);
+        if (bestMove == null) break;
+        InversionManipulator.Apply(assignment, bestMove.Index1, bestMove.Index2);
+        quality.Value += bestQuality;
+        localIterations.Value++;
+        cancellation.ThrowIfCancellationRequested();
+      }
+    }
+
+    public override IOperation Apply() {
+      var maxIterations = MaximumIterationsParameter.ActualValue.Value;
+      var assignment = PermutationParameter.ActualValue;
+      var maximization = MaximizationParameter.ActualValue.Value;
+      var distances = DistanceMatrixParameter.ActualValue;
+      var quality = QualityParameter.ActualValue;
+      var localIterations = LocalIterationsParameter.ActualValue;
+      var evaluations = EvaluatedSolutionsParameter.ActualValue;
+      var realizations = RealizationsParameter.Value;
+      if (localIterations == null) {
+        localIterations = new IntValue(0);
+        LocalIterationsParameter.ActualValue = localIterations;
+      }
+
+      Improve(assignment, distances, quality, localIterations, evaluations, maximization, maxIterations, CancellationToken, realizations);
+
+      localIterations.Value = 0;
+      return base.Apply();
+    }
+  }
+}
Index: branches/PTSP/HeuristicLab.Problems.PTSP/3.3/MoveEvaluators/TwoOpt/PTSPAnalyticalInversionMovePathEvaluator.cs
===================================================================
--- branches/PTSP/HeuristicLab.Problems.PTSP/3.3/MoveEvaluators/TwoOpt/PTSPAnalyticalInversionMovePathEvaluator.cs	(revision 12225)
+++ branches/PTSP/HeuristicLab.Problems.PTSP/3.3/MoveEvaluators/TwoOpt/PTSPAnalyticalInversionMovePathEvaluator.cs	(revision 12228)
@@ -35,5 +35,5 @@
   public class PTSPAnalyticalInversionMovePathEvaluator : PTSPPathMoveEvaluator, IPermutationInversionMoveOperator {
 
-    private static ItemList<DoubleValue> probabilities;
+    private static DoubleArray probabilities;
     private static DoubleMatrix A;
     private static DoubleMatrix B;
@@ -46,6 +46,6 @@
     }
 
-    public IValueParameter<ItemList<DoubleValue>> ProbabilitiesParameter {
-      get { return (IValueParameter<ItemList<DoubleValue>>)Parameters["Probabilities"]; }
+    public IValueParameter<DoubleArray> ProbabilitiesParameter {
+      get { return (IValueParameter<DoubleArray>)Parameters["Probabilities"]; }
     }
 
@@ -103,15 +103,15 @@
         case 1:
           if (j == i + 1) {
-            return (1/(1-probabilities[i+1].Value))*A[i,2]+(1 - probabilities[i].Value)*(A[i+1,1]-A[i+1,probabilities.Capacity-1]);
+            return (1/(1-probabilities[i+1]))*A[i,2]+(1 - probabilities[i])*(A[i+1,1]-A[i+1,probabilities.Length-1]);
           } else if (i == j) {
             return A[i,1];
           } else {
             // Equation 25
-            return ((1 - probabilities[i].Value) / (1 - probabilities[j].Value)) * RecursiveExpectedCost(1, i + 1, j - 1) + (1 - probabilities[i].Value) * (1);
+            return ((1 - probabilities[i]) / (1 - probabilities[j])) * RecursiveExpectedCost(1, i + 1, j - 1) + (1 - probabilities[i]) * (1);
           }
           
         case 2:
           if (j == i + 1) {
-            return (1 - probabilities[i + 1].Value) * (B[i, 1] - B[i, probabilities.Capacity - 1]) + (1 / (1 - probabilities[i].Value)) * (B[i + 1, 2]);
+            return (1 - probabilities[i + 1]) * (B[i, 1] - B[i, probabilities.Length - 1]) + (1 / (1 - probabilities[i])) * (B[i + 1, 2]);
           } else if (i == j) {
             return B[i,1];
@@ -123,5 +123,5 @@
         case 3:
           if (j == i + 1) {
-            return A[i, 2] + A[i + 1, 1] - A[i + 1, probabilities.Capacity - 1] + B[i, 1] - B[i, probabilities.Capacity - 1] + B[i + 1, 2];
+            return A[i, 2] + A[i + 1, 1] - A[i + 1, probabilities.Length - 1] + B[i, 1] - B[i, probabilities.Length - 1] + B[i + 1, 2];
           } else if (i == j) {
             return A[i,1]+B[i,1];
Index: branches/PTSP/HeuristicLab.Problems.PTSP/3.3/PTSP.cs
===================================================================
--- branches/PTSP/HeuristicLab.Problems.PTSP/3.3/PTSP.cs	(revision 12225)
+++ branches/PTSP/HeuristicLab.Problems.PTSP/3.3/PTSP.cs	(revision 12228)
@@ -40,4 +40,6 @@
   public abstract class ProbabilisticTravelingSalesmanProblem : SingleObjectiveBasicProblem<PermutationEncoding>, IStorableContent,
   IProblemInstanceConsumer<TSPData> {
+    private static readonly int DistanceMatrixSizeLimit = 1000;
+
     #region Parameter Properties
     public OptionalValueParameter<DoubleMatrix> CoordinatesParameter {
@@ -53,6 +55,6 @@
       get { return (OptionalValueParameter<Permutation>)Parameters["BestKnownSolution"]; }
     }
-    public OptionalValueParameter<ItemList<DoubleValue>> ProbabilityMatrixParameter {
-      get { return (OptionalValueParameter<ItemList<DoubleValue>>)Parameters["ProbabilityMatrix"]; }
+    public ValueParameter<DoubleArray> ProbabilityMatrixParameter {
+      get { return (ValueParameter<DoubleArray>)Parameters["ProbabilityMatrix"]; }
     }
     public ValueParameter<IntValue> SampleSizeParameter {
@@ -79,5 +81,5 @@
       set { BestKnownSolutionParameter.Value = value; }
     }
-    public ItemList<DoubleValue> ProbabilityMatrix {
+    public DoubleArray ProbabilityMatrix {
       get { return ProbabilityMatrixParameter.Value; }
       set { ProbabilityMatrixParameter.Value = value; }
@@ -105,17 +107,49 @@
       Parameters.Add(new ValueParameter<BoolValue>("UseDistanceMatrix", "True if the coordinates based evaluators should calculate the distance matrix from the coordinates and use it for evaluation similar to the distance matrix evaluator, otherwise false.", new BoolValue(true)));
       Parameters.Add(new OptionalValueParameter<Permutation>("BestKnownSolution", "The best known solution of this TSP instance."));
-      Parameters.Add(new OptionalValueParameter<ItemList<DoubleValue>>("ProbabilityMatrix", "The matrix which contains the probabilities of each of the cities."));
+      Parameters.Add(new ValueParameter<DoubleArray>("ProbabilityMatrix", "The matrix which contains the probabilities of each of the cities."));
+
+      Coordinates = new DoubleMatrix(new double[,] {
+        { 100, 100 }, { 100, 200 }, { 100, 300 }, { 100, 400 },
+        { 200, 100 }, { 200, 200 }, { 200, 300 }, { 200, 400 },
+        { 300, 100 }, { 300, 200 }, { 300, 300 }, { 300, 400 },
+        { 400, 100 }, { 400, 200 }, { 400, 300 }, { 400, 400 }
+      });
+
+      ProbabilityMatrix = new DoubleArray(new double[] {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1});
       
     }
 
     public virtual void Load(TSPData data) {
+      if (data.Coordinates == null && data.Distances == null)
+        throw new System.IO.InvalidDataException("The given instance specifies neither coordinates nor distances!");
+      if (data.Dimension > DistanceMatrixSizeLimit && (data.DistanceMeasure == DistanceMeasure.Att
+        || data.DistanceMeasure == DistanceMeasure.Manhattan
+        || data.DistanceMeasure == DistanceMeasure.Maximum))
+        throw new System.IO.InvalidDataException("The given instance uses an unsupported distance measure and is too large for using a distance matrix.");
+      if (data.Coordinates != null && data.Coordinates.GetLength(1) != 2)
+        throw new System.IO.InvalidDataException("The coordinates of the given instance are not in the right format, there need to be one row for each customer and two columns for the x and y coordinates.");
+
+      Name = data.Name;
+      Description = data.Description;
+
+      bool clearCoordinates = false, clearDistanceMatrix = false;
+      if (data.Coordinates != null && data.Coordinates.GetLength(0) > 0)
+        Coordinates = new DoubleMatrix(data.Coordinates);
+      else clearCoordinates = true;
+
+      // reset them after assigning the evaluator
+      if (clearCoordinates) Coordinates = null;
+      if (clearDistanceMatrix) DistanceMatrix = null;
+
       DistanceMatrix = new DistanceMatrix(data.GetDistanceMatrix());
       // Get Probabilities of cities using random with seed from hash function on the Name of the instance
-      ProbabilityMatrix = new ItemList<DoubleValue>(data.Dimension);
+      ProbabilityMatrix = new DoubleArray(data.Dimension);
       Random r = new Random(data.Name.GetHashCode());
       for (int i = 0; i < data.Dimension; i++) {
-        ProbabilityMatrix.Add(new DoubleValue(r.NextDouble()));
+        ProbabilityMatrix[i] = r.NextDouble();
       }
       Encoding.Length = data.Dimension;
+
+      OnReset();
     }
   }
Index: branches/PTSP/HeuristicLab.Problems.PTSP/3.3/PathPTSPTour.cs
===================================================================
--- branches/PTSP/HeuristicLab.Problems.PTSP/3.3/PathPTSPTour.cs	(revision 12228)
+++ branches/PTSP/HeuristicLab.Problems.PTSP/3.3/PathPTSPTour.cs	(revision 12228)
@@ -0,0 +1,223 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 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.Drawing;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.PermutationEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.PTSP {
+  /// <summary>
+  /// Represents a tour of a Probabilistic Traveling Salesman Problem given in path representation which can be visualized in the GUI.
+  /// </summary>
+  [Item("PathTSPTour", "Represents a tour of a Probabilistic Traveling Salesman Problem given in path representation which can be visualized in the GUI.")]
+  [StorableClass]
+  public sealed class PathPTSPTour : Item {
+    public static new Image StaticItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Image; }
+    }
+
+    [Storable]
+    private DoubleMatrix coordinates;
+    public DoubleMatrix Coordinates {
+      get { return coordinates; }
+      set {
+        if (coordinates != value) {
+          if (coordinates != null) DeregisterCoordinatesEvents();
+          coordinates = value;
+          if (coordinates != null) RegisterCoordinatesEvents();
+          OnCoordinatesChanged();
+        }
+      }
+    }
+    [Storable]
+    private Permutation permutation;
+    public Permutation Permutation {
+      get { return permutation; }
+      set {
+        if (permutation != value) {
+          if (permutation != null) DeregisterPermutationEvents();
+          permutation = value;
+          if (permutation != null) RegisterPermutationEvents();
+          OnPermutationChanged();
+        }
+      }
+    }
+    [Storable]
+    private DoubleValue quality;
+    public DoubleValue Quality {
+      get { return quality; }
+      set {
+        if (quality != value) {
+          if (quality != null) DeregisterQualityEvents();
+          quality = value;
+          if (quality != null) RegisterQualityEvents();
+          OnQualityChanged();
+        }
+      }
+    }
+    [Storable]
+    private DoubleArray probabilities;
+    public DoubleArray Probabilities {
+      get { return probabilities; }
+      set {
+        if (probabilities != value) {
+          if (probabilities != null) DeregisterProbabilitiesEvents();
+          probabilities = value;
+          if (probabilities != null) RegisterProbabilitiesEvents();
+          OnQualityChanged();
+        }
+      }
+    }
+
+    [StorableConstructor]
+    private PathPTSPTour(bool deserializing) : base(deserializing) { }
+    private PathPTSPTour(PathPTSPTour original, Cloner cloner)
+      : base(original, cloner) {
+      this.coordinates = cloner.Clone(original.coordinates);
+      this.probabilities = cloner.Clone(original.probabilities);
+      this.permutation = cloner.Clone(original.permutation);
+      this.quality = cloner.Clone(original.quality);
+      Initialize();
+    }
+    public PathPTSPTour() : base() { }
+    public PathPTSPTour(DoubleMatrix coordinates, DoubleArray probabilities)
+      : base() {
+      this.coordinates = coordinates;
+      this.probabilities = probabilities;
+      Initialize();
+    }
+    public PathPTSPTour(DoubleMatrix coordinates, DoubleArray probabilities, Permutation permutation)
+      : base() {
+      this.coordinates = coordinates;
+      this.probabilities = probabilities;
+      this.permutation = permutation;
+      Initialize();
+    }
+    public PathPTSPTour(DoubleMatrix coordinates, DoubleArray probabilities, Permutation permutation, DoubleValue quality)
+      : base() {
+      this.coordinates = coordinates;
+      this.probabilities = probabilities;
+      this.permutation = permutation;
+      this.quality = quality;
+      Initialize();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new PathPTSPTour(this, cloner);
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Initialize();
+    }
+
+    private void Initialize() {
+      if (coordinates != null) RegisterCoordinatesEvents();
+      if (probabilities != null) RegisterProbabilitiesEvents();
+      if (permutation != null) RegisterPermutationEvents();
+      if (quality != null) RegisterQualityEvents();
+    }
+
+    #region Events
+    public event EventHandler CoordinatesChanged;
+    private void OnCoordinatesChanged() {
+      var changed = CoordinatesChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    public event EventHandler ProbabilitiesChanged;
+    private void OnProbabilitiesChanged() {
+      var changed = ProbabilitiesChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    public event EventHandler PermutationChanged;
+    private void OnPermutationChanged() {
+      var changed = PermutationChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+    public event EventHandler QualityChanged;
+    private void OnQualityChanged() {
+      var changed = QualityChanged;
+      if (changed != null)
+        changed(this, EventArgs.Empty);
+    }
+
+    private void RegisterCoordinatesEvents() {
+      Coordinates.ItemChanged += new EventHandler<EventArgs<int, int>>(Coordinates_ItemChanged);
+      Coordinates.Reset += new EventHandler(Coordinates_Reset);
+    }
+    private void DeregisterCoordinatesEvents() {
+      Coordinates.ItemChanged -= new EventHandler<EventArgs<int, int>>(Coordinates_ItemChanged);
+      Coordinates.Reset -= new EventHandler(Coordinates_Reset);
+    }
+    private void RegisterProbabilitiesEvents() {
+      Probabilities.ItemChanged += new EventHandler<EventArgs<int>>(Probabilities_ItemChanged);
+      Probabilities.Reset += new EventHandler(Probabilities_Reset);
+    }
+    private void DeregisterProbabilitiesEvents() {
+      Probabilities.ItemChanged -= new EventHandler<EventArgs<int>>(Probabilities_ItemChanged);
+      Probabilities.Reset -= new EventHandler(Probabilities_Reset);
+    }
+    private void RegisterPermutationEvents() {
+      Permutation.ItemChanged += new EventHandler<EventArgs<int>>(Permutation_ItemChanged);
+      Permutation.Reset += new EventHandler(Permutation_Reset);
+    }
+    private void DeregisterPermutationEvents() {
+      Permutation.ItemChanged -= new EventHandler<EventArgs<int>>(Permutation_ItemChanged);
+      Permutation.Reset -= new EventHandler(Permutation_Reset);
+    }
+    private void RegisterQualityEvents() {
+      Quality.ValueChanged += new EventHandler(Quality_ValueChanged);
+    }
+    private void DeregisterQualityEvents() {
+      Quality.ValueChanged -= new EventHandler(Quality_ValueChanged);
+    }
+
+    private void Coordinates_ItemChanged(object sender, EventArgs<int, int> e) {
+      OnCoordinatesChanged();
+    }
+    private void Coordinates_Reset(object sender, EventArgs e) {
+      OnCoordinatesChanged();
+    }
+    private void Probabilities_ItemChanged(object sender, EventArgs<int> e) {
+      OnProbabilitiesChanged();
+    }
+    private void Probabilities_Reset(object sender, EventArgs e) {
+      OnProbabilitiesChanged();
+    }
+    private void Permutation_ItemChanged(object sender, EventArgs<int> e) {
+      OnPermutationChanged();
+    }
+    private void Permutation_Reset(object sender, EventArgs e) {
+      OnPermutationChanged();
+    }
+    private void Quality_ValueChanged(object sender, EventArgs e) {
+      OnQualityChanged();
+    }
+    #endregion
+  }
+}
Index: branches/PTSP/PTSP.sln
===================================================================
--- branches/PTSP/PTSP.sln	(revision 12225)
+++ branches/PTSP/PTSP.sln	(revision 12228)
@@ -5,4 +5,6 @@
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.PTSP-3.3", "HeuristicLab.Problems.PTSP\3.3\HeuristicLab.Problems.PTSP-3.3.csproj", "{97198965-AFEA-496B-B3B1-316905C43FD6}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.PTSP.Views-3.3", "HeuristicLab.Problems.PTSP.Views\3.3\HeuristicLab.Problems.PTSP.Views-3.3.csproj", "{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}"
 EndProject
 Global
@@ -16,4 +18,8 @@
 		{97198965-AFEA-496B-B3B1-316905C43FD6}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{97198965-AFEA-496B-B3B1-316905C43FD6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{90B6CA12-9791-4430-B2D7-CD3ED7F75E2B}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
